RNNs在股票价格预测的应用

Posted 2020-09-26 曹明

　　　　　　　　　　　　　　　　RNNs在股票价格预测的应用

 

前言

RNN和LSTMs在时态数据上表现特别好，这就是为什么他们在语音识别上是有效的。我们通过前25天的开高收低价格，去预测下一时刻的前收盘价。每个时间序列通过一个高斯分布和2层LSTM模型训练数据。文章分为两个版块，外汇价格预测和每日盘中价格预测(30分钟、15分钟、5分钟,等等)。源代码请在文末获取！

 

 

外汇预测（用英语描述）

a. Daily Data is pulled from Yahoo’s Data Reader

b. Only the training set is preprocessed because we create a separate test set later on

c. “model_forex” is the model for to build and train.

d. Create separate daily test set by specifying dates which start after your training set ends.

e. You can see “model_forex” is plugged in here for running the prediction

predicted_st = predict_standard(X_test_stock,y_test_stock, model_forex)

 

 

盘中预测（用英语描述）

a. Intraday Data is pulled from Google’s API. The second argument is the time in seconds (900 secs = 15 mins) and the third argument it the number of days, the max backtrack day for Googles API is 15 days I believe.

df = get_google_data(INTRA_DAY_TICKER, 900, 150)

b. Preprocess the full set of data and train test split it with “train_test_split_intra”

c. “model_intra” is the model for to build and train.

d. You can see “model_intra” is plugged in here for running the prediction

predicted_intra = predict_intra(X_test_intra,y_test_intra, model_intra)

 

 

代码展示

SITE = "http://en.wikipedia.org/wiki/List_of_S%26P_500_companies"

def scrape_list(site):
    hdr = {‘User-Agent‘: ‘Mozilla/5.0‘}
    req = urllib2.Request(site, headers=hdr)
    page = urllib2.urlopen(req)
    soup = BeautifulSoup(page)

    table = soup.find(‘table‘, {‘class‘: ‘wikitable sortable‘})
    sector_tickers = dict()    for row in table.findAll(‘tr‘):
        col = row.findAll(‘td‘)        if len(col) > 0:
            sector = str(col[3].string.strip()).lower().replace(‘ ‘, ‘_‘)
            ticker = str(col[0].string.strip())            if sector not in sector_tickers:
                sector_tickers[sector] = list()
            sector_tickers[sector].append(ticker)    return sector_tickers
sector_tickers = scrape_list(SITE)
##Help functions to normalize and denormalize values
（省略）

# Sequence Length, or # of days of tradingSEQ_LENGTH = 25

# Number of units in the two hidden (LSTM) layersN_HIDDEN = 256

#Number of attributes used for each trading daynum_attr = 4

#Out of those attribute how many are indicatorsnum_indicators = 0

#Variable to help define how far you want your y to reachREWARD_LAG = 1

#How many dats ahead do you want to predictLOOK_AHEAD = 5

#Window StrideSTRIDE = 1

def _load_data(data, n_prev = SEQ_LENGTH):  
    docX, docY = [], []    for i in range(len(data)-n_prev):
        x,y = norm(data.iloc[i:i+n_prev,:num_attr].as_matrix(),data.iloc[i+n_prev-1,num_attr:].as_matrix())
        docX.append(x)
        docY.append(y)
    alsX = np.array(docX)
    alsY = np.array(docY)    return alsX, alsYdef _load_data_test(data, n_prev = SEQ_LENGTH):  
    docX, docY = [], []
    num_sequences = (len(data)-n_prev+1)/STRIDE    for i in range(num_sequences):
        i = i*STRIDE
        x = (data.iloc[i:i+n_prev,:num_attr].as_matrix())
        y = (data.iloc[i+n_prev-1,num_attr:].as_matrix())        #x,y = norm(data.iloc[i:i+n_prev,:num_attr].as_matrix(),data.iloc[i+n_prev-1,num_attr:].as_matrix())
        docX.append(x)
        docY.append(y)
    alsX = np.array(docX)
    alsY = np.array(docY)    return alsX, alsYdef _load_data_norm(data, n_prev = SEQ_LENGTH):  
    docX, docY = [], []    for i in range(len(data)-n_prev):
        x = np.array((data.iloc[i:i+n_prev,:num_attr].as_matrix()))
        y = np.array((data.iloc[i+n_prev-1,num_attr:].as_matrix()))
