Tutorial RNN (rețea neuronală recurentă): Exemplu TensorFlow

De ce avem nevoie de o rețea neuronală recurentă (RNN)?

Rețeaua neuronală recurentă (RNN) vă permite să modelați unități de memorie pentru a persista datele și a modela dependențe pe termen scurt. De asemenea, este utilizat în prognoza serii temporale pentru identificarea corelațiilor și modelelor de date. De asemenea, ajută la producerea de rezultate predictive pentru date secvențiale prin furnizarea unui comportament similar ca un creier uman.

Structura unui Retele neuronale artificiale este relativ simplu și se referă în principal la multiplicarea matricelor. În prima etapă, intrările sunt înmulțite cu ponderi inițial aleatorii, iar valorile de eroare sunt transformate cu o funcție de activare, iar valorile de ieșire sunt utilizate pentru a face o predicție. Această etapă oferă o idee despre cât de departe este rețeaua de realitate.

Metrica aplicată este pierderea. Cu cât funcția de pierdere este mai mare, cu atât modelul este mai prost. Pentru a îmbunătăți cunoașterea rețelei, este necesară o anumită optimizare prin ajustarea greutăților rețelei. Coborârea gradientului stocastic este metoda folosită pentru a modifica valorile greutăților în direcția dreptului. Odată efectuată ajustarea, rețeaua poate folosi un alt lot de date pentru a-și testa noile cunoștințe.

Din fericire, eroarea este mai mică decât înainte, dar nu suficient de mică. Pasul de optimizare se face iterativ până când eroarea este minimizată, adică nu se mai pot extrage informații.tracted.

Problema cu acest tip de model este ca nu are memorie. Înseamnă că intrarea și ieșirea sunt independente. Cu alte cuvinte, modelului nu îi pasă de ceea ce a venit înainte. Se ridică o întrebare când trebuie să preziceți serii de timp sau propoziții, deoarece rețeaua trebuie să aibă informații despre datele istorice sau despre cuvintele trecute.

Pentru a depăși această problemă, a fost dezvoltat un nou tip de arhitectură: Rețeaua neuronală recurentă (RNN în continuare)

Ce este o rețea neuronală recurentă (RNN)?

O rețea neuronală recurentă (RNN) este o clasă de rețea neuronală artificială în care conexiunea dintre diferite noduri formează un graf orientat pentru a oferi un comportament dinamic temporal. Aceasta ajută la modelarea datelor secvențiale derivate din rețelele feedforward. Funcționează similar creierului uman pentru a oferi rezultate predictive.

O rețea neuronală recurentă arată destul de asemănătoare cu o rețea neuronală tradițională, cu excepția faptului că neuronilor li se adaugă o stare de memorie. Calculul pentru a include o memorie este simplu.

Imaginați-vă un model simplu cu un singur neuron alimentat de un lot de date. Într-o rețea neuronală tradițională, modelul produce ieșirea prin înmulțirea intrării cu ponderea și funcția de activare. Cu o rețea neuronală restrânsă (RNN), această ieșire este trimisă înapoi la sine însuși de un număr de ori. Numim pas de timp intervalul de timp în care ieșirea devine intrarea următoarei înmulțiri matriceale.

De exemplu, în imaginea de mai jos, puteți vedea că rețeaua este compusă dintr-un neuron. Rețeaua calculează multiplicarea matricelor între intrare și greutate și adaugă neliniaritate cu funcția de activare. Devine ieșirea la t-1. Această ieșire este intrarea celei de-a doua înmulțiri a matricei.

Rețea neuronală recurentă (RNN)

Mai jos, codificăm un RNN simplu în TensorFlow pentru a înțelege pasul și, de asemenea, forma ieșirii.

Rețeaua este compusă din:

• Patru intrări
• Șase neuroni
• 2 pași de timp

Rețeaua va proceda așa cum este prezentat în imaginea de mai jos.

Rețeaua se numește „recurent” deoarece efectuează aceeași operație în fiecare pătrat de activare. Rețeaua a calculat greutățile intrărilor și ale ieșirii anterioare înainte de a utiliza o funcție de activare.

