这是本系列专题研究的第四篇:基于卷积神经网络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)是“误差反向传播”的简称,是一种与最优化方法(如梯度下降法)结合使用的,用来训练人工神经网络的常见方法。该方法对网络中所有权重计算损失函数的梯度,这个梯度会反馈给最优化方法,用来更新权值以最小化损失函数。
一句话解释:前向传递输入信号直至输出产生误差,反向传播误差信息更新权重矩阵。
以没有隐层的神经网络为例,如逻辑回归,其中小黄帽代表输出层节点,左侧接受输入信号,右侧产生输出结果,小蓝猫则代表了误差,指导参数往更优的方向调整。由于小蓝猫可以直接将误差反馈给小黄帽,同时只有一个参数矩阵和小黄帽直接相连,所以可以直接通过误差进行参数优化(实线),迭代几轮,误差会降低到最小。
$$图1:无隐层反向传播算法示意$$
1.2 CNN图像识别原理
卷积神经网络的结构模仿了眼睛的视觉神经的工作原理。对于眼睛来说,大量的视觉神经分工协作,各自负责一小部分区域的视觉图像,再将图像的各种局部特征抽象组合到高层的视觉概念,传送到大脑使人类产生视觉。卷积神经网络也是类似,它包含了至少一层卷积层,由多个卷积核对图像的局部区域进行特征提取,最后进行合成。
以经典的LeNet-5模型为例:
$$图2:LeNet-5卷积神经网络模型$$
原始输入数据(图1中的input)为二维图像,横轴和纵轴分别是图像的高度和宽度的像素点,为了识别该图像,模型依次完成以下步骤:
- 第一层卷积层(图1中的conv1)进行卷积运算。该层由若干卷积核组成,每个卷积核的参数都是通过反向传播算法优化得到的。卷积核的目的是通过扫描整张图片提取不同特征,第一层卷积层可能只能提取一些低级的特征如边缘、线条和角等层级。在卷积层之后都会使用非线性激活函数(如RELU,tanh 等)对特征进行非线性变换。
- 第一层池化层(图1中的pool1)进行池化运算。通常在卷积层之后会得到维度很大的特征,池化层可以非常有效地缩小参数矩阵的尺寸,从而减少最后全连层中的参数数量。使用池化层既可以加快计算速度也有防止过拟合的作用。一般池化层将特征切成几个区域,取其最大值或平均值,得到新的、维度较小的特征。池化层其实是在对具有高维特征的图片进行特征降维(subsample)。
- 第二层卷积层和第二层池化层(图1中的conv2 和pool2) 进行进一步的特征提取和特征降维,得到更加高层和抽象的特征。
- 全连接层(图1中的hidden4 和full connection) 把卷积核池化得到的特征展平为一维特征,用来进行最后的训练和预测。
总结而言,卷积层进行特征提取,池化层进行特征降维以防止过拟合。CNN通过上述过程实现了图像识别:
$$图3:CNN图像识别$$
通过第一层卷积识别边缘等低级特征,池化后通过第二层卷积识别眼睛、鼻子等小区域器官这样的中级特征,池化,最后通过第三层卷积识别整个面容这样的高级特征,最后通过全连接层整合,识别出最终的图像。
2、一维CNN在时间序列中的应用
CNN最主要应用于计算机视觉领域,通过卷积运算,从二维图像中提取特征,最终实现优秀的图像识别功能。对于这样一种优秀的算法,我们自然会思考如何将其运用到时间序列分析中。很容易想到,有两种思路:
- 将一维的时间序列二维化。考虑历史截面期,将每个样本的特征数据组织成二维形式,尝试构建“特征图片”。如总共有3000个样本,每个样本有10个特征,那就考虑5个截面期,每个样本整合5个截面得到一张“特征图片”,用时间数据作为图片标签。如此,可以得到3000个带时间特征的图片,然后运用二维CNN处理。这种方法的具体实现可参见华泰证券的研报《人工智能选股之卷积神经网络》
- 探索一维CNN在时间序列上的运用。本篇研究就是基于这个思路。如果将时间理解为图像的长或者宽,其他特征理解为一个维度,那么就可以用一维CNN进行处理。
2.1 一维卷积
一维卷积,也就是从序列中按照一定大小的窗口提取局部一维序列段(即子序列),然后与一个权重做点积,然后输出为新序列上的一个部分。以大小为5的时间窗口为例:
$$图4:一维CNN的一层卷积示意$$
2.2 一维池化
同二维池化一样,一维池化的目的也是为了对卷积的结果“模糊化”,归纳局部区域内的统计特征,并且通过降维避免过拟合。一维池化是从输入中提取一维序列段(即子序列), 然后输出其最大值(最大池化)或平均值(平均池化),降低一维输入的长度(子采样)。
3、实例:CNN模型选股
$$图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。
预测结果如下:
$$图6:CNN模型预测结果$$
回测结果如下:
$$图7:CNN模型回测结果$$
可以看到,CNN的回测结果还是非常惊喜的,相比于基准收益有着非常突出的表现。所以,我们认为将CNN卷积神经网络应用于资本市场因子选股是很有前景的。在本次的策略中,我们运用了两层的一维CNN模型,具体的卷积层数、模型参数有非常大的调整空间,欢迎大家尝试。
# 本代码由可视化策略环境自动生成 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].
参考文献
- 华泰证券 《人工智能选股之卷积神经网络》2019-02-13
- 《 深度学习因子选股模型-基于卷积神经网络》
- 《 一文搞懂反向传播算法》