如何使用TensorFlow 2和Keras在Python中预测股票价格

预测股价一直是吸引投资者和研究人员的话题。投资者总是猜测股票的价格是否会上涨，因为有许多复杂的财务指标，只有投资者和具有良好财务知识的人才能理解，所以股市的走势对普通百姓来说非常难以琢磨。

对于非专家而言，机器学习是一个很好的机会，它可以准确地预测并获得稳定的财富，并且可以帮助专家获得最有用的指标并做出更好的预测。

本教程的目的是在TensorFlow 2和Keras中构建一个预测股市价格的神经网络。更具体地说，我们将使用LSTM单元构建循环神经网络，因为这是时间序列预测的最新技术。

一、安装环境

好吧，让我们开始吧。首先，您需要安装Tensorflow 2和其他库：

pip3 install tensorflow pandas numpy matplotlib yahoo_fin sklearn

完成所有设置后，打开一个新的Python文件（或bfwstuio）并导入以下库：

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout, Bidirectional
from tensorflow.keras.callbacks import ModelCheckpoint, TensorBoard
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from yahoo_fin import stock_info as si
from collections import deque

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import time
import os
import random

我们正在使用yahoo_fin模块，它实际上是一个Python抓取工具，可从Yahoo Finance平台提取财务数据，因此它不是可靠的API，请随时使用Alpha Vantage等其他数据源。

另外，我们需要确保在进行培训/测试后我们能获得稳定的结果，设置种子可以帮助：

# set seed, so we can get the same results after rerunning several times
np.random.seed(314)
tf.random.set_seed(314)
random.seed(314)

二、准备数据集

第一步，我们需要编写一个函数，该函数从Internet下载数据集并对其进行预处理：

def load_data(ticker, n_steps=50, scale=True, shuffle=True, lookup_step=1, 
test_size=0.2, feature_columns=['adjclose', 'volume', 'open', 'high', 'low']):
"""
Loads data from Yahoo Finance source, as well as scaling, shuffling, normalizing and splitting.
Params:
ticker (str/pd.DataFrame): the ticker you want to load, examples include AAPL, TESL, etc.
n_steps (int): the historical sequence length (i.e window size) used to predict, default is 50
scale (bool): whether to scale prices from 0 to 1, default is True
shuffle (bool): whether to shuffle the data, default is True
lookup_step (int): the future lookup step to predict, default is 1 (e.g next day)
test_size (float): ratio for test data, default is 0.2 (20% testing data)
feature_columns (list): the list of features to use to feed into the model, default is everything grabbed from yahoo_fin
"""
# see if ticker is already a loaded stock from yahoo finance
if isinstance(ticker, str):
# load it from yahoo_fin library
df = si.get_data(ticker)
elif isinstance(ticker, pd.DataFrame):
# already loaded, use it directly
df = ticker
else:
raise TypeError("ticker can be either a str or a `pd.DataFrame` instances")
# this will contain all the elements we want to return from this function
result = {}
# we will also return the original dataframe itself
result['df'] = df.copy()
# make sure that the passed feature_columns exist in the dataframe
for col in feature_columns:
assert col in df.columns, f"'{col}' does not exist in the dataframe."
if scale:
column_scaler = {}
# scale the data (prices) from 0 to 1
for column in feature_columns:
scaler = preprocessing.MinMaxScaler()
df[column] = scaler.fit_transform(np.expand_dims(df[column].values, axis=1))
column_scaler[column] = scaler
# add the MinMaxScaler instances to the result returned
result["column_scaler"] = column_scaler
# add the target column (label) by shifting by `lookup_step`
df['future'] = df['adjclose'].shift(-lookup_step)
# last `lookup_step` columns contains NaN in future column
# get them before droping NaNs
last_sequence = np.array(df[feature_columns].tail(lookup_step))
# drop NaNs
df.dropna(inplace=True)
sequence_data = []
sequences = deque(maxlen=n_steps)
for entry, target in zip(df[feature_columns].values, df['future'].values):
sequences.append(entry)
if len(sequences) == n_steps:
sequence_data.append([np.array(sequences), target])
# get the last sequence by appending the last `n_step` sequence with `lookup_step` sequence
# for instance, if n_steps=50 and lookup_step=10, last_sequence should be of 60 (that is 50+10) length
# this last_sequence will be used to predict future stock prices not available in the dataset
last_sequence = list(sequences) + list(last_sequence)
last_sequence = np.array(last_sequence)
# add to result
result['last_sequence'] = last_sequence
# construct the X's and y's
X, y = [], []
for seq, target in sequence_data:
X.append(seq)
y.append(target)
# convert to numpy arrays
X = np.array(X)
y = np.array(y)
# reshape X to fit the neural network
X = X.reshape((X.shape[0], X.shape[2], X.shape[1]))
# split the dataset
result["X_train"], result["X_test"], result["y_train"], result["y_test"] = train_test_split(X, y, 
test_size=test_size, shuffle=shuffle)
# return the result
return result

