【专题研究】基于一维CNN模型的智能选股策略

iQuant · 2019-05-29 09:54:52 UTC

这是本系列专题研究的第四篇：基于卷积神经网络CNN的深度学习因子选股模型。卷积神经网络（Convolutional Neural Network, CNN），是计算机视觉研究和应用领域中最具影响力的模型之一。同样，如果将时间看作一个空间维度，类似于二维图像的高度或宽度，CNN也可以对时间序列处理产生令人惊喜的效果。本文首先大致介绍了CNN的原理，然后详细解释了一维CNN模型如何进行应用于时间序列并进行特征选取，最后以一个实例展示一维CNN模型在因子选股方面的应用。

$$目录$$
1、CNN原理介绍
1.1 反向传播算法
 1.2 CNN图像识别原理
2、一维CNN在时间序列中的应用
2.1 一维卷积
 2.2 一维池化
3、实例：CNN模型选股

1、CNN原理介绍

1.1 反向传播算法

反向传播（Backpropagation，缩写为BP）是“误差反向传播”的简称，是一种与最优化方法（如梯度下降法）结合使用的，用来训练人工神经网络的常见方法。该方法对网络中所有权重计算损失函数的梯度，这个梯度会反馈给最优化方法，用来更新权值以最小化损失函数。

一句话解释：前向传递输入信号直至输出产生误差，反向传播误差信息更新权重矩阵。

以没有隐层的神经网络为例，如逻辑回归，其中小黄帽代表输出层节点，左侧接受输入信号，右侧产生输出结果，小蓝猫则代表了误差，指导参数往更优的方向调整。由于小蓝猫可以直接将误差反馈给小黄帽，同时只有一个参数矩阵和小黄帽直接相连，所以可以直接通过误差进行参数优化（实线），迭代几轮，误差会降低到最小。

PNG
$$图1：无隐层反向传播算法示意$$

1.2 CNN图像识别原理

卷积神经网络的结构模仿了眼睛的视觉神经的工作原理。对于眼睛来说，大量的视觉神经分工协作，各自负责一小部分区域的视觉图像，再将图像的各种局部特征抽象组合到高层的视觉概念，传送到大脑使人类产生视觉。卷积神经网络也是类似，它包含了至少一层卷积层，由多个卷积核对图像的局部区域进行特征提取，最后进行合成。

以经典的LeNet-5模型为例：

PNG

$$图2：LeNet-5卷积神经网络模型$$

原始输入数据（图1中的input）为二维图像，横轴和纵轴分别是图像的高度和宽度的像素点，为了识别该图像，模型依次完成以下步骤：

第一层卷积层（图1中的conv1）进行卷积运算。该层由若干卷积核组成，每个卷积核的参数都是通过反向传播算法优化得到的。卷积核的目的是通过扫描整张图片提取不同特征，第一层卷积层可能只能提取一些低级的特征如边缘、线条和角等层级。在卷积层之后都会使用非线性激活函数（如RELU，tanh 等）对特征进行非线性变换。
第一层池化层（图1中的pool1）进行池化运算。通常在卷积层之后会得到维度很大的特征，池化层可以非常有效地缩小参数矩阵的尺寸，从而减少最后全连层中的参数数量。使用池化层既可以加快计算速度也有防止过拟合的作用。一般池化层将特征切成几个区域，取其最大值或平均值，得到新的、维度较小的特征。池化层其实是在对具有高维特征的图片进行特征降维（subsample）。
第二层卷积层和第二层池化层（图1中的conv2 和pool2) 进行进一步的特征提取和特征降维，得到更加高层和抽象的特征。
全连接层（图1中的hidden4 和full connection) 把卷积核池化得到的特征展平为一维特征，用来进行最后的训练和预测。

总结而言，卷积层进行特征提取，池化层进行特征降维以防止过拟合。CNN通过上述过程实现了图像识别：
PNG
$$图3：CNN图像识别$$
通过第一层卷积识别边缘等低级特征，池化后通过第二层卷积识别眼睛、鼻子等小区域器官这样的中级特征，池化，最后通过第三层卷积识别整个面容这样的高级特征，最后通过全连接层整合，识别出最终的图像。

2、一维CNN在时间序列中的应用

CNN最主要应用于计算机视觉领域，通过卷积运算，从二维图像中提取特征，最终实现优秀的图像识别功能。对于这样一种优秀的算法，我们自然会思考如何将其运用到时间序列分析中。很容易想到，有两种思路：

将一维的时间序列二维化。考虑历史截面期，将每个样本的特征数据组织成二维形式，尝试构建“特征图片”。如总共有3000个样本，每个样本有10个特征，那就考虑5个截面期，每个样本整合5个截面得到一张“特征图片”，用时间数据作为图片标签。如此，可以得到3000个带时间特征的图片，然后运用二维CNN处理。这种方法的具体实现可参见华泰证券的研报《人工智能选股之卷积神经网络》
探索一维CNN在时间序列上的运用。本篇研究就是基于这个思路。如果将时间理解为图像的长或者宽，其他特征理解为一个维度，那么就可以用一维CNN进行处理。

2.1 一维卷积

一维卷积，也就是从序列中按照一定大小的窗口提取局部一维序列段(即子序列)，然后与一个权重做点积，然后输出为新序列上的一个部分。以大小为5的时间窗口为例：

$$图4：一维CNN的一层卷积示意$$

2.2 一维池化

同二维池化一样，一维池化的目的也是为了对卷积的结果“模糊化”，归纳局部区域内的统计特征，并且通过降维避免过拟合。一维池化是从输入中提取一维序列段(即子序列)，然后输出其最大值(最大池化)或平均值(平均池化)，降低一维输入的长度(子采样)。

3、实例：CNN模型选股

%E6%B5%81%E7%A8%8B%E5%9B%BE
$$图5：CNN智能选股策略$$

如图5所示，一维CNN选股策略构建包含下列步骤：

