Modelarea și simularea unei rețele LSTM în

Python pentru aplicații în predicția seriilor

temporale

Coordonator științific, Student

Prof. univ. Dr. Ing. Radu DOGARU Răzvan-Alexandru STANCIU
Modelarea și simularea unei
rețele LSTM în Python
pentru aplicații în predicția
seriilor temporale
Abstract – Această lucrare are ca scop
prezentarea funcționalității unei rețele
LSTM în predicția unei serii
temporale, în acest caz, evoluția
indicelui S&P 500.
INTRODUCERE
Rețele LSTM
O rețea de tipul LSTM (Long
Short-Term Memory) reprezintă un tip
de rețea neurală recurentă capabilă să
învețe dependențele de ordine în
problemele de predicție a secvențelor.
[1]
Aceste rețele reprezintă un tip
mai special de rețele neurale recurente
deoarece problema gradientului care
dispare este eliminată, problemă
întâlnită la rețelele RNN. [2]
Arhitectura unui LSTM este
formată din trei părți, după cum se
poate vedea și în următoarea figură:
Fig. 1 Structura LSTM
Prima parte are rolul de a decide
dacă informația care vine este
importantă și trebuie memorată sau
dacă nu trebuie păstrată. În a doua
parte, celula încearcă să rețină
informația de la intrare. În final, în
ultima parte a structurii, celula
transmite informația din timestamp-ul
actual către următorul. [2]
Aceste trei părți sunt cunoscute
și ca porți. Ele controlează fluxul
informației la intrarea și ieșirea celulei
de memorie. Prima poartă se numește
”Forget gate” – poarta de uitare, a
doua ”Input gate” – poarta de intrare,
iar ultima poartă numele de ”Output
Gate” – poarta de ieșire. [2]
Python
Python este un limbaj de
programare introdus în anul 1991 de
către Guido van Rossum. Este un
limbaj de programare de nivel înalt și
reprezintă unul dintre cele mai simple
și ușor de înțeles limbaje de
programare. [3]
 Acest limbaj de programare este poate fi utilizată și pentru modul în
folosit de multe ori în machine care modificările asociate cu punctul
learning, analiza datelor, statistică și de date ales se compară cu schimbările
multe alte domenii. De asemenea, altor variabile în aceeași perioadă de
Python suportă modele de programare, timp.
incluzând programarea procedurală,
Seriile temporale sunt utilizate
obiect-orientată și funcțională. [3]
în mai multe contexte non-financiare,
cum ar fi măsurarea schimbării
populației în timp. [4]
Serii temporale
Datele folosite în această
O serie temporală reprezintă o lucrare reprezintă prețurile de Open,
secvență de puncte de date care apar în High, Low, Close și Volumul zilnic al
ordine succesivă pe o anumită indexului S&P 500 din ianuarie 2000
perioadă de timp. până în septembrie 2018.
Când vine vorba de domeniul O astfel de serie temporală este
investițiilor o serie temporală reprezentată în fig. 2, reprezentând
urmărește mișcarea punctelor de date creșterea populației în SUA începând
alese, cum ar fi prețul unui titlu, pe o cu anii 1900 până în anii 2000.
anumită perioadă de timp, cu punctele
de date înregistrate la intervale
regulate. O serie temporală poate fi
luată pentru orice variabilă care se
modifică în timp. În investiții, se
folosesc de obicei pentru a urmări
prețul unui titlu în timp. Acest lucru
poate fi urmărit pe termen scurt, cum
ar fi prețul unui titlu pe oră în cursul
unei zile lucrătoare, sau pe termen
Fig. 2 Serie temporală pentru populația SUA
lung, cum ar fi prețul unui titlu la
închidere în ultima zi a fiecărei luni,
timp de cinci ani.
Analiza seriilor temporale poate
fi utilă pentru a vedea cum se modifică
un anumit activ sau variabilă
economică în timp. De asemenea,
Implementarea rețelei de preț în care s-ar putea afla în viitor
indicele.
LSTM și rezultate
În cazul predicției de secvență
Rețeaua poate realiza trei tipuri
completă, după cum se poate observa
diferite de predicții:
în figura 4, pare să fie cea mai puțin
• Predicții punct cu punct utilă metodă de predicție din cele trei.
• Predicții de secvență Putem observa cum la început modelul
completă prezintă o creștere a indicelui, dar
• Predicții multi-secvență după converge către echilibrul seriei
temporale.
La rularea programului pentru
predicții punct cu punct rezultatul este
unul mulțumitor la prima vedere, după
cum se poate observa în figura 3.

