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

Question

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

对于任何对此类数据感兴趣的人，我强烈建议您查看 https://github.com/martinobdl/ITCH 以获取 Book Constructor 和一些示例数据（无论如何，这比您在其他任何地方得到的都多）

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

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

Bid     Ask        1_bid_vol  1_ask_vol  2_bid_vol  2_ask_vol   
162.49  162.52     300.0      200.0      500.0      200.0       
162.48  162.51     300.0      600.0      800.0      500.0       
162.49  162.51     100.0      10.0       1000.0     500.0       
162.48  162.52     469.0      600.0      618.0      500.0       

除了规范化数据外，我还创建了固定长度的序列，因为它适用于 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)

这样输入数据的形状 = (n_samples, history_size, n_features)

我目前的架构如下：

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 数据点进行训练的验证集上得到的结果（我会让你们都想象一下它在测试集上的样子）：

Predictions on validation set

如您所见，该模型在验证集上的开始很好，而不是它基本上开始预测随机异常值/峰值。

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

Answer 1

这是一个预测未来股价的 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]]

您可以在下面的我的博客中找到其他一些预测未来股票价格的示例。

https://github.com/ASH-WICUS/Notebooks