Notă privind versiunea: Codul din acest tutorial vizează API-ul grafic TensorFlow 1.x. Pe TensorFlow 2.x, același script rulează în continuare după import tensorflow.compat.v1 as tf la care se adauga tf.disable_v2_behavior(), deoarece substituenții, sesiunile și modulul rnn_cell se află acum sub tf.compat.v1Echivalentul idiomatic 2.x este tf.keras.layers.SimpleRNN.

import numpy as np
import tensorflow as tf
n_inputs = 4
n_neurons = 6
n_timesteps = 2
The data is a sequence of a number from 0 to 9 and divided into three batches of data.
## Data 
X_batch = np.array([
        [[0, 1, 2, 5], [9, 8, 7, 4]], # Batch 1
        [[3, 4, 5, 2], [0, 0, 0, 0]], # Batch 2
        [[6, 7, 8, 5], [6, 5, 4, 2]], # Batch 3
    ])

Putem construi rețeaua cu un substituent pentru date, etapa recurentă și rezultatul.

Definiți substituentul pentru date

X = tf.placeholder(tf.float32, [None, n_timesteps, n_inputs])

Aici:

• Niciunul: necunoscut și va lua dimensiunea lotului
• n_timesteps: De câte ori rețeaua va trimite ieșirea înapoi la neuron
• n_inputs: Numărul de intrări per lot

Definiți rețeaua recurentă

După cum se menționează în imaginea de mai sus, rețeaua este compusă din 6 neuroni. Rețeaua va calcula un produs punctual:

• Date de intrare cu primul set de greutăți (adică 6: egal cu numărul de neuroni)
• Rezultatul anterior cu un al doilea set de ponderi (adică, 6: corespunzător numărului de rezultate)

Rețineți că, în timpul primului feedforward, valorile rezultatelor anterioare sunt egale cu zerouri, deoarece nu avem nicio valoare disponibilă.

Obiectul pentru a construi un RNN este tf.contrib.rnn.BasicRNNCell cu argumentul num_units pentru a defini numărul de intrare

basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)

Acum că rețeaua este definită, puteți calcula ieșirile și stările

outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)

Acest obiect folosește o buclă internă pentru a multiplica matricele de numărul corespunzător de ori.

Rețineți că neuronul recurent este o funcție a tuturor intrărilor din pașii de timp anteriori. Acesta este modul în care rețeaua își construiește propria memorie. Informațiile din timpul anterior se pot propaga în timp viitor. Aceasta este magia rețelei neuronale recurente.

## Define the shape of the tensor
X = tf.placeholder(tf.float32, [None, n_timesteps, n_inputs])
## Define the network
basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)
outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)
init = tf.global_variables_initializer()
init = tf.global_variables_initializer()
with tf.Session() as sess:
    init.run()
    outputs_val = outputs.eval(feed_dict={X: X_batch})
print(states.eval(feed_dict={X: X_batch}))
[[ 0.38941205 -0.9980438   0.99750966  0.7892596   0.9978241   0.9999997 ]
 [ 0.61096436  0.7255889   0.82977575 -0.88226104  0.29261455 -0.15597084]
 [ 0.62091285 -0.87023467  0.99729395 -0.58261937  0.9811445   0.99969864]]

În scop explicativ, afișați valorile stării anterioare. Rezultatul afișat mai sus arată rezultatul ultimei stări. Acum afișați toate rezultatele; puteți observa că stările reprezintă rezultatele anterioare ale fiecărui lot. Adică, rezultatele anterioare conțin informații despre întreaga secvență.

print(outputs_val)    
print(outputs_val.shape)    
[[[-0.75934666 -0.99537754  0.9735819  -0.9722234  -0.14234993
   -0.9984044 ]
  [ 0.99975264 -0.9983206   0.9999993  -1.         -0.9997506
   -1.        ]]

 [[ 0.97486496 -0.98773265  0.9969686  -0.99950117 -0.7092863
   -0.99998885]
  [ 0.9326837   0.2673438   0.2808514  -0.7535883  -0.43337247
    0.5700631 ]]

 [[ 0.99628735 -0.9998728   0.99999213 -0.99999976 -0.9884324
   -1.        ]
  [ 0.99962527 -0.9467421   0.9997403  -0.99999714 -0.99929446
   -0.9999795 ]]]
(3, 2, 6)

Vizualizarea adnotată de mai jos împarte același tensor imprimat lot cu lot.

Ieșirea are forma (3, 2, 6):