此函数很长但很方便，它接受几个参数以使其尽可能灵活。

该股票的说法是，我们要加载的股票，例如，你可以使用TSLA特斯拉股市，AAPL苹果等。

n_steps整数表示我们要使用的历史序列长度，有人称它为窗口大小，回想一下我们将要使用递归神经网络，我们需要将序列数据输入网络，选择50表示我们将使用50天的股价来预测第二天。

scale是一个布尔变量，指示是否将价格从0缩放到1，我们将其设置为True，因为将高值从0缩放到1将帮助神经网络更快，更有效地学习。

lookup_step是要预测的将来的查找步骤，默认设置为1（例如，第二天）。

我们将使用此数据集中所有可用的功能，即开盘价，最高价，最低价，成交量和调整后的收盘价。请查看本教程，以了解更多这些指标。

上面的函数执行以下操作：

首先，它使用yahoo_fin模块中的stock_info.get_data（）函数加载数据集。
如果将scale参数作为True传递，它将使用sklearn的MinMaxScaler类将所有价格从0缩放到1（包括volume）。请注意，每列都有自己的缩放器。
然后，通过将调整后的关闭列移动lookup_step，添加指示目标值（用于预测的标签或y的目标）的Future列。
之后，它会重新整理和拆分数据并返回结果。
为了更好地理解代码，我强烈建议您手动打印输出变量（result），并查看功能和标签的制作方式。

三、模型制作

现在我们有了一个适当的函数来加载和准备数据集，我们需要另一个核心函数来构建模型：

def create_model(sequence_length, units=256, cell=LSTM, n_layers=2, dropout=0.3,
loss="mean_absolute_error", optimizer="rmsprop", bidirectional=False):
model = Sequential()
for i in range(n_layers):
if i == 0:
# first layer
if bidirectional:
model.add(Bidirectional(cell(units, return_sequences=True), input_shape=(None, sequence_length)))
else:
model.add(cell(units, return_sequences=True, input_shape=(None, sequence_length)))
elif i == n_layers - 1:
# last layer
if bidirectional:
model.add(Bidirectional(cell(units, return_sequences=False)))
else:
model.add(cell(units, return_sequences=False))
else:
# hidden layers
if bidirectional:
model.add(Bidirectional(cell(units, return_sequences=True)))
else:
model.add(cell(units, return_sequences=True))
# add dropout after each layer
model.add(Dropout(dropout))
model.add(Dense(1, activation="linear"))
model.compile(loss=loss, metrics=["mean_absolute_error"], optimizer=optimizer)
return model

同样，此功能也很灵活，您可以更改层数，丢失率，RNN单元，损耗和用于编译模型的优化器。

上面的函数构造了一个具有密集层的RNN作为带有1个神经元的输出层，该模型需要一系列具有sequence_length特征的 序列（在这种情况下，我们将传递50 或 100个）连续的时间步长（在此数据集中为天）并输出一个指示下一个时间价格的单一值。

您可以根据需要调整默认参数，n_layers是要堆叠的RNN层数，dropout是每个RNN层后的丢包率，units是RNN cell单位数（无论是LSTM，SimpleRNN还是GRU），bidirectional是一个布尔值指示是否使用双向RNN，尝试一下！

四、训练模型

现在我们已经准备好所有核心功能，让我们训练模型，但是在执行此操作之前，让我们初始化所有参数（以便以后可以根据需要编辑它们）：

