Exxact | Deep Learning, HPC, AV, Distribution & More

Come prevedere i prezzi del mercato azionario utilizzando LSTM

L’industria finanziaria è stata una delle prime industrie ad abbracciare l’uso del machine learning e del deep learning nelle sue analisi e operazioni di investimento per aggiungere valore ai loro clienti. Prima del machine learning, del deep learning e dell’intera rivoluzione “Quant” negli anni 2000 fino ad oggi, gli analisti e gli investitori si affidavano a tecniche meno tecnologiche. L’analisi fondamentale e tecnica regnava sovrana e, anche se costituiscono ancora una grande parte dell’analisi, ora sono combinate con previsioni e analisi fatte dai computer.

Come la maggior parte delle persone sa, il mercato azionario è un luogo dove la gente compra e vende azioni. L’atto di comprare e vendere queste azioni (cioè il trading) avviene in ambienti fisici e virtuali chiamati “Borse”. Queste borse sono case per indici (quelli comunemente conosciuti sono il Dow Jones Industrial Average e il NASDAQ Composite). Le borse sono il luogo in cui viene fissato il prezzo delle azioni che compongono gli indici.

Ci sono molti fattori che possono far fluttuare il prezzo di un’azione. Le notizie quotidiane che riportano notizie buone o cattive sulle prospettive attuali o future di un’azienda sono probabilmente uno dei fattori più influenti che guidano le fluttuazioni quotidiane del prezzo. La redditività di un’azienda, la crescita dei ricavi e le prospettive di espansione futura sono indicatori che possono determinare variazioni di prezzo a lungo e a breve termine. L’apprendimento profondo e altri modelli statistici possono solo rendere conto di così tanto e di solito è più adatto per previsioni a breve-medio termine piuttosto che a lungo termine (ad esempio anni).

Interessato ad ottenere risultati più veloci?
Scopri di più sulle soluzioni Exxact Deep Learning Solutions

Modelli a memoria lunga e breve termine (LSTM)

Modelli a memoria lunga e breve termine (LSTM)

Fonte

LSTM sono un derivato di una rete neurale ricorrente (RNN). Una RNN è un modello adeguato per un breve orizzonte temporale, forse da una settimana a un mese. Andando oltre, è improbabile che la RNN produca previsioni affidabili. Questo è dovuto al problema del gradiente di Vanishing Gradient.

Un normale metodo di serie temporali come AR e i suoi derivati o ANN (Artificial Neural Network) può imparare applicando un grande peso verso il prezzo del giorno precedente più altre caratteristiche. Per le serie temporali finanziarie, si utilizzerebbero i modelli ARCH e i loro derivati per prevedere i rendimenti o la volatilità. In una rete feed forward, questi punti sono considerati come indipendenti l’uno dall’altro. Ciò significa che l’LSTM non ha lo stesso approccio dei metodi tradizionali di previsione delle serie temporali.

LSTM usa dipendenze diverse nella previsione

Un LSTM prenderà i dati attraverso ciò che chiama “celle”, come si può vedere nel diagramma sopra raffigurato nel rettangolo centrale. È attraverso questo stato di cella che l’LSTM può scegliere di ricordare o dimenticare le cose.

Un LSTM avrà 3 diverse dipendenze a seconda delle informazioni che riceve:

    1. Lo stato della cella precedente (cioè l’informazione che era presente nella memoria dopo il passo temporale precedente)
    2. Lo stato nascosto precedente (cioè questo è lo stesso dell’output della cella precedente)
    3. L’input al passo temporale corrente (cioè le nuove informazioni che vengono immesse in quel momento)

Al dominio della previsione del prezzo delle attività finanziarie, queste dipendenze possono essere spiegate come segue:

  1. Lo stato precedente della cella – L’andamento del titolo nel giorno precedente.
  2. Lo stato nascosto precedente – Il prezzo del titolo nel giorno precedente.
  3. L’input nella fase temporale corrente – Altri fattori che possono influenzare il prezzo. Questi saranno tipicamente gli avvisi di notizie che diventano disponibili per gli investitori durante il giorno.

Gli stati delle celle di LSTM in come sono memorizzati

Fonte

