Exxact | Deep Learning, HPC, AV, Distributie & Meer

Hoe aandelenmarktprijzen te voorspellen met LSTM

De financiële sector was een van de eerste sectoren die machine learning en deep learning toepaste bij beleggingsanalyses en -activiteiten om waarde toe te voegen aan hun klanten. Voorafgaand aan machine learning, deep learning, en de hele “Quant” revolutie in de jaren 2000 tot nu, vertrouwden analisten en beleggers op minder technologisch vertrouwde technieken. Fundamentele en technische analyse heersten en, hoewel ze nog steeds een groot deel van de analyse uitmaken, worden ze nu gecombineerd met voorspellingen en analyses die door computers worden gedaan.

Zoals de meeste mensen weten, is de effectenbeurs een plaats waar mensen aandelen kopen en verkopen. Het kopen en verkopen van deze aandelen (d.w.z. de handel) vindt plaats in fysieke en virtuele omgevingen die “beurzen” worden genoemd. Deze beurzen zijn huizen voor indexen (algemeen bekend zijn de Dow Jones Industrial Average en de NASDAQ Composite). De beurzen zijn de plaatsen waar de prijzen van de aandelen die deel uitmaken van de indexen worden vastgesteld.

Er zijn vele factoren die de prijs van een aandeel kunnen doen schommelen. Dagelijkse nieuwsberichten met goed of slecht nieuws over de huidige of toekomstige vooruitzichten van een onderneming is aantoonbaar een van de meest invloedrijke factoren die dagelijkse koersschommelingen veroorzaken. De winstgevendheid van een bedrijf, de omzetgroei en de toekomstige expansievooruitzichten zijn indicatoren die lange- en kortetermijnprijsveranderingen kunnen bepalen. Deep Learning en andere statistische modellen kunnen slechts met zo veel rekening houden en zijn meestal beter geschikt voor prognoses op korte en middellange termijn dan op lange termijn (bijv. jaren).

Benieuwd naar snellere resultaten?
Lees meer over Exxact Deep Learning Solutions

Uitpakken van Long Short Term Memory Modellen (LSTM)

Long Short Term Memory Modellen (LSTM)

Bron

LSTM’s zijn een afgeleide van een Recurrent Neural Network (RNN). Een RNN is een adequaat model voor een korte tijdshorizon van misschien een week tot een maand. Verder dan dat is het onwaarschijnlijk dat het RNN betrouwbare voorspellingen zal opleveren. Dit is te wijten aan het verdwijnende gradiëntprobleem.

Een normale tijdreeksmethode zoals AR en zijn derivaten of ANN (Artificial Neural Network) kan leren door een groot gewicht toe te kennen aan de koers van de vorige dag plus enkele andere kenmerken. Voor financiële tijdreeksen zou u ARCH-modellen en hun derivaten gebruiken om het rendement of de volatiliteit te voorspellen. In een feed forward netwerk worden deze punten als onafhankelijk van elkaar beschouwd. Dit betekent dat het LSTM niet dezelfde benadering volgt als de traditionele tijdreeksvoorspellingsmethoden.

LSTM gebruikt verschillende afhankelijkheden bij het voorspellen

Een LSTM neemt de gegevens door wat het “cellen” noemt, zoals u kunt zien in het diagram hierboven, afgebeeld in de middelste rechthoek. Het is door deze celstaat dat het LSTM kan kiezen om dingen te onthouden of te vergeten.

Een LSTM zal 3 verschillende afhankelijkheden hebben, afhankelijk van de informatie die het ontvangt:

    1. De vorige celtoestand (d.w.z. de informatie die in het geheugen aanwezig was na de vorige tijdstap)
    2. De vorige verborgen toestand (d.w.z. dit is hetzelfde als de output van de vorige cel)
    3. De input bij de huidige tijdstap (d.w.z. de nieuwe informatie die op dat moment wordt ingevoerd)

Op het gebied van de voorspelling van de koers van financiële activa kunnen deze afhankelijkheden als volgt worden verklaard:

  1. De vorige celtoestand – De trend van het aandeel op de vorige dag.
  2. De vorige verborgen toestand – De koers van het aandeel op de vorige dag.
  3. De input bij de huidige tijdstap – Andere factoren die de koers kunnen beïnvloeden. Dit zijn meestal nieuwsberichten die in de loop van de dag voor beleggers beschikbaar komen.

Celtoestanden van LSTM in hoe ze worden opgeslagen

Bron

In bovenstaand diagram geeft de horizontale lijn ct de celtoestand aan, die het geheugen van het LSTM is. Zoals we hierboven al aangaven, heeft dit betrekking op de trend van het aandeel in de vorige dag (1). Die informatie stroomt de cel binnen en wordt verwerkt met de andere informatie die binnenstroomt. De lijn die wordt aangeduid met ct-1 is de verborgen staat (2) die in ons geval van aandelenvoorspelling de informatie van de vorige tijdstappen zal bevatten (d.w.z. de aandelenkoers van de vorige dag). De horizontale lijn, aangeduid met ht-1, is de input op het huidige tijdstip, namelijk de huidige aandelenkoers (3). Met behulp van de informatie van de vorige aandelenprijs (Hidden State), de huidige prijs in combinatie met de trend van de vorige dag (Cell State), zal het LSTM een output genereren.

AMD EPYC SERVER SALE

Python-code om een LSTM-voorspellingsmodel te maken

De volgende Python-code neemt ons mee door de stappen om een LSTM-model te maken dat de prijs van een aandeel voorspelt.

  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

Een programma dat beurskoersen kan voorspellen met behulp van LSTM

U heeft nu de Python code waarmee u aan de slag kunt om de koersen van aandelen op de beurzen te voorspellen met behulp van LSTM. Probeer het eens en laat ons weten hoe het voor u werkt. We staan nog maar aan het begin van het uitpakken van LSTM’s mogelijkheden in verschillende toepassingen, en we zijn enthousiast over de toekomst.

Lees meer over hoe LSTM Recurrent Neural Networks worden gebruikt in andere toepassingen.

Heeft u vragen over deep learning werkstations of servers?
Contact Exxact Vandaag

Leave a Reply

Geef een antwoord

Het e-mailadres wordt niet gepubliceerd.