# Window size or the sequence length
N_STEPS = 70
# Lookup step, 1 is the next day
LOOKUP_STEP = 1
# test ratio size, 0.2 is 20%
TEST_SIZE = 0.2
# features to use
FEATURE_COLUMNS = ["adjclose", "volume", "open", "high", "low"]
# date now
date_now = time.strftime("%Y-%m-%d")
### model parameters
N_LAYERS = 3
# LSTM cell
CELL = LSTM
# 256 LSTM neurons
UNITS = 256
# 40% dropout
DROPOUT = 0.4
# whether to use bidirectional RNNs
BIDIRECTIONAL = False
### training parameters
# mean absolute error loss
# LOSS = "mae"
# huber loss
LOSS = "huber_loss"
OPTIMIZER = "adam"
BATCH_SIZE = 64
EPOCHS = 400
# Tesla stock market
ticker = "TSLA"
ticker_data_filename = os.path.join("data", f"{ticker}_{date_now}.csv")
# model name to save, making it as unique as possible based on parameters
model_name = f"{date_now}_{ticker}-{LOSS}-{OPTIMIZER}-{CELL.__name__}-seq-{N_STEPS}-step-{LOOKUP_STEP}-layers-{N_LAYERS}-units-{UNITS}"
if BIDIRECTIONAL:
model_name += "-b"

因此，以上代码都是关于定义我们将要使用的所有超级参数的，我们解释了其中一些，而未涉及其他参数：

TEST_SIZE：测试采样率。例如0.2表示总数据集的20％。
FEATURE_COLUMNS：我们将用来预测下一个价格值的功能。
N_LAYERS：要使用的RNN层数。
CELL：要使用的RNN单元，默认值为LSTM。
UNITS：cell单位数量。
DROPOUT：辍学率是未训练某个层中给定节点的概率，其中0.0表示完全没有辍学。这种类型的正则化可以帮助模型不会过度拟合我们的训练数据。
BIDIRECTIONAL：是否使用双向递归神经网络。
LOSS：用于此回归问题的损失函数，我们使用的是Huber损失，也可以使用平均绝对误差（mae）或均方误差（mse）。
OPTIMIZER：要使用的优化算法，默认为Adam。
BATCH_SIZE：每次训练迭代中使用的数据样本数。
EPOCHS：学习算法将遍历整个训练数据集的次数，我们在这里使用了400次，但尝试进一步增加它。
随意尝试这些值以获得比我的更好的结果。

好吧，让我们确保在训练之前，结果，日志和数据文件夹存在：

# create these folders if they does not exist
if not os.path.isdir("results"):
os.mkdir("results")
if not os.path.isdir("logs"):
os.mkdir("logs")
if not os.path.isdir("data"):
os.mkdir("data")

最后，让我们训练模型：

# load the data
data = load_data(ticker, N_STEPS, lookup_step=LOOKUP_STEP, test_size=TEST_SIZE, feature_columns=FEATURE_COLUMNS)
# save the dataframe
data["df"].to_csv(ticker_data_filename)
# construct the model
model = create_model(N_STEPS, loss=LOSS, units=UNITS, cell=CELL, n_layers=N_LAYERS,
dropout=DROPOUT, optimizer=OPTIMIZER, bidirectional=BIDIRECTIONAL)
# some tensorflow callbacks
checkpointer = ModelCheckpoint(os.path.join("results", model_name + ".h5"), save_weights_only=True, save_best_only=True, verbose=1)
tensorboard = TensorBoard(log_dir=os.path.join("logs", model_name))
history = model.fit(data["X_train"], data["y_train"],
batch_size=BATCH_SIZE,
epochs=EPOCHS,
validation_data=(data["X_test"], data["y_test"]),
callbacks=[checkpointer, tensorboard],
verbose=1)
model.save(os.path.join("results", model_name) + ".h5")

我们使用ModelCheckpoint在训练期间将模型保存在每个时期。我们还使用TensorBoard在训练过程中可视化模型的性能。

运行上面的代码块之后，它将训练模型300个纪元，因此将需要一些时间，这是第一行输出：

