学习笔记——深度学习模型Stock Trend预测实例

Quandl世界经济金融数据平台，拥有海量的经济和金融数据

使用quandl提供的数据集安装库导入即可，pip install quandl

quandl提供的Google Stock数据集，数据集中变量介绍：

• Date：日期
• Open：开盘价
• High：最高价
• Low：最低价
• Close：收盘价
• Volume：总交易额

开盘价和收盘价代表股票在某一天的起始价和最终价

交易总量指当天买卖的股票数量

损益的计算通常是由股票当日的收盘价决定，因此我们将收盘价作为预测目标

用多输入单输出的网络结构LSTM进行stock trend预测

具体过程：取一定时间点的数据作为输入，预测该段时间的下一个交易日的收盘价，不断缩小真实收盘价与预测收盘价的差值loss

文末附基于tensorflow实现的完整代码，学习探索阶段仅是调试跑大佬的代码学习一下！

1.加载数据

start = date(2000,10,12)
end = date.today()
google_stock = pd.Dataframe(quandl.get("WIKI/GOOGL", start_date=start, end_date=end))
print(google_stock.shape)
google_stock.tail()
google_stock.head()

2.绘制股票历史趋势图

plt.figure(figsize=(16, 8))
plt.plot(google_stock['Close'])
plt.show()

 3.构造训练集与验证集

每50个交易日作为输入预测一个收盘价

训练集大小0-2800

验证集大小2800之后

训练集：输入是50个交易日  输出是一个收盘价  通过迭代构造

time_stamp = 50  # 时间点长度

# 划分训练集与验证集
google_stock = google_stock[['Open', 'High', 'Low', 'Close', 'Volume']]  # 'Volume'
train = google_stock[0:2800 + time_stamp]
valid = google_stock[2800 - time_stamp:]

# 归一化
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(train)
x_train, y_train = [], []

# 训练集
print(scaled_data.shape)
print(scaled_data[1, 3])
for i in range(time_stamp, len(train)):
    x_train.append(scaled_data[i - time_stamp:i])
    y_train.append(scaled_data[i, 3])
x_train, y_train = np.array(x_train), np.array(y_train)

# 验证集
scaled_data = scaler.fit_transform(valid)
x_valid, y_valid = [], []
for i in range(time_stamp, len(valid)):
    x_valid.append(scaled_data[i - time_stamp:i])
    y_valid.append(scaled_data[i, 3])
x_valid, y_valid = np.array(x_valid), np.array(y_valid)

print(x_train.shape)
print(x_valid.shape)
train.head()

 4.创建并训练LSTM模型

epochs = 3 即三个迭代

LSTM 参数:

• return_sequences  为True时LSTM输出为一个序列，相当于多层叠加。默认值为False，输出一个值，即只有一层
• input_dim：输入单个样本特征值的维度
• input_length：输入的时间点长度

loss='mean_squared_error'  误差衡量

# 超参数
epochs = 3
batch_size = 16
model = Sequential()

model.add(LSTM(units=100, return_sequences=True, input_dim=x_train.shape[-1], input_length=x_train.shape[1]))
model.add(LSTM(units=50))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, verbose=1)

 5.预测stock价格

closing_price = model.predict(x_valid)
scaler.fit_transform(pd.Dataframe(valid['Close'].values))
# 反归一化
closing_price = scaler.inverse_transform(closing_price)
y_valid = scaler.inverse_transform([y_valid])
# print(y_valid)
# print(closing_price)
rms = np.sqrt(np.mean(np.power((y_valid - closing_price), 2)))
print(rms)
print(closing_price.shape)
print(y_valid.shape)

6.拟合stock trend

plt.figure(figsize=(16, 8))
dict_data = {
    'Predictions': closing_price.reshape(1,-1)[0],
    'Close': y_valid[0]
}
data_pd = pd.Dataframe(dict_data)
plt.plot(data_pd[['Close', 'Predictions']])
plt.show()