• 3: Numărul de loturi
• 2: Numărul pasului de timp
• 6: Numărul de neuroni

Optimizarea unei rețele neuronale recurente este identică cu o rețea neuronală tradițională. Veți vedea mai detaliat cum să codificați optimizarea în următoarea parte a acestui tutorial de rețea neuronală recurentă.

Aplicații ale RNN

RNN are multiple utilizări, mai ales când vine vorba de prezicerea viitorului. În industria financiară, RNN poate fi de ajutor în prezicerea prețurilor acțiunilor sau a semnului direcției pieței de valori (adică pozitiv sau negativ).

RNN este util pentru o mașină autonomă, deoarece poate evita un accident de mașină anticipând traiectoria vehiculului.

RNN este utilizat pe scară largă în analiza textului, subtitrărea imaginilor, analiza sentimentelor și traducerea automată. De exemplu, se poate folosi o recenzie a filmului pentru a înțelege sentimentul pe care l-a perceput spectatorul după vizionarea filmului. Automatizarea acestei sarcini este foarte utilă atunci când compania de film nu are suficient timp pentru a revizui, eticheta, consolida și analiza recenziile. Aparatul poate face treaba cu un nivel mai ridicat de precizie.

Limitările RNN

În teorie, RNN ar trebui să transporte informațiile până la ori. Cu toate acestea, este destul de dificil să propagați toate aceste informații atunci când intervalul de timp este prea lung. Când o rețea are prea multe straturi adânci, devine imposibil de antrenat. Această problemă se numește: dispariția problemei gradientului. Dacă vă amintiți, rețeaua neuronală actualizează greutatea folosind algoritmul de coborâre a gradientului. Gradienții devin mai mici atunci când rețeaua progresează în straturi inferioare.

În concluzie, gradienții rămân constanți, ceea ce înseamnă că nu există loc de îmbunătățiri. Modelul învață dintr-o modificare a gradientului; această modificare afectează rezultatul rețelei. Cu toate acestea, dacă diferența de gradient este prea mică (adică, ponderile se modifică puțin), rețeaua nu poate învăța nimic și, prin urmare, rezultatul. Prin urmare, o rețea care se confruntă cu o problemă de gradient care dispare nu poate converge către o soluție bună.

Îmbunătățirea LSTM

Pentru a depăși potențiala problemă a gradientului de dispariție cu care se confruntă RNN, trei cercetători, Hochreiter, Schmidhuber și Bengio, au îmbunătățit RNN cu o arhitectură numită Long Short-Term Memory (LSTM). Pe scurt, LSTM furnizează rețelei informații relevante din trecut, din perioade mai recente. Mașina folosește o arhitectură mai bună pentru a selecta și transporta informații înapoi în timp.

Arhitectura LSTM este disponibilă în TensorFlow, tf.contrib.rnn.LSTMCell. LSTM nu este inclus în acest tutorial. Puteți consulta versiunea oficială. documentaţie pentru mai multe informații

Pe TensorFlow 2.x, acea celulă este atinsă ca tf.compat.v1.nn.rnn_cell.LSTMCell, în timp ce noul cod folosește în mod normal tf.keras.layers.LSTM sau bricheta cu poartă tf.keras.layers.GRU, care atinge o precizie comparabilă cu mai puțini parametri.

RNN în serii de timp

În acest tutorial TensorFlow RNN, veți utiliza o RNN cu date din serii temporale. Seriile temporale depind de timpul anterior, ceea ce înseamnă că valorile trecute includ informații relevante din care rețeaua poate învăța. Ideea din spatele predicției seriilor temporale este de a estima valoarea viitoare a unei serii, să zicem, prețul acțiunilor, temperatura, PIB-ul și așa mai departe.

Pregătirea datelor pentru Keras RNN și seriile de timp poate fi puțin dificilă. În primul rând, obiectivul este de a prezice următoarea valoare a seriei, adică veți folosi informațiile trecute pentru a estima valoarea la t + 1. Eticheta este egală cu secvența de intrare și este deplasată cu o perioadă înainte. În al doilea rând, numărul de intrări este setat la 1, adică o observație pe dată. În cele din urmă, pasul de timp este egal cu succesiunea valorii numerice. De exemplu, dacă setați intervalul de timp la 10, secvența de intrare va reveni de zece ori consecutiv.

