复制链接

克隆策略

In [10]:

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


# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m13_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    window = input_2.shape[1]
    return Outputs(data_1=None, data_2=window, data_3=None)

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

import tensorflow as tf
    
def m14_user_activation_bigquant_run(x):
    return tf.atan(x)
    
 

import tensorflow as tf

def m29_user_activation_bigquant_run(x):
    return tf.atan(x)


import tensorflow as tf

def m16_user_activation_bigquant_run(x):
    return tf.atan(x)


# 功能：自定义 大盘因子 训练集 证券代码列表
# 逻辑：如果 input_2 接 股票因子 预测集 证券代码列表，
#       则令 大盘因子 训练集 证券代码列表 end_date 
#         为 
#            股票因子 预测集 证券代码列表 start_date 前一交易日
def m28_run_bigquant_run(input_1, input_2, input_3, start_date = '', end_date = ''):
    # 示例代码如下。在这里编写您的代码
        
    if input_2 is not None: # input_2 接 股票因子 预测集 证券代码列表
        
        instrument_module_dict = input_2.read_pickle()
    
        end_date = instrument_module_dict['start_date']
        tdays = list(D.trading_days(end_date = end_date)['date'])
        end_date = tdays[-1].strftime('%Y-%m-%d') if tdays[-1].strftime('%Y-%m-%d') < end_date else tdays[-2].strftime('%Y-%m-%d')
        
    else:
        
        instrument_module_dict = {}
                
    instrument_module_dict['start_date'] = start_date
    instrument_module_dict['end_date'] = end_date

    data = DataSource.write_pickle(instrument_module_dict)
    
    return Outputs(data_1 = None, data_2 = data, data_3 = None)

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

# 本模块功能：延长 证券代码列表模块 截止日 30 日，
# 本模块目的：解决 自动标注模块 对其输入“证券代码列表”模块 截止日 不标注 问题
# 输入端：
#     input_2：接 证券代码列表模块
def m39_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    data = input_2.read_pickle()
    end_date = data['end_date']
    data['end_date'] = (datetime.datetime.strptime(end_date,'%Y-%m-%d').date()
                        + datetime.timedelta(days = 30)).strftime('%Y-%m-%d')
    data = DataSource.write_pickle(data)
    return Outputs(data_1=None, data_2=data, data_3=None)

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

# 本模块功能：标签 训练集 过滤掉 训练集 证券代码列表模块 截止日后 数据
# 本模块目的：确保 标签 训练集 截止日 早于 预测集 开始日
# 输入端：
#     input_1：接 训练集 证券代码列表模块
#     input_2：接 自动标注模块/标签提取模块
#     input_3：接 预测集 证券代码列表模块

def m40_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    
    # 取 训练集 证券代码列表模块 截止日
    train_end_date = input_1.read_pickle()['end_date'] 
    # 取 预测集 证券代码列表模块 开始日
    predict_start_date = input_3.read_pickle()['start_date'] 
    # 取 标注/标签 数据
    data = input_2.read_df() 
    
    if train_end_date >= predict_start_date:
        print("标签 训练集 截止日 必须早于 预测集开始日！! 请检查。。。。。。")
    else: # 标签 训练集 过滤掉 训练集 证券代码列表模块 截止日后 数据   
        data = data.query('date <= @ train_end_date') 
    
    data = DataSource.write_df(data)
    
    return Outputs(data_1=None, data_2=data, data_3=None)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
# 输入端：
  # input_1：接 输入层Input
  # input_2：基于 大盘因子训练集 代码列表 和 股票因子测试集 代码列表 抽取的 指数特征（大盘因子）数据集
  # input_3：接 大盘因子训练集 代码列表
#  # input_2：基于 测试集代码列表 抽取的 指数特征（大盘因子）数据集
#  # input_3：接 测试集代码列表
# 输出端：
  # data_1：大盘因子滑动窗口训练集，数组类型字典
  # data_2：大盘因子滑动窗口测试集，数组类型字典，保留 第一个 前补 window
#  # data_3：大盘因子测试集，完整保留原始列   
  # data_3：大盘因子测试集，丢弃 第一个 前补 window，完整保留原始列   
    
def m5_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码

    #window = 7 # m18.data.shape[1] # 每个input的长度
    #window = input_1.shape[1] # 每个input的长度，对应 LSTM time_steps
    window = input_1 # 每个input的长度，对应 LSTM time_steps
    
#    print('window：',window)
    
    # 指数特征（大盘因子）数据集：基于 测试集 代码列表 时间区间，但 向前保留一个 window 天数 用于 训练集 
#    df = input_2.read_df() 
#    df = input_2.read_df().reset_index(drop = True)
    df = (input_2.read_df()
#                 .dropna(subset=['bm_label']) # 不能 dropna, 否则 会删掉 测试集最后一天记录，导致模拟交易无预测信号 
                 .drop_duplicates() # 去除可能因 测试集 向前多取 window 导致的重复行
                 .reset_index(drop=True)) # 重置索引
        
    # 大盘因子名称去除前缀'bm_'
    cols = df.columns
    df.columns = [(col.partition('bm_')[2] if col.startswith('b') else col) for col in cols ]
    
    # 大盘因子数据集 去除 ['date','instrument','label'] 三列
    df_x = df[df.columns.difference(['date','instrument','label'] )] 

#    # 取 测试集开始日期 为 大盘因子测试集开始日期 
#    start_date = input_3.read()['start_date'] 
    