Nel diagramma sopra, la linea orizzontale ct denota lo stato della cella che è la memoria della LSTM. Come abbiamo subito detto sopra, questo si riferisce all’andamento del titolo nel giorno precedente (1). Questa informazione entrerà nella cella e sarà elaborata con le altre informazioni che entrano. La linea che è denotata da ct-1 è lo Stato Nascosto (2) che nel nostro caso di previsione delle azioni conterrà le informazioni dei passi temporali precedenti (cioè il prezzo delle azioni del giorno precedente). La linea orizzontale denotata da ht-1 è l’input al momento attuale che è il prezzo corrente delle azioni (3). Utilizzando le informazioni del prezzo precedente delle azioni (Hidden State), il prezzo attuale combinato con l’andamento del giorno precedente (Cell State), l’LSTM genererà un output.

AMD EPYC SERVER SALE

Codice Python per creare un modello di previsione LSTM

Il seguente codice Python ci porta attraverso i passi per creare un modello LSTM che predice il prezzo di un’azione.

  1. # -*- coding: utf-8 -*-
  2. """EXXACT - Stock Market Prediction LSTM.ipynb
  3. Automatically generated by Colaboratory.
  4. """
  5. # By running this line of code, you will be prompted to select your file to upload.
  6. from google.colab import files
  7. uploaded = files.upload()
  8. import io
  9. import pandas as pd
  10. import numpy as np
  11. import matplotlib.pyplot as plt
  12. %matplotlib inline
  13. from matplotlib.pylab import rcParams
  14. rcParams=20,10
  15. from keras.models import Sequential
  16. from keras.layers import LSTM,Dropout,Dense
  17. from sklearn.preprocessing import MinMaxScaler
  18. df = pd.read_csv(io.BytesIO(uploaded))
  19. print(df)
  20. df=pd.to_datetime(df.Date,format="%Y-%m-%d")
  21. df.index=df
  22. data=df.sort_index(ascending=True,axis=0)
  23. new_dataset=pd.DataFrame(index=range(0,len(df)),columns=)
  24. for i in range(0,len(data)):
  25. new_dataset=data
  26. new_dataset=data
  27. train_data=final_dataset
  28. valid_data=final_dataset
  29. new_dataset.index=new_dataset.Date
  30. new_dataset.drop("Date",axis=1,inplace=True)
  31. scaler=MinMaxScaler(feature_range=(0,1))
  32. scaled_data=scaler.fit_transform(new_dataset)
  33. x_train_data,y_train_data=,
  34. for i in range(60,len(train_data)):
  35. x_train_data.append(scaled_data)
  36. y_train_data.append(scaled_data)
  37. x_train_data,y_train_data=np.array(x_train_data),np.array(y_train_data)
  38. x_train_data=np.reshape(x_train_data,(x_train_data.shape,x_train_data.shape,1))
  39. lstm_model=Sequential()
  40. lstm_model.add(LSTM(units=50,return_sequences=True,input_shape=(x_train_data.shape,1)))
  41. lstm_model.add(LSTM(units=50))
  42. lstm_model.add(Dense(1))
  43. inputs_data=new_dataset.values
  44. inputs_data=inputs_data.reshape(-1,1)
  45. inputs_data=scaler.transform(inputs_data)
  46. lstm_model.compile(loss='mean_squared_error',optimizer='adam')
  47. lstm_model.fit(x_train_data,y_train_data,epochs=1,batch_size=1,verbose=2)
  48. X_test=
  49. for i in range(60,inputs_data.shape):
  50. X_test.append(inputs_data)
  51. X_test=np.array(X_test)
  52. X_test=np.reshape(X_test,(X_test.shape,X_test.shape,1))
  53. predicted_closing_price=lstm_model.predict(X_test)
  54. predicted_closing_price=scaler.inverse_transform(predicted_closing_price)
  55. train_data=new_dataset
  56. valid_data=new_dataset
  57. valid_data=predicted_closing_price

Un programma capace di predire i prezzi del mercato azionario usando LSTM

Ora avete il codice Python per iniziare a predire i prezzi delle azioni in borsa usando LSTM. Fate una prova e fateci sapere come funziona per voi. Siamo solo all’inizio dello spacchettamento delle capacità di LSTM in diverse applicazioni, e siamo entusiasti del futuro.

Impara di più su come le reti neurali ricorrenti LSTM sono usate in altre applicazioni.

Hai qualche domanda sulle workstation o i server di deep learning?
Contatta Exxact oggi

Leave a Reply

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.