Uită-te la graficul de mai jos, am reprezentat datele seriei temporale în stânga și o secvență de intrare fictivă în dreapta. Creați o funcție pentru a returna un set de date cu valoare aleatorie pentru fiecare zi din ianuarie 2001 până în decembrie 2016

# To plot pretty figures
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
import pandas as pd
def create_ts(start = '2001', n = 201, freq = 'M'):
    rng = pd.date_range(start=start, periods=n, freq=freq)
    ts = pd.Series(np.random.uniform(-18, 18, size=len(rng)), rng).cumsum()
    return ts
ts= create_ts(start = '2001', n = 192, freq = 'M')
ts.tail(5)

producție

2016-08-31    -93.459631
2016-09-30    -95.264791
2016-10-31    -95.551935
2016-11-30   -105.879611
2016-12-31   -123.729319
Freq: M, dtype: float64

ts = create_ts(start = '2001', n = 222)

# Left
plt.figure(figsize=(11,4))
plt.subplot(121)
plt.plot(ts.index, ts)
plt.plot(ts.index[90:100], ts[90:100], "b-", linewidth=3, label="A training instance")
plt.title("A time series (generated)", fontsize=14)

# Right
plt.subplot(122)
plt.title("A training instance", fontsize=14)
plt.plot(ts.index[90:100], ts[90:100], "b-", markersize=8, label="instance")
plt.plot(ts.index[91:101], ts[91:101], "bo", markersize=10, label="target", markerfacecolor='red')
plt.legend(loc="upper left")
plt.xlabel("Time")

plt.show()

Partea dreaptă a graficului arată toate seriile. Acestea au început din 2001 și se termină în 2019. Nu are sens să introduceți toate datele în rețea, în schimb, trebuie să creați un lot de date cu o lungime egală cu pasul de timp. Acest lot va fi variabila X. Variabila Y este aceeași cu X, dar decalată cu o perioadă (adică, doriți să prognozați t+1).

Ambii vectori au aceeași lungime. O puteți vedea în partea dreaptă a graficului de mai sus. Linia reprezintă cele zece valori ale intrării X, în timp ce punctele roșii sunt cele zece valori ale etichetei, Y. Rețineți că, eticheta începe cu o perioadă înainte de X și se termină cu o perioadă după.

Creați un RNN pentru a prezice serii temporale în TensorFlow

Acum, în acest antrenament RNN, este timpul să vă construiți primul RNN pentru a prezice seria de mai sus. Trebuie să specificați niște hiperparametri (parametrii modelului, adică numărul de neuroni etc.) pentru model:

• Număr de intrări: 1
• Pas de timp (ferestre în seria temporală): 10
• Număr de neuroni: 120
• Număr de ieșiri: 1

Rețeaua ta va învăța dintr-o secvență de 10 zile și va conține 120 de neuroni recurenți. Alimentați modelul cu o singură intrare, adică o zi. Nu ezitați să modificați valorile pentru a vedea dacă modelul s-a îmbunătățit.

Înainte de a construi modelul, trebuie să împărțiți setul de date într-un set de antrenare și un set de testare. Setul complet de date are 222 de puncte de date; veți folosi primele 201 puncte pentru a antrena modelul și ultimele 21 de puncte pentru a testa modelul.

După ce definiți un tren și un set de testare, trebuie să creați un obiect care conține loturile. În aceste loturi, aveți valori X și valori Y. Rețineți că valorile X sunt întârziate cu o perioadă. Prin urmare, utilizați primele 200 de observații, iar pasul de timp este egal cu 10. Obiectul X_batches ar trebui să conțină 20 de loturi de dimensiunea 10*1. Obiectul y_batches are aceeași formă ca și obiectul X_batches, dar cu o perioadă înainte.

Pas 1) Creați trenul și testați

În primul rând, transformi seria într-un NumPy matrice; apoi definiți ferestrele (de exemplu, numărul de timp din care rețeaua va învăța), numărul de intrare, ieșire și dimensiunea setului de tren, așa cum se arată în exemplul TensorFlow RNN de mai jos.

series = np.array(ts)
n_windows = 20   
n_input =  1
n_output = 1
size_train = 201

După aceea, pur și simplu împărțiți matricea în două seturi de date.

