关键词：
第一部分：从RNN到LSTM
1、什么是RNN
RNN全称循环神经网络（Recurrent Neural Networks），是用来处理序列数据的。在传统的神经网络模型中，从输入层到隐含层再到输出层，层与层之间是全连接的，每层之间的节点是无连接的。但是这种普通的神经网络对于很多关于时间序列的问题却无能无力。例如，你要预测句子的下一个单词是什么，一般需要用到前面的单词，因为一个句子中前后单词并不是独立的。RNN之所以称为循环神经网路，即一个序列当前的输出与前面的输出也有关。具体的表现形式为网络会对前面时刻的信息进行记忆并应用于当前输出的计算中，即隐藏层之间的节点不再无连接而是有连接的，并且隐藏层的输入不仅包括输入层的输出还包括上一时刻隐藏层的输出,如下图所示：
传统的神经网络中，数据从输入层输入，在隐藏层加工，从输出层输出。RNN不同的就是在隐藏层的加工方法不一样，后一个节点不仅受输入层输入的影响，还包受上一个节点的影响。
展开来就是这个样子：图中的xt−1，xt， xt+1代表不同时刻的输入，每个x都具有input layer的n维特征，依次进入循环神经网络以后，隐藏层输出st受到上一时刻st−1的隐藏层输出以及此刻输入层输入xt
的两方面影响。
缺点：RNN利用内部的记忆来处理任意时序的输入序列，并且在其处理单元之间既有内部的反馈连接又有前馈连接，这使得RNN可以更加容易处理不分段的文本等。但是由于RNN只能对部分序列进行记忆，所以在长序列上表现远不如短序列，造成了一旦序列过长便使得准确率下降的结果。
2、什么是LSTM
长短记忆神经网络——通常称作LSTM，是一种特殊的RNN，能够学习长的依赖关系。 他们由Hochreiter＆Schmidhuber引入，并被许多人进行了改进和普及。他们在各种各样的问题上工作的非常好，现在被广泛使用。
LSTM是为了避免长依赖问题而精心设计的。 记住较长的历史信息实际上是他们的默认行为，而不是他们努力学习的东西。
所有循环神经网络都具有神经网络的重复模块链的形式。 在标准的RNN中，该重复模块将具有非常简单的结构，例如单个tanh层。
LSTM也拥有这种链状结构，但是重复模块则拥有不同的结构。与神经网络的简单的一层相比，LSTM拥有四层，这四层以特殊的方式进行交互。
LSTM背后的核心理念
LSTM的关键是细胞状态，表示细胞状态的这条线水平的穿过图的顶部。
细胞的状态类似于输送带，细胞的状态在整个链上运行，只有一些小的线性操作作用其上，信息很容易保持不变的流过整个链。
门(Gate)是一种可选地让信息通过的方式。 它由一个Sigmoid神经网络层和一个点乘法运算组成。
Sigmoid神经网络层输出0和1之间的数字，这个数字描述每个组件有多少信息可以通过， 0表示不通过任何信息，1表示全部通过
LSTM有三个门，用于保护和控制细胞的状态。
一步步的拆解LSTM
LSTM的第一步是决定我们要从细胞状态中丢弃什么信息。 该决定由被称为“忘记门”的Sigmoid层实现。它查看ht-1(前一个输出)和xt(当前输入)，并为单元格状态Ct-1(上一个状态)中的每个数字输出0和1之间的数字。1代表完全保留，而0代表彻底删除。
让我们回到语言模型的例子，试图根据以前的语料来预测下一个单词。 在这样的问题中，细胞状态可能包括当前主题的性别，从而决定使用正确的代词。 当我们看到一个新主题时，我们想要忘记旧主题的性别。
下一步是决定我们要在细胞状态中存储什么信息。 这部分分为两步。 首先，称为“输入门层”的Sigmoid层决定了我们将更新哪些值。 接下来一个tanh层创建候选向量Ct,该向量将会被加到细胞的状态中。 在下一步中，我们将结合这两个向量来创建更新值。
在我们的语言模型的例子中，我们希望将新主题的性别添加到单元格状态，以替换我们忘记的旧对象。
现在是时候去更新上一个状态值Ct−1了，将其更新为Ct。签名的步骤以及决定了应该做什么，我们只需实际执行即可。
我们将上一个状态值乘以ft，以此表达期待忘记的部分。之后我们将得到的值加上 it∗C? t。这个得到的是新的候选值， 按照我们决定更新每个状态值的多少来衡量.
在语言模型的例子中，对应着实际删除关于旧主题性别的信息，并添加新信息，正如在之前的步骤中描述的那样。
最后，我们需要决定我们要输出什么。 此输出将基于我们的细胞状态，但将是一个过滤版本。 首先，我们运行一个sigmoid层，它决定了我们要输出的细胞状态的哪些部分。 然后，我们将单元格状态通过tanh（将值规范化到-1和1之间），并将其乘以Sigmoid门的输出，至此我们只输出了我们决定的那些部分。
对于语言模型的例子，由于只看到一个主题，考虑到后面可能出现的词，它可能需要输出与动词相关的信息。 例如，它可能会输出主题是单数还是复数，以便我们知道动词应该如何组合在一起。
3、股票预测实战1
在对理论有理解的基础上，我们使用LSTM对股票进行预测。
环境配置如下：
- Python 3.5.x
- TensorFlow 1.10.0
- Numpy 1.15.0
- Keras 2.2.2
- Matplotlib 2.2.2
步骤一、导入数据：
import math
import numpy as np
import pandas as pd
class DataLoader():
"""A class for loading and transforming data for the lstm model"""
def __init__(self, filename, split, cols):
dataframe = pd.read_csv(filename)
i_split = int(len(dataframe) * split)
self.data_train = dataframe.get(cols).values[:i_split]
self.data_test = dataframe.get(cols).values[i_split:]
self.len_train = len(self.data_train)
self.len_test = len(self.data_test)
self.len_train_windows = None
def get_test_data(self, seq_len, normalise):
‘‘‘
Create x, y test data windows
Warning: batch method, not generative, make sure you have enough memory to
load data, otherwise reduce size of the training split.
‘‘‘
data_windows = []
for i in range(self.len_test - seq_len):
data_windows.append(self.data_test[i:i+seq_len])
data_windows = np.array(data_windows).astype(float)
data_windows = self.normalise_windows(data_windows, single_window=False) if normalise else data_windows
x = data_windows[:, :-1]
y = data_windows[:, -1, [0]]
return x,y
def get_train_data(self, seq_len, normalise):
‘‘‘
Create x, y train data windows
Warning: batch method, not generative, make sure you have enough memory to
load data, otherwise use generate_training_window() method.
‘‘‘
data_x = []
data_y = []
for i in range(self.len_train - seq_len):
x, y = self._next_window(i, seq_len, normalise)
data_x.append(x)
data_y.append(y)
return np.array(data_x), np.array(data_y)
def generate_train_batch(self, seq_len, batch_size, normalise):
‘‘‘Yield a generator of training data from filename on given list of cols split for train/test‘‘‘
i = 0
while i < (self.len_train - seq_len):
x_batch = []
y_batch = []
for b in range(batch_size):
if i >= (self.len_train - seq_len):
# stop-condition for a smaller final batch if data doesn‘t divide evenly
yield np.array(x_batch), np.array(y_batch)
i = 0
x, y = self._next_window(i, seq_len, normalise)
x_batch.append(x)
y_batch.append(y)
i += 1
yield np.array(x_batch), np.array(y_batch)
def _next_window(self, i, seq_len, normalise):
‘‘‘Generates the next data window from the given index location i‘‘‘
window = self.data_train[i:i+seq_len]
window = self.normalise_windows(window, single_window=True)[0] if normalise else window
x = window[:-1]
y = window[-1, [0]]
return x, y
def normalise_windows(self, window_data, single_window=False):
‘‘‘Normalise window with a base value of zero‘‘‘
normalised_data = []
window_data = [window_data] if single_window else window_data
for window in window_data:
normalised_window = []
for col_i in range(window.shape[1]):
normalised_col = [((float(p) / float(window[0, col_i])) - 1) for p in window[:, col_i]]
normalised_window.append(normalised_col)
normalised_window = np.array(normalised_window).T # reshape and transpose array back into original multidimensional format
normalised_data.append(normalised_window)
return np.array(normalised_data)
步骤二、定义模型
import os
import math
import numpy as np
import datetime as dt
from numpy import newaxis
from core.utils import Timer
from keras.layers import Dense, Activation, Dropout, LSTM
from keras.models import Sequential, load_model
from keras.callbacks import EarlyStopping, ModelCheckpoint
class Model():
"""A class for an building and inferencing an lstm model"""
def __init__(self):
self.model = Sequential()
def load_model(self, filepath):
print(‘[Model] Loading model from file %s‘ % filepath)
self.model = load_model(filepath)
def build_model(self, configs):
timer = Timer()
timer.start()
for layer in configs[‘model‘][‘layers‘]:
neurons = layer[‘neurons‘] if ‘neurons‘ in layer else None
dropout_rate = layer[‘rate‘] if ‘rate‘ in layer else None
activation = layer[‘activation‘] if ‘activation‘ in layer else None
return_seq = layer[‘return_seq‘] if ‘return_seq‘ in layer else None
input_timesteps = layer[‘input_timesteps‘] if ‘input_timesteps‘ in layer else None
input_dim = layer[‘input_dim‘] if ‘input_dim‘ in layer else None
if layer[‘type‘] == ‘dense‘:
self.model.add(Dense(neurons, activation=activation))
if layer[‘type‘] == ‘lstm‘:
self.model.add(LSTM(neurons, input_shape=(input_timesteps, input_dim), return_sequences=return_seq))
if layer[‘type‘] == ‘dropout‘:
self.model.add(Dropout(dropout_rate))
self.model.compile(loss=configs[‘model‘][‘loss‘], optimizer=configs[‘model‘][‘optimizer‘])
print(‘[Model] Model Compiled‘)
timer.stop()
def train(self, x, y, epochs, batch_size, save_dir):
timer = Timer()
timer.start()
print(‘[Model] Training Started‘)
print(‘[Model] %s epochs, %s batch size‘ % (epochs, batch_size))
save_fname = os.path.join(save_dir, ‘%s-e%s.h5‘ % (dt.datetime.now().strftime(‘%d%m%Y-%H%M%S‘), str(epochs)))
callbacks = [
EarlyStopping(monitor=‘val_loss‘, patience=2),
ModelCheckpoint(filepath=save_fname, monitor=‘val_loss‘, save_best_only=True)
]
self.model.fit(
x,
y,
epochs=epochs,
batch_size=batch_size,
callbacks=callbacks
)
self.model.save(save_fname)
print(‘[Model] Training Completed. Model saved as %s‘ % save_fname)
timer.stop()
def train_generator(self, data_gen, epochs, batch_size, steps_per_epoch, save_dir):
timer = Timer()
timer.start()
print(‘[Model] Training Started‘)
print(‘[Model] %s epochs, %s batch size, %s batches per epoch‘ % (epochs, batch_size, steps_per_epoch))
save_fname = os.path.join(save_dir, ‘%s-e%s.h5‘ % (dt.datetime.now().strftime(‘%d%m%Y-%H%M%S‘), str(epochs)))
callbacks = [
ModelCheckpoint(filepath=save_fname, monitor=‘loss‘, save_best_only=True)
]
self.model.fit_generator(
data_gen,
steps_per_epoch=steps_per_epoch,
epochs=epochs,
callbacks=callbacks,
workers=1
)
print(‘[Model] Training Completed. Model saved as %s‘ % save_fname)
timer.stop()
def predict_point_by_point(self, data):
#Predict each timestep given the last sequence of true data, in effect only predicting 1 step ahead each time
print(‘[Model] Predicting Point-by-Point...‘)
predicted = self.model.predict(data)
predicted = np.reshape(predicted, (predicted.size,))
return predicted
def predict_sequences_multiple(self, data, window_size, prediction_len):
#Predict sequence of 50 steps before shifting prediction run forward by 50 steps
print(‘[Model] Predicting Sequences Multiple...‘)
prediction_seqs = []
for i in range(int(len(data)/prediction_len)):
curr_frame = data[i*prediction_len]
predicted = []
for j in range(prediction_len):
predicted.append(self.model.predict(curr_frame[newaxis,:,:])[0,0])
curr_frame = curr_frame[1:]
curr_frame = np.insert(curr_frame, [window_size-2], predicted[-1], axis=0)
prediction_seqs.append(predicted)
return prediction_seqs
def predict_sequence_full(self, data, window_size):
#Shift the window by 1 new prediction each time, re-run predictions on new window
print(‘[Model] Predicting Sequences Full...‘)
curr_frame = data[0]
predicted = []
for i in range(len(data)):
predicted.append(self.model.predict(curr_frame[newaxis,:,:])[0,0])
curr_frame = curr_frame[1:]
curr_frame = np.insert(curr_frame, [window_size-2], predicted[-1], axis=0)
return predicted
步骤三、模型训练
import os
import json
import time
import math
import matplotlib.pyplot as plt
from core.data_processor import DataLoader
from core.model import Model
def plot_results(predicted_data, true_data):
fig = plt.figure(facecolor=‘white‘)
ax = fig.add_subplot(111)
ax.plot(true_data, label=‘True Data‘)
plt.plot(predicted_data, label=‘Prediction‘)
plt.legend()
plt.show()
def plot_results_multiple(predicted_data, true_data, prediction_len):
fig = plt.figure(facecolor=‘white‘)
ax = fig.add_subplot(111)
ax.plot(true_data, label=‘True Data‘)
# Pad the list of predictions to shift it in the graph to it‘s correct start
for i, data in enumerate(predicted_data):
padding = [None for p in range(i * prediction_len)]
plt.plot(padding + data, label=‘Prediction‘)
plt.legend()
plt.show()
def main():
configs = json.load(open(‘config.json‘, ‘r‘))
if not os.path.exists(configs[‘model‘][‘save_dir‘]): os.makedirs(configs[‘model‘][‘save_dir‘])
data = DataLoader(
os.path.join(‘data‘, configs[‘data‘][‘filename‘]),
configs[‘data‘][‘train_test_split‘],
configs[‘data‘][‘columns‘]
)
model = Model()
model.build_model(configs)
x, y = data.get_train_data(
seq_len=configs[‘data‘][‘sequence_length‘],
normalise=configs[‘data‘][‘normalise‘]
)
‘‘‘
# in-memory training
model.train(
x,
y,
epochs = configs[‘training‘][‘epochs‘],
batch_size = configs[‘training‘][‘batch_size‘],
save_dir = configs[‘model‘][‘save_dir‘]
)
‘‘‘
# out-of memory generative training
steps_per_epoch = math.ceil((data.len_train - configs[‘data‘][‘sequence_length‘]) / configs[‘training‘][‘batch_size‘])
model.train_generator(
data_gen=data.generate_train_batch(
seq_len=configs[‘data‘][‘sequence_length‘],
batch_size=configs[‘training‘][‘batch_size‘],
normalise=configs[‘data‘][‘normalise‘]
),
epochs=configs[‘training‘][‘epochs‘],
batch_size=configs[‘training‘][‘batch_size‘],
steps_per_epoch=steps_per_epoch,
save_dir=configs[‘model‘][‘save_dir‘]
)
x_test, y_test = data.get_test_data(
seq_len=configs[‘data‘][‘sequence_length‘],
normalise=configs[‘data‘][‘normalise‘]
)
predictions = model.predict_sequences_multiple(x_test, configs[‘data‘][‘sequence_length‘], configs[‘data‘][‘sequence_length‘])
# predictions = model.predict_sequence_full(x_test, configs[‘data‘][‘sequence_length‘])
# predictions = model.predict_point_by_point(x_test)
plot_results_multiple(predictions, y_test, configs[‘data‘][‘sequence_length‘])
# plot_results(predictions, y_test)
if __name__ == ‘__main__‘:
main()
最终运行结果显示：
深度学习lstm预测股票价格(代码片段)
...深度学习1年多了，该还的还得还，没接触过LSTM的预测项目，这就来活了。文章目录前言1.开工1.1引入必须的库1.2数据初探1.3划分数据集1.4数据归一化1.5数据分组1.6搭建模型1.7训练1.8测试集总结前言LSTM是一个处理时序... 查看详情
多元 LSTM 股票预测
】多元LSTM股票预测【英文标题】：MultivarateLSTMstockprediction【发布时间】：2020-05-1515:29:33【问题描述】：我正在使用keras构建股票预测。我知道如何用单变量（例如\'Open\'）做一个简单的。我想处理多个变量，例如“打开、关闭、... 查看详情
深度学习100例-循环神经网络（lstm）实现股票预测|第10天(代码片段)
🔗运行环境：python3🚩作者：K同学啊🥇精选专栏：《深度学习100例》🔥选自专栏：《新手入门深度学习》📚推荐专栏：《Matplotlib教程》🧿优秀专栏：《Python入门100题》文章目录一... 查看详情
python金融量化9-100九预测股票收益方法总结(代码片段)
背景介绍：量化投资有两大主流门派：主动投资和被动投资。这也代表了不同的学术观点：市场到底是不是有效的？如果市场是有效的，那我们一定能找到赚钱的办法，只要付诸足够的努力，再加上一... 查看详情
[pytorch系列-55]：循环神经网络-使用lstm网络对股票走势进行预测(代码片段)
...5.3loss损失迭代过程第6章测试训练效果6.2去归一化6.3显示预测结果与实际股价的关系第1章LSTM神经网络理论基础[Pytorch系列-53]：循环神经网络-torch.nn.LSTM（）参数详解_文火冰糖（王文兵）的博客-CSDN博客https://blo... 查看详情
时间序列深度学习：状态lstm模型预测太阳黑子(代码片段)
...方面取得了显着进展。随着这些ML/DL工具的发展，企业和金融机构现在可以通过应用这些新技术来解决旧问题，从而更好地进行预测。在本文中，我们 查看详情
使用tensorflow进行股票价格预测的简单深度学习模型(代码片段)
使用TensorFlow进行股票价格预测的简单深度学习模型（翻译）原文链接：https://medium.com/mlreview/a-simple-deep-learning-model-for-stock-price-prediction-using-tensorflow-30505541d877深度学习在金融市场的应用越来越广泛，这篇来 查看详情
在 Keras 中使用 LSTM 预测股票（Python 3.7、Tensorflow 2.1.0）
】在Keras中使用LSTM预测股票（Python3.7、Tensorflow2.1.0）【英文标题】：ForecastingstockswithLSTMinKeras(Python3.7,Tensorflow2.1.0)【发布时间】：2020-10-1615:17:03【问题描述】：我正在尝试使用LSTM来预测道琼斯工业平均指数在未来几个月的表现。... 查看详情
基于lstm的序列预测:飞机月流量预测(代码片段)
基于LSTM的序列预测:飞机月流量预测 循环神经网络，如RNN，LSTM等模型，比较适合用于序列预测，下面以一个比较经典的飞机月流量数据集，介绍LSTM的使用方法和训练过程。完整的项目代码下载：https://down... 查看详情
深度学习100例——利用pytorch长短期记忆网络lstm实现股票预测分析|第5例
前言大家好，我是阿光。本专栏整理了《深度学习100例》，内包含了各种不同的深度学习项目，包含项目原理以及源码，每一个项目实例都附带有完整的代码+数据集。正在更新中~✨ 查看详情
如何使用 LSTM Keras 预测未来库存
】如何使用LSTMKeras预测未来库存【英文标题】：HowtopredictfutureStockusingLSTMKeras【发布时间】：2020-06-0200:35:41【问题描述】：首先，我必须说，我是这个AI事物的初学者。我遵循了大多数关于股市预测的教程，它们几乎都一样。这些... 查看详情
lstm预测基于matlab贝叶斯网络改进lstm预测含matlab源码1158期(代码片段)
一、简介基于matlab贝叶斯网络改进LSTM预测二、源代码%%%%%%%%%%GaussianProcessRegression(GPR)%%%%%%%%%%Demo:predictionusingGPR%---------------------------------------------------------------------%clccloseallclearalladdpath 查看详情
蚁群算法aco优化lstm超参数(代码片段)
前言LSTM航空乘客预测单步预测的两种情况。简单运用LSTM模型进行预测分析。加入注意力机制的LSTM对航空乘客预测采用了目前市面上比较流行的注意力机制，将两者进行结合预测。多层LSTM对航空乘客预测简单运用多层的LSTM... 查看详情
基于lstm的序列预测:飞机月流量预测(代码片段)
基于LSTM的序列预测:飞机月流量预测 循环神经网络，如RNN，LSTM等模型，比较适合用于序列预测，下面以一个比较经典的飞机月流量数据集，介绍LSTM的使用方法和训练过程。完整的项目代码下载：https://down... 查看详情
你如何使用 LSTM 模型预测未来的预测？
】你如何使用LSTM模型预测未来的预测？【英文标题】：HowdoyoupredictfuturepredictionswithanLSTMmodel?【发布时间】：2020-08-2414:28:33【问题描述】：您如何使用此模型预测未来价值？我尝试将时间步长窗口更改为比股票数据库更大的值，... 查看详情
pytorchnote42lstm做词性预测(代码片段)
PytorchNote42LSTM做词性预测文章目录PytorchNote42LSTM做词性预测模型介绍编码构建单个字符的lstm模型构建词性分类的lstm模型开始训练预测全部笔记的汇总贴：PytorchNote快乐星球模型介绍对于一个单词，会有这不同的词性，... 查看详情
基于优化ｌｓｔｍ模型的股票预测
...诞生以来，便以其在处理时间序列方面的优越性能在预测回归，语音翻译等领域广受青睐。今天，主要研究的是通过对LSTM模型的优化来实现股票预测。其实，关于股票预测，LSTM模型已经表现的相当成熟，... 查看详情
基于优化ｌｓｔｍ模型的股票预测
...诞生以来，便以其在处理时间序列方面的优越性能在预测回归，语音翻译等领域广受青睐。今天，主要研究的是通过对LSTM模型的优化来实现股票预测。其实，关于股票预测，LSTM模型已经表现的相当成熟，... 查看详情