克隆策略

In [93]:

# 本代码由可视化策略环境自动生成 2019年3月30日 16:02
# 本代码单元只能在可视化模式下编辑。您也可以拷贝代码，粘贴到新建的代码单元或者策略，然后修改。


# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m5_run_bigquant_run(input_1, alpha=0.9):
    # 示例代码如下。在这里编写您的代码
    import numpy as np
    import pandas as pd
    df = input_1.read_df()
    data = df.ewm(alpha=alpha).mean()
    data_1 = DataSource.write_df(data)
    return Outputs(data_1=data_1)

# 后处理函数，可选。输入是主函数的输出，可以在这里对数据做处理，或者返回更友好的outputs数据格式。此函数输出不会被缓存。
def m5_post_run_bigquant_run(outputs):
    return outputs

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m10_run_bigquant_run(input_1, window):
    # 示例代码如下。在这里编写您的代码
    df = input_1.read_df()
    del(df['Date'])
    del(df['Adj Close'])
    
    # 获取预测指标
    def compute_prediction_int(df, n):
        pred = np.sign(df.shift(-n)['Close'] - df['Close'])
        pred = pred.iloc[:-n]
        return pred.astype(int)

    # 获取技术指标
    ## 计算Stochastic Oscillator
    def stochastic_oscillator_d(df, n):
        SOK = [0]
        for i in range(n, len(df)):
            high = df.loc[(i-n):i, 'High']
            low = df.loc[(i-n):i, 'Low']
            SOK.append((df.loc[i, 'Close'] - min(low)) / (max(high) - min(low)))
        SOK = pd.Series(SOK, name='SOK')
        df = df.join(SOK)
        return df

    ## 计算Williams %R
    def williams_R(df, n):
        R = [0]
        for i in range(n, len(df)):
            high = df.loc[(i-n):i, 'High']
            low = df.loc[(i-n):i, 'Low']
            R.append((max(high) - df.loc[i, 'Close']) / (max(high) - min(low))*(-100))
        williams_R = pd.Series(R, name='williams_R')
        df = df.join(williams_R)
        return df


    ## 计算变化率
    def rate_of_change(df, n):
        M = df['Close'].diff(n - 1)
        N = df['Close'].shift(n - 1)
        ROC = pd.Series(M / N, name='ROC_' + str(n))
        df = df.join(ROC)
        return df

    ## 计算RSI
    def relative_strength_index(df, n):
        i = 0
        UpI = [0]
        DoI = [0]
        while i + 1 <= df.index[-1]:
            UpMove = df.loc[i + 1, 'High'] - df.loc[i, 'High']
            DoMove = df.loc[i, 'Low'] - df.loc[i + 1, 'Low']
            if UpMove > DoMove and UpMove > 0:
                UpD = UpMove
            else:
                UpD = 0
            UpI.append(UpD)
            if DoMove > UpMove and DoMove > 0:
                DoD = DoMove
            else:
                DoD = 0
            DoI.append(DoD)
            i = i + 1
        UpI = pd.Series(UpI)
        DoI = pd.Series(DoI)
        PosDI = pd.Series(UpI.ewm(span=n, min_periods=n).mean())
        NegDI = pd.Series(DoI.ewm(span=n, min_periods=n).mean())
        RSI = pd.Series(PosDI / (PosDI + NegDI), name='RSI_' + str(n))
        df = df.join(RSI)
        return df

    ## 计算On Balance Volume
    def on_balance_volume(df, n):
        i = 0
        OBV = [0]
        while i < df.index[-1]:
            if df.loc[i + 1, 'Close'] - df.loc[i, 'Close'] > 0:
                OBV.append(df.loc[i + 1, 'Volume'])
            if df.loc[i + 1, 'Close'] - df.loc[i, 'Close'] == 0:
                OBV.append(0)
            if df.loc[i + 1, 'Close'] - df.loc[i, 'Close'] < 0:
                OBV.append(-df.loc[i + 1, 'Volume'])
            i = i + 1
        OBV = pd.Series(OBV)
        OBV_ma = pd.Series(OBV.rolling(n, min_periods=n).mean(), name='OBV_' + str(n))
        df = df.join(OBV_ma)
        return df

    ## 计算MACD
    def macd(df, n_fast, n_slow):
        EMAfast = pd.Series(df['Close'].ewm(span=n_fast, min_periods=n_slow).mean())
        EMAslow = pd.Series(df['Close'].ewm(span=n_slow, min_periods=n_slow).mean())
        MACD = pd.Series(EMAfast - EMAslow, name='MACD_' + str(n_fast) + '_' + str(n_slow))
        df = df.join(MACD)
        return df

    # 数据集准备
    def feature_extraction(data):
        data = relative_strength_index(data, n=14)
        data = stochastic_oscillator_d(data, n=14)
        data = rate_of_change(data, n=14)
        data = on_balance_volume(data, n=14)
        data = macd(data, 12, 26)
        data = williams_R(data, n = 14)

        del(data['Open'])
        del(data['High'])
        del(data['Low'])
        del(data['Volume'])

        return data

    def prepare_data(df, horizon):
        data = feature_extraction(df).dropna().iloc[:-horizon]
        data['label'] = compute_prediction_int(data, n=horizon)
        del(data['Close'])
        return data.dropna()
    
    data = prepare_data(df, horizon=window) 
    features = [x for x in data.columns if x not in ['gain', 'label']]
    data_1 = DataSource.write_df(data)
    data_2 = DataSource.write_pickle(features)
    return Outputs(data_1=data_1, data_2=data_2)