获取数据 ：A股所有股票。
特征和标签提取 ：计算7个因子作为样本特征；计算第2日的个股收益，极值处理后分成20类作为标签。
特征预处理 ：进行缺失值处理；去掉特征异常的股票，比如某个特征值高于99.5%或低于0.5%的；标准化处理，去除特征量纲/数量级差异的影响。
序列窗口滚动 ：窗口大小设置为5，滚动切割。
搭建CNN模型 ：构建一个简单的两层一维卷积神经网络预测股票价格。
模型训练与预测 ：使用CNN模型进行训练和预测；可以尝试多种激活函数，策略默认为relu。
策略回测 ：利用2010到2014年数据进行训练，预测2015到2017年的股票表现。每日买入预测排名最靠前的20只股票，至少持有2日，同时淘汰排名靠后的股票。具体而言，预测排名越靠前，分配到的资金越多且最大资金占用比例不超过20%；初始5日平均分配资金，之后，尽量使用剩余资金（这里设置最多用等量的1.5倍）。
模型评价 ：查看模型回测结果。

一维CNN模型的参数如下：

输入数据：输入是形状为 (samples, time, features)的三维张量，并返回类似形状的三维张量。卷积窗口是时间轴上的一维窗口(时间轴是输入张量的第二个轴)。7个因子，时间窗口为5，因此输入7*5的一个矩阵。
卷积层：2层一维卷积层（Conv1D层），每层包含20 个卷积核。激活函数采用relu。同时选择“valid”参数，只进行有效卷积，对边界数据不处理。卷积核权重使用glorot_uniform初始化方法，偏置向量使用Zeros初始化方法。
池化层：2层池化层。
全连接层：激活函数linear。权重使用glorot_uniform初始化方法，偏置向量使用Zeros初始化方法。
训练次数率：epochs值为5，共训练5轮，以mae作为评估指标。
优化器和：RMSProp。
损失函数：均方误差MSE。

预测结果如下：
prediction
$$图6：CNN模型预测结果$$

回测结果如下：

$$图7：CNN模型回测结果$$

可以看到，CNN的回测结果还是非常惊喜的，相比于基准收益有着非常突出的表现。所以，我们认为将CNN卷积神经网络应用于资本市场因子选股是很有前景的。在本次的策略中，我们运用了两层的一维CNN模型，具体的卷积层数、模型参数有非常大的调整空间，欢迎大家尝试。

克隆策略

In [2]:

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


# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m4_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    df =  input_1.read_pickle()
    feature_len = len(input_2.read_pickle())
    
    
    df['x'] = df['x'].reshape(df['x'].shape[0], int(feature_len), int(df['x'].shape[1]/feature_len))
    
    data_1 = DataSource.write_pickle(df)
    return Outputs(data_1=data_1)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m8_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    df =  input_1.read_pickle()
    feature_len = len(input_2.read_pickle())
    
    
    df['x'] = df['x'].reshape(df['x'].shape[0], int(feature_len), int(df['x'].shape[1]/feature_len))
    
    data_1 = DataSource.write_pickle(df)
    return Outputs(data_1=data_1)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m24_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    pred_label = input_1.read_pickle()
    df = input_2.read_df()
    df = pd.DataFrame({'pred_label':pred_label[:,0], 'instrument':df.instrument, 'date':df.date})
    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 m24_post_run_bigquant_run(outputs):
    return outputs

# 回测引擎：初始化函数，只执行一次
def m19_initialize_bigquant_run(context):
    # 加载预测数据
    context.ranker_prediction = context.options['data'].read_df()

    # 系统已经设置了默认的交易手续费和滑点，要修改手续费可使用如下函数
    context.set_commission(PerOrder(buy_cost=0.0003, sell_cost=0.0013, min_cost=5))
    # 预测数据，通过options传入进来，使用 read_df 函数，加载到内存 (DataFrame)
    # 设置买入的股票数量，这里买入预测股票列表排名靠前的5只
    stock_count = 20
    # 每只的股票的权重，如下的权重分配会使得靠前的股票分配多一点的资金，[0.339160, 0.213986, 0.169580, ..]
    context.stock_weights = T.norm([1 / math.log(i + 2) for i in range(0, stock_count)])
    # 设置每只股票占用的最大资金比例
    context.max_cash_per_instrument = 0.2
    context.options['hold_days'] = 2

# 回测引擎：每日数据处理函数，每天执行一次
def m19_handle_data_bigquant_run(context, data):
    # 按日期过滤得到今日的预测数据
    ranker_prediction = context.ranker_prediction[
        context.ranker_prediction.date == data.current_dt.strftime('%Y-%m-%d')]

    # 1. 资金分配
    # 平均持仓时间是hold_days，每日都将买入股票，每日预期使用 1/hold_days 的资金
    # 实际操作中，会存在一定的买入误差，所以在前hold_days天，等量使用资金；之后，尽量使用剩余资金（这里设置最多用等量的1.5倍）
    is_staging = context.trading_day_index < context.options['hold_days'] # 是否在建仓期间（前 hold_days 天）
    cash_avg = context.portfolio.portfolio_value / context.options['hold_days']
    cash_for_buy = min(context.portfolio.cash, (1 if is_staging else 1.5) * cash_avg)
    cash_for_sell = cash_avg - (context.portfolio.cash - cash_for_buy)
    positions = {e.symbol: p.amount * p.last_sale_price
                 for e, p in context.perf_tracker.position_tracker.positions.items()}

    # 2. 生成卖出订单：hold_days天之后才开始卖出；对持仓的股票，按机器学习算法预测的排序末位淘汰
    if not is_staging and cash_for_sell > 0:
        equities = {e.symbol: e for e, p in context.perf_tracker.position_tracker.positions.items()}
        instruments = list(reversed(list(ranker_prediction.instrument[ranker_prediction.instrument.apply(
                lambda x: x in equities and not context.has_unfinished_sell_order(equities[x]))])))
        # print('rank order for sell %s' % instruments)
        for instrument in instruments:
            context.order_target(context.symbol(instrument), 0)
            cash_for_sell -= positions[instrument]
            if cash_for_sell <= 0:
                break

    # 3. 生成买入订单：按机器学习算法预测的排序，买入前面的stock_count只股票
    buy_cash_weights = context.stock_weights
    buy_instruments = list(ranker_prediction.instrument[:len(buy_cash_weights)])
    max_cash_per_instrument = context.portfolio.portfolio_value * context.max_cash_per_instrument
    for i, instrument in enumerate(buy_instruments):
        cash = cash_for_buy * buy_cash_weights[i]
        if cash > max_cash_per_instrument - positions.get(instrument, 0):
            # 确保股票持仓量不会超过每次股票最大的占用资金量
            cash = max_cash_per_instrument - positions.get(instrument, 0)
        if cash > 0:
            context.order_value(context.symbol(instrument), cash)