LSTM能够处理文本序列的位置信息，因此它能比CNN更好地处理文本，但由于它无法和CNN那样并行化计算，导致其训练速度会比CNN慢很多。

所以，为了能够在处理文本过程中获取文本的序列信息，且能在训练过程中并行化计算，谷歌提出了self-attention机制，它几乎取代了RNN和LSTM

本文的核心思想其实就是梯度下降（可参考这篇关于梯度下降的介绍），对于不同的任务，我们无非是换了不同的网络结构，用上了不同的loss，采用了不同的超参数设定去训练，整体的思想始终不变；梯度下降思想也是深度学习的核心思想，只有了解梯度下降的就基本原理，才能更好 地使用与创造适用于各种任务的网络结构 

学习过程中也遇到了很多问题，通过解决问题学习知识！

使用Jupyter调试代码更加可视化

了解了tensorflow 

还是需要基础的，接下来的两周准备看些机器学习，然后慢慢深入到深度学习，之后尝试用pytorch或者tensorflow跑一下别人的代码，了解模型结构的使用机制，总而言之多动手看代码！

from datetime import date
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import numpy as np
import pandas as pd
import quandl
from sklearn.preprocessing import MinMaxScaler
from matplotlib import pyplot as plt
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.layers import LSTM

# 1.获取数据
start = date(2000,10,12)
end = date.today()
google_stock = pd.Dataframe(quandl.get("WIKI/GOOGL", start_date=start, end_date=end))
print(google_stock.shape)
google_stock.tail()
google_stock.head()


# 2.绘制历史收盘价趋势图
plt.figure(figsize=(16, 8))
plt.plot(google_stock['Close'])
plt.show()


# 3.构造数据集与验证集
time_stamp = 50  # 时间点长度

# 划分训练集与验证集
google_stock = google_stock[['Open', 'High', 'Low', 'Close', 'Volume']]  # 'Volume'
train = google_stock[0:2800 + time_stamp]
valid = google_stock[2800 - time_stamp:]

# 归一化
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(train)
x_train, y_train = [], []

# 训练集
print(scaled_data.shape)
print(scaled_data[1, 3])
for i in range(time_stamp, len(train)):
    x_train.append(scaled_data[i - time_stamp:i])
    y_train.append(scaled_data[i, 3])
x_train, y_train = np.array(x_train), np.array(y_train)

# 验证集
scaled_data = scaler.fit_transform(valid)
x_valid, y_valid = [], []
for i in range(time_stamp, len(valid)):
    x_valid.append(scaled_data[i - time_stamp:i])
    y_valid.append(scaled_data[i, 3])
x_valid, y_valid = np.array(x_valid), np.array(y_valid)

print(x_train.shape)
print(x_valid.shape)
train.head()


# 4.创建并训练LSTM模型
# 超参数
epochs = 3
batch_size = 16
# LSTM 参数: return_sequences=True LSTM输出为一个序列。默认为False，输出一个值。
# input_dim：输入单个样本特征值的维度
# input_length：输入的时间点长度
model = Sequential()

model.add(LSTM(units=100, return_sequences=True, input_dim=x_train.shape[-1], input_length=x_train.shape[1]))
model.add(LSTM(units=50))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, verbose=1)


# 5.预测股票价格
closing_price = model.predict(x_valid)
scaler.fit_transform(pd.Dataframe(valid['Close'].values))
# 反归一化
closing_price = scaler.inverse_transform(closing_price)
y_valid = scaler.inverse_transform([y_valid])
# print(y_valid)
# print(closing_price)
rms = np.sqrt(np.mean(np.power((y_valid - closing_price), 2)))
print(rms)
print(closing_price.shape)
print(y_valid.shape)


# 6.拟合stock trend
plt.figure(figsize=(16, 8))
dict_data = {
    'Predictions': closing_price.reshape(1,-1)[0],
    'Close': y_valid[0]
}
data_pd = pd.Dataframe(dict_data)
plt.plot(data_pd[['Close', 'Predictions']])
plt.show()