#    train_df = df.query("date<@start_date") # 大盘因子训练集
#    test_df = df.query("date>=@start_date") # 大盘因子测试集
##    train_df = df[df['date'] < start_date]  # 大盘因子 训练集
##    test_df = df[df['date'] >= start_date] # 大盘因子 预测集
    
    # 大盘因子训练集 开始日期 和 结束日期
    start_date = input_3.read()['start_date'] 
    end_date = input_3.read()['end_date']
    
    # 大盘因子 训练集 和 测试集
    train_df = df.query("@start_date <= date and date <= @end_date") # 大盘因子训练集
    train_df_end_ix = train_df.tail(1).index[0] # train_df 尾行索引值
    test_df = df.iloc[(train_df_end_ix +1 - window):]  # 大盘因子测试集，使用 索引 确保完整包含 向前多取的 window
#    test_df = df.iloc[(train_df_end_ix +1 - window):].drop_duplicates()  # 大盘因子测试集，使用 索引 确保完整包含 向前多取的 window
#    test_df = df.query("index > @ train_df_end_ix") # 大盘因子测试集，使用 索引 确保完整包含 向前多取的 window
    
#    train_df = df.query("@start_date <= date and date <= @end_date").dropna(subset=['label']) # 大盘因子训练集
#    test_df = df.query("date > @end_date") # 大盘因子测试集，包含 一个 多取的 向前的 window
    
#    print('\n')
#     print('\n大盘因子预处理模块：标准化、滑动窗口、滑动窗口型大盘因子数据集 拆分为 训练集和测试集')
#     print('大盘因子预处理前训练集train_df长度：',len(train_df))
#     print('大盘因子预处理前测试集test_df长度：',len(test_df))
#    print('大盘因子预处理前训练集train_df：',(train_df)).tail(10)
    
#    # 大盘因子测试集 向前补一个 window，以便以该 window 为基础 预测 原测试集 首个 window 各日对应 label
#    test_df = pd.concat([train_df.tail(window),test_df]) 
    
#    if len(train_df) < train_len:
#        print('大盘因子数据集长度不足！')
#        print('请调增‘指数特征抽取模块’的‘行情数据向前抽取天数’，或调减‘输入层Input’ shape 长度参数，或调减 train_length 参数！')
#        return
    
    train_x = train_df[train_df.columns.difference(['date','instrument','label'] )] # 大盘因子训练集 x，去除 ['date','instrument','label'] 三列
    train_y = train_df['label'] # 大盘因子训练集 y，仅 ['label'] 列
    test_x = test_df[test_df.columns.difference(['date','instrument','label'] )] # 大盘因子测试集 x，去除 ['date','instrument','label'] 三列
    
#     print('大盘因子训练集 train_df：\n',(train_df))
#     print('大盘因子测试集 test_df：\n',(test_df))
    
    # 数据处理：标签独热编码
#    from sklearn.preprocessing import OneHotEncoder
#    onehot_model = OneHotEncoder()
#    train_y = onehot_model.fit_transform(train_df[['label']]).toarray() # 大盘因子训练集 y，仅 ['label'] 列
    
    # 数据处理：标准化
    from sklearn.preprocessing import scale,StandardScaler
    train_x = scale(train_x) 
    test_x = scale(test_x) 
#     print('scale(train_x)：\n{}\n{}'.format(scale(train_x),scale(train_x).shape))
#     print('scale(test_x)：\n{}\n{}'.format(scale(test_x),scale(test_x).shape))
#     scaler = StandardScaler().fit(train_x)
#     train_x = scaler.transform(train_x)  # 与 scale(train_x) 相同
#     test_x = scaler.transform(test_x)    # 与 scale(test_x)  不同
    
#     print('标准化及滑动窗口前大盘因子训练集train_x长度：',len(train_x))
#     print('标准化及滑动窗口前大盘因子训练集train_y长度：',len(train_y))
#     print('标准化及滑动窗口前大盘因子测试集test_x长度：',len(test_x), '\n')
#     print('train_x：\n{}\n{}'.format(train_x,train_x.shape))
#     print('train_y：\n{}\n{}'.format(train_y,train_y.shape))
#     print('test_x：\n{}\n{}'.format(test_x,test_x.shape))
    
    # 数据处理：窗口化，生成 滑动窗口数据，基于前一个 滑动窗口（window） 训练和预测   
#    train_x = [scale(train_x[i:i + window]) for i in range(len(train_x) - window)]  # x 元素形状：(window,len(fields))
#    train_y = [train_y[window + i:window + i + 1].values[0] for i in range(len(train_y) - window)]
    
#    test_x = [scale(test_x[i:i + window]) for i in range(len(test_x) - window)]  # x 元素形状：(window,len(fields))
    
    train_x = [(train_x[i:i + window]) for i in range(len(train_x) - window)]  # x 元素形状：(window,len(fields))
    train_y = [train_y[window + i] for i in range(len(train_y) - window)]
#    train_y = [train_y[window + i:window + i + 1].values[0] for i in range(len(train_y) - window)]
    
    test_x = [(test_x[i:i + window]) for i in range(len(test_x) - window)]  # x 元素形状：(window,len(fields))，经滑动自动缩短前补 window 导致的增量长度