Epoch 1/300
3510/3510 [==============================] - 21s 6ms/sample - loss: 0.0117 - mean_absolute_error: 0.0515 - val_loss: 0.0065 - val_mean_absolute_error: 0.0487
Epoch 2/300
3264/3510 [==========================>...] - ETA: 0s - loss: 0.0049 - mean_absolute_error: 0.0352
Epoch 00002: val_loss did not improve from 0.00650
3510/3510 [==============================] - 1s 309us/sample - loss: 0.0051 - mean_absolute_error: 0.0357 - val_loss: 0.0082 - val_mean_absolute_error: 0.0494
Epoch 3/300
3456/3510 [============================>.] - ETA: 0s - loss: 0.0039 - mean_absolute_error: 0.0329
Epoch 00003: val_loss improved from 0.00650 to 0.00095, saving model to results\2020-01-08_NFLX-mse-LSTM-seq-50-step-1-layers-3-units-256
3510/3510 [==============================] - 14s 4ms/sample - loss: 0.0039 - mean_absolute_error: 0.0328 - val_loss: 9.5337e-04 - val_mean_absolute_error: 0.0150
Epoch 4/300
3264/3510 [==========================>...] - ETA: 0s - loss: 0.0034 - mean_absolute_error: 0.0304
Epoch 00004: val_loss did not improve from 0.00095
3510/3510 [==============================] - 1s 222us/sample - loss: 0.0037 - mean_absolute_error: 0.0316 - val_loss: 0.0034 - val_mean_absolute_error: 0.0300

训练结束后（或在训练期间），请尝试使用以下命令运行tensorboard：

tensorboard --logdir="logs"
现在，这将启动本地HTTP服务器“ localhost：6006”，进入浏览器后，您将看到类似以下内容：



损失是在LOSS参数中指定的Huber损失（您可以随时将其更改为平均误差或均方误差），橙色曲线是训练损失，而蓝色曲线是我们最关心的是验证损失。如您所见，它随着时间的推移而显着减少，因此这是可行的！

五、测试模型

在测试模型之前，我们将需要重新加载数据而无须改组，因为我们将以正确的顺序绘制股价曲线：

data = load_data(ticker, N_STEPS, lookup_step=LOOKUP_STEP, test_size=TEST_SIZE,
feature_columns=FEATURE_COLUMNS, shuffle=False)
# construct the model
model = create_model(N_STEPS, loss=LOSS, units=UNITS, cell=CELL, n_layers=N_LAYERS,
dropout=DROPOUT, optimizer=OPTIMIZER, bidirectional=BIDIRECTIONAL)
model_path = os.path.join("results", model_name) + ".h5"
model.load_weights(model_path)

如果要随身携带笔记本，则不应重构模型并加载权重，因此需要将其注释掉。但是，如果您使用另一个Python文件进行测试，则应该这样做。


现在让我们测试模型：

# evaluate the model
mse, mae = model.evaluate(data["X_test"], data["y_test"], verbose=0)
# calculate the mean absolute error (inverse scaling)
mean_absolute_error = data["column_scaler"]["adjclose"].inverse_transform([[mae]])[0][0]
print("Mean Absolute Error:", mean_absolute_error)

请记住，输出将是介于0到1之间的值，因此我们需要将其恢复为实际价格值，这是输出：

Mean Absolute Error: 6.516846878481972

不错，平均而言，预测价格仅比实际价格高出6.52 $。

好吧，让我们尝试预测苹果股票市场的未来价格：

def predict(model, data):
# retrieve the last sequence from data
last_sequence = data["last_sequence"][-N_STEPS:]
# retrieve the column scalers
column_scaler = data["column_scaler"]
# reshape the last sequence
last_sequence = last_sequence.reshape((last_sequence.shape[1], last_sequence.shape[0]))
# expand dimension
last_sequence = np.expand_dims(last_sequence, axis=0)
# get the prediction (scaled from 0 to 1)
prediction = model.predict(last_sequence)
# get the price (by inverting the scaling)
predicted_price = column_scaler["adjclose"].inverse_transform(prediction)[0][0]
return predicted_price

此函数使用我们保存在load_data（）函数中的last_sequence变量，该变量基本上是价格的最后一个序列，我们用它来预测下一个价格，我们称之为：

# predict the future price
future_price = predict(model, data)
print(f"Future price after {LOOKUP_STEP} days is {future_price:.2f}$")

输出：

Future price after 1 days is 404.78$

听起来不错 ！前两天，价格为447.37 $，昨天为416.43 $ ，该模型表示第二天价格为404.78 $ 。趋势下降。该模型仅使用了70 天的功能就能够获得该价值，让我们绘制价格并查看：