# 后处理函数，可选。输入是主函数的输出，可以在这里对数据做处理，或者返回更友好的outputs数据格式。此函数输出不会被缓存。
def m10_post_run_bigquant_run(outputs):
    return outputs

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m9_run_bigquant_run(input_1):
    # 示例代码如下。在这里编写您的代码
    data = input_1.read_df()
    # 训练集划分
    train_size = 2*len(data) // 3
    train_df = data[:train_size]
    test_df = data[train_size:]

    print('len train', len(train_df))
    print('len test', len(test_df))
    columns = [k for k in test_df.columns if k!='label']
    data_1 = DataSource.write_df(train_df)
    data_2 = DataSource.write_df(test_df)
    
    return Outputs(data_1=data_1, data_2=data_2)

# 后处理函数，可选。输入是主函数的输出，可以在这里对数据做处理，或者返回更友好的outputs数据格式。此函数输出不会被缓存。
def m9_post_run_bigquant_run(outputs):
    return outputs

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m11_run_bigquant_run(input_1, input_2):
    # 示例代码如下。在这里编写您的代码
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.metrics import f1_score, precision_score, confusion_matrix, recall_score, accuracy_score
    
    data = input_1.read()
    y_pred = data['pred_label']
    y_test = input_2.read_df()
    y_test = y_test['label']
    precision = precision_score(y_pred=y_pred, y_true=y_test)
    recall = recall_score(y_pred=y_pred, y_true=y_test)
    f1 = f1_score(y_pred=y_pred, y_true=y_test)
    accuracy = accuracy_score(y_pred=y_pred, y_true=y_test)
    print('precision: {0:1.2f}, recall: {1:1.2f}, f1: {2:1.2f}, accuracy: {3:1.2f}'.format(precision, recall, f1, accuracy))

    return Outputs()

# 后处理函数，可选。输入是主函数的输出，可以在这里对数据做处理，或者返回更友好的outputs数据格式。此函数输出不会被缓存。
def m11_post_run_bigquant_run(outputs):
    return outputs


m4 = M.csv_read.v3(
    csv_path='AAPL.csv',
    encoding='utf-8'
)

m5 = M.cached.v3(
    input_1=m4.data,
    run=m5_run_bigquant_run,
    post_run=m5_post_run_bigquant_run,
    input_ports='',
    params='{\'alpha\':0.9}',
    output_ports=''
)

m10 = M.cached.v3(
    input_1=m5.data_1,
    run=m10_run_bigquant_run,
    post_run=m10_post_run_bigquant_run,
    input_ports='',
    params='{\'window\':10}',
    output_ports=''
)

m9 = M.cached.v3(
    input_1=m10.data_1,
    run=m9_run_bigquant_run,
    post_run=m9_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m2 = M.random_forest_train.v2(
    training_ds=m9.data_1,
    features=m10.data_2,
    n_estimators=65,
    max_features='auto',
    max_depth=30,
    min_samples_leaf=200,
    n_jobs=1,
    algo='classifier'
)

m3 = M.random_forest_predict.v2(
    model=m2.model,
    data=m9.data_2,
    date_col='',
    instrument_col='',
    sort=False
)

m11 = M.cached.v3(
    input_1=m3.predictions,
    input_2=m9.data_2,
    run=m11_run_bigquant_run,
    post_run=m11_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports='',
    m_cached=False
)

[2019-03-30 16:00:18.854293] INFO: bigquant: csv_read.v3 开始运行..

[2019-03-30 16:00:18.865572] INFO: bigquant: 命中缓存

[2019-03-30 16:00:18.868511] INFO: bigquant: csv_read.v3 运行完成[0.014228s].

[2019-03-30 16:00:18.872226] INFO: bigquant: cached.v3 开始运行..

[2019-03-30 16:00:18.876757] INFO: bigquant: 命中缓存

[2019-03-30 16:00:18.878055] INFO: bigquant: cached.v3 运行完成[0.005824s].

[2019-03-30 16:00:18.888480] INFO: bigquant: cached.v3 开始运行..

[2019-03-30 16:00:18.894727] INFO: bigquant: 命中缓存

[2019-03-30 16:00:18.896114] INFO: bigquant: cached.v3 运行完成[0.007633s].

[2019-03-30 16:00:18.900465] INFO: bigquant: cached.v3 开始运行..

[2019-03-30 16:00:18.911851] INFO: bigquant: 命中缓存

[2019-03-30 16:00:18.913304] INFO: bigquant: cached.v3 运行完成[0.012836s].

[2019-03-30 16:00:18.915801] INFO: bigquant: random_forest_train.v2 开始运行..

[2019-03-30 16:00:18.921733] INFO: bigquant: 命中缓存

[2019-03-30 16:00:18.923045] INFO: bigquant: random_forest_train.v2 运行完成[0.007238s].

[2019-03-30 16:00:18.925282] INFO: bigquant: random_forest_predict.v2 开始运行..

[2019-03-30 16:00:18.929138] INFO: bigquant: 命中缓存

[2019-03-30 16:00:18.930312] INFO: bigquant: random_forest_predict.v2 运行完成[0.00503s].

[2019-03-30 16:00:18.932886] INFO: bigquant: cached.v3 开始运行..

[2019-03-30 16:00:18.954776] INFO: bigquant: cached.v3 运行完成[0.021873s].

precision: 0.75, recall: 0.75, f1: 0.75, accuracy: 0.70