#    train_x = [scale(train_x[i:i+window]) for i in range(len(train_x)-window)]  # x 元素形状：(window,len(fields))
#    test_x = [scale(test_x[i:i+window]) for i in range(len(test_x)-window)]  # x 元素形状：(window,len(fields))
#    train_x = [scale(train_x[i:i+window]) for i in range(len(train_x)-window-1)]  # x 元素形状：(window,len(fields))
#    train_y = [train_y[window+i:window+i+1].values[0] for i in range(len(train_y)-window-1)]
#    train_x = [scale(train_x[i:i+window+1]) for i in range(len(train_x)-window)]  # x 元素形状：(window,len(fields))
#    train_y = [train_y[window+i-1:window+i].values[0] for i in range(len(train_y)-window)]
#    train_y = [train_y[i:i+1].values[0] for i in range(len(train_y)-window)]
#    train_x = [scale(train_x[i:i+window]) for i in range(len(train_x))]  # x 元素形状：(window,len(fields))
#    train_y = [train_y[i] for i in range(len(train_y)-window)]
#    train_y = [train_y[i] for i in range(len(train_y))]
#    test_x = [scale(df_x[i:i+window]) for i in range(len(df_x)-len(test_df),len(df_x)-window)]  # x 元素形状：(window,len(fields))
#    test_x = [scale(df_x[i+1-window:i+1]) for i in range(len(df_x)-len(test_df),len(df_x))]  # x 元素形状：(window,len(fields))
#    test_x = [scale(test_x[i:i+window]) for i in range(len(test_x))]  # x 元素形状：(window,len(fields))

    # LSTM 训练和预测模块接受 数组类型字典 的输入
    train = {'x':np.array(train_x),'y':np.array(train_y)}
    test  = {'x':np.array(test_x)}

#     print('标准化及滑动窗口后大盘因子训练集train_x长度：',len(train_x))
#     print('标准化及滑动窗口后大盘因子训练集train_y长度：',len(train_y))
#     print('标准化及滑动窗口后大盘因子测试集test_x长度：',len(test_x), '\n')
# #    print('标准化及滑动窗口后大盘因子测试集test长度：',len(test['x']))
#     print("train['x']：\n{}\n{}".format(train['x'],train['x'].shape))
#     print("train['y']：\n{}\n{}".format(train['y'],train['y'].shape))
#     print("test['x']：\n{}\n{}".format(test['x'],test['x'].shape))
    
    data_1 = DataSource.write_pickle(train) # 大盘因子滑动窗口训练集，数组类型字典
    data_2 = DataSource.write_pickle(test)  # 大盘因子滑动窗口测试集，数组类型字典，长度已 不含 第一个 前补 window 的长度
#    data_2 = DataSource.write_pickle(test['x'])  # 大盘因子滑动窗口测试集，数组类型字典，长度已 不含 第一个 前补 window 的长度
#    data_3 = DataSource.write_df(test_df) # 大盘因子测试集，丢弃 第一个 前补 window，完整保留原始列   
    data_3 = DataSource.write_df(test_df.iloc[window:]) # 大盘因子测试集，丢弃 第一个 前补 window，完整保留原始列   
#    data_3 = DataSource.write_df(test_df) # 大盘因子测试集，完整保留原始列   
    return Outputs(data_1=data_1, data_2=data_2, data_3=data_3)
# 后处理函数，可选。输入是主函数的输出，可以在这里对数据做处理，或者返回更友好的outputs数据格式。此函数输出不会被缓存。
def m5_post_run_bigquant_run(outputs):
    return outputs

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m3_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
        
    mdl_dict = input_1.read_pickle() # 获取 模型字典
    pred_label = input_2.read_pickle() # 大盘因子预测标签
    df = input_3.read_df() # 大盘因子测试集，含实际标签
    
    # 获取 模型 return_sequences 参数
    return_sequences = mdl_dict['model_graph'].partition('return_sequences:')[2].partition('return_state')[0]
            
#    print('\nLSTM 是否返回整个序列？ ', return_sequences)
        
    df = pd.DataFrame({'pred_label':pred_label[:,-1,-1] if return_sequences.startswith('true') else 
                                    pred_label[:,0], 
                       'date':df.date, 
                       'label':df.label})
    df.sort_values(['date','pred_label'],inplace=True, ascending=[True,False])
    
    return Outputs(data_1=DataSource.write_df(df), data_2=None, data_3=None)


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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m34_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    
    df = input_2.read()
    df.fillna(0,inplace = True)
    pred_label = df['pred_label']
    label = df['label']   
           
    df['方向预测成功与否'] = np.sign(pred_label) == np.sign(label)
    succed = df['方向预测成功与否']
    
    from sklearn.metrics import mean_squared_error
    mse = mean_squared_error(df['label'],df['pred_label'])
    print('MSE:', mse)
    
    data_2 = DataSource.write_df(df)
    data_3 = DataSource.write_pickle(mse)
    return Outputs(data_1=None, data_2=data_2, data_3=data_3)

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