# 回测引擎：准备数据，只执行一次
def m19_prepare_bigquant_run(context):
    pass


m1 = M.instruments.v2(
    start_date='2010-01-01',
    end_date='2015-01-01',
    market='CN_STOCK_A',
    instrument_list=' ',
    max_count=0
)

m2 = M.advanced_auto_labeler.v2(
    instruments=m1.data,
    label_expr="""# #号开始的表示注释
# 0. 每行一个，顺序执行，从第二个开始，可以使用label字段
# 1. 可用数据字段见 https://bigquant.com/docs/data_history_data.html
#   添加benchmark_前缀，可使用对应的benchmark数据
# 2. 可用操作符和函数见 `表达式引擎 <https://bigquant.com/docs/big_expr.html>`_

# 计算收益：5日收盘价(作为卖出价格)除以明日开盘价(作为买入价格)
shift(close, -2) / shift(open, -1)-1

# 极值处理：用1%和99%分位的值做clip
clip(label, all_quantile(label, 0.01), all_quantile(label, 0.99))

# 过滤掉一字涨停的情况 (设置label为NaN，在后续处理和训练中会忽略NaN的label)
where(shift(high, -1) == shift(low, -1), NaN, label)
""",
    start_date='',
    end_date='',
    benchmark='000300.SHA',
    drop_na_label=True,
    cast_label_int=False
)

m13 = M.standardlize.v8(
    input_1=m2.data,
    columns_input='label'
)

m3 = M.input_features.v1(
    features="""close_0/mean(close_0,5)
close_0/mean(close_0,10)
close_0/mean(close_0,20)
close_0/open_0
open_0/mean(close_0,5)
open_0/mean(close_0,10)
open_0/mean(close_0,20)"""
)

m15 = M.general_feature_extractor.v7(
    instruments=m1.data,
    features=m3.data,
    start_date='',
    end_date='',
    before_start_days=0
)

m16 = M.derived_feature_extractor.v3(
    input_data=m15.data,
    features=m3.data,
    date_col='date',
    instrument_col='instrument',
    drop_na=True,
    remove_extra_columns=False
)

m14 = M.standardlize.v8(
    input_1=m16.data,
    input_2=m3.data,
    columns_input=''
)

m7 = M.join.v3(
    data1=m13.data,
    data2=m14.data,
    on='date,instrument',
    how='inner',
    sort=False
)

m26 = M.dl_convert_to_bin.v2(
    input_data=m7.data,
    features=m3.data,
    window_size=5,
    feature_clip=5,
    flatten=True,
    window_along_col='instrument'
)

