使用LSTM-RNN建立股票预测模型

188金宝搏官网 5

  硕士毕业之前曾经对基于LSTM循环神经网络的股价预测方法进行过小小的研究,趁着最近工作不忙,把其中的一部分内容写下来做以记录。

引自:

 

 

  此次股票价格预测模型仅根据股票的历史数据来建立,不考虑消息面对个股的影响。曾有日本学者使用深度学习的方法来对当天的新闻内容进行分析,以判断其对股价正面性/负面性影响,并将其与股票的历史数据相结合,各自赋予一定的权重来对近日的股价进行预测[1]。该预测方法取得了一定的效果。

中文文档: 
官方文档: 
文档主要是以keras2.0。

  而这里我没有引入消息面的影响,主要出于以下几点考虑:


  1.消息的及时性难以保证:很多时候,在一只股票的利好/利空消息出来之前,其股价已经有了较大幅度的增长/下跌。信息的不对称性导致普通群众缺乏第一手消息源。

.

  2.消息的准确性难以保证:互联网上信息传播速度极快,媒体之间经常会出现相互抄袭新闻的情况,而这种抄来的新闻(非原创新闻)往往没有经过严格的审核,存在着内容虚假,夸大宣传的可能性。一旦分析模型错用了某条谣言或真实性不高的新闻,很有可能得出错误的预测结果。

Keras系列:

1、keras系列︱Sequential与Model模型、keras基本结构功能(一) 
2、keras系列︱Application中五款已训练模型、VGG16框架(Sequential式、Model式)解读(二) 
3、keras系列︱图像多分类训练与利用bottleneck
features进行微调(三) 
4、keras系列︱人脸表情分类与识别:opencv人脸检测+Keras情绪分类(四) 
5、keras系列︱迁移学习:利用InceptionV3进行fine-tuning及预测、完整案例(五)


金宝搏平台,  3.语言的歧义性:一条新闻,其正面性/负面性往往存在着多种解读。例如“习主席宣布中国将裁军30万”——新华每日电讯2015.09.04。这条新闻一般意义上可以解读为:中央政府深入推进改革,精兵简政,大力发展国防军工事业。这是一种正面性的解读。而在使用机器学习模型时,如传统的奇异值分解算法(SVD),很有可能会判定其与“去年五大行裁员近3万”这种新闻具有较高的相似度,因而将其划分为负面新闻。

零、keras介绍与基本的模型保存

写成了思维导图,便于观察与理解。

  4.技术实现较为繁杂:这其实是一个非常重要的原因啦~,获取正确的信息并进行NLP操作,往往需要经过以下流程:人工浏览网页确定稳定可靠的信息源→设计爬虫实现有效信息的获取→设计新闻裁剪(填充)方案以应对不同长度的新闻→人工标注新闻的正/负性(也可以用当日股价涨跌来标注)→设计网络模型→训练及验证模型。其中的每一步都非常麻烦耗时,而且对于个股来说,并不是每天都会有新闻出现。

1.keras网络结构

188金宝搏官网 1

 

2.keras网络配置

188金宝搏官网 2
其中回调函数callbacks应该是keras的精髓~

  上面说了这么多,还没有开始对我这个预测模型进行介绍,下面开始进入正题。在决定排除消息面的考量之后,我开始思考股价涨跌的本质,我认为股价就是资金博弈结果的体现。这次建立的预测模型,朴素的想法是通过深度学习模型来洞悉庄家的操作规律,对拉升、砸盘的情况进行预测。为了达到以下目的,我决定选取以下七个特征来构建网络模型,即:

3.keras预处理功能

188金宝搏官网 3

涨跌幅  最高涨幅  最低跌幅  大单净流入 
中单净流入  小单净流入  换手率

4、模型的节点信息提取

# 节点信息提取
config = model.get_config()  # 把model中的信息,solver.prototxt和train.prototxt信息提取出来
model = Model.from_config(config)  # 还回去
# or, for Sequential:
model = Sequential.from_config(config) # 重构一个新的Model模型,用去其他训练,fine-tuning比较好用

使用这七个特征来对股票的涨跌情况以及资金的流动情况建立适当的模型。此外,其他的指标类似MACD、均线等也是通过一些基础数据的运算得出,在构建模型时并没有将其纳入考量范围。

