Python 使用LSTM进行高频股票预测的不稳定结果

我有几个数据集包含纳斯达克的高频数据（限价订单簿）

对于任何对此类数据感兴趣的人，我强烈建议他们查看一本书的构造函数和一些示例数据（无论如何，比你在其他任何地方都要多）

我想使用LSTM网络来尝试和预测下一个出价和下一个要价，同时使用一些其他功能，例如订单中的数量和数量不平衡

这是我的列车数据的前五列的样子（来自AAPL的数据，数据点之间的1s）：

除了规范化数据外，我还创建了适合LSTM的固定长度序列，如下所示：

def slicing(df,history_size):
data = []
labels = []
tmp_df=np.array(df)
start_index = history_size
for i in range(start_index, len(df)):
    indices = range(i-history_size, i)
    data.append(tmp_df[indices,:])
    labels.append(tmp_df[i,:2])

return np.array(data), np.array(labels)

callback = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=5)
LSTM = tf.keras.models.Sequential([
  tf.keras.layers.LSTM(128,input_shape= 
      (X_train.shape[1],X_train.shape[2]),activation='relu',return_sequences=True),
  tf.keras.layers.LSTM(62,input_shape=(X_train.shape[1],X_train.shape[2]),activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(2)
   ])
 opt = tf.keras.optimizers.Adam(learning_rate=0.001)
 LSTM.compile(optimizer=opt, loss='mse')
 LSTM.fit(x=X_train,y=y_train, epochs=50, validation_data=(X_val,y_val),callbacks=[callback]) 

因此，输入数据具有shape=（n_样本、历史大小、n_特征）

我目前的架构如下：

def slicing(df,history_size):
data = []
labels = []
tmp_df=np.array(df)
start_index = history_size
for i in range(start_index, len(df)):
    indices = range(i-history_size, i)
    data.append(tmp_df[indices,:])
    labels.append(tmp_df[i,:2])

return np.array(data), np.array(labels)

callback = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=5)
LSTM = tf.keras.models.Sequential([
  tf.keras.layers.LSTM(128,input_shape= 
      (X_train.shape[1],X_train.shape[2]),activation='relu',return_sequences=True),
  tf.keras.layers.LSTM(62,input_shape=(X_train.shape[1],X_train.shape[2]),activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(2)
   ])
 opt = tf.keras.optimizers.Adam(learning_rate=0.001)
 LSTM.compile(optimizer=opt, loss='mse')
 LSTM.fit(x=X_train,y=y_train, epochs=50, validation_data=(X_val,y_val),callbacks=[callback]) 

以下是我使用14k数据点进行训练得到的验证集结果（我让你们想象一下测试集的情况）：

正如您所看到的，该模型在验证集上起步很好，而不是基本上开始预测沿途的随机异常值/峰值

---

请注意，即使在更改超参数、模型架构、甚至更改数据（例如使用其他股票）以及使用更小的时间窗口（以便我可以使用更多的数据进行训练）之后，此结果仍会持续出现。有鉴于此，我怀疑这一定是某种常见的问题，如果有经验/精通使用RNN/LSTM的人能提供任何帮助/资源，我将不胜感激。

这里有一个预测未来股价的LSTM模型，但它预测的是第二天的股价，而不是第二秒钟的股价。我用这个策略和其他类似的策略赚了数百万美元，但是赚几百万需要一点时间，我不认为你会在一秒钟内做到

from pandas_datareader import data as wb
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.pylab import rcParams
from sklearn.preprocessing import MinMaxScaler

start = '2019-06-30'
end = '2020-06-30'

tickers = ['GOOG']

thelen = len(tickers)

price_data = []
for ticker in tickers:
    prices = wb.DataReader(ticker, start = start, end = end, data_source='yahoo')[['Open','Adj Close']]
    price_data.append(prices.assign(ticker=ticker)[['ticker', 'Open', 'Adj Close']])

#names = np.reshape(price_data, (len(price_data), 1))

df = pd.concat(price_data)
df.reset_index(inplace=True)

for col in df.columns: 
    print(col) 
    
#used for setting the output figure size
rcParams['figure.figsize'] = 20,10
#to normalize the given input data
scaler = MinMaxScaler(feature_range=(0, 1))
#to read input data set (place the file name inside  ' ') as shown below


df['Adj Close'].plot()
plt.legend(loc=2)
plt.xlabel('Date')
plt.ylabel('Price')
plt.show()

ntrain = 80
df_train = df.head(int(len(df)*(ntrain/100)))
ntest = -80
df_test = df.tail(int(len(df)*(ntest/100)))


#importing the packages 
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import Dense, Dropout, LSTM

#dataframe creation
seriesdata = df.sort_index(ascending=True, axis=0)
new_seriesdata = pd.DataFrame(index=range(0,len(df)),columns=['Date','Adj Close'])
length_of_data=len(seriesdata)
for i in range(0,length_of_data):
    new_seriesdata['Date'][i] = seriesdata['Date'][i]
    new_seriesdata['Adj Close'][i] = seriesdata['Adj Close'][i]
#setting the index again
new_seriesdata.index = new_seriesdata.Date
new_seriesdata.drop('Date', axis=1, inplace=True)
#creating train and test sets this comprises the entire data’s present in the dataset
myseriesdataset = new_seriesdata.values
totrain = myseriesdataset[0:255,:]
tovalid = myseriesdataset[255:,:]
#converting dataset into x_train and y_train
scalerdata = MinMaxScaler(feature_range=(0, 1))
scale_data = scalerdata.fit_transform(myseriesdataset)
x_totrain, y_totrain = [], []
length_of_totrain=len(totrain)
for i in range(60,length_of_totrain):
    x_totrain.append(scale_data[i-60:i,0])
    y_totrain.append(scale_data[i,0])
x_totrain, y_totrain = np.array(x_totrain), np.array(y_totrain)
x_totrain = np.reshape(x_totrain, (x_totrain.shape[0],x_totrain.shape[1],1))

In [85]:

#LSTM neural network
lstm_model = Sequential()
lstm_model.add(LSTM(units=50, return_sequences=True, input_shape=(x_totrain.shape[1],1)))
lstm_model.add(LSTM(units=50))
lstm_model.add(Dense(1))
lstm_model.compile(loss='mean_squared_error', optimizer='adadelta')
lstm_model.fit(x_totrain, y_totrain, epochs=10, batch_size=1, verbose=2)
#predicting next data stock price
myinputs = new_seriesdata[len(new_seriesdata) - (len(tovalid)+1) - 60:].values
myinputs = myinputs.reshape(-1,1)
myinputs  = scalerdata.transform(myinputs)
tostore_test_result = []
for i in range(60,myinputs.shape[0]):
    tostore_test_result.append(myinputs[i-60:i,0])
tostore_test_result = np.array(tostore_test_result)
tostore_test_result = np.reshape(tostore_test_result,(tostore_test_result.shape[0],tostore_test_result.shape[1],1))
myclosing_priceresult = lstm_model.predict(tostore_test_result)
myclosing_priceresult = scalerdata.inverse_transform(myclosing_priceresult)
    
totrain = df_train
tovalid = df_test

#predicting next data stock price
myinputs = new_seriesdata[len(new_seriesdata) - (len(tovalid)+1) - 60:].values


#  Printing the next day’s predicted stock price. 
print(len(tostore_test_result));
print(myclosing_priceresult);

结果:

[[1396.532]]

你可以在我的博客下面找到一些预测未来股价的其他样本

---

你是否期望该模型能够预测未来2000个时间单位的股票价值？是的，你确实做到了，伙计，我不认为这对我有什么帮助