Fig. 4 Predicția cu secvență completă

Al treilea tip de predicție, cea

multi-secvență, îmbină metodele
Fig. 3 Predicția punct cu punct pentru S&P 500 anterioare, obținând în final mai multe
predicții pentru trendurile indexului,
Însă, această metodă este după cum se poate observa în figura 5.
înșelătoare. Linia de predicții este
compusă din puncte singulare de
predicție care au avut în spate întreaga
fereastră anterioară a istoriei
adevărate. Din acest motiv, nu este
necesar ca rețeaua să știe prea multe
informații despre seria temporală, ci
doar că următoarele puncte nu o să fie
prea depărtate față de cel anterior.
Această metodă poate să fie Fig. 5 Predicția multi-secvență
folosită pentru a aproxima intervalul
 În acest model de predicție,
atunci când se întălnește un punct în
care fereastra este formată din
predicții din trecut se oprește, trece cu
o fereastră întreagă peste, resetează
fereastră cu date adevărate de test și
începe procesul iar. În acest fel,
obținem mai multe predicții asemenea
unor trenduri din datele de test pentru
a vedea cum poate modelul să
detecteze posibile trenduri în viitor.
[5]
În continuare, o să analizăm ce
se întâmplă cu rezultatele atunci când
modificăm anumiți parametrii din
fișierul ”config.json”.
În primul caz, o să analizăm
efectul schimbărilor parametrilor în
cazul predicțiilor multi-secvență. În
figura 6, putem observa rezultatul
optim, cu parametrii inițiali,
batch_size = 32 și neurons = 100.
Fig. 6 Predicție multi-secvență
(parametrii inițiali)
După cum putem vedea, rețeaua
reușește să ofere predicții corecte
pentru diferitele trenduri ale indexului.
Curbele de aproximație crescătoare
sunt urmate o creștere reală a
indexului S&P 500. Același lucru se
întâmplă și cu predicțiile de scădere a
indexului.
În continuare, la modificarea
batch_size-ului la 16 produce
următoarele modificări, după cum se
poate observa în figura 7. Majoritatea
curbelor de predicție sunt mult mai
abrupte, iar unele sunt chiar eronate.
Spre exemplu, linia de predicție maro
din figură semnalează teoretic un
platou al prețului indexului, însă în
realitate urmează o creștere a prețului,
lucru semnalat în predicția anterioară,
cu parametrii inițiali. De asemenea,
același comportament îl putem
observa și pentru linia turcoaz,
predicția inițială și corectă este de
creștere, însă în acest caz modelul
anunță o scădere, lucru incorect.
Fig. 7 Predicție batch_size = 16
În următorul caz am păstrat
batch_size-ul la 32, dar am modificat
numărul de neuroni la 50. Rezultatele
sunt asemănătoare cu cazul anterior, în
care am scăzut batch_size-ul. Figura 8 Primul caz abordat este cel în
prezintă rezultatele obținute în urma care batch_size-ul este modificat la
rulării programului. valoarea 16. Rezultatul, prezent în
figura 10, denotă faptul că modelul
încă reușește să urmărească trendurile
de creștere și descreștere a prețului
indexului, însă există abateri. În prima
jumătate a graficului se poate observa
cum modelul prezice o scădere
majoră, însă, în realitate, acest lucru
nu se întâmplă, având loc chiar o
creștere a indexului. De asemenea, în
a doua parte a graficului, creșterea
indicelui prezisă de model este mai
Fig. 8 Batch_size=32, 50 neuroni
mică decât cea din realitate.
În continuare, o să analizez
predicția punct cu punct și rezultatele
obținute în urma modificării
paramterilor batch_size și neurons.
Figura 9 prezintă rezultatul
pentru predicția punct cu punct,
utilizând parametrii inițiali, batch_size
= 32 ș 100 de neuroni. Putem observa
cum modelul reușește să prezică
parcursul prețului indicelui pe întreaga
perioadă de timp, cu mici abateri. Fig. 10 Batch_size = 16, 100 neuroni

În cazul în care am păstrat

batch_size-ul = 32, dar am schimbat
numărul neuronilor la 50, am obținut o
îmbunătățire față de cazul anterior,
însă există abateri față de modelul
optim. Acest lucru poate să fie
observat în figura 11.

Fig. 9 Batch_size = 32, 100 neuroni


