这里数据是基于kaggle ，New York Stock Exchange 主要关注序列分析，当然真实炒股还要很多维度的分析，特别中国更要看宏观分析，比如kaggle有根据新闻数据辅助预测的比赛。真的炒股还需要各种操盘软件了。

总之股市有风险入市需谨慎，可以学习多角度分析。

数据读取

from __future__ import print_function

import numpy as np

import pandas as pd

import os

from subprocess import check_output

from keras.layers.core import Dense, Activation, Dropout

from keras.layers.recurrent import LSTM

from keras.models import Sequential

from sklearn.model_selection import train_test_split

import time #helper libraries

from sklearn.preprocessing import MinMaxScaler

import matplotlib.pyplot as plt

from numpy import newaxis

import warnings

warnings.filterwarnings("ignore")

def readData(path):

"""

使用pandas读取数据

"""

data = pd.read_csv(path)

cols = list(data.columns.values)

return data[cols]

if __name__ == "__main__":

# 设置显示格式

pd.set_option('display.width', 1000)

homePath = os.path.dirname(os.path.abspath('__file__'))

# Windows下的存储路径与Linux并不相同

if os.name == "nt":

dataPath = "%s\\prices.csv" % homePath

else:

dataPath = "%s/prices.csv" % homePath

prices = readData(dataPath)

可以看数据，是基本的股票数据，包括开盘价，收盘价，最低价，最高价，交易量等。

取一只雅虎股票来分析，

yahoo = prices[prices['symbol']=='YHOO']

yahoo_stock_prices = yahoo.close.values.astype('float32') #取收盘价

yahoo_stock_prices = yahoo_stock_prices.reshape(1762, 1) #转为数组

yahoo_stock_prices.shape

#查看价格趋势

print(yahoo.head())

plt.plot(yahoo_stock_prices)

plt.show()

image.png

分训练测试集

train_size = int(len(yahoo_stock_prices) * 0.80) #前80%数据作为训练

test_size = len(yahoo_stock_prices) - train_size

train, test = yahoo_stock_prices[0:train_size,:], yahoo_stock_prices[train_size:len(yahoo_stock_prices),:]

print(len(train), len(test))

将数组转换为数据的矩阵

def create_dataset(dataset, look_back=1): #look_back默认为1表示预测一天后的

dataX, dataY = [], [] #dataX为原始数据列，y就是它下一天的值，转为自回归问题。

for i in range(len(dataset)-look_back-1):

a = dataset[i:(i+look_back), 0] #t+look_bak时刻之前的数据

dataX.append(a)

dataY.append(dataset[i + look_back, 0]) #t+look_back的数据

return np.array(dataX), np.array(dataY)

# reshape into X=t and Y=t+1

#t时刻以及t前的数据预测t+1时刻的值

look_back = 1

trainX, trainY = create_dataset(train, look_back)

testX, testY = create_dataset(test, look_back)

转为矩阵格式

trainX = trainX.reshape(trainX.shape[0], 1, trainX.shape[1])

testX = testX.reshape(testX.shape[0], 1, testX.shape[1])

trainX.shape

建模

model = Sequential() #初始化序列模型

model.add(LSTM(

input_dim=1,

output_dim=50,

return_sequences=True))

model.add(Dropout(0.2))

model.add(LSTM(

100,

return_sequences=False))

model.add(Dropout(0.2))

model.add(Dense(

output_dim=1))

model.add(Activation('linear'))

start = time.time()

model.compile(loss='mse', optimizer='rmsprop')

print ('compilation time : ', time.time() - start)

训练

model.fit(

trainX,

trainY,

batch_size=128,

nb_epoch=10,

validation_split=0.05)

def plot_results_multiple(predicted_data, true_data,length):

plt.plot(scaler.inverse_transform(true_data.reshape(-1, 1))[length:])

plt.plot(scaler.inverse_transform(np.array(predicted_data).reshape(-1, 1))[length:])

plt.show()

#predict lenght consecutive values from a real one

def predict_sequences_multiple(model, firstValue,length):

prediction_seqs = []

curr_frame = firstValue

for i in range(length):

predicted = []

print(model.predict(curr_frame[newaxis,:,:]))

predicted.append(model.predict(curr_frame[newaxis,:,:])[0,0])

curr_frame = curr_frame[0:]

curr_frame = np.insert(curr_frame[0:], i+1, predicted[-1], axis=0)

prediction_seqs.append(predicted[-1])

return prediction_seqs

predict_length=5

predictions = predict_sequences_multiple(model, testX[0], predict_length)

print(scaler.inverse_transform(np.array(predictions).reshape(-1, 1)))

plot_results_multiple(predictions, testY, predict_length)