## Split data
train = series[:size_train]
test = series[size_train:]
print(train.shape, test.shape)
(201,) (21,)

Pas 2) Creați funcția pentru a returna X_batches și y_batches

Pentru a fi mai ușor, puteți crea o funcție care returnează două matrice diferite, una pentru X_batches și una pentru y_batches.

Să scriem o funcție RNN TensorFlow pentru a construi loturile.

Rețineți că, loturile X sunt întârziate cu o perioadă (luăm valoarea t-1). Ieșirea funcției ar trebui să aibă trei dimensiuni. Primele dimensiuni sunt egale cu numărul de loturi, a doua dimensiunea ferestrelor și ultima cu numărul de intrări.

Partea dificilă este să selectați corect punctele de date. Pentru punctele de date X, alegeți observațiile de la t = 1 la t = 200, în timp ce pentru punctul de date Y, returnați observațiile de la t = 2 la 201. Odată ce aveți punctele de date corecte, este ușor să remodelați serialul.

Pentru a construi obiectul cu loturile, trebuie să împărțiți setul de date în zece loturi de lungime egală (adică 20). Puteți folosi metoda de remodelare și treceți -1, astfel încât seria să fie similară cu dimensiunea lotului. Valoarea 20 este numărul de observații pe lot și 1 este numărul de intrare.

Trebuie să faceți același pas, dar pentru etichetă.

Rețineți că trebuie să mutați datele la numărul de dăți la care doriți să faceți prognoza. De exemplu, dacă doriți să faceți prognoza cu o dată în viitor, mutați seria cu 1. Dacă doriți să faceți prognoza pentru două zile, mutați datele cu 2.

x_data = train[:size_train-1]: Select all the training instance minus one day
X_batches = x_data.reshape(-1, windows, input): create the right shape for the batch e.g (10, 20, 1)
def create_batches(df, windows, input, output):
    ## Create X         
        x_data = train[:size_train-1] # Select the data
        X_batches = x_data.reshape(-1, windows, input)  # Reshape the data 
    ## Create y
        y_data = train[n_output:size_train]
        y_batches = y_data.reshape(-1, windows, output)
        return X_batches, y_batches

Acum că funcția este definită, o puteți apela pentru a crea loturile așa cum se arată în exemplul RNN de mai jos.

X_batches, y_batches = create_batches(df = train,
                                      windows = n_windows,
                                      input = n_input,
                                      output = n_output)

Puteți imprima forma pentru a vă asigura că dimensiunile sunt corecte.

print(X_batches.shape, y_batches.shape)
(10, 20, 1) (10, 20, 1)

Trebuie să creați setul de testare cu un singur lot de date și 20 de observații.

Rețineți că, estimați zile după zile, înseamnă că a doua valoare estimată se va baza pe valoarea reală a primei zile (t+1) a setului de date de testare. De fapt, adevărata valoare va fi cunoscută.

Dacă doriți să prognozați t+2 (adică, cu două zile înainte), trebuie să utilizați valoarea prezisă t+1; dacă urmează să preziceți t+3 (cu trei zile înainte), trebuie să utilizați valoarea prezisă t+1 și t+2. Este logic că este dificil să prezici cu exactitate t+n zile înainte.

X_test, y_test = create_batches(df = test, windows = 20,input = 1, output = 1)
print(X_test.shape, y_test.shape)
(10, 20, 1) (10, 20, 1)

Bine, dimensiunea lotului este gata, puteți construi arhitectura RNN. Amintiți-vă, aveți 120 de neuroni recurenți.

Pas 3) Construiți modelul

Pentru a crea modelul, trebuie să definiți trei părți:

1. Variabila cu tensorii
2. RNN
3. Pierderea și optimizarea

Pas 3.1) Variabile

Trebuie să specificați variabilele X și y cu forma corespunzătoare. Acest pas este banal. Tensorul are aceeași dimensiune ca și obiectele X_batch și y_batch.

De exemplu, tensorul X este un substituent (consultați tutorialul despre Introducere în TensorFlow pentru a vă reîmprospăta mintea cu privire la declarația variabilă) are trei dimensiuni:

• Notă: dimensiunea lotului
• n_windows: Lungimea ferestrelor. adică, numărul de ori în care modelul privește înapoi
• n_input: Numărul de intrare