m4 = M.cached.v3(
    input_1=m26.data,
    input_2=m3.data,
    run=m4_run_bigquant_run,
    post_run=m4_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m9 = M.instruments.v2(
    start_date=T.live_run_param('trading_date', '2015-01-01'),
    end_date=T.live_run_param('trading_date', '2017-01-01'),
    market='CN_STOCK_A',
    instrument_list='',
    max_count=0
)

m17 = M.general_feature_extractor.v7(
    instruments=m9.data,
    features=m3.data,
    start_date='',
    end_date='',
    before_start_days=0
)

m18 = M.derived_feature_extractor.v3(
    input_data=m17.data,
    features=m3.data,
    date_col='date',
    instrument_col='instrument',
    drop_na=True,
    remove_extra_columns=False
)

m25 = M.standardlize.v8(
    input_1=m18.data,
    input_2=m3.data,
    columns_input=''
)

m27 = M.dl_convert_to_bin.v2(
    input_data=m25.data,
    features=m3.data,
    window_size=5,
    feature_clip=5,
    flatten=True,
    window_along_col='instrument'
)

m8 = M.cached.v3(
    input_1=m27.data,
    input_2=m3.data,
    run=m8_run_bigquant_run,
    post_run=m8_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m6 = M.dl_layer_input.v1(
    shape='7,5',
    batch_shape='',
    dtype='float32',
    sparse=False,
    name=''
)

m10 = M.dl_layer_conv1d.v1(
    inputs=m6.data,
    filters=20,
    kernel_size='3',
    strides='1',
    padding='valid',
    dilation_rate=1,
    activation='relu',
    use_bias=True,
    kernel_initializer='glorot_uniform',
    bias_initializer='Zeros',
    kernel_regularizer='None',
    kernel_regularizer_l1=0,
    kernel_regularizer_l2=0,
    bias_regularizer='None',
    bias_regularizer_l1=0,
    bias_regularizer_l2=0,
    activity_regularizer='None',
    activity_regularizer_l1=0,
    activity_regularizer_l2=0,
    kernel_constraint='None',
    bias_constraint='None',
    name=''
)

m12 = M.dl_layer_maxpooling1d.v1(
    inputs=m10.data,
    pool_size=1,
    padding='valid',
    name=''
)

m32 = M.dl_layer_conv1d.v1(
    inputs=m12.data,
    filters=20,
    kernel_size='3',
    strides='1',
    padding='valid',
    dilation_rate=1,
    activation='relu',
    use_bias=True,
    kernel_initializer='glorot_uniform',
    bias_initializer='Zeros',
    kernel_regularizer='None',
    kernel_regularizer_l1=0,
    kernel_regularizer_l2=0,
    bias_regularizer='None',
    bias_regularizer_l1=0,
    bias_regularizer_l2=0,
    activity_regularizer='None',
    activity_regularizer_l1=0,
    activity_regularizer_l2=0,
    kernel_constraint='None',
    bias_constraint='None',
    name=''
)

m33 = M.dl_layer_maxpooling1d.v1(
    inputs=m32.data,
    pool_size=1,
    padding='valid',
    name=''
)

m28 = M.dl_layer_globalmaxpooling1d.v1(
    inputs=m33.data,
    name=''
)

m30 = M.dl_layer_dense.v1(
    inputs=m28.data,
    units=1,
    activation='linear',
    use_bias=True,
    kernel_initializer='glorot_uniform',
    bias_initializer='Zeros',
    kernel_regularizer='None',
    kernel_regularizer_l1=0,
    kernel_regularizer_l2=0,
    bias_regularizer='None',
    bias_regularizer_l1=0,
    bias_regularizer_l2=0,
    activity_regularizer='None',
    activity_regularizer_l1=0,
    activity_regularizer_l2=0,
    kernel_constraint='None',
    bias_constraint='None',
    name=''
)

m34 = M.dl_model_init.v1(
    inputs=m6.data,
    outputs=m30.data
)

m5 = M.dl_model_train.v1(
    input_model=m34.data,
    training_data=m4.data_1,
    optimizer='RMSprop',
    loss='mean_squared_error',
    metrics='mae',
    batch_size=256,
    epochs=5,
    n_gpus=0,
    verbose='2:每个epoch输出一行记录'
)

m11 = M.dl_model_predict.v1(
    trained_model=m5.data,
    input_data=m8.data_1,
    batch_size=1024,
    n_gpus=0,
    verbose='2:每个epoch输出一行记录'
)

m24 = M.cached.v3(
    input_1=m11.data,
    input_2=m18.data,
    run=m24_run_bigquant_run,
    post_run=m24_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m19 = M.trade.v4(
    instruments=m9.data,
    options_data=m24.data_1,
    start_date='',
    end_date='',
    initialize=m19_initialize_bigquant_run,
    handle_data=m19_handle_data_bigquant_run,
    prepare=m19_prepare_bigquant_run,
    volume_limit=0.025,
    order_price_field_buy='open',
    order_price_field_sell='close',
    capital_base=1000000,
    auto_cancel_non_tradable_orders=True,
    data_frequency='daily',
    price_type='后复权',
    product_type='股票',
    plot_charts=True,
    backtest_only=False,
    benchmark='000300.SHA'
)

[2019-07-20 15:25:59.683218] INFO: bigquant: instruments.v2 开始运行..

[2019-07-20 15:25:59.762775] INFO: bigquant: 命中缓存

[2019-07-20 15:25:59.767594] INFO: bigquant: instruments.v2 运行完成[0.08436s].

[2019-07-20 15:25:59.773017] INFO: bigquant: advanced_auto_labeler.v2 开始运行..

[2019-07-20 15:25:59.837249] INFO: bigquant: 命中缓存

[2019-07-20 15:25:59.843380] INFO: bigquant: advanced_auto_labeler.v2 运行完成[0.070327s].

[2019-07-20 15:25:59.849448] INFO: bigquant: standardlize.v8 开始运行..

[2019-07-20 15:25:59.918860] INFO: bigquant: 命中缓存

[2019-07-20 15:25:59.924219] INFO: bigquant: standardlize.v8 运行完成[0.074752s].

[2019-07-20 15:25:59.927747] INFO: bigquant: input_features.v1 开始运行..

[2019-07-20 15:25:59.973522] INFO: bigquant: 命中缓存

[2019-07-20 15:25:59.975867] INFO: bigquant: input_features.v1 运行完成[0.048111s].

[2019-07-20 15:26:00.025017] INFO: bigquant: general_feature_extractor.v7 开始运行..

[2019-07-20 15:26:00.068755] INFO: bigquant: 命中缓存

[2019-07-20 15:26:00.074077] INFO: bigquant: general_feature_extractor.v7 运行完成[0.049049s].

[2019-07-20 15:26:00.084380] INFO: bigquant: derived_feature_extractor.v3 开始运行..

[2019-07-20 15:26:00.182546] INFO: bigquant: 命中缓存

[2019-07-20 15:26:00.187946] INFO: bigquant: derived_feature_extractor.v3 运行完成[0.103547s].

[2019-07-20 15:26:00.194068] INFO: bigquant: standardlize.v8 开始运行..

[2019-07-20 15:26:00.240796] INFO: bigquant: 命中缓存

[2019-07-20 15:26:00.242894] INFO: bigquant: standardlize.v8 运行完成[0.048848s].

[2019-07-20 15:26:00.249391] INFO: bigquant: join.v3 开始运行..

[2019-07-20 15:26:00.327568] INFO: bigquant: 命中缓存

[2019-07-20 15:26:00.330232] INFO: bigquant: join.v3 运行完成[0.080828s].

[2019-07-20 15:26:00.380464] INFO: bigquant: dl_convert_to_bin.v2 开始运行..

[2019-07-20 15:26:00.458069] INFO: bigquant: 命中缓存

[2019-07-20 15:26:00.460815] INFO: bigquant: dl_convert_to_bin.v2 运行完成[0.080343s].

[2019-07-20 15:26:00.466553] INFO: bigquant: cached.v3 开始运行..

[2019-07-20 15:26:00.510869] INFO: bigquant: 命中缓存

[2019-07-20 15:26:00.513708] INFO: bigquant: cached.v3 运行完成[0.047155s].

[2019-07-20 15:26:00.517913] INFO: bigquant: instruments.v2 开始运行..

[2019-07-20 15:26:00.607155] INFO: bigquant: 命中缓存

[2019-07-20 15:26:00.609706] INFO: bigquant: instruments.v2 运行完成[0.091785s].

[2019-07-20 15:26:00.709598] INFO: bigquant: general_feature_extractor.v7 开始运行..

[2019-07-20 15:26:00.800432] INFO: bigquant: 命中缓存

[2019-07-20 15:26:00.803253] INFO: bigquant: general_feature_extractor.v7 运行完成[0.093645s].

[2019-07-20 15:26:00.806967] INFO: bigquant: derived_feature_extractor.v3 开始运行..

[2019-07-20 15:26:00.849316] INFO: bigquant: 命中缓存

[2019-07-20 15:26:00.851691] INFO: bigquant: derived_feature_extractor.v3 运行完成[0.044715s].

[2019-07-20 15:26:00.855313] INFO: bigquant: standardlize.v8 开始运行..

[2019-07-20 15:26:00.898520] INFO: bigquant: 命中缓存

[2019-07-20 15:26:00.901521] INFO: bigquant: standardlize.v8 运行完成[0.046187s].

[2019-07-20 15:26:00.960752] INFO: bigquant: dl_convert_to_bin.v2 开始运行..

[2019-07-20 15:26:01.009647] INFO: bigquant: 命中缓存

[2019-07-20 15:26:01.012488] INFO: bigquant: dl_convert_to_bin.v2 运行完成[0.051732s].

[2019-07-20 15:26:01.017883] INFO: bigquant: cached.v3 开始运行..

[2019-07-20 15:26:01.089642] INFO: bigquant: 命中缓存

[2019-07-20 15:26:01.092497] INFO: bigquant: cached.v3 运行完成[0.074597s].

[2019-07-20 15:26:01.379171] INFO: bigquant: cached.v3 开始运行..

[2019-07-20 15:26:01.443137] INFO: bigquant: 命中缓存

[2019-07-20 15:26:01.445891] INFO: bigquant: cached.v3 运行完成[0.066714s].

[2019-07-20 15:26:01.563017] INFO: bigquant: 命中缓存

[2019-07-20 15:26:01.566385] INFO: bigquant: dl_model_train.v1 运行完成[0.117266s].

[2019-07-20 15:26:01.646183] INFO: bigquant: 命中缓存

[2019-07-20 15:26:01.648509] INFO: bigquant: dl_model_predict.v1 运行完成[0.07935s].

[2019-07-20 15:26:01.654507] INFO: bigquant: cached.v3 开始运行..

[2019-07-20 15:26:01.705902] INFO: bigquant: 命中缓存

[2019-07-20 15:26:01.708622] INFO: bigquant: cached.v3 运行完成[0.054099s].

[2019-07-20 15:26:01.905786] INFO: bigquant: backtest.v8 开始运行..

[2019-07-20 15:26:02.000316] INFO: bigquant: 命中缓存

[2019-07-20 15:26:06.204740] INFO: bigquant: backtest.v8 运行完成[4.298953s].

DataSource(8aebe9b6f33a4036a5e4b713593316c8T, v3)

收益率266.63%
年化收益率95.6%
基准收益率-6.33%
阿尔法0.74
贝塔0.91
夏普比率1.73
胜率0.56
盈亏比1.06
收益波动率42.45%
信息比率0.15
最大回撤48.99%

bigcharts-data-start/{"__id":"bigchart-5518e5a7b63147c098e8241e2a8b8ecd","__type":"tabs"}/bigcharts-data-end

参考文献

华泰证券《人工智能选股之卷积神经网络》2019-02-13
《深度学习因子选股模型-基于卷积神经网络》
《一文搞懂反向传播算法》

asonyang · 2019-06-06 03:20:50 UTC

端午节有事做了。

sunxking · 2019-06-07 03:11:44 UTC

nb啊，请问下因子的选择是根据什么原理或标准来的

antuar · 2019-06-08 13:02:37 UTC

真的很牛逼啊

pengxm · 2019-06-11 10:04:36 UTC

请问为什么要把收益分成20个标签啊

iQuant · 2019-06-12 01:50:19 UTC

就是对股票未来表现分档可以分的更多也可以更少，默认的 20类是经过尝试调优后效果比较好的结果，您也可以自己调优尝试。

copen · 2019-06-12 04:19:09 UTC

离散化以后，只有20个数值，模型不会学得太细，一定程度上可以规避过拟合。

jluo80 · 2019-07-12 03:25:01 UTC

好像直接实盘模拟失败

kingwmj · 2019-07-18 01:30:04 UTC

修改日期后报错，这是怎么回事呢？
KeyError Traceback (most recent call last)
in ()
143 m13 = M.standardlize.v8(
144 input_1=m2.data,
–> 145 columns_input=’[‘label’]’
146 )
147

KeyError: “Column not found: [‘label’]”

kingwmj · 2019-07-18 01:35:26 UTC

直接模拟交易也出错。

sharping · 2019-07-18 05:03:16 UTC

克隆之后运行显示以下错误：
KeyError
Traceback (most recent call last)
in ()
143 m13 = M.standardlize.v8(
144 input_1=m2.data,
–> 145 columns_input=’[‘label’]’
146 )
147

KeyError: “Column not found: [‘label’]”

cash01 · 2019-07-19 08:30:28 UTC

同错，同问，同等

iQuant · 2019-07-19 10:22:00 UTC

已提交至策略工程师，请大家稍等

kobe · 2019-07-20 07:55:52 UTC

克隆策略

In [2]:

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


# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m4_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    df =  input_1.read_pickle()
    feature_len = len(input_2.read_pickle())
    
    
    df['x'] = df['x'].reshape(df['x'].shape[0], int(feature_len), int(df['x'].shape[1]/feature_len))
    
    data_1 = DataSource.write_pickle(df)
    return Outputs(data_1=data_1)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m8_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    df =  input_1.read_pickle()
    feature_len = len(input_2.read_pickle())
    
    
    df['x'] = df['x'].reshape(df['x'].shape[0], int(feature_len), int(df['x'].shape[1]/feature_len))
    
    data_1 = DataSource.write_pickle(df)
    return Outputs(data_1=data_1)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m24_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    pred_label = input_1.read_pickle()
    df = input_2.read_df()
    df = pd.DataFrame({'pred_label':pred_label[:,0], 'instrument':df.instrument, 'date':df.date})
    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 m24_post_run_bigquant_run(outputs):
    return outputs

# 回测引擎：初始化函数，只执行一次
def m19_initialize_bigquant_run(context):
    # 加载预测数据
    context.ranker_prediction = context.options['data'].read_df()

    # 系统已经设置了默认的交易手续费和滑点，要修改手续费可使用如下函数
    context.set_commission(PerOrder(buy_cost=0.0003, sell_cost=0.0013, min_cost=5))
    # 预测数据，通过options传入进来，使用 read_df 函数，加载到内存 (DataFrame)
    # 设置买入的股票数量，这里买入预测股票列表排名靠前的5只
    stock_count = 20
    # 每只的股票的权重，如下的权重分配会使得靠前的股票分配多一点的资金，[0.339160, 0.213986, 0.169580, ..]
    context.stock_weights = T.norm([1 / math.log(i + 2) for i in range(0, stock_count)])
    # 设置每只股票占用的最大资金比例
    context.max_cash_per_instrument = 0.2
    context.options['hold_days'] = 2

# 回测引擎：每日数据处理函数，每天执行一次
def m19_handle_data_bigquant_run(context, data):
    # 按日期过滤得到今日的预测数据
    ranker_prediction = context.ranker_prediction[
        context.ranker_prediction.date == data.current_dt.strftime('%Y-%m-%d')]

    # 1. 资金分配
    # 平均持仓时间是hold_days，每日都将买入股票，每日预期使用 1/hold_days 的资金
    # 实际操作中，会存在一定的买入误差，所以在前hold_days天，等量使用资金；之后，尽量使用剩余资金（这里设置最多用等量的1.5倍）
    is_staging = context.trading_day_index < context.options['hold_days'] # 是否在建仓期间（前 hold_days 天）
    cash_avg = context.portfolio.portfolio_value / context.options['hold_days']
    cash_for_buy = min(context.portfolio.cash, (1 if is_staging else 1.5) * cash_avg)
    cash_for_sell = cash_avg - (context.portfolio.cash - cash_for_buy)
    positions = {e.symbol: p.amount * p.last_sale_price
                 for e, p in context.perf_tracker.position_tracker.positions.items()}

    # 2. 生成卖出订单：hold_days天之后才开始卖出；对持仓的股票，按机器学习算法预测的排序末位淘汰
    if not is_staging and cash_for_sell > 0:
        equities = {e.symbol: e for e, p in context.perf_tracker.position_tracker.positions.items()}
        instruments = list(reversed(list(ranker_prediction.instrument[ranker_prediction.instrument.apply(
                lambda x: x in equities and not context.has_unfinished_sell_order(equities[x]))])))
        # print('rank order for sell %s' % instruments)
        for instrument in instruments:
            context.order_target(context.symbol(instrument), 0)
            cash_for_sell -= positions[instrument]
            if cash_for_sell <= 0:
                break

    # 3. 生成买入订单：按机器学习算法预测的排序，买入前面的stock_count只股票
    buy_cash_weights = context.stock_weights
    buy_instruments = list(ranker_prediction.instrument[:len(buy_cash_weights)])
    max_cash_per_instrument = context.portfolio.portfolio_value * context.max_cash_per_instrument
    for i, instrument in enumerate(buy_instruments):
        cash = cash_for_buy * buy_cash_weights[i]
        if cash > max_cash_per_instrument - positions.get(instrument, 0):
            # 确保股票持仓量不会超过每次股票最大的占用资金量
            cash = max_cash_per_instrument - positions.get(instrument, 0)
        if cash > 0:
            context.order_value(context.symbol(instrument), cash)

# 回测引擎：准备数据，只执行一次
def m19_prepare_bigquant_run(context):
    pass


m1 = M.instruments.v2(
    start_date='2010-01-01',
    end_date='2015-01-01',
    market='CN_STOCK_A',
    instrument_list=' ',
    max_count=0
)

m2 = M.advanced_auto_labeler.v2(
    instruments=m1.data,
    label_expr="""# #号开始的表示注释
# 0. 每行一个，顺序执行，从第二个开始，可以使用label字段
# 1. 可用数据字段见 https://bigquant.com/docs/data_history_data.html
#   添加benchmark_前缀，可使用对应的benchmark数据
# 2. 可用操作符和函数见 `表达式引擎 <https://bigquant.com/docs/big_expr.html>`_

# 计算收益：5日收盘价(作为卖出价格)除以明日开盘价(作为买入价格)
shift(close, -2) / shift(open, -1)-1

# 极值处理：用1%和99%分位的值做clip
clip(label, all_quantile(label, 0.01), all_quantile(label, 0.99))

# 过滤掉一字涨停的情况 (设置label为NaN，在后续处理和训练中会忽略NaN的label)
where(shift(high, -1) == shift(low, -1), NaN, label)
""",
    start_date='',
    end_date='',
    benchmark='000300.SHA',
    drop_na_label=True,
    cast_label_int=False
)

m13 = M.standardlize.v8(
    input_1=m2.data,
    columns_input='label'
)

m3 = M.input_features.v1(
    features="""close_0/mean(close_0,5)
close_0/mean(close_0,10)
close_0/mean(close_0,20)
close_0/open_0
open_0/mean(close_0,5)
open_0/mean(close_0,10)
open_0/mean(close_0,20)"""
)

m15 = M.general_feature_extractor.v7(
    instruments=m1.data,
    features=m3.data,
    start_date='',
    end_date='',
    before_start_days=0
)

m16 = M.derived_feature_extractor.v3(
    input_data=m15.data,
    features=m3.data,
    date_col='date',
    instrument_col='instrument',
    drop_na=True,
    remove_extra_columns=False
)

m14 = M.standardlize.v8(
    input_1=m16.data,
    input_2=m3.data,
    columns_input=''
)

m7 = M.join.v3(
    data1=m13.data,
    data2=m14.data,
    on='date,instrument',
    how='inner',
    sort=False
)

m26 = M.dl_convert_to_bin.v2(
    input_data=m7.data,
    features=m3.data,
    window_size=5,
    feature_clip=5,
    flatten=True,
    window_along_col='instrument'
)

m4 = M.cached.v3(
    input_1=m26.data,
    input_2=m3.data,
    run=m4_run_bigquant_run,
    post_run=m4_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m9 = M.instruments.v2(
    start_date=T.live_run_param('trading_date', '2015-01-01'),
    end_date=T.live_run_param('trading_date', '2017-01-01'),
    market='CN_STOCK_A',
    instrument_list='',
    max_count=0
)

m17 = M.general_feature_extractor.v7(
    instruments=m9.data,
    features=m3.data,
    start_date='',
    end_date='',
    before_start_days=0
)

m18 = M.derived_feature_extractor.v3(
    input_data=m17.data,
    features=m3.data,
    date_col='date',
    instrument_col='instrument',
    drop_na=True,
    remove_extra_columns=False
)

m25 = M.standardlize.v8(
    input_1=m18.data,
    input_2=m3.data,
    columns_input=''
)

m27 = M.dl_convert_to_bin.v2(
    input_data=m25.data,
    features=m3.data,
    window_size=5,
    feature_clip=5,
    flatten=True,
    window_along_col='instrument'
)

m8 = M.cached.v3(
    input_1=m27.data,
    input_2=m3.data,
    run=m8_run_bigquant_run,
    post_run=m8_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m6 = M.dl_layer_input.v1(
    shape='7,5',
    batch_shape='',
    dtype='float32',
    sparse=False,
    name=''
)

m10 = M.dl_layer_conv1d.v1(
    inputs=m6.data,
    filters=20,
    kernel_size='3',
    strides='1',
    padding='valid',
    dilation_rate=1,
    activation='relu',
    use_bias=True,
    kernel_initializer='glorot_uniform',
    bias_initializer='Zeros',
    kernel_regularizer='None',
    kernel_regularizer_l1=0,
    kernel_regularizer_l2=0,
    bias_regularizer='None',
    bias_regularizer_l1=0,
    bias_regularizer_l2=0,
    activity_regularizer='None',
    activity_regularizer_l1=0,
    activity_regularizer_l2=0,
    kernel_constraint='None',
    bias_constraint='None',
    name=''
)

m12 = M.dl_layer_maxpooling1d.v1(
    inputs=m10.data,
    pool_size=1,
    padding='valid',
    name=''
)

m32 = M.dl_layer_conv1d.v1(
    inputs=m12.data,
    filters=20,
    kernel_size='3',
    strides='1',
    padding='valid',
    dilation_rate=1,
    activation='relu',
    use_bias=True,
    kernel_initializer='glorot_uniform',
    bias_initializer='Zeros',
    kernel_regularizer='None',
    kernel_regularizer_l1=0,
    kernel_regularizer_l2=0,
    bias_regularizer='None',
    bias_regularizer_l1=0,
    bias_regularizer_l2=0,
    activity_regularizer='None',
    activity_regularizer_l1=0,
    activity_regularizer_l2=0,
    kernel_constraint='None',
    bias_constraint='None',
    name=''
)

m33 = M.dl_layer_maxpooling1d.v1(
    inputs=m32.data,
    pool_size=1,
    padding='valid',
    name=''
)

m28 = M.dl_layer_globalmaxpooling1d.v1(
    inputs=m33.data,
    name=''
)

m30 = M.dl_layer_dense.v1(
    inputs=m28.data,
    units=1,
    activation='linear',
    use_bias=True,
    kernel_initializer='glorot_uniform',
    bias_initializer='Zeros',
    kernel_regularizer='None',
    kernel_regularizer_l1=0,
    kernel_regularizer_l2=0,
    bias_regularizer='None',
    bias_regularizer_l1=0,
    bias_regularizer_l2=0,
    activity_regularizer='None',
    activity_regularizer_l1=0,
    activity_regularizer_l2=0,
    kernel_constraint='None',
    bias_constraint='None',
    name=''
)

m34 = M.dl_model_init.v1(
    inputs=m6.data,
    outputs=m30.data
)

m5 = M.dl_model_train.v1(
    input_model=m34.data,
    training_data=m4.data_1,
    optimizer='RMSprop',
    loss='mean_squared_error',
    metrics='mae',
    batch_size=256,
    epochs=5,
    n_gpus=0,
    verbose='2:每个epoch输出一行记录'
)

m11 = M.dl_model_predict.v1(
    trained_model=m5.data,
    input_data=m8.data_1,
    batch_size=1024,
    n_gpus=0,
    verbose='2:每个epoch输出一行记录'
)

m24 = M.cached.v3(
    input_1=m11.data,
    input_2=m18.data,
    run=m24_run_bigquant_run,
    post_run=m24_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m19 = M.trade.v4(
    instruments=m9.data,
    options_data=m24.data_1,
    start_date='',
    end_date='',
    initialize=m19_initialize_bigquant_run,
    handle_data=m19_handle_data_bigquant_run,
    prepare=m19_prepare_bigquant_run,
    volume_limit=0.025,
    order_price_field_buy='open',
    order_price_field_sell='close',
    capital_base=1000000,
    auto_cancel_non_tradable_orders=True,
    data_frequency='daily',
    price_type='后复权',
    product_type='股票',
    plot_charts=True,
    backtest_only=False,
    benchmark='000300.SHA'
)

2019-07-20 15:25:59.683218 INFO: bigquant: instruments.v2 开始运行.

2019-07-20 15:25:59.762775 INFO: bigquant: 命中缓

2019-07-20 15:25:59.767594 INFO: bigquant: instruments.v2 运行完成[0.08436s]

2019-07-20 15:25:59.773017 INFO: bigquant: advanced_auto_labeler.v2 开始运行.

2019-07-20 15:25:59.837249 INFO: bigquant: 命中缓

2019-07-20 15:25:59.843380 INFO: bigquant: advanced_auto_labeler.v2 运行完成[0.070327s]

2019-07-20 15:25:59.849448 INFO: bigquant: standardlize.v8 开始运行.

2019-07-20 15:25:59.918860 INFO: bigquant: 命中缓

2019-07-20 15:25:59.924219 INFO: bigquant: standardlize.v8 运行完成[0.074752s]

2019-07-20 15:25:59.927747 INFO: bigquant: input_features.v1 开始运行.

2019-07-20 15:25:59.973522 INFO: bigquant: 命中缓

2019-07-20 15:25:59.975867 INFO: bigquant: input_features.v1 运行完成[0.048111s]

2019-07-20 15:26:00.025017 INFO: bigquant: general_feature_extractor.v7 开始运行.

2019-07-20 15:26:00.068755 INFO: bigquant: 命中缓

2019-07-20 15:26:00.074077 INFO: bigquant: general_feature_extractor.v7 运行完成[0.049049s]

2019-07-20 15:26:00.084380 INFO: bigquant: derived_feature_extractor.v3 开始运行.

2019-07-20 15:26:00.182546 INFO: bigquant: 命中缓

2019-07-20 15:26:00.187946 INFO: bigquant: derived_feature_extractor.v3 运行完成[0.103547s]

2019-07-20 15:26:00.194068 INFO: bigquant: standardlize.v8 开始运行.

2019-07-20 15:26:00.240796 INFO: bigquant: 命中缓

2019-07-20 15:26:00.242894 INFO: bigquant: standardlize.v8 运行完成[0.048848s]

2019-07-20 15:26:00.249391 INFO: bigquant: join.v3 开始运行.

2019-07-20 15:26:00.327568 INFO: bigquant: 命中缓

2019-07-20 15:26:00.330232 INFO: bigquant: join.v3 运行完成[0.080828s]

2019-07-20 15:26:00.380464 INFO: bigquant: dl_convert_to_bin.v2 开始运行.

2019-07-20 15:26:00.458069 INFO: bigquant: 命中缓

2019-07-20 15:26:00.460815 INFO: bigquant: dl_convert_to_bin.v2 运行完成[0.080343s]

2019-07-20 15:26:00.466553 INFO: bigquant: cached.v3 开始运行.

2019-07-20 15:26:00.510869 INFO: bigquant: 命中缓

2019-07-20 15:26:00.513708 INFO: bigquant: cached.v3 运行完成[0.047155s]

2019-07-20 15:26:00.517913 INFO: bigquant: instruments.v2 开始运行.

2019-07-20 15:26:00.607155 INFO: bigquant: 命中缓

2019-07-20 15:26:00.609706 INFO: bigquant: instruments.v2 运行完成[0.091785s]

2019-07-20 15:26:00.709598 INFO: bigquant: general_feature_extractor.v7 开始运行.

2019-07-20 15:26:00.800432 INFO: bigquant: 命中缓

2019-07-20 15:26:00.803253 INFO: bigquant: general_feature_extractor.v7 运行完成[0.093645s]

2019-07-20 15:26:00.806967 INFO: bigquant: derived_feature_extractor.v3 开始运行.

2019-07-20 15:26:00.849316 INFO: bigquant: 命中缓

2019-07-20 15:26:00.851691 INFO: bigquant: derived_feature_extractor.v3 运行完成[0.044715s]

2019-07-20 15:26:00.855313 INFO: bigquant: standardlize.v8 开始运行.

2019-07-20 15:26:00.898520 INFO: bigquant: 命中缓

2019-07-20 15:26:00.901521 INFO: bigquant: standardlize.v8 运行完成[0.046187s]

2019-07-20 15:26:00.960752 INFO: bigquant: dl_convert_to_bin.v2 开始运行.

2019-07-20 15:26:01.009647 INFO: bigquant: 命中缓

2019-07-20 15:26:01.012488 INFO: bigquant: dl_convert_to_bin.v2 运行完成[0.051732s]

2019-07-20 15:26:01.017883 INFO: bigquant: cached.v3 开始运行.

2019-07-20 15:26:01.089642 INFO: bigquant: 命中缓

2019-07-20 15:26:01.092497 INFO: bigquant: cached.v3 运行完成[0.074597s]

2019-07-20 15:26:01.379171 INFO: bigquant: cached.v3 开始运行.

2019-07-20 15:26:01.443137 INFO: bigquant: 命中缓

2019-07-20 15:26:01.445891 INFO: bigquant: cached.v3 运行完成[0.066714s]

2019-07-20 15:26:01.563017 INFO: bigquant: 命中缓

2019-07-20 15:26:01.566385 INFO: bigquant: dl_model_train.v1 运行完成[0.117266s]

2019-07-20 15:26:01.646183 INFO: bigquant: 命中缓

2019-07-20 15:26:01.648509 INFO: bigquant: dl_model_predict.v1 运行完成[0.07935s]

2019-07-20 15:26:01.654507 INFO: bigquant: cached.v3 开始运行.

2019-07-20 15:26:01.705902 INFO: bigquant: 命中缓

2019-07-20 15:26:01.708622 INFO: bigquant: cached.v3 运行完成[0.054099s]

2019-07-20 15:26:01.905786 INFO: bigquant: backtest.v8 开始运行.

2019-07-20 15:26:02.000316 INFO: bigquant: 命中缓

2019-07-20 15:26:06.204740 INFO: bigquant: backtest.v8 运行完成[4.298953s]

DataSource(8aebe9b6f33a4036a5e4b713593316c8T, v3)

收益率266.63%
年化收益率95.6%
基准收益率-6.33%
阿尔法0.74
贝塔0.91
夏普比率1.73
胜率0.56
盈亏比1.06
收益波动率42.45%
信息比率0.15
最大回撤48.99%

bigcharts-data-start/{"__id":"bigchart-5518e5a7b63147c098e8241e2a8b8ecd","__type":"tabs"}/bigcharts-data-end

user404 · 2019-07-26 15:21:40 UTC

KeyError Traceback (most recent call last)
in ()
143 m13 = M.standardlize.v8(
144 input_1=m2.data,
–> 145 columns_input=’[‘label’]’
146 )
147

KeyError: “Column not found: [‘label’]”

iQuant · 2019-07-27 01:13:15 UTC

您克隆一下上方这个更新后的策略模板。

iQuant · 2019-07-27 02:41:01 UTC

帖子已经修复

Quant_Squall · 2019-08-19 01:27:47 UTC

请问这个策略里面的深度学习训练模块中的lr学习率超参数如何界面上调整？希望能够增加此参数的界面调整功能，谢谢！

iQuant · 2019-08-19 03:08:51 UTC

选自定义

然后下面填参数

image.png1616x998 71.1 KB
目标函数也可以自己修改

11191 · 2019-08-22 03:52:25 UTC

是否有详细介绍自定义优化器的文档，包括支持的参数和优化器说明