5、 模型概况查询(包括权重查询)

# 1、模型概括打印
model.summary()

# 2、返回代表模型的JSON字符串,仅包含网络结构,不包含权值。可以从JSON字符串中重构原模型:
from models import model_from_json

json_string = model.to_json()
model = model_from_json(json_string)

# 3、model.to_yaml:与model.to_json类似,同样可以从产生的YAML字符串中重构模型
from models import model_from_yaml

yaml_string = model.to_yaml()
model = model_from_yaml(yaml_string)

# 4、权重获取
model.get_layer()      #依据层名或下标获得层对象
model.get_weights()    #返回模型权重张量的列表,类型为numpy array
model.set_weights()    #从numpy array里将权重载入给模型,要求数组具有与model.get_weights()相同的形状。

# 查看model中Layer的信息
model.layers 查看layer信息

 

6、模型保存与加载

model.save_weights(filepath)
# 将模型权重保存到指定路径,文件类型是HDF5(后缀是.h5)

model.load_weights(filepath, by_name=False)
# 从HDF5文件中加载权重到当前模型中, 默认情况下模型的结构将保持不变。
# 如果想将权重载入不同的模型(有些层相同)中,则设置by_name=True,只有名字匹配的层才会载入权重.

一.源数据及其预处理

7、如何在keras中设定GPU使用的大小

本节来源于:深度学习theano/tensorflow多显卡多人使用问题集(参见:Limit
the resource usage for tensorflow backend · Issue #1538 ·
fchollet/keras ·
GitHub) 
在使用keras时候会出现总是占满GPU显存的情况,可以通过重设backend的GPU占用情况来进行调节。

import tensorflow as tf
from keras.backend.tensorflow_backend import set_session
config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.3
set_session(tf.Session(config=config))

 

188金宝搏官网,需要注意的是,虽然代码或配置层面设置了对显存占用百分比阈值,但在实际运行中如果达到了这个阈值,程序有需要的话还是会突破这个阈值。换而言之如果跑在一个大数据集上还是会用到更多的显存。以上的显存限制仅仅为了在跑小数据集时避免对显存的浪费而已。(2017年2月20日补充)

  通过某股票交易软件,我获得的源数据约有20来个特征,包括:涨幅、现价、涨跌、买入、卖价、成交量等等。为了得到上面所述的七种特征,挑选出涨跌幅、大单净流入、中单净流入、小单净流入、换手率这5个特征,并计算最高涨幅、最高跌幅两个特征。通过下列公式计算获得。

8.更科学地模型训练与模型保存

filepath = 'model-ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5'
checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min')
# fit model
model.fit(x, y, epochs=20, verbose=2, callbacks=[checkpoint], validation_data=(x, y))

 

save_best_only打开之后,会如下:

 ETA: 3s - loss: 0.5820Epoch 00017: val_loss did not improve

 

如果val_loss 提高了就会保存,没有提高就不会保存。

188金宝搏官网 4

9.如何在keras中使用tensorboard

    RUN = RUN + 1 if 'RUN' in locals() else 1   # locals() 函数会以字典类型返回当前位置的全部局部变量。

    LOG_DIR = model_save_path + '/training_logs/run{}'.format(RUN)
    LOG_FILE_PATH = LOG_DIR + '/checkpoint-{epoch:02d}-{val_loss:.4f}.hdf5'   # 模型Log文件以及.h5模型文件存放地址

    tensorboard = TensorBoard(log_dir=LOG_DIR, write_images=True)
    checkpoint = ModelCheckpoint(filepath=LOG_FILE_PATH, monitor='val_loss', verbose=1, save_best_only=True)
    early_stopping = EarlyStopping(monitor='val_loss', patience=5, verbose=1)

    history = model.fit_generator(generator=gen.generate(True), steps_per_epoch=int(gen.train_batches / 4),
                                  validation_data=gen.generate(False), validation_steps=int(gen.val_batches / 4),
                                  epochs=EPOCHS, verbose=1, callbacks=[tensorboard, checkpoint, early_stopping])

 

