前言
最近在学习TensorFlow进行机器学习，看到了国外大佬写的一篇文章“A simple deep learning model for stock price prediction using TensorFlow”，这篇文章中对股票中S&P500进行了预测。文章中对一些代码的解读不够明确，因些重写一篇详细阐述一下。
思路
如何对S&P500股指进行预测分析，需要建立什么样的神经网络模型，训练方法，次数，拟合效果，这些都是需要考虑到的，但这一切源于数据。
股票中的数据是S&P500指数和500支股票的价格值，因此，思路便有了，根据500支股票的价格来预测S&P500股指。
思路：
1.使用pandas读取csv数据；
2.数据处理；
3.样本数据和测试数据拆分；
4.数据缩放；
5.建立神经网络模型；
6.训练，拟合。
代码实现
代码实现是参照原文进行实现的，原文地址：
https://medium.com/mlreview/a-simple-deep-learning-model-for-stock-price-prediction-using-tensorflow-30505541d877
- 引入python库
import tensorflow as tf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
- 数据处理
# Import data
data = pd.read_csv('data_stocks.csv')
# Drop date variable
data = data.drop(['DATE'], 1)
# Dimensions of dataset
n = data.shape[0] # 行数row count
p = data.shape[1] # 列数column count
# 可以使用以下两条将SP500的股指曲线图打印出来
# plt.plot(data['SP500'])
# plt.show()
# Make data a numpy array
data = data.values
- 数据拆分及缩放
# Training and test data
train_start = 0
train_end = int(np.floor(0.8 * n))
test_start = train_end
test_end = n
data_train = data[np.arange(train_start, train_end), :]
data_test = data[np.arange(test_start, test_end), :]
scaler = MinMaxScaler()
data_train = scaler.fit_transform(data_train)
data_test = scaler.transform(data_test)
在这里需要说明一点是，数据缩放首先对训练数据调用fit_transform（fit是求均值方差等参数，transform是缩放。fit_transform是两者的整合），然后只对data_test进行缩放。这是因为如果对所有的数据进行缩放拆分，就会发生问题。以训练数据的标准来对测试数据进行缩放，这样标准相同，对测试数据有更好的检验。
- 输入输出数据的界定
# Build X and y
X_train = data_train[:, 1:] # 取第1列往后的所有列，以列形式返回
y_train = data_train[:, 0] # 取第0列数据以行形式返回
X_test = data_test[:, 1:]
y_test = data_test[:, 0]
- 构建神经网络
# Number of stocks in training data
n_stocks = X_train.shape[1] # 列数，值为500
# Neurons 神经元，500->1024->512->256->128->1
n_neurons_1 = 1024
n_neurons_2 = 512
n_neurons_3 = 256
n_neurons_4 = 128
n_target = 1
# Session
net = tf.InteractiveSession()
# Placeholder
X = tf.placeholder(dtype=tf.float32, shape=[None, n_stocks])
Y = tf.placeholder(dtype=tf.float32, shape=[None])
# Initializers
sigma = 1
weight_initializer = tf.variance_scaling_initializer(mode="fan_avg",
distribution="uniform", scale=sigma)
bias_initializer = tf.zeros_initializer()
# Hidden weights
W_hidden_1 = tf.Variable(weight_initializer([n_stocks, n_neurons_1]))
bias_hidden_1 = tf.Variable(bias_initializer([n_neurons_1]))
W_hidden_2 = tf.Variable(weight_initializer([n_neurons_1, n_neurons_2]))
bias_hidden_2 = tf.Variable(bias_initializer([n_neurons_2]))
W_hidden_3 = tf.Variable(weight_initializer([n_neurons_2, n_neurons_3]))
bias_hidden_3 = tf.Variable(bias_initializer([n_neurons_3]))
W_hidden_4 = tf.Variable(weight_initializer([n_neurons_3, n_neurons_4]))
bias_hidden_4 = tf.Variable(bias_initializer([n_neurons_4]))
# Output layer: Variables for output weights and biases
W_out = tf.Variable(weight_initializer([n_neurons_4, n_target]))
bias_out = tf.Variable(bias_initializer([n_target]))
# Hidden layer
hidden_1 = tf.nn.relu(tf.add(tf.matmul(X, W_hidden_1), bias_hidden_1))
hidden_2 = tf.nn.relu(tf.add(tf.matmul(hidden_1, W_hidden_2), bias_hidden_2))
hidden_3 = tf.nn.relu(tf.add(tf.matmul(hidden_2, W_hidden_3), bias_hidden_3))
hidden_4 = tf.nn.relu(tf.add(tf.matmul(hidden_3, W_hidden_4), bias_hidden_4))
# Output layer (must be transposed)
out = tf.transpose(tf.add(tf.matmul(hidden_4, W_out), bias_out))
# Cost function
mse = tf.reduce_mean(tf.squared_difference(out, Y))
# Optimizer
opt = tf.train.AdamOptimizer().minimize(mse)
（1）神经网络模型
所构建的神经网络共有1个输入、1个输出和4个隐含层。
500 --> 1024 --> 512 --> 256 --> 128 --> 1
（2）placeholder占位符
X的Shape为[None, n_stocks]，使用None更灵活，可以根据batch_size来确定；
Y的Shape也为[None]，更方便。
（3）初始化方法
tf.variance_scaling_initializer(scale, mode, distribution, seed, dtype)
初始化程序能够使其规模适应权重张量的形状。
使用distribution="normal"，样本从以0为中心的截断正态分布中抽取；使用stddev = sqrt(scale / n)，其中n为：
如果mode =“fan_in”，n为权重张量中输入单元的数量；
如果mode =“fan_out”，n为输出单元的数量；
如果mode =“fan_avg”，n为平均输入的数量和输出单元的数量。
使用distribution="uniform"，样本从[-limit, limit]，其中limit = sqrt(3 * scale / n)，内的均匀分布中抽取。
参数：
scale：比例因子（正浮点数）。
mode：为“fan_in”、“fan_out”以及“fan_avg”中的一个。
distribution：随机分配使用，“normal”，“uniform”其中之一。
seed：一个Python的整数用于创建随机种子；
dtype：数据类型，仅支持浮点类型。
（4）激励函数
采用relu进行激励，也有其它的激励函数例如tanh, sigmoid等。
（5）代价计算方法
使用平方差的方式进行计算，squared_difference。
（6）优化器
优化器采用默认的优化方法：AdamOptimizer。
- 训练
# Init
net.run(tf.global_variables_initializer())
# Setup plot
plt.ion()
fig = plt.figure()
ax1 = fig.add_subplot(111)
line1, = ax1.plot(y_test)
line2, = ax1.plot(y_test * 0.5)
plt.show()
# Fit neural net
batch_size = 256
mse_train = []
mse_test = []
# Run
epochs = 10
for e in range(epochs):
# Shuffle training data
shuffle_indices = np.random.permutation(np.arange(len(y_train)))
X_train = X_train[shuffle_indices]
y_train = y_train[shuffle_indices]
# Minibatch training
for i in range(0, len(y_train) // batch_size):
start = i * batch_size
batch_x = X_train[start:start + batch_size]
batch_y = y_train[start:start + batch_size]
# Run optimizer with batch
net.run(opt, feed_dict={X: batch_x, Y: batch_y})
# Show progress
if np.mod(i, 50) == 0:
# MSE train and test
mse_train.append(net.run(mse, feed_dict={X: X_train, Y: y_train}))
mse_test.append(net.run(mse, feed_dict={X: X_test, Y: y_test}))
print('MSE Train: ', mse_train[-1])
print('MSE Test: ', mse_test[-1])
# Prediction
pred = net.run(out, feed_dict={X: X_test})
line2.set_ydata(pred)
plt.title('Epoch ' + str(e) + ', Batch ' + str(i))
plt.pause(0.01)
epoch和batch的区别是，一个epoch的执行包含了所有的batch的执行，一个batch指一个批次，将该批次中所有的样本执行一遍。
结束语
上述所建立的神经网络模型，是一个较简单，也较标准的模型。文中没有对训练部分进行过多的介绍，是因为这些道理都比较浅显易懂。
在实现完之后，运行可以看到，在每执行一次epoch，mse和变化和曲线的动态拟合。该例可以扩展到其它类似的例子。对于时序型的数据，采用循环神经网络RNN更好一些，目前也仍在研究中。