Rezultatul este:

tf.placeholder(tf.float32, [None, n_windows, n_input])

## 1. Construct the tensors
X = tf.placeholder(tf.float32, [None, n_windows, n_input])   
y = tf.placeholder(tf.float32, [None, n_windows, n_output])

Pas 3.2) Creați RNN

În a doua parte a acestui exemplu RNN TensorFlow, trebuie să definiți arhitectura rețelei. Ca și înainte, utilizați obiectul BasicRNNCell și dynamic_rnn din estimatorul TensorFlow.

## 2. create the model
basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu)   
rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)   

Următoarea parte este puțin mai complicată, dar permite un calcul mai rapid. Trebuie să transformați rezultatul rulării într-un strat dens și apoi să îl convertiți din nou pentru a avea aceeași dimensiune ca și intrarea.

stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron])          
stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output)       
outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])  

Pas 3.3) Creați pierderea și optimizarea

Optimizarea modelului depinde de sarcina pe care o efectuați. În tutorialul anterior despre CNN, obiectivul tău a fost să clasifici imagini, în acest tutorial RNN, obiectivul este ușor diferit. Ți se cere să faci o predicție asupra unei variabile continue în comparație cu o clasă.

Această diferență este importantă deoarece va schimba problema de optimizare. Problema de optimizare pentru o variabilă continuă este de a minimiza eroarea pătratică medie. Pentru a construi aceste valori în TF, puteți utiliza:

tf.reduce_sum(tf.square(ieșiri – y))

Restul codului RNN este același ca înainte; utilizați un optimizator Adam pentru a reduce pierderea (adică, MSE):

tf.train.AdamOptimizer(learning_rate=learning_rate)

optimizator.minimize(pierdere)

Gata, poți împacheta totul, iar modelul tău este gata de antrenament.

tf.reset_default_graph()
r_neuron = 120    

## 1. Construct the tensors
X = tf.placeholder(tf.float32, [None, n_windows, n_input])   
y = tf.placeholder(tf.float32, [None, n_windows, n_output])

## 2. create the model
basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu)   
rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)              

stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron])          
stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output)       
outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])   

## 3. Loss + optimization
learning_rate = 0.001  
 
loss = tf.reduce_sum(tf.square(outputs - y))    
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)         
training_op = optimizer.minimize(loss)                                          

init = tf.global_variables_initializer() 

Veți antrena modelul folosind 1500 de epoci și veți imprima pierderea la fiecare 150 de iterații. Odată ce modelul este antrenat, evaluați modelul pe setul de testare și creați un obiect care conține predicțiile, așa cum se arată în exemplul de mai jos al rețelei neuronale recurente.

iteration = 1500 

with tf.Session() as sess:
    init.run()
    for iters in range(iteration):
        sess.run(training_op, feed_dict={X: X_batches, y: y_batches})
        if iters % 150 == 0:
            mse = loss.eval(feed_dict={X: X_batches, y: y_batches})
            print(iters, "\tMSE:", mse)
    
    y_pred = sess.run(outputs, feed_dict={X: X_test})
0 	MSE: 502893.34
150 	MSE: 13839.129
300 	MSE: 3964.835
450 	MSE: 2619.885
600 	MSE: 2418.772
750 	MSE: 2110.5923
900 	MSE: 1887.9644
1050 	MSE: 1747.1377
1200 	MSE: 1556.3398
1350 	MSE: 1384.6113

În cele din urmă, în acest tutorial RNN Deep Learning, puteți reprezenta grafic valoarea reală a seriei cu valoarea prezisă. Dacă modelul dvs. este corectat, valorile prezise ar trebui puse peste valorile reale.

După cum puteți vedea, modelul are loc de îmbunătățiri. Depinde de dvs. să modificați hiperparametrii precum ferestrele, dimensiunea lotului sau numărul de neuroni recurenți.

plt.title("Forecast vs Actual", fontsize=14)
plt.plot(pd.Series(np.ravel(y_test)), "bo", markersize=8, label="Actual", color='green')
plt.plot(pd.Series(np.ravel(y_pred)), "r.", markersize=8, label="Forecast", color='red')
plt.legend(loc="lower left")
plt.xlabel("Time")

plt.show()

Prognoză vs Real

Întrebări frecvente