都是在回调函数中起作用:

  • EarlyStopping patience:当early 
    (1)stop被激活(如发现loss相比上一个epoch训练没有下降),则经过patience个epoch后停止训练。 
    (2)mode:‘auto’,‘min’,‘max’之一,在min模式下,如果检测值停止下降则中止训练。在max模式下,当检测值不再上升则停止训练。

  • 模型检查点ModelCheckpoint  
    (1)save_best_only:当设置为True时,将只保存在验证集上性能最好的模型 
    (2)
    mode:‘auto’,‘min’,‘max’之一,在save_best_only=True时决定性能最佳模型的评判准则,例如,当监测值为val_acc时,模式应为max,当检测值为val_loss时,模式应为min。在auto模式下,评价准则由被监测值的名字自动推断。 
    (3)save_weights_only:若设置为True,则只保存模型权重,否则将保存整个模型(包括模型结构,配置信息等) 
    (4)period:CheckPoint之间的间隔的epoch数

  • 可视化tensorboard write_images: 是否将模型权重以图片的形式可视化

其他内容可参考keras中文文档

.


经过处理的股票特征数据存储在 股票名.csv文件中,类似下图:

一、Sequential 序贯模型

序贯模型是函数式模型的简略版,为最简单的线性、从头到尾的结构顺序,不分叉。

 188金宝搏官网 5

Sequential模型的基本组件

一般需要:

  • 1、model.add,添加层;
  • 2、model.compile,模型训练的BP模式设置;
  • 3、model.fit,模型训练参数设置 + 训练;
  • 4、模型评估
  • 5、模型预测

图中的特征顺序为:日期,大单净流入,中单净流入,小单净流入,涨跌幅,最高涨幅,最高跌幅,换手率,股价。股价在这里的用处是拼接训练样本输出时,计算多日的总涨跌幅。

1. add:添加层——train_val.prototxt

add(self, layer)

# 譬如:
model.add(Dense(32, activation='relu', input_dim=100))
model.add(Dropout(0.25))

 

add里面只有层layer的内容,当然在序贯式里面,也可以model.add(other_model)加载另外模型,在函数式里面就不太一样,详见函数式。

注:在对源数据进行处理的时候,经常会遇到空值问题:即,有些特征值为0的时候,系统给出的源数据为”-”或”“。需要进行特殊处理。(经常遇见新股第一天的涨跌幅为空,或某交易日大单净流入为空。)

2、compile 训练模式——solver.prototxt文件

compile(self, optimizer, loss, metrics=None, sample_weight_mode=None)

 

其中: 
optimizer: 字符串(预定义优化器名)或优化器对象,参考优化器 
loss: 字符串(预定义损失函数名)或目标函数,参考损失函数 
metrics:
列表,包含评估模型在训练和测试时的网络性能的指标,典型用法是metrics=[‘accuracy’] 
sample_weight_mode:如果你需要按时间步为样本赋权(2D权矩阵),将该值设为“temporal”。 
默认为“None”,代表按样本赋权(1D权)。在下面fit函数的解释中有相关的参考内容。 
kwargs:
使用TensorFlow作为后端请忽略该参数,若使用Theano作为后端,kwargs的值将会传递给
K.function

注意: 
模型在使用前必须编译,否则在调用fit或evaluate时会抛出异常。

1     if fin_temp.ix[day,12]=='-' or  fin_temp.ix[day,12]=='':  # 新股的涨跌幅一栏会出现'','-',需要特殊处理
2         raise_value = 0.0
3     else:
4         raise_value = float(fin_temp.ix[day,12])

3、fit 模型训练参数+训练——train.sh+soler.prototxt(部分)

fit(self, x, y, batch_size=32, epochs=10, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0)

 