def plot_graph(model, data):
y_test = data["y_test"]
X_test = data["X_test"]
y_pred = model.predict(X_test)
y_test = np.squeeze(data["column_scaler"]["adjclose"].inverse_transform(np.expand_dims(y_test, axis=0)))
y_pred = np.squeeze(data["column_scaler"]["adjclose"].inverse_transform(y_pred))
# last 200 days, feel free to edit that
plt.plot(y_test[-200:], c='b')
plt.plot(y_pred[-200:], c='r')
plt.xlabel("Days")
plt.ylabel("Price")
plt.legend(["Actual Price", "Predicted Price"])
plt.show()

此函数绘制测试集的最后200天（您可以根据需要对其进行编辑）以及预测价格的图表，我们对其进行调用并查看其外观：

plot_graph(model, data)

结果：

如您所见，蓝色曲线是实际测试集，红色曲线是预测价格，太好了！请注意，正如我们预测的那样，最近股价正在下跌。

如果您的LOOKUP_STEP数据更高，这仍然会起作用，但是它将使用较旧的数据（按LOOKUP_STEP天数表示）以绘制红线。

到目前为止，我们仅习惯于预测第二天，我尝试构建使用不同lookup_steps的其他模型，这是张量板中的一个有趣结果：



有趣的是，蓝色曲线是我们在本教程中使用的模型，该模型使用下一时间步股票价格作为标签，而绿色和橙色曲线分别使用了10和30个查找步骤，例如，在本示例中，橙色模型可以预测30天后的股价，这是进行长期投资的理想模型（通常是这种情况）。

现在您可能会认为，但是，如果我们只是想预测价格是上涨还是下跌，而不是像我们在这里所做的那样，那么您可以使用以下两种方法之一来进行预测吗？将预测价格与当前价格一起做出决定，或者构建一个完整的模型并将最后输出的激活函数更改为sigmoid，同时将损失和度量标准更改为Sigmoid。

以下函数通过将预测价格转换为0或1（0表示价格下跌，而1表示价格上涨）来计算准确性得分：

def get_accuracy(model, data):
y_test = data["y_test"]
X_test = data["X_test"]
y_pred = model.predict(X_test)
y_test = np.squeeze(data["column_scaler"]["adjclose"].inverse_transform(np.expand_dims(y_test, axis=0)))
y_pred = np.squeeze(data["column_scaler"]["adjclose"].inverse_transform(y_pred))
y_pred = list(map(lambda current, future: int(float(future) > float(current)), y_test[:-LOOKUP_STEP], y_pred[LOOKUP_STEP:]))
y_test = list(map(lambda current, future: int(float(future) > float(current)), y_test[:-LOOKUP_STEP], y_test[LOOKUP_STEP:]))
return accuracy_score(y_test, y_pred)

现在让我们调用该函数：

print(str(LOOKUP_STEP) + ":", "Accuracy Score:", get_accuracy(model, data))

这是我为不同的人训练3个模型时的结果LOOKUP_STEPS：

1: Accuracy Score: 0.5642570281124498
10: Accuracy Score: 0.7192622950819673
30: Accuracy Score: 0.8318965517241379

您可能会注意到，该模型对长期价格的预测更为准确，当我们训练模型以预测未来10天的价格时，该模型的准确性约为71.9％，而使用30个查找步骤时，该模型的准确性约为83.2％。

六、结论

好了，就是本教程的内容了，您可以调整参数并查看如何提高模型性能，尝试训练更多的时期（例如500甚至更多），增加或减少BATCH_SIZE，看看是否确实变好了，或与N_STEPS和LOOKUP_STEPS一起玩，看看哪种组合效果最好。

您还可以更改模型参数，例如增加层数或LSTM单位数，甚至尝试使用GRU单元代替LSTM。

请注意，还有其他功能和指标要使用，为了改进预测，通常会使用一些其他信息作为功能，例如技术指标，公司产品创新，利率，汇率，公共政策，网络和财经新闻，甚至还有雇员人数！

我鼓励您更改模型架构，尝试使用CNN或Seq2Seq模型，甚至向该现有模型添加双向LSTM，以查看是否可以改进它！

另外，使用不同的股票市场，查看Yahoo Finance页面，然后查看您真正想要的页面！

如果您不使用笔记本电脑或交互式外壳，我已将代码拆分为不同的Python文件，每个文件都有其用途，请在此处进行检查。