Fig. 11 Batch_size = 32, 50 neuroni
Concluzii
Rețelele LSTM sunt folosite
într-o multitudine de probleme din
viața reală, de la corectarea automată a
textelor, până la detectarea anomaliilor
și a fraudelor.
Utilizarea acestui tip de rețea în
cadrul unei serii temporale din
domeniul financiar are anumite
limitări din cauza proprietăților
nestaționare. Spre exemplu, în cazul
predicției punct cu punct, rețeaua nu
trebuie să cunoască prea multe despre
seria temporală, ci doar că următoarele
puncte nu sunt prea departe de ultimul.
Bibliografie
[1] “A Gentle Introduction to Long Short-Term
Memory Networks by the Experts”, Jason
Brownlee,https://machinelearningmastery.com/g
entle-introduction-long-short-term-memory-
networks-experts/, 24 mai 2017
[2] “Learn About Long Short-Term Memory
(LSTM) Algorithms”, Shipra Saxena,
https://www.analyticsvidhya.com/blog/2021/03/i
ntroduction-to-long-short-term-memory-lstm/, 16
martie 2021
[3] “C++ Vs Python: Overview, Uses & Key
Differences”, Ravikiran A S,
https://www.simplilearn.com/tutorials/cpp-
tutorial/cpp-vs-python, 21 februarie 2023
[4] “What Is a Time Series and How Is It Used to
Analyze Data?”, Adam Hayes,
https://www.investopedia.com/terms/t/timeseries.
asp, 12 iunie 2022
[5] „Time Series Prediction Using LSTM Deep
Neural Networks”, Jakob Aungiers,
https://www.altumintelligence.com/articles/a/Tim
e-Series-Prediction-Using-LSTM-Deep-Neural-
Networks, 01 septembrie 2018
Anexa
Codul utilizat face parte din notebook-
ul pus la dispoziție în cadrul cursului
de SCIN.
__author__ = "Jakob Aungiers"
__copyright__ = "Jakob Aungiers
2018"
__version__ = "2.0.0"
__license__ = "MIT"
import os
import json
import time
import math
import matplotlib.pyplot as plt
from core.data_processor import
DataLoader
from core.model import Model
def plot_results(predicted_data,
true_data):
fig =
plt.figure(facecolor='white')
ax = fig.add_subplot(111)
 ax.plot(true_data, label='True
Data')
plt.plot(predicted_data,
label='Prediction')
plt.legend()
plt.show()
def
plot_results_multiple(predicted_da
ta, true_data, prediction_len):
fig =
plt.figure(facecolor='white')
ax = fig.add_subplot(111)
ax.plot(true_data, label='True
Data')
# Pad the list of predictions to
shift it in the graph to it's
correct start
for i, data in
enumerate(predicted_data):
padding = [None for p in
range(i * prediction_len)]
plt.plot(padding + data,
label='Prediction')
plt.legend()
plt.show()
def main():
configs =
json.load(open('config.json',
'r'))
if not
os.path.exists(configs['model']['s
ave_dir']):
os.makedirs(configs['model']['save
_dir'])
data = DataLoader(
os.path.join('data',
configs['data']['filename']),
configs['data']['train_tes
t_split'],
configs['data']['columns']
)
model = Model()
model.build_model(configs)
x, y = data.get_train_data(
seq_len=configs['data']['s
equence_length'],
normalise=configs['data'][
'normalise']
)
'''
# in-memory training
model.train(
x,
y,
epochs =
configs['training']['epochs'],
batch_size =
configs['training']['batch_size'],
save_dir =
configs['model']['save_dir']
)
'''
# out-of memory generative
training
steps_per_epoch =
math.ceil((data.len_train -
configs['data']['sequence_length']
) /
configs['training']['batch_size'])
model.train_generator(
data_gen=data.generate_tra
in_batch(
seq_len=configs['data'
]['sequence_length'],
batch_size=configs['tr
aining']['batch_size'],
normalise=configs['dat
a']['normalise']
),
epochs=configs['training']
['epochs'],
batch_size=configs['traini
ng']['batch_size'],
 steps_per_epoch=steps_per_
epoch,
save_dir=configs['model'][
'save_dir']
)

x_test, y_test =
data.get_test_data(
seq_len=configs['data']['s
equence_length'],
normalise=configs['data'][
'normalise']
)

#predictions =
model.predict_sequences_multiple(x
_test,
configs['data']['sequence_length']
,
configs['data']['sequence_length']
)
#predictions =
model.predict_sequence_full(x_test
,
configs['data']['sequence_length']
)
predictions =
model.predict_point_by_point(x_tes
t)

#plot_results_multiple(predict
ions, y_test,
configs['data']['sequence_length']
)
plot_results(predictions,
y_test)

if __name__ == '__main__':
main()