本函数将模型训练nb_epoch轮,其参数有:

  • x:输入数据。如果模型只有一个输入,那么x的类型是numpy 
    array,如果模型有多个输入,那么x的类型应当为list,list的元素是对应于各个输入的numpy
    array
  • y:标签,numpy array
  • batch_size:整数,指定进行梯度下降时每个batch包含的样本数。训练时一个batch的样本会被计算一次梯度下降,使目标函数优化一步。
  • epochs:整数,训练的轮数,每个epoch会把训练集轮一遍。
  • verbose:日志显示,0为不在标准输出流输出日志信息,1为输出进度条记录,2为每个epoch输出一行记录
  • callbacks:list,其中的元素是keras.callbacks.Callback的对象。这个list中的回调函数将会在训练过程中的适当时机被调用,参考回调函数
  • validation_split:0~1之间的浮点数,用来指定训练集的一定比例数据作为验证集。验证集将不参与训练,并在每个epoch结束后测试的模型的指标,如损失函数、精确度等。注意,validation_split的划分在shuffle之前,因此如果你的数据本身是有序的,需要先手工打乱再指定validation_split,否则可能会出现验证集样本不均匀。
  • validation_data:形式为(X,y)的tuple,是指定的验证集。此参数将覆盖validation_spilt。
  • shuffle:布尔值或字符串,一般为布尔值,表示是否在训练过程中随机打乱输入样本的顺序。若为字符串“batch”,则是用来处理HDF5数据的特殊情况,它将在batch内部将数据打乱。
  • class_weight:字典,将不同的类别映射为不同的权值,该参数用来在训练过程中调整损失函数(只能用于训练)
  • sample_weight:权值的numpy 
    array,用于在训练时调整损失函数(仅用于训练)。可以传递一个1D的与样本等长的向量用于对样本进行1对1的加权,或者在面对时序数据时,传递一个的形式为(samples,sequence_length)的矩阵来为每个时间步上的样本赋不同的权。这种情况下请确定在编译模型时添加了sample_weight_mode=’temporal’。
  • initial_epoch:
    从该参数指定的epoch开始训练,在继续之前的训练时有用。

fit函数返回一个History的对象,其History.history属性记录了损失函数和其他指标的数值随epoch变化的情况,如果有验证集的话,也包含了验证集的这些指标变化情况 
注意: 
要与之后的fit_generator做区别,两者输入x/y不同。

 

4.evaluate 模型评估

evaluate(self, x, y, batch_size=32, verbose=1, sample_weight=None)

 

本函数按batch计算在某些输入数据上模型的误差,其参数有:

  • x:输入数据,与fit一样,是numpy array或numpy array的list
  • y:标签,numpy array
  • batch_size:整数,含义同fit的同名参数
  • verbose:含义同fit的同名参数,但只能取0或1
  • sample_weight:numpy array,含义同fit的同名参数

本函数返回一个测试误差的标量值(如果模型没有其他评价指标),或一个标量的list(如果模型还有其他的评价指标)。model.metrics_names将给出list中各个值的含义。

如果没有特殊说明,以下函数的参数均保持与fit的同名参数相同的含义 
如果没有特殊说明,以下函数的verbose参数(如果有)均只能取0或1

 二.训练样本拼接

5 predict 模型评估

predict(self, x, batch_size=32, verbose=0)
predict_classes(self, x, batch_size=32, verbose=1)
predict_proba(self, x, batch_size=32, verbose=1)

本函数按batch获得输入数据对应的输出,其参数有:

函数的返回值是预测值的numpy array 
predict_classes:本函数按batch产生输入数据的类别预测结果; 
predict_proba:本函数按batch产生输入数据属于各个类别的概率

        
首先设置一个滑动窗口,本次实验中将滑动窗口设置为50个交易日。每一个训练样本由50个连续的交易日组成,每个交易日的数据包含上述的七个特征,即一个50*7的矩阵,而一个样本的输出则是三个交易日之后的收盘价对比今日(即样本的输入中最后一个交易日)收盘价的涨跌幅,设置其上限为0.3,下限为-0.3(当然,连续三个涨停板的涨幅会超过0.3,这里将其统一视作0.3)。之所以选择三个交易日之后的涨跌幅作为训练样本的输出,是因为我国股市是T+1操作规则,当日买入不可卖出,预测的稍微靠后一些可留有操作空间;再有就是一天的拉升/砸盘偶然性太大,不易预测,对稍微长期一点的状况进行预测有着更高的稳定性。

6 on_batch 、batch的结果,检查

