有趣的应用 | 使用RNN预测股票价格系列一

01 概述

我们将解释如何建立一个有LSTM单元的RNN模型来预测S&P500指数的价格。 数据集可以从Yahoo!下载。 在例子中,使用了从1950年1月3日(Yahoo! Finance可以追溯到的最大日期)的S&P 500数据到2017年6月23日。 为了简单起见,我们只使用每日收盘价进行预测。 同时,我将演示如何使用TensorBoard轻松调试和模型跟踪。

02 关于RNN和LSTM

RNN的目的使用来处理序列数据。在传统的神经网络模型中,是从输入层到隐含层再到输出层,层与层之间是全连接的,每层之间的节点是无连接的。但是这种普通的神经网络对于很多问题却无能无力。例如,你要预测句子的下一个单词是什么,一般需要用到前面的单词,因为一个句子中前后单词并不是独立的。

RNN之所以称为循环神经网路,即一个序列当前的输出与前面的输出也有关。具体的表现形式为网络会对前面的信息进行记忆并应用于当前输出的计算中,即隐藏层之间的节点不再无连接而是有连接的,并且隐藏层的输入不仅包括输入层的输出还包括上一时刻隐藏层的输出。理论上,RNN能够对任何长度的序列数据进行处理。

Long Short Term 网络,一般就叫做 LSTM,是一种 RNN 特殊的类型,LSTM区别于RNN的地方,主要就在于它在算法中加入了一个判断信息有用与否的“处理器”,这个处理器作用的结构被称为cell。一个cell当中被放置了三扇门,分别叫做输入门、遗忘门和输出门。一个信息进入LSTM的网络当中,可以根据规则来判断是否有用。

只有符合算法认证的信息才会留下,不符的信息则通过遗忘门被遗忘。说起来无非就是一进二出的工作原理,却可以在反复运算下解决神经网络中长期存在的大问题。目前已经证明,LSTM是解决长序依赖问题的有效技术,并且这种技术的普适性非常高,导致带来的可能性变化非常多。各研究者根据LSTM纷纷提出了自己的变量版本,这就让LSTM可以处理千变万化的垂直问题。

数据准备

股票价格是长度为NN,定义为p0,p1,...,pN-1,其中pi是第i天的收盘价,0≤i<N。 我们有一个大小固定的移动窗口w(后面我们将其称为input_size),每次我们将窗口向右移动w个单位,以使所有移动窗口中的数据之间没有重叠。

我们使用一个移动窗口中的内容来预测下一个,而在两个连续的窗口之间没有重叠。

我们将建立RNN模型将LSTM单元作为基本的隐藏单元。 我们使用此值从时间t内将第一个移动窗口W0移动到窗口Wt:

预测价格在下一个窗口在Wt+1

我们试图学习一个近似函数,

展开的RNN

考虑反向传播(BPTT)是如何工作的,我们通常将RNN训练成一个“unrolled”的样式,这样我们就不需要做太多的传播计算,而且可以节省训练的复杂性。

以下是关于Tensorflow教程中input_size的解释:

By design, the output of a recurrent neural network (RNN) depends on arbitrarily distant inputs. Unfortunately, this makes backpropagation computation difficult. In order to make the learning process tractable, it is common practice to create an “unrolled” version of the network, which contains a fixed number (num_steps) of LSTM inputs and outputs. The model is then trained on this finite approximation of the RNN. This can be implemented by feeding inputs of length num_steps at a time and performing a backward pass after each such input block.

价格的顺序首先被分成不重叠的小窗口。 每个窗口都包含input_size数字,每个数字被视为一个独立的输入元素。 然后,任何num_steps连续的输入元素被分配到一个训练输入中,形成一个训练

在Tensorfow上的“unrolled”版本的RNN。 相应的标签就是它们后面的输入元素。

例如,如果input_size = 3和num_steps = 2,我们的第一批的训练样例如下所示:

以下是数据格式化的关键部分:

seq = [np.array(seq[i * self.input_size: (i + 1) * self.input_size]) for i in range(len(seq) // self.input_size)] # Split into groups of `num_steps` X = np.array([seq[i: i + self.num_steps] for i in range(len(seq) - self.num_steps)]) y = np.array([seq[i + self.num_steps] for i in range(len(seq) - self.num_steps)])

培训/测试拆分

由于我们总是想预测未来,我们以最新的10%的数据作为测试数据。

正则化

标准普尔500指数随着时间的推移而增加,导致测试集中大部分数值超出训练集的范围,因此模型必须预测一些以前从未见过的数字。 但这却不是很理想。

为了解决样本外的问题,我们在每个移动窗口中对价格进行了标准化。 任务变成预测相对变化率而不是绝对值。 在t时刻的标准化滑动窗口W't中,所有的值除以最后一个未知价格 Wt-1中的最后一个价格:

建立模型

定义

  • lstm_size:一个LSTM图层中的单元数。
  • num_layers:堆叠的LSTM层的数量。
  • keep_prob:单元格在 dropout 操作中保留的百分比。
  • init_learning_rate:开始学习的速率。
  • learning_rate_decay:后期训练时期的衰减率。
  • init_epoch:使用常量init_learning_rate的时期数。
  • max_epoch:训练次数在训练中的总数
  • input_size:移动窗口的大小/一个训练数据点
  • batch_size:在一个小批量中使用的数据点的数量。

The LSTM model has num_layers stacked LSTM layer(s) and each layer contains lstm_sizenumber of LSTM cells. Then a dropout mask with keep probability keep_prob is applied to the output of every LSTM cell. The goal of dropout is to remove the potential strong dependency on one dimension so as to prevent overfitting. *T he training requires max_epoch epochs in total; an epoch is a single full pass of all the training data points. In one epoch, the training data points are split into mini-batches of size batch_size. We send one mini-batch to the model for one BPTT learning. The learning rate is set to init_learning_rate during the first init_epoch epochs and then decay by learning_rate_decay during every succeeding epoch.‍‍‍*

# Configuration is wrapped in one object for easy tracking and passing. class RNNConfig(): input_size=1 num_steps=30 lstm_size=128 num_layers=1 keep_prob=0.8 batch_size = 64 init_learning_rate = 0.001 learning_rate_decay = 0.99 init_epoch = 5 max_epoch = 50 config = RNNConfig()

定义图形

(1) Initialize a new graph first.

import tensorflow as tf tf.reset_default_graph() lstm_graph = tf.Graph()

(2) How the graph works should be defined within its scope.

with lstm_graph.as_default():

(3) Define the data required for computation. Here we need three input variables, all defined as

tf.placeholder

because we don’t know what they are at the graph construction stage.

  • inputs: the training data X, a tensor of shape (# data examples, num_steps, input_size); the number of data examples is unknown, so it is None. In our case, it would be batch_sizein training session. Check the input format example if confused.
  • targets: the training label y, a tensor of shape (# data examples, input_size).
  • learning_rate: a simple float.

# Dimension = ( # number of data examples, # number of input in one computation step, # number of numbers in one input # ) # We don't know the number of examples beforehand, so it is None. inputs = tf.placeholder(tf.float32, [None, config.num_steps, config.input_size]) targets = tf.placeholder(tf.float32, [None, config.input_size]) learning_rate = tf.placeholder(tf.float32, None)

(4) This function returns one

LSTMCell

with or without dropout operation.

def _create_one_cell(): return tf.contrib.rnn.LSTMCell(config.lstm_size, state_is_tuple=True) if config.keep_prob < 1.0: return tf.contrib.rnn.DropoutWrapper(lstm_cell, output_keep_prob=config.keep_prob)

(5) Let’s stack the cells into multiple layers if needed.

MultiRNNCell

helps connect sequentially multiple simple cells to compose one cell.

cell = tf.contrib.rnn.MultiRNNCell( [_create_one_cell() for _ in range(config.num_layers)], state_is_tuple=True ) if config.num_layers > 1 else _create_one_cell()

(6)tf.nn.dynamic_rnn constructs a recurrent neural network specified by cell (RNNCell). It returns a pair of (model outpus, state), where the outputs val is of size (batch_size, num_steps, lstm_size) by default. The state refers to the current state of the LSTM cell, not consumed here.

val, _ = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)

(7)tf.transpose

converts the outputs from the dimension (batch_size, num_steps, lstm_size) to (num_steps, batch_size, lstm_size). Then the last output is picked.

# Before transpose, val.get_shape() = (batch_size, num_steps, lstm_size) # After transpose, val.get_shape() = (num_steps, batch_size, lstm_size) val = tf.transpose(val, [1, 0, 2]) # last.get_shape() = (batch_size, lstm_size) ast = tf.gather(val, int(val.get_shape()[0]) - 1, name="last_lstm_output")

(8) Define weights and biases between the hidden and output layers.

weight = tf.Variable(tf.truncated_normal([config.lstm_size, config.input_size])) bias = tf.Variable(tf.constant(0.1, shape=[targets_width])) prediction = tf.matmul(last, weight) + bias

(9) We use mean square error as the loss metric and the RMSPropOptimizer algorithm for gradient descent optimization.

loss = tf.reduce_mean(tf.square(prediction - targets)) optimizer = tf.train.RMSPropOptimizer(learning_rate) minimize = optimizer.minimize(loss)

开始训练过程

(1) To start training the graph with real data, we need to start a tf.session

first.

with tf.Session(graph=lstm_graph) as sess:

(2) Initialize the variables as defined.

tf.global_variables_initializer().run()

(0) The learning rates for training epochs should have been precomputed beforehand. The index refers to the epoch index.

learning_rates_to_use = [ config.init_learning_rate * ( config.learning_rate_decay ** max(float(i + 1 - config.init_epoch), 0.0) ) for i in range(config.max_epoch)]

(3) Each loop below completes one epoch training.

for epoch_step in range(config.max_epoch): current_lr = learning_rates_to_use[epoch_step] # Check https://github.com/lilianweng/stock-rnn/blob/master/data_wrapper.py # if you are curious to know what is StockDataSet and how generate_one_epoch() # is implemented. for batch_X, batch_y in stock_dataset.generate_one_epoch(config.batch_size): train_data_feed = { nputs: batch_X, targets: batch_y, learning_rate: current_lr } train_loss, _ = sess.run([loss, minimize], train_data_feed)

(4) Don’t forget to save your trained model at the end.

saver.save(sess, "your_awesome_model_path_and_name", global_step=max_epoch_step)

使用TensorBoard

在没有可视化的情况下构建图形就像在黑暗中绘制,非常模糊和容易出错。 Tensorboard提供了图形结构和学习过程的简单可视化。 看看下面这个案例,非常实用:

Brief Summary

  • Use with [tf.name_scope] (https://www.tensorflow.org/api_docs/python/tf/name_scope)("your_awesome_module_name") : to wrap elements working on the similar goal together.
  • Many tf.* methods accepts name= argument. Assigning a customized name can make your life much easier when reading the graph.
  • Methods like tf.summary.scalar and tf.summary.histogram help track the values of variables in the graph during iterations.
  • In the training session, define a log file using tf.summary.FileWriter.

with tf.Session(graph=lstm_graph) as sess: merged_summary = tf.summary.merge_all() writer = tf.summary.FileWriter("location_for_keeping_your_log_files", sess.graph) writer.add_graph(sess.graph)

Later, write the training progress and summary results into the file.

_summary = sess.run([merged_summary], test_data_feed) writer.add_summary(_summary, global_step=epoch_step) # epoch_step in range(config.max_epoch)

结果

我们在例子中使用了以下配置。

num_layers=1 keep_prob=0.8 batch_size = 64 init_learning_rate = 0.001 learning_rate_decay = 0.99 init_epoch = 5 max_epoch = 100 num_steps=30

总的来说预测股价并不是一件容易的事情。 特别是在正则化后,价格趋势看起来非常嘈杂。

测试数据中最近200天的预测结果。 模型是用 input_size= 1 和 lstm_size= 32 来训练的。

image.png

测试数据中最近200天的预测结果。 模型是用 input_size= 1 和 lstm_size= 128 来训练的。

image.png

测试数据中最近200天的预测结果。 模型是用 input_size= 5 和 lstm_size= 128 来训练的。

image.png

代码:

stock-rnn/main.py

import os
import pandas as pd
import pprint
import tensorflow as tf
import tensorflow.contrib.slim as slim
 from data_model import StockDataSet
from model_rnn import LstmRNN  flags = tf.app.flags flags.DEFINE_integer("stock_count", 100, "Stock count [100]") flags.DEFINE_integer("input_size", 5, "Input size [5]") flags.DEFINE_integer("num_steps", 30, "Num of steps [30]") flags.DEFINE_integer("num_layers", 1, "Num of layer [1]") flags.DEFINE_integer("lstm_size", 128, "Size of one LSTM cell [128]") flags.DEFINE_integer("batch_size", 64, "The size of batch images [64]") flags.DEFINE_float("keep_prob", 0.8, "Keep probability of dropout layer. [0.8]") flags.DEFINE_float("init_learning_rate", 0.001, "Initial learning rate at early stage. [0.001]")
flags.DEFINE_float("learning_rate_decay", 0.99, "Decay rate of learning rate. [0.99]") flags.DEFINE_integer("init_epoch", 5, "Num. of epoches considered as early stage. [5]")
flags.DEFINE_integer("max_epoch", 50, "Total training epoches. [50]") flags.DEFINE_integer("embed_size", None, "If provided, use embedding vector of this size. [None]")
flags.DEFINE_string("stock_symbol", None, "Target stock symbol [None]") flags.DEFINE_integer("sample_size", 4, "Number of stocks to plot during training. [4]") flags.DEFINE_boolean("train", False, "True for training, False for testing [False]")  FLAGS = flags.FLAGS  pp = pprint.PrettyPrinter()
 if not os.path.exists("logs"):    
os.mkdir("logs")
def show_all_variables():    
model_vars = tf.trainable_variables()    
slim.model_analyzer.analyze_vars(model_vars, print_info=True)
 def load_sp500(input_size, num_steps, k=None, target_symbol=None, test_ratio=0.05):    
if target_symbol is not None:        
return [            
StockDataSet(               
target_symbol,                
input_size=input_size,                
num_steps=num_steps,               
test_ratio=test_ratio)        ]     
# Load metadata of s & p 500 stocks   
info = pd.read_csv("data/constituents-financials.csv")    
info = info.rename(columns={col: col.lower().replace(' ', '_') for col in info.columns})    info['file_exists'] = info['symbol'].map(lambda x: os.path.exists("data/{}.csv".format(x)))    print info['file_exists'].value_counts().to_dict()     
info = info[info['file_exists'] == True].reset_index(drop=True)   
 info = info.sort('market_cap', ascending=False).reset_index(drop=True)     
if k is not None:        
info = info.head(k)     
print "Head of S&P 500 info:\n", info.head()     
# Generate embedding meta file    
info[['symbol', 'sector']].to_csv(os.path.join("logs/metadata.tsv"), sep='\t', index=False)     return [        StockDataSet(row['symbol'],                     
input_size=input_size,                     
num_steps=num_steps,                     
test_ratio=0.05)        
for _, row in info.iterrows()]   def main(_):    pp.pprint(flags.FLAGS.__flags)     
# gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)    run_config = tf.ConfigProto()    
run_config.gpu_options.allow_growth = True     
with tf.Session(config=run_config) as sess:        
rnn_model = LstmRNN(            
sess,            
FLAGS.stock_count,            
lstm_size=FLAGS.lstm_size,            
num_layers=FLAGS.num_layers,            
num_steps=FLAGS.num_steps,            
input_size=FLAGS.input_size,            
keep_prob=FLAGS.keep_prob,            
embed_size=FLAGS.embed_size,        )         
show_all_variables()         
stock_data_list = load_sp500(            
FLAGS.input_size,            
FLAGS.num_steps,            
k=FLAGS.stock_count,            
target_symbol=FLAGS.stock_symbol,        )         
if FLAGS.train:            
rnn_model.train(stock_data_list, FLAGS)        
else:            
if not rnn_model.load()[0]:                
raise Exception("[!] Train a model first, then run test mode")
if __name__ == '__main__':    tf.app.run()

原文发布于微信公众号 - 人工智能LeadAI(atleadai)

原文发表时间:2017-12-28

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏ATYUN订阅号

一个简单而强大的深度学习库—PyTorch

AiTechYun 编辑:yuxiangyu 每过一段时间,总会有一个python库被开发出来,改变深度学习领域。而PyTorch就是这样一个库。 在过去的几周...

3976
来自专栏非著名程序员

Android二维码扫描开发(二):YUV图像格式详解

? 前一篇提到了,相机返回的是YUV格式的图像数据,那么YUV到底是怎样一种格式呢?本篇将对YUV图像格式进行详细的解释。 上一篇中,我们了解了Android...

29810
来自专栏人工智能LeadAI

卷积神经网络中PET/CT图像的纹理特征提取

Author: Zongwei Zhou 周纵苇 Weibo: @MrGiovanni Email: zongweiz@asu.edu Please cit...

3513
来自专栏数据魔术师

干货 | 变邻域搜索算法(Variable Neighborhood Search,VNS)超详细一看就懂

8545
来自专栏大数据文摘

21副GIF动图让你了解各种数学概念

1625
来自专栏Duncan's Blog

数据挖掘整理

2.1数据清洗:填写缺失值、光滑噪声数据,识别或删除离群点,并解决不一致性来“清理”数据

933
来自专栏企鹅号快讯

使用RNN预测股票价格系列一

正文共11490个字,16张图,预计阅读时间:29分钟。 01 概述 我们将解释如何建立一个有LSTM单元的RNN模型来预测S&P500指数的价格。 数据集可以...

2349
来自专栏程序员互动联盟

21副GIF动图让你了解各种数学概念

“让我们面对它;总的来说数学是不容易的,但当你征服了问题,并达到新的理解高度,这就是它给你的回报。” ——Danica McKellar 数学是很难的学科,但...

3348
来自专栏大数据杂谈

【Excel系列】Excel数据分析:相关与回归分析

相关系数 15.1 相关系数的概念 著名统计学家卡尔·皮尔逊设计了统计指标——相关系数(Correlation coefficient)。相关系数是用以反映变量...

3298
来自专栏专知

机器翻译新时代:Facebook 开源无监督机器翻译模型和大规模训练语料

【导读】基于深度学习的机器翻译往往需要数量非常庞大的平行语料,这一前提使得当前最先进的技术无法被有效地用于那些平行语料比较匮乏的语言之间。为了解决这一问题,Fa...

42611

扫码关注云+社区