g = T.Graph({

    'm1': 'M.dl_layer_input.v1',
    'm1.shape': '20,30',
    'm1.batch_shape': '',
    'm1.dtype': 'float32',
    'm1.sparse': False,
    'm1.name': '',

    'm13': 'M.cached.v3',
    'm13.input_2': T.Graph.OutputPort('m1.data'),
    'm13.run': m13_run_bigquant_run,
    'm13.post_run': m13_post_run_bigquant_run,
    'm13.input_ports': '',
    'm13.params': '{}',
    'm13.output_ports': '',
    'm13.m_cached': False,

    'm14': 'M.dl_layer_lstm.v1',
    'm14.inputs': T.Graph.OutputPort('m1.data'),
    'm14.units': 5,
    'm14.activation': 'selu',
    'm14.user_activation': m14_user_activation_bigquant_run,
    'm14.recurrent_activation': 'tanh',
    'm14.use_bias': True,
    'm14.kernel_initializer': 'glorot_uniform',
    'm14.recurrent_initializer': 'Orthogonal',
    'm14.bias_initializer': 'Zeros',
    'm14.unit_forget_bias': True,
    'm14.kernel_regularizer': 'None',
    'm14.kernel_regularizer_l1': 0,
    'm14.kernel_regularizer_l2': 0.00001,
    'm14.recurrent_regularizer': 'None',
    'm14.recurrent_regularizer_l1': 0.00001,
    'm14.recurrent_regularizer_l2': 0,
    'm14.bias_regularizer': 'None',
    'm14.bias_regularizer_l1': 0,
    'm14.bias_regularizer_l2': 0,
    'm14.activity_regularizer': 'None',
    'm14.activity_regularizer_l1': 0,
    'm14.activity_regularizer_l2': 0,
    'm14.kernel_constraint': 'None',
    'm14.recurrent_constraint': 'None',
    'm14.bias_constraint': 'None',
    'm14.dropout': 0,
    'm14.recurrent_dropout': 0,
    'm14.return_sequences': False,
    'm14.implementation': '2',
    'm14.name': '',

    'm15': 'M.dl_layer_dropout.v1',
    'm15.inputs': T.Graph.OutputPort('m14.data'),
    'm15.rate': 0.00752,
    'm15.noise_shape': '',
    'm15.seed': 0,
    'm15.name': '',

    'm29': 'M.dl_layer_dense.v1',
    'm29.inputs': T.Graph.OutputPort('m15.data'),
    'm29.units': 5,
    'm29.activation': 'selu',
    'm29.user_activation': m29_user_activation_bigquant_run,
    'm29.use_bias': True,
    'm29.kernel_initializer': 'glorot_uniform',
    'm29.bias_initializer': 'Zeros',
    'm29.kernel_regularizer': 'None',
    'm29.kernel_regularizer_l1': 0.000,
    'm29.kernel_regularizer_l2': 0.0005,
    'm29.bias_regularizer': 'None',
    'm29.bias_regularizer_l1': 0,
    'm29.bias_regularizer_l2': 0,
    'm29.activity_regularizer': 'None',
    'm29.activity_regularizer_l1': 0,
    'm29.activity_regularizer_l2': 0,
    'm29.kernel_constraint': 'None',
    'm29.bias_constraint': 'None',
    'm29.name': '',

    'm16': 'M.dl_layer_dense.v1',
    'm16.inputs': T.Graph.OutputPort('m29.data'),
    'm16.units': 1,
    'm16.activation': 'tanh',
    'm16.user_activation': m16_user_activation_bigquant_run,
    'm16.use_bias': True,
    'm16.kernel_initializer': 'glorot_uniform',
    'm16.bias_initializer': 'Zeros',
    'm16.kernel_regularizer': 'L1L2',
    'm16.kernel_regularizer_l1': 0.000,
    'm16.kernel_regularizer_l2': 0.005,
    'm16.bias_regularizer': 'None',
    'm16.bias_regularizer_l1': 0,
    'm16.bias_regularizer_l2': 0.005,
    'm16.activity_regularizer': 'None',
    'm16.activity_regularizer_l1': 0,
    'm16.activity_regularizer_l2': 0.005,
    'm16.kernel_constraint': 'None',
    'm16.bias_constraint': 'None',
    'm16.name': '',

    'm17': 'M.dl_model_init.v1',
    'm17.inputs': T.Graph.OutputPort('m1.data'),
    'm17.outputs': T.Graph.OutputPort('m16.data'),

    'm6': 'M.input_features.v1',
    'm6.features': """#开盘价/收盘价，最高价/收盘价，最低价/收盘价，收盘价日涨幅，交易量日涨幅，持仓量日涨幅，收盘价5日平均/收盘价，收盘价10日平均/收盘价，收盘价20日平均/收盘价，交易量5日平均/交易量，交易量10日平均/交易量，交易量20日平均/交易量，持仓量5日平均/持仓量，持仓量10日平均/持仓量，持仓量20日平均/持仓量，收盘价14日RSI指数
# 20210831-1:169%
# 20210831-1-ep800:176%
# 20210831-1-ep1000:156%

bm_close= close
bm_open= open
bm_high= high
bm_low= low
bm_amount= amount
bm_volume= volume


bm_amplitude= (high-low)/shift(close, 1)
bm_max_amplitude_5= ts_max(bm_amplitude, 5)
bm_min_amplitude_5= ts_min(bm_amplitude, 5)

#bm_ret_5=close / shift(open, 5) - 1
#bm_ret_10=close / shift(open, 10) - 1
#bm_ret_20=close / shift(open, 20) - 1
bm_mean_close_5= mean(close,5)
#bm_mean_close_10= mean(close,10)
#bm_mean_close_20= mean(close,20)
bm_high_5= ts_max(high, 5)
bm_low_5= ts_min(low, 5)
bm_amount_5= sum(amount,5)
bm_mean_amount_5= mean(amount,5)
#bm_mean_amount_10= mean(amount,10)
bm_volume_5= sum(volume,5)
bm_mean_volume_5= mean(volume,5)
#bm_mean_volume_10= mean(volume,10)

bm_open_close= open / close
bm_high_close= high / close
bm_low_close= low / close
bm_close_delta= close / shift(close, 1)
bm_volume_delta= volume / shift(volume, 1)
bm_mean_close_5_close= mean(close,5) / close
#bm_mean_close_10_close= mean(close,10) / close
#bm_mean_close_20_close= mean(close,20) / close
bm_mean_volume_5_volume= mean(volume,5) / volume
#bm_mean_volume_10_volume= mean(volume,10) / volume
#bm_mean_volume_20_volume= mean(volume,20) / volume

#timeperiod周期的相对强弱指标
#bm_rsi_1= ta_rsi(close, 1) 参数错误
#bm_rsi_5= ta_rsi(close, 5)
bm_rsi_6= ta_rsi(close, 6)
#bm_rsi_14= ta_rsi(close, 14)
#timeperiod周期的顺势指标
#bm_cci_1= ta_cci(high, low, close, 1) 参数错误
bm_cci_5= ta_cci(high, low, close, 5)
bm_cci_10= ta_cci(high, low, close, 10)
#bm_cci_20= ta_cci(high, low, close, 20)
bm_cci_30= ta_cci(high, low, close, 30)
#bm_cci_40= ta_cci(high, low, close, 40)
#timeperiod乖离率
bm_bias_1= ta_bias(close, 1)
bm_bias_5= ta_bias(close, 5)
#bm_bias_10= ta_bias(close, 10)
#timeperiod周期的动量指标
bm_mom_1= ta_mom(close,1)
#bm_mom_5= ta_mom(close,5)
#timeperiod周期的变动率指标
bm_roc_1= ta_roc(close,1)
bm_roc_5= ta_roc(close,5)
#bm_roc_10= ta_roc(close,10)
#bm_willr_5= ta_willr(close, 5)
# bm_diff_close_sma 需要较多的 向前抽取天数
bm_diff_close_sma= close /((ta_sma(close,30) + ta_sma(close,72)) / 2) -1
#timeperiod移动平均线
#bm_ta_ma_5= ta_ma(close, 5)
#timeperiod移动平均线,金叉
bm_ta_ma_golden_cross= ta_ma(close, derive='golden_cross')
#timeperiod移动平均线,死叉
bm_ta_ma_death_cross= ta_ma(close, derive='death_cross')
#timeperiod移动平均线,多头
bm_ma_long_5= ta_ma(close, 5, derive='long')
#timeperiod移动平均线,空头
bm_ma_short_5= ta_ma(close, 5, derive='short')
#bm_ma_long_10= ta_ma(close, 10, derive='long')
#bm_ma_short_10= ta_ma(close, 10, derive='short')
#bm_ma_long_20= ta_ma(close, 20, derive='long')
#bm_ma_short_20= ta_ma(close, 20, derive='short')
#timeperiod平行线差,金叉
#bm_ta_dma_golden_cross= ta_dma(close, 'golden_cross')
#timeperiod平行线差,死叉
#bm_ta_dma_death_cross= ta_dma(close, 'death_cross')
#timeperiod平行线差,多头
#bm_ta_dma_long= ta_dma(close, 'long')
#timeperiod平行线差,空头
#bm_ta_dma_short= ta_dma(close, 'short')

#timeperiod指数平滑移动平均线
#bm_ta_macd_dif= ta_macd_dif(close)
#timeperiodDIF的Ｎ日(默认９日)指数平滑移动平均线
#bm_ta_macd_dea= ta_macd_dea(close)
#timeperiod 2*(DIF-DEA)
#bm_ta_macd_hist= ta_macd_hist(close)
#timeperiod指数平滑移动平均线,金叉
#bm_ta_macd_golden_cross= ta_macd(close,'golden_cross')
#timeperiod指数平滑移动平均线,死叉
#bm_ta_macd_death_cross= ta_macd(close,'death_cross')
#timeperiod指数平滑移动平均线,多头
#bm_ta_macd_long= ta_macd(close,'long')
#timeperiod指数平滑移动平均线,空头
#bm_ta_macd_short= ta_macd(close,'short')
#timeperiod随机指标,金叉
#bm_ta_kdj_golden_cross_5_3_3= ta_kdj(high, low, close, 5, 3, 3, 'golden_cross')
#timeperiod随机指标,死叉
#bm_ta_kdj_death_cross_5_3_3= ta_kdj(high, low, close, 5, 3, 3, 'death_cross')
#timeperiod随机指标,多头
#bm_ta_kdj_long_5_3_3= ta_kdj(high, low, close, 5, 3, 3, 'long')
#timeperiod随机指标,空头
#bm_ta_kdj_short_5_3_3= ta_kdj(high, low, close, 5, 3, 3, 'short')
#timeperiod随机指标,买入信号
#bm_ta_kdj_buy_5_3_3= ta_kdj(high, low, close, 5, 3, 3, 'buy')
#timeperiod随机指标,卖出信号
#bm_ta_kdj_sell_5_3_3= ta_kdj(high, low, close, 5, 3, 3, 'sell')
#timeperiodKDJ指标的K值
#bm_ta_kdj_k_5_3_3= ta_kdj_k(high, low, close, 5, 3)
#timeperiodKDJ指标的D值
#bm_ta_kdj_d_5_3_3= ta_kdj_d(high, low, close, 5, 3, 3)
#timeperiodKDJ指标的J值
#bm_ta_kdj_j_5_3_3= ta_kdj_j(high, low, close, 5, 3, 3)
#ta_bbands_u(close, timeperiod),#timeperiod布林线上线
#ta_bbands_m(close, timeperiod),#timeperiod布林线中线
#ta_bbands_l(close, timeperiod),#timeperiod布林线下线


# timeperiod 周期的平均波幅指标
#bm_ta_atr_1= ta_atr(high, low, close, 1) 
#bm_ta_atr_5= ta_atr(high, low, close, 5) 
# timeperiod 周期的平均趋向指数
bm_ta_adx_5= ta_adx(high, low, close, 5)
#bm_ta_adx_14= ta_adx(high, low, close, 14)
# timeperiod 周期的平均趋向指数
#bm_ta_adxr_10= ta_adxr(high, low, close, 10)
#bm_ta_adxr_5= ta_adxr(high, low, close, 5)
# 资金流量指标
#bm_ta_MFI_5= ta_MFI(high, low, close, volume, 5)
#timeperiod周期的回归斜率
#bm_ta_beta= ta_beta(x, y, timeperiod)
#timeperiod多空指数,多头市场
#bm_ta_bbi_long= ta_bbi(close, 'long')
#timeperiod多空指数,空头市场
#bm_ta_bbi_short= ta_bbi(close, 'short')


########################## 国泰君安 alpha191 因子   #################################
# 因大盘因子只涉及大盘数据，涉及横截面排名计算的因子无效，可考虑尝试剔除横截面计算的修正因子

bm_vwap=amount / volume
##ret=close_0 / close_1 - 1
bm_dtm=where(open<=delay(open,1),0,max((high-open),(open-delay(open,1))))
bm_dbm=where(open>=delay(open,1),0,max((open-low),(open-delay(open,1))))
bm_tr=max(max(high-low,abs(high-delay(close,1))),abs(low-delay(close,1)))
bm_hd=high-delay(high,1)
bm_ld=delay(low,1)-low 
bm_ret= close/shift(close, 1) - 1

# alpha_001：刻画成交量变化排名与日内收益率排名的偏离程度，表现为成交量变化排名上升，日内收益率排名下降；成交量变化排名下降，日内收益率排名上升。
##bm_alpha_001=-1*correlation(rank(delta(log(volume),1)),rank(((close-open)/open)),6)
bm_alpha_001=-1*correlation((delta(log(volume),1)),(((close-open)/open)),6)

# alpha_002：刻画多空失衡变动情况，用(CLOSE - LOW) - (HIGH - CLOSE)) / (HIGH - LOW)表示多空力量不平衡度。
bm_alpha_002=-1*delta((((close-low)-(high-close))/(high-low)),1)            

# alpha_003：刻画短期（6天）内累计的按最高最低价调整前收盘价后的收盘价变动情况
#bm_alpha_003=sum(where(close==delay(close,1),0,close)-where(close>delay(close,1),min(low,delay(close,1)),max(high,delay(close,1))),6)
bm_alpha_003=sum(where(close==delay(close,1),\
                    0,\
                    close-where(close>delay(close,1),\
                                min(low,delay(close,1)),\
                                max(high,delay(close,1)))),6)

# alpha_004：区间突破因子。价格（2日均价）突破布林带（8日）上限取-1，价格突破布林带下限取1，价格在布林带区间内时，成交量放大或不变取1，成交量缩小取-1
bm_alpha_004=where(((sum(close,8)/8)+std(close,8))<(sum(close,2)/2),\
                -1,\
                where((sum(close,2)/2)<((sum(close,8)/8)-std(close,8)),\
                      1,\
                      where((volume/mean(volume,20))>=1,\
                            1,\
                            -1)))

# alpha_005：短期（3天）内成交量、高点最大偏离程度。表现为短周期内（5天）成交量上升，最高价下降；或者成交量下降，最高价上升
##bm_alpha_005=-1*ts_max(correlation(ts_rank(volume,5),ts_rank(high,5),5),3)
bm_alpha_005=-1*(correlation(delta(log(volume),1),delta(high,1),6))

# alpha_006：刻画当前价格位置和此前位置价格的差距，进行动量交易
##bm_alpha_006=-1*rank(sign(delta((((open*0.85)+(high*0.15))),4)))
##bm_alpha_006=-1*(sign(delta((((open*0.85)+(high*0.15))),4)))
bm_alpha_006=-1*((delta((((open*0.85)+(high*0.15))),4)))



##bm_alpha_007=((rank(max((bm_vwap-close),3))+rank(min((bm_vwap-close),3)))*rank(delta(volume,3)))

##bm_alpha_008=-1*rank(delta(((((high+low)/2)*0.2)+(bm_vwap*0.8)),4))
#bm_alpha_008=-1*ts_rank(delta(((((high+low)/2)*0.2)+(bm_vwap*0.8)),4),6)
bm_alpha_008=-1*(delta(((((high+low)/2)*0.2)+(bm_vwap*0.8)),4))

##bm_alpha_010=(rank(max(where((bm_ret<0),std(bm_ret,20),close)**2,5)))
bm_alpha_010=((max(where((bm_ret<0),std(bm_ret,20),close)**2,5)))

##bm_alpha_041=(rank(max(delta((bm_vwap),3),5))*(-1))
bm_alpha_041=((max(delta((bm_vwap),3),5))*(-1))
""",

    'm7': 'M.input_features.v1',
    'm7.features': """# 大盘因子标签

#bm_label=shift(close, -1) / close - 1  # 次日收益率
bm_label=shift(close, -2) / close - 1  # 2日收益率
#bm_label=shift(close, -1) - close 
#bm_label=log(shift(close, -1) / close) 
""",

    'm33': 'M.instruments.v2',
    'm33.start_date': '2021-10-01',
    'm33.end_date': '2022-04-20',
    'm33.market': 'CN_STOCK_A',
    'm33.instrument_list': '',
    'm33.max_count': 0,

    'm22': 'M.index_feature_extract.v3',
    'm22.input_1': T.Graph.OutputPort('m33.data'),
    'm22.input_2': T.Graph.OutputPort('m7.data'),
    'm22.before_days': 200,
    'm22.index': '000001.HIX',

    'm21': 'M.dropnan.v2',
    'm21.input_data': T.Graph.OutputPort('m22.data_1'),

    'm19': 'M.index_feature_extract.v3',
    'm19.input_1': T.Graph.OutputPort('m33.data'),
    'm19.input_2': T.Graph.OutputPort('m6.data'),
    'm19.before_days': 200,
    'm19.index': '000001.HIX',

    'm20': 'M.dropnan.v2',
    'm20.input_data': T.Graph.OutputPort('m19.data_1'),

    'm27': 'M.del_data_before_startdate.v13',
    'm27.input_1': T.Graph.OutputPort('m21.data'),
    'm27.input_2': T.Graph.OutputPort('m33.data'),
    'm27.input_3': T.Graph.OutputPort('m13.data_2'),
    'm27.before_start_date_days': 0,

    'm28': 'M.cached.v3',
    'm28.input_2': T.Graph.OutputPort('m33.data'),
    'm28.run': m28_run_bigquant_run,
    'm28.post_run': m28_post_run_bigquant_run,
    'm28.input_ports': '',
    'm28.params': """{
 'start_date' : '2006-01-01',   
 'end_date'   : '2019-12-31'  
}""",
    'm28.output_ports': '',

    'm9': 'M.index_feature_extract.v3',
    'm9.input_1': T.Graph.OutputPort('m28.data_2'),
    'm9.input_2': T.Graph.OutputPort('m6.data'),
    'm9.before_days': 200,
    'm9.index': '000001.HIX',

    'm10': 'M.dropnan.v2',
    'm10.input_data': T.Graph.OutputPort('m9.data_1'),

    'm25': 'M.del_data_before_startdate.v5',
    'm25.input_1': T.Graph.OutputPort('m10.data'),
    'm25.input_2': T.Graph.OutputPort('m28.data_2'),

    'm39': 'M.cached.v3',
    'm39.input_2': T.Graph.OutputPort('m28.data_2'),
    'm39.run': m39_run_bigquant_run,
    'm39.post_run': m39_post_run_bigquant_run,
    'm39.input_ports': '',
    'm39.params': '{}',
    'm39.output_ports': '',

    'm4': 'M.index_feature_extract.v3',
    'm4.input_1': T.Graph.OutputPort('m39.data_2'),
    'm4.input_2': T.Graph.OutputPort('m7.data'),
    'm4.before_days': 200,
    'm4.index': '000001.HIX',

    'm40': 'M.cached.v3',
    'm40.input_1': T.Graph.OutputPort('m28.data_2'),
    'm40.input_2': T.Graph.OutputPort('m4.data_1'),
    'm40.input_3': T.Graph.OutputPort('m33.data'),
    'm40.run': m40_run_bigquant_run,
    'm40.post_run': m40_post_run_bigquant_run,
    'm40.input_ports': '',
    'm40.params': '{}',
    'm40.output_ports': '',

    'm8': 'M.dropnan.v2',
    'm8.input_data': T.Graph.OutputPort('m40.data_2'),

    'm24': 'M.del_data_before_startdate.v5',
    'm24.input_1': T.Graph.OutputPort('m8.data'),
    'm24.input_2': T.Graph.OutputPort('m28.data_2'),

    'm23': 'M.concat.v3',
    'm23.input_data_1': T.Graph.OutputPort('m24.data'),
    'm23.input_data_2': T.Graph.OutputPort('m27.data'),

    'm26': 'M.del_data_before_startdate.v13',
    'm26.input_1': T.Graph.OutputPort('m20.data'),
    'm26.input_2': T.Graph.OutputPort('m33.data'),
    'm26.input_3': T.Graph.OutputPort('m13.data_2'),
    'm26.before_start_date_days': 0,

    'm32': 'M.dataclean.v46',
    'm32.feature_data1': T.Graph.OutputPort('m25.data'),
    'm32.feature_data2': T.Graph.OutputPort('m26.data'),
    'm32.nan_method': '中位数填充',
    'm32.outlier_method': 'MAD法',
    'm32.n_components': 30,
    'm32.grp_len': 10,
    'm32.if_nan': False,
    'm32.if_inf': False,
    'm32.if_outlier': False,
    'm32.if_neutralize': False,
    'm32.neutral_feature_remained': False,
    'm32.if_standardize': False,
    'm32.if_pca': True,

    'm31': 'M.concat.v3',
    'm31.input_data_1': T.Graph.OutputPort('m32.cleaned_data1'),
    'm31.input_data_2': T.Graph.OutputPort('m32.cleaned_data2'),

    'm11': 'M.join.v3',
    'm11.data1': T.Graph.OutputPort('m23.data'),
    'm11.data2': T.Graph.OutputPort('m31.data'),
    'm11.on': 'date',
    'm11.how': 'right',
    'm11.sort': True,

    'm12': 'M.sort.v4',
    'm12.input_ds': T.Graph.OutputPort('m11.data'),
    'm12.sort_by': 'date',
    'm12.group_by': '',
    'm12.keep_columns': '--',
    'm12.ascending': True,

    'm5': 'M.cached.v3',
    'm5.input_1': T.Graph.OutputPort('m13.data_2'),
    'm5.input_2': T.Graph.OutputPort('m12.sorted_data'),
    'm5.input_3': T.Graph.OutputPort('m28.data_2'),
    'm5.run': m5_run_bigquant_run,
    'm5.post_run': m5_post_run_bigquant_run,
    'm5.input_ports': '',
    'm5.params': '',
    'm5.output_ports': 'data_1,data_2,data_3',
    'm5.m_cached': False,

    'm42': 'M.DL_train_or_train_go_on.v29',
    'm42.input_model': T.Graph.OutputPort('m17.data'),
    'm42.training_data': T.Graph.OutputPort('m5.data_1'),
    'm42.path': '/home/bigquant/work/userlib/',
    'm42.before_train_model_file_name': '',
    'm42.after_train_model_file_name': '',
    'm42.seed': 0,
    'm42.optimizer': 'Nadam',
    'm42.loss': 'mean_squared_error',
    'm42.metrics': ['MAE'],
    'm42.batch_size': 4096,
    'm42.epochs': 10,
    'm42.verbose': '2:每个epoch输出一行记录',
    'm42.validation_split': 0.0,
    'm42.initial_epoch': 000,

    'm2': 'M.dl_model_predict.v1',
    'm2.trained_model': T.Graph.OutputPort('m42.trained_model'),
    'm2.input_data': T.Graph.OutputPort('m5.data_2'),
    'm2.batch_size': 32,
    'm2.n_gpus': 0,
    'm2.verbose': '2:每个epoch输出一行记录',

    'm3': 'M.cached.v3',
    'm3.input_1': T.Graph.OutputPort('m42.trained_model'),
    'm3.input_2': T.Graph.OutputPort('m2.data'),
    'm3.input_3': T.Graph.OutputPort('m5.data_3'),
    'm3.run': m3_run_bigquant_run,
    'm3.post_run': m3_post_run_bigquant_run,
    'm3.input_ports': '',
    'm3.params': '{}',
    'm3.output_ports': '',
    'm3.m_cached': False,

    'm34': 'M.cached.v3',
    'm34.input_2': T.Graph.OutputPort('m3.data_1'),
    'm34.run': m34_run_bigquant_run,
    'm34.post_run': m34_post_run_bigquant_run,
    'm34.input_ports': '',
    'm34.params': '{}',
    'm34.output_ports': '',
    'm34.m_cached': False,
})