train_on_batch(self, x, y, class_weight=None, sample_weight=None)
test_on_batch(self, x, y, sample_weight=None)
predict_on_batch(self, x)
  • train_on_batch:本函数在一个batch的数据上进行一次参数更新,函数返回训练误差的标量值或标量值的list,与evaluate的情形相同。
  • test_on_batch:本函数在一个batch的样本上对模型进行评估,函数的返回与evaluate的情形相同
  • predict_on_batch:本函数在一个batch的样本上对模型进行测试,函数返回模型在一个batch上的预测结果

  归一化相关工作:因为神经网络激活函数的限制,需要在训练前将数据映射到0~1区间。本次试验中,对近两年的数据,获取其各项特征的最大值与最小值。设置归一化与函数,在样本拼接的同时将数据进行归一化。

7 fit_generator

#利用Python的生成器,逐个生成数据的batch并进行训练。
#生成器与模型将并行执行以提高效率。
#例如,该函数允许我们在CPU上进行实时的数据提升,同时在GPU上进行模型训练
# 参考链接:http://keras-cn.readthedocs.io/en/latest/models/sequential/

 

有了该函数,图像分类训练任务变得很简单。

fit_generator(self, generator, steps_per_epoch, epochs=1, verbose=1, callbacks=None, validation_data=None, validation_steps=None, class_weight=None, max_q_size=10, workers=1, pickle_safe=False, initial_epoch=0)

# 案例:
def generate_arrays_from_file(path):
    while 1:
            f = open(path)
            for line in f:
                # create Numpy arrays of input data
                # and labels, from each line in the file
                x, y = process_line(line)
                yield (x, y)
        f.close()

model.fit_generator(generate_arrays_from_file('/my_file.txt'),
        samples_per_epoch=10000, epochs=10)

 

其他的两个辅助的内容:

evaluate_generator(self, generator, steps, max_q_size=10, workers=1, pickle_safe=False)
predict_generator(self, generator, steps, max_q_size=10, workers=1, pickle_safe=False, verbose=0)

 

evaluate_generator:本函数使用一个生成器作为数据源评估模型,生成器应返回与test_on_batch的输入数据相同类型的数据。该函数的参数与fit_generator同名参数含义相同,steps是生成器要返回数据的轮数。 
predcit_generator:本函数使用一个生成器作为数据源预测模型,生成器应返回与test_on_batch的输入数据相同类型的数据。该函数的参数与fit_generator同名参数含义相同,steps是生成器要返回数据的轮数。

样本 输入的归一化:

案例一:简单的2分类

For a single-input model with 2 classes (binary classification):

from keras.models import Sequential
from keras.layers import Dense, Activation

#模型搭建阶段
model= Sequential()
model.add(Dense(32, activation='relu', input_dim=100))
# Dense(32) is a fully-connected layer with 32 hidden units.
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])

其中: 
Sequential()代表类的初始化; 
Dense代表全连接层,此时有32个全连接层,最后接relu,输入的是100维度 
model.add,添加新的全连接层, 
compile,跟prototxt一样,一些训练参数,solver.prototxt

# Generate dummy data
import numpy as np
data = np.random.random((1000, 100))
labels = np.random.randint(2, size=(1000, 1))

# Train the model, iterating on the data in batches of 32 samples
model.fit(data, labels, nb_epoch =10, batch_size=32)

 

之前报过这样的错误,是因为版本的问题。 版本1.2里面是nb_epoch
,而keras2.0是epochs = 10

 error:
    TypeError: Received unknown keyword arguments: {'epochs': 10}

 

其中: 
epoch=batch_size * iteration,10次epoch代表训练十次训练集

最终代码是基于keras ==1.2

# -*- coding:utf-8 -*-

from keras.models import Sequential
from keras.layers import Dense, Activation

#模型搭建阶段
model= Sequential()#最简单的线性、从头到尾的结构顺序,不分叉
model.add(Dense(32, activation='relu', input_dim=100))
# Dense(32) is a fully-connected layer with 32 hidden units.
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])

# Generate dummy data
import numpy as np
data = np.random.random((1000, 100))
labels = np.random.randint(2, size=(1000, 1))

# Train the model, iterating on the data in batches of 32 samples
model.fit(data, labels, nb_epoch =10, batch_size=32)

 

 

 1 def normalize_oneday(stockN,fdata,day):
 2     max_min = list(max_min_list[stockN])
 3     in_1 = (fdata.ix[day,1]-max_min[1])/(max_min[0]-max_min[1])
 4     in_2 = (fdata.ix[day,2]-max_min[3])/(max_min[2]-max_min[3])
 5     in_3 = (fdata.ix[day,3]-max_min[5])/(max_min[4]-max_min[5])
 6     in_4 = (fdata.ix[day,4]-max_min[7])/(max_min[6]-max_min[7])
 7     in_5 = (fdata.ix[day,5]-max_min[9])/(max_min[8]-max_min[9])
 8     in_6 = (fdata.ix[day,6]-max_min[11])/(max_min[10]-max_min[11])
 9     in_7 = (fdata.ix[day,7]-max_min[13])/(max_min[12]-max_min[13])
10     return [in_1,in_2,in_3,in_4,in_5,in_6,in_7]

案例二:多分类-VGG的卷积神经网络

import numpy as np
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.optimizers import SGD
from keras.utils import np_utils

# Generate dummy data
x_train = np.random.random((100, 100, 100, 3))
# 100张图片,每张100*100*3
y_train = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10)
# 100*10
x_test = np.random.random((20, 100, 100, 3))
y_test = keras.utils.to_categorical(np.random.randint(10, size=(20, 1)), num_classes=10)
# 20*100

model = Sequential()
# input: 100x100 images with 3 channels -> (100, 100, 3) tensors.
# this applies 32 convolution filters of size 3x3 each.
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(100, 100, 3)))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd)

model.fit(x_train, y_train, batch_size=32, epochs=10)
score = model.evaluate(x_test, y_test, batch_size=32)

 

标准序贯网络,标签的训练模式 
注意: 
这里非常重要的一点,对于我这样的新手,这一步的作用?

keras.utils.to_categorical

 

特别是多分类时候,我之前以为输入的就是一列(100,),但是keras在多分类任务中是不认得这个的,所以需要再加上这一步,让其转化为Keras认得的数据格式。

 

最终代码基于Keras==2.0

# -*- coding:utf-8 -*-


import numpy as np
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.optimizers import SGD
from keras.utils import np_utils

# Generate dummy data
x_train = np.random.random((100, 100, 100, 3))
# 100张图片,每张100*100*3
y_train = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10)
# 100*10
x_test = np.random.random((20, 100, 100, 3))
y_test = keras.utils.to_categorical(np.random.randint(10, size=(20, 1)), num_classes=10)
# 20*100

model = Sequential()#最简单的线性、从头到尾的结构顺序,不分叉
# input: 100x100 images with 3 channels -> (100, 100, 3) tensors.
# this applies 32 convolution filters of size 3x3 each.
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(100, 100, 3)))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd)

model.fit(x_train, y_train, batch_size=32, epochs=10)
score = model.evaluate(x_test, y_test, batch_size=32)

 

样本 输出的归一化与反归一化:

案例三:使用LSTM的序列分类

具体的专门有链接来写:

.


def normalize_raise(volume):
    norm_value = (volume+0.3)/0.6
    if norm_value>1:
        norm_value = 1   #涨跌幅超过30%的都定义为 1或0
    elif norm_value<0:
        norm_value = 0
    return norm_value
def denormalize_raise(value):
    volume = value*0.6-0.3
    return volume

三、Model式模型

来自keras中文文档: 
比序贯模型要复杂,但是效果很好,可以同时/分阶段输入变量,分阶段输出想要的模型; 
一句话,只要你的模型不是类似VGG一样一条路走到黑的模型,或者你的模型需要多于一个的输出,那么你总应该选择函数式模型。

不同之处: 
书写结构完全不一致

         设置滑动窗口sample_window =
[],每次遍历一行特征数据,归一化后插入窗口末尾,当窗口大小满50时,计算3天后涨跌幅,拼接出一个训练样本,并将sample_window中第一个交易日的值弹出。

函数式模型基本属性与训练流程

一般需要: 
1、model.layers,添加层信息;  
2、model.compile,模型训练的BP模式设置; 
3、model.fit,模型训练参数设置 + 训练; 
4、evaluate,模型评估; 
5、predict 模型预测

发表评论

电子邮件地址不会被公开。 必填项已用*标注