LSTM用于股票预测和字符识别时网络结构的不同

最新推荐文章于 2022-07-20 16:31:33 发布

wzw845212252

最新推荐文章于 2022-07-20 16:31:33 发布

阅读量501

点赞数

文章标签：深度学习机器学习 tensorflow

本文链接：https://blog.csdn.net/wzw845212252/article/details/106716023

版权

LSTM用于股票预测和字符识别时网络结构的不同

一、这几天运行了其他博主关于股票预测和字符识别的代码（代码见参考链接），就代码实现方面，两者在网络结构的不同主要有两点：
1、预测股票在训练过程中，为了提高训练精度，使用了两层lstm，第一层需要每个时间点都要输出一个output，即直接根据当前 input数据得到一个输出hidden state，所以一个batch训练后输出的hidden state包含全部时间步的结果；字符分类则只需要最后一个时间点的hidden state，一个batch训练后输出的hidden state是最后一个时间步的结果；在代码中这主要由参数return_sequences控制，祥见这篇文章理解LSTM在keras API中参数return_sequences和return_state；
我们先来看一下一个用正弦曲线预测余弦曲线的代码。

# import os
# os.environ['KERAS_BACKEND']='tensorflow'
import numpy as np
np.random.seed(1337)  # for reproducibility
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import LSTM, TimeDistributed, Dense
from keras.optimizers import Adam

BATCH_START = 0
TIME_STEPS = 20
BATCH_SIZE = 50
INPUT_SIZE = 1
OUTPUT_SIZE = 1
CELL_SIZE = 20
LR = 0.006


def get_batch():
    global BATCH_START, TIME_STEPS
    # xs shape (50batch, 20steps)
    xs = np.arange(BATCH_START, BATCH_START+TIME_STEPS*BATCH_SIZE).reshape((BATCH_SIZE, TIME_STEPS)) / (10*np.pi)
    seq = np.sin(xs)
    res = np.cos(xs)
    BATCH_START += TIME_STEPS
    # plt.plot(xs[0, :], res[0, :], 'r', xs[0, :], seq[0, :], 'b--')
    # plt.show()
    return [seq[:, :, np.newaxis], res[:, :, np.newaxis], xs]

model = Sequential()
# build a LSTM RNN
model.add(LSTM(
    batch_input_shape=(BATCH_SIZE, TIME_STEPS, INPUT_SIZE),       # Or: input_dim=INPUT_SIZE, input_length=TIME_STEPS,
    output_dim=CELL_SIZE,
    return_sequences=True,      # True: output at all steps. False: output as last step. 
))
# add output layer
model.add(TimeDistributed(Dense(OUTPUT_SIZE)))
adam = Adam(LR)
model.compile(optimizer=adam,
              loss='mse',)

print('Training ------------')
for step in range(501):
    # data shape = (batch_num, steps, inputs/outputs)
    X_batch, Y_batch, xs = get_batch()
    cost = model.train_on_batch(X_batch, Y_batch)
    pred = model.predict(X_batch, BATCH_SIZE)
    plt.plot(xs[0, :], Y_batch[0].flatten(), 'r', xs[0, :], pred.flatten()[:TIME_STEPS], 'b--')
    plt.ylim((-1.2, 1.2))
    plt.draw()
    plt.pause(0.1)
    if step % 10 == 0:
        print('train cost: ', cost)

可以看到35行的return_sequences设置成了Ture，对应的就要在每个时间步上均操作Dense，所以全连接层是model.add(TimeDistributed(Dense(OUTPUT_SIZE)))而不是model.add(Dense(OUTPUT_SIZE))。
再来看一下预测股票代码中构建lstm模型的部分：

seq_len = 22
d = 0.2
shape = [4, seq_len, 1] # feature, window, output
neurons = [128, 128, 32, 1]

def build_model2(layers, neurons, d):
    model = Sequential()

    model.add(LSTM(neurons[0], input_shape=(layers[1], layers[0]), return_sequences=True))
    model.add(Dropout(d))

    model.add(LSTM(neurons[1], input_shape=(layers[1], layers[2]), return_sequences=False))
    model.add(Dropout(d))

    model.add(Dense(neurons[2], kernel_initializer="uniform", activation='relu'))
    model.add(Dense(neurons[3], kernel_initializer="uniform", activation='linear'))
    # model = load_model('my_LSTM_stock_model1000.h5')
    adam = keras.optimizers.Adam(decay=0.2)
    model.compile(loss='mse', optimizer='adam', metrics=['accuracy'])
    model.summary()
    return model

model = build_model2(shape, neurons, d)

代码中有两层lstm和两层全连接层，我认为是为了提高训练精度。由于第二层的return_sequences=False所以全连接层就直接用Dense（）了。
模型结构如下图所示。
在这里插入图片描述
我简单画了第一层lstm的网络结构：

字符识别代码中的构建lstm部分：

##处理数据，因为图片的大小是（28，28），所以将神经网络的输入设置为（28，），也就是一行一行的读入像素值，这样时间序列的值为列数值28。
#时间序列数量
n_step = 28
#每次输入的维度
n_input = 28
#分类类别数
n_classes = 10
n_lstm_out = 128

#LSTM层
model.add(LSTM(
        units = n_lstm_out,
        input_shape = (n_step, n_input)))
#全连接层
model.add(Dense(units = n_classes))
#激活层
model.add(Activation('softmax'))

默认return_sequences=False。
模型结构如下图所示：
在这里插入图片描述

2、预测股票最后不需要分类层softmax，字符分类需要，这点容易理解。

二、return_sequences的取值
LSTM层的输入输出关系如图。
在这里插入图片描述

1-One-to-one
model.add(Dense(output_size, input_shape=input_shape))
2-One-to-many:
model.add(RepeatVector(number_of_times, input_shape=input_shape))
model.add(LSTM(output_size, return_sequences=True))
3-Many-to-one:
model = Sequential()
model.add(LSTM(1, input_shape=(timesteps, data_dim)))
4-Many-to-many
model = Sequential()
model.add(LSTM(1, input_shape=(timesteps, data_dim), return_sequences=True))

1、对于上文中的正弦余弦模型，每次训练时用20个正弦点预测20个余弦点，是多对多的对应关系，如下图。
在这里插入图片描述
20个输入对应20个输出，所以return_sequences=True。

2、字符识别是将一副28*28的图片按行输入，相当于时间步长是28，然后输出一个预测值，是多对一的关系，如图。
在这里插入图片描述
return_sequences=False，因为只需要输出一个结果。

3、股票预测是用22天的数据预测一天的数据，也是多对一的关系，和字符识别不同的是有两层lstm，提高了训练精度，如图。
在这里插入图片描述
所以在代码中，第一层lstm的参数return_sequences=True，输出一个序列作为第二层lstm的输入，而第二层的return_sequences=False，因为只需输出一个结果。