（省略）

 

外汇数据

##Dataset on just single ticker to test performancesdf = data.DataReader(‘EUR=X‘, ‘yahoo‘, datetime(2010,8,1), datetime(2014,8,1))
# df[‘RSI‘] = ta.RSI(df.Close.values,timeperiod=14)# _,_, macdhist = ta.MACD(df.Close.values, fastperiod=12, slowperiod=26, signalperiod=9)# df[‘MACDHist‘] = macdhist
##Add the predicted coloumn Y, as the last coloumn can be defined however you think is a good representation of a good decision 
##Clean the rest of the Data Frame
y = []for i in range(0,len(df)):    if i >= (len(df)- STRIDE):
        y.append(None)    else:        if (REWARD_LAG > 1):
            val = 0
            for n in range(REWARD_LAG):
                val = val + df[‘Close‘][i+n+1]
            val = val / float(REWARD_LAG)
            y.append(val)        else:
            y.append(df[‘Close‘][i+REWARD_LAG])


df[‘Y_Values‘] =np.asarray(y)
df = df.dropna()#print (df)sliced_df = df.drop([‘Adj Close‘,‘Volume‘] ,axis=1)#print (sliced_df)#(X_train, y_train), (X_test, y_test) = train_test_split(sliced_df)(X_train, y_train) = train_test_split(sliced_df)
print(X_train[0],y_train[0])print (X_train.shape,y_train.shape)