# g.run({})


def m18_param_grid_builder_bigquant_run():
    param_grid = {}

    # 在这里设置需要调优的参数备选
    # param_grid['m3.features'] = ['close_1/close_0', 'close_2/close_0\nclose_3/close_0']
    # param_grid['m6.number_of_trees'] = [5, 10, 20]
#     param_grid['m1.shape'] = [(2,30), (3,30), (4,30), (5,30), (6,30), (7,30), (8,30), (9,30), (10,30), (20,30)]
#     param_grid['m15.rate'] = [0.01, 0.05, 0.00748, 0.00749, 0.0075, 0.00751, 0.00752]
    param_grid['m15.rate'] = [0.00752]

    return param_grid

def m18_scoring_bigquant_run(result):
    mse = result.get('m34').data_3.read()
    return mse



m18 = M.hyper_parameter_search.v1(
    param_grid_builder=m18_param_grid_builder_bigquant_run,
    scoring=m18_scoring_bigquant_run,
    search_algorithm='网格搜索',
    search_iterations=1,
    random_state=0,
    workers=1,
    worker_distributed_run=True,
    worker_silent=True,
    run_now=True,
    bq_graph=g
)

[2022-05-04 17:45:36.469812] INFO: cached.v3.f2eaf35e: 任务状态: Pending

[2022-05-04 17:45:46.503250] INFO: cached.v3.f2eaf35e: 任务状态: Running

[2022-05-04 17:46:26.631460] INFO: cached.v3.f2eaf35e: 任务状态: Succeeded

[2022-05-04 17:46:26.947920] INFO: cached.v3.10fdfb02: 任务状态: Pending

[2022-05-04 17:46:36.982147] INFO: cached.v3.10fdfb02: 任务状态: Running

[2022-05-04 17:46:57.051653] INFO: cached.v3.10fdfb02: 任务状态: Succeeded

[2022-05-04 17:46:57.065986] INFO: moduleinvoker: hyper_parameter_search.v1 运行完成[81.27332s].

Fitting 1 folds for each of 1 candidates, totalling 1 fits
[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[CV 1/1; 1/1] START m15.rate=0.00752............................................

[CV 1/1; 1/1] END ..........................m15.rate=0.00752; total time=  50.7s
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:   50.7s remaining:    0.0s
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:   50.7s finished

In [11]:

m18.result.best_score_

Out[11]:

0.2388823926448822

In [12]:

m18.result.best_params_

Out[12]:

{'m15.rate': 0.00752}