(array([[-0.76244909, -0.75153814, -1.36800657, -1.28695383],
       [-1.28305706, -1.17005084, -1.66649887, -1.50673145],

（省略）

 

盘中数据

def get_google_data(symbol, period, window):
    url_root = ‘http://www.google.com/finance/getprices?i=‘
    url_root += str(period) + ‘&p=‘ + str(window)
    url_root += ‘d&f=d,o,h,l,c,v&df=cpct&q=‘ + symbol
    print(url_root)
    response = urllib2.urlopen(url_root)
    data = response.read().split(‘\n‘)    #actual data starts at index = 7
    #first line contains full timestamp,
    #every other line is offset of period from timestamp
    parsed_data = []
    anchor_stamp = ‘‘
    end = len(data)    for i in range(7, end):
        cdata = data[i].split(‘,‘)        if ‘a‘ in cdata[0]:            #first one record anchor timestamp
            anchor_stamp = cdata[0].replace(‘a‘, ‘‘)
            cts = int(anchor_stamp)        else:            try:
                coffset = int(cdata[0])
                cts = int(anchor_stamp) + (coffset * period)
                parsed_data.append((dt.datetime.fromtimestamp(float(cts)), float(cdata[1]), float(cdata[2]), float(cdata[3]), float(cdata[4]), float(cdata[5])))            except:                pass # for time zone offsets thrown into data
    df = pd.DataFrame(parsed_data)
    df.columns = [‘ts‘, ‘Open‘, ‘High‘, ‘Low‘, ‘Close‘, ‘Volume‘]
    df.index = df.ts    del df[‘ts‘]    return df

 

盘中创建单独的数据集

df = get_google_data(‘AAPL‘, 900, 150)#print(df)plt.plot(df[‘Close‘].values[:])
y = []for i in range(0,len(df)):    if i >= (len(df)- REWARD_LAG):
        y.append(None)    else:        if (REWARD_LAG > 1):
            val = 0
            for n in range(REWARD_LAG):
                val = val + df[‘Close‘][i+n+1]
            val = val / float(REWARD_LAG)
            y.append(val)
            print(‘here‘)        else:
            y.append(df[‘Close‘][i+REWARD_LAG])


df[‘Y_Values‘] =np.asarray(y)
df = df.dropna()
sliced_df = df.drop([‘Volume‘] ,axis=1)#print(sliced_df)(X_train, y_train), (X_test, y_test) = train_test_split_intra(sliced_df)#print(X_train[0],y_train[0])print(len(X_train),len(X_test))#print(X_test[0],y_test[0])

(1168, 108)

 

 

构建网络结构

model_intra = Sequential() 

model_intra.add(LSTM(N_HIDDEN, return_sequences=True, activation=‘tanh‘, input_shape=(SEQ_LENGTH, num_attr)))#model_intra.add(LSTM(N_HIDDEN, return_sequences=True, activation=‘tanh‘))model_intra.add(LSTM(N_HIDDEN, return_sequences=False, activation=‘tanh‘))

model_intra.add(Dense(1,activation=‘linear‘))
model_intra.compile(loss="mean_squared_error", optimizer=‘adam‘)
model_intra_full = Sequential() 

model_intra_full.add(LSTM(N_HIDDEN, return_sequences=True, activation=‘tanh‘, input_shape=(SEQ_LENGTH, num_attr)))#model_intra_full.add(LSTM(N_HIDDEN, return_sequences=True, activation=‘tanh‘))model_intra_full.add(LSTM(N_HIDDEN, return_sequences=False, activation=‘tanh‘))

model_intra_full.add(Dense(1,activation=‘linear‘))
model_intra_full.compile(loss="mean_squared_error", optimizer=‘adam‘)

model_forex = Sequential() 

model_forex.add(LSTM(N_HIDDEN, return_sequences=True, activation=‘tanh‘, input_shape=(SEQ_LENGTH, num_attr)))#model_forex.add(LSTM(N_HIDDEN, return_sequences=True, activation=‘tanh‘))model_forex.add(LSTM(N_HIDDEN, return_sequences=False, activation=‘tanh‘))

model_forex.add(Dense(1,activation=‘linear‘))
model_forex.compile(loss="mean_squared_error", optimizer

 

符合模型的模型和参数

print(X_train.shape)
print(y_train.shape)

(1018, 25, 4)
(1018, 1)

model_intra.fit(X_train, y_train, batch_size=50, nb_epoch=

Train on 1156 samples, validate on 12 samples
Epoch 1/150
1156/1156 [==============================] - 1s - loss: 1.9575 - val_loss: 0.5494
Epoch 2/150
1156/1156 [==============================] - 1s - loss: 1.4731 - val_loss: 0.4006

（省略）

 

 

辅助绩效评估功能

#Function to normalize the test input then denormalize the result. Calculate the rmse of the predicted values on the test setdef predict(X_test,y_test, myModel):
    predicted = []    for example in X_test:
        x = copy.copy(example)        #print (x)
        x_norm, mn, mx = normalize(x)
        toPred = []
        toPred.append(x_norm)
        add = np.array(toPred)        #Predict for the standard model
        predict_standard = myModel.predict(add)
        pred_st = copy.copy(predict_standard)
        y_real_st = deNormalizeY(pred_st,mn,mx)
        predicted.append(y_real_st[0])        #Predict for the bidirectional model#         predict_bidirectional = myModel.predict([add,add])#         pred_bi = copy.copy(predict_bidirectional)#         y_real_bi = deNormalizeY(pred_bi,mn,mx)#         predicted.append(y_real_bi[0])（省略）df_test = data.DataReader(‘EUR=X‘, ‘yahoo‘, datetime(2014,8,1), datetime(2015,8,1))# df_test[‘RSI‘] = ta.RSI(df_test.Close.values,timeperiod=14)# _,_, macdhist = ta.MACD(df_test.Close.values, fastperiod=12, slowperiod=26, signalperiod=9)# df_test[‘MACDHist‘] = macdhisty = []for i in range(0,len(df_test)):    if i >= (len(df_test)- STRIDE):

        y.append(None)    else:        if (REWARD_LAG > 1):
            val = 0
            for n in range(REWARD_LAG):
                val = val + df_test[‘Close‘][i+n+1]
            val = val / float(REWARD_LAG)
            y.append(val)        else:
            y.append(df_test[‘Close‘][i+REWARD_LAG])

（省略）

MAE for LSTM is: [0.0035823152701196983]
MAE for doing nothing is: [0.0045693478326778786]
RMSE for LSTM is: [0.0050684837061917686]
RMSE for doing nothing is: [0.0061416562709802761]
Net profit for 0.0 threshhold is 245.261025777 making 234 trades
Net profit for 0.001 threshhold is 242.673572498 making 201 trades
（省略）

 

 

盘中交易评价和结果

def predict_intra(X_test, y_test, myModel):
    print(len(X_test))
    predicted = []    for example in X_test:        #Transform the training example into gaussing distribution
        x_norm, mean, std = normDist(np.array(example))        #Add examples to array to predict
        toPred = []
        toPred.append(x_norm)
        add = np.array(toPred)        #Predict these examples
        predict_standard = myModel.predict(add)
        pred = copy.copy(predict_standard)
        y_real = deNormDist(pred,mean,std)
        predicted.append(y_real[0])    return predicted

predicted_intra = predict_intra(X_test,y_test, model_intra)
plt.figure(figsize=(20,20))
plt.plot(y_test) 
plt.plot(predicted_intra)
plt.show()

 

MAE and RMSE 评估

sum_error = 0sum_error_donothing = 0for i in range(len(predicted_intra)):    if i>0:
        sum_error = sum_error + abs(predicted_intra[i] - y_test[i])
        sum_error_donothing = sum_error_donothing + abs(predicted_intra[i] - y_test[i-1])
MAE_lstm = sum_error/len(predicted_intra)
MAE_donothing = sum_error_donothing/len(predicted_intra)
print("MAE for LSTM is: " + str(MAE_lstm))
print("MAE for doing nothing is: " + str(MAE_donothing))

MAE for LSTM is: [0.091961468484759237]
MAE for doing nothing is: [0.16699238882416201]

sum_error = 0sum_error_donothing = 0for i in range(len(predicted_intra)):    if i>0:
        sum_error = sum_error + (predicted_intra[i] - y_test[i])**2
        sum_error_donothing = sum_error_donothing + (predicted_intra[i] - y_test[i-1])**2RMSE_lstm = (sum_error/len(predicted_intra))**(1.0/2.0)
RMSE_donothing = (sum_error_donothing/len(predicted_intra))**(1.0/2.0)
print("RMSE for LSTM is: " + str(RMSE_lstm))
print("RMSE for doing nothing is: " + str(RMSE_dono

RMSE for LSTM is: [0.15719269057322682]
RMSE for doing nothing is: [0.23207816758496383]

 

 

Policy的功能评价

net_profits = []
protits_per_trade = []for i in range(50):
    THRESH = i/10000.0
    LOT_SIZE = 100
    net_profit = 0
    num_trades = 0
    for i in range(len(predicted_intra)):        if i>1:
            predicted_change = ((predicted_intra[i] / y_test[i-1]) - 1)            #print(predicted_change)
            actual_change = (predicted_intra[i] -  y_test[i])*LOT_SIZE            if predicted_change >= THRESH:                #print("Buy")
                net_profit = net_profit + actual_change 
                num_trades = num_trades + 1
（省略）

(array([327.67074597699519], dtype=object), 106)
(array([322.81673063817777], dtype=object), 103)

plt.plot(net_profits)
plt.show()

plt.plot(protits_per_trade)
plt.show()

 

 

其他

buyTotal = 0sellTotal = 0correct = 0sellCorrect = 0buyCorrect = 0for i in range(len(predicted_st)):
    realAnswer = y_test_stock[i][0][0]    if predicted_st[i][1] > predicted_st[i][0]:
        predicted = 0 #Buy
    else:
        predicted = 1 #Sell

    if realAnswer == 0:        ##This is where the actual answer is Buy:Up:[0,1]:0
        buyTotal = buyTotal + 1
        if predicted == realAnswer:
            buyCorrect = buyCorrect + 1
            correct = correct + 1（省略）

(349, 730, 0.4780821917808219)
(210, 382, 0.5497382198952879)
(139, 348, 0.3994252873563218)
0.523287671233
0.476712328767

MMM
AYI
ALK
ALLE(省略)

 

 

创造基线RMSE

totalCorrect = 0total = 0for stock in testing_dataframes[:50]:

    X_test_stock, y_test_stock = _load_data_test(stock[1])
    predicted_st = predict_standard(X_test_stock,y_test_stock, model)

    buyTotal = 0
    sellTotal = 0
    correct = 0
    sellCorrect = 0
    buyCorrect = 0（省略）

#Count the number of positive and the number of negative calls you got righttotalCorrect = 0total = 0buyTotal = 0sellTotal = 0correct = 0sellCorrect = 0buyCorrect = 0for i in range(len(predicted_st)):
    realAnswer = y_test_stock[i][0][0]    if predicted_st[i][1] > predicted_st[i][0]:
        predicted = 0 #Buy
（省略）

(104, 235, 0.4425531914893617)
(104, 104, 1.0)
(0, 131, 0.0)
0.442553191489
0.557446808511

from sklearn.metrics import f1_score##Calculate F1 scoreactual = []
result = []for y in y_test_merged:    if y[0] == 0:
        actual.append(0)    else:
        actual.append(1)for y in predicted_st:    if y[1] > y[0]:
        result.append(0)    else:
        result.append(1)
score = f1_score(actual,result,average=‘weighted‘,pos_label=1)
print(score)

0.498192044998

 

#Same percentage calculations but with a thresholdTHRESH = 0.1totalCorrect = 0total = 0noDecision = 0buyTotal = 0sellTotal = 0correct = 0sellCorrect = 0buyCorrect = 0for i in range(len(predicted_st)):
    realAnswer = y_test_merged[i][0]    if predicted_st[i][1] - THRESH > .5:
        predicted = 0 #Buy
    elif predicted_st[i][0] - THRESH > .5:
        predicted = 1 #Sell
    else:
        predicted = 2 #Pass, do not count towards percentages because you make no decision if .6>x>.4（省略）

(347, 750, 0.46266666666666667)
(190, 351, 0.5413105413105413)
(157, 399, 0.39348370927318294)
If you just predicted all Up 0.468
If you just predicted all Down 0.532

 

thresholds = []
totalAcc = []
positiveAcc = []
negativeAcc = []##Graph this graph of the threshold vs accuracyfor i in range(10):
    thresh = i/100.0
    totalCorrect = 0
    total = 0
    noDecision = 0
    buyTotal = 0
    sellTotal = 0
    correct = 0
    sellCorrect = 0
    buyCorrect = 0
    for i in range(len(predicted_st)):
        realAnswer = y_test_merged[i][0]        if predicted_st[i][1] - thresh > .5:
            predicted = 0 #Buy
        elif predicted_st[i][0] - thresh > .5:
            predicted = 1 #Sell
（省略）    

plt.plot(totalAcc)
plt.show()

plt.plot(positiveAcc)
plt.show()

plt.plot(negativeAcc)
plt.show()

 

通过测试表明，每日价格预测，外汇有更好的表现，比传统股票。因为他有更少的噪音。