RNN (Rekurentna neuronska mreža) Vodič: Primjer TensorFlow

Zašto nam je potrebna rekurentna neuronska mreža (RNN)?

Ponavljajuća neuronska mreža (RNN) omogućuje modeliranje memorijskih jedinica za zadržavanje podataka i modeliranje kratkoročnih ovisnosti. Također se koristi u predviđanju vremenskih serija za identifikaciju korelacija podataka i obrazaca. Također pomaže u stvaranju prediktivnih rezultata za sekvencijalne podatke pružajući slično ponašanje kao ljudski mozak.

Struktura an Umjetna neuronska mreža je relativno jednostavan i uglavnom se odnosi na množenje matrica. Tijekom prvog koraka, ulazi se množe s početno slučajnim težinama i pristranošću, transformiraju se aktivacijskom funkcijom, a izlazne vrijednosti se koriste za predviđanje. Ovaj korak daje ideju o tome koliko je mreža udaljena od stvarnosti.

Primijenjena metrika je gubitak. Što je veća funkcija gubitka, to je model gluplji. Kako bi se poboljšalo poznavanje mreže, potrebna je određena optimizacija podešavanjem težine mreže. Stohastički gradijentni pad je metoda koja se koristi za promjenu vrijednosti pondera u pravom smjeru. Nakon što se izvrši prilagodba, mreža može koristiti drugu skupinu podataka za testiranje svog novog znanja.

Pogreška je, srećom, manja nego prije, ali nije dovoljno mala. Korak optimizacije se izvodi iterativno dok se pogreška ne minimizira, tj. ne mogu se dobiti više informacija.tracted.

Problem s ovom vrstom modela je što nema memorije. To znači da su ulaz i izlaz neovisni. Drugim riječima, model ne mari za ono što je bilo prije. Postavlja se pitanje kada trebate predvidjeti vremenske serije ili rečenice jer mreža treba imati informacije o povijesnim podacima ili prošlim riječima.

Kako bi se riješio ovaj problem, razvijena je nova vrsta arhitekture: Rekurentna neuronska mreža (u daljnjem tekstu RNN)

Što je rekurentna neuronska mreža (RNN)?

Rekurentna neuronska mreža (RNN) je klasa umjetnih neuronskih mreža u kojima veza između različitih čvorova tvori usmjereni graf kako bi se dobilo vremensko dinamičko ponašanje. Pomaže u modeliranju sekvencijalnih podataka koji se izvode iz mreža s unaprijednom povratnom vezom. Radi slično ljudskom mozgu kako bi pružila prediktivne rezultate.

Rekurentna neuronska mreža izgleda prilično slično tradicionalnoj neuronskoj mreži osim što je neuronima dodano stanje pamćenja. Izračun za uključivanje memorije je jednostavan.

Zamislite jednostavan model s samo jednim neuronom koji prima podatke. U tradicionalnoj neuronskoj mreži, model proizvodi izlaz množenjem ulaza s težinom i aktivacijskom funkcijom. S RNN-om, ovaj izlaz se šalje natrag samom sebi određeni broj puta. Pozivamo vremenski korak količina vremena u kojoj izlaz postaje ulaz sljedećeg množenja matrica.

Na primjer, na slici ispod možete vidjeti da se mreža sastoji od jednog neurona. Mreža izračunava množenje matrice između ulaza i težine i dodaje nelinearnost s aktivacijskom funkcijom. To postaje izlaz pri t-1. Ovaj izlaz je ulaz drugog matričnog množenja.

Rekurentna neuronska mreža (RNN)

U nastavku kodiramo jednostavan RNN u TensorFlowu kako bismo razumjeli korak i oblik izlaza.

Mreža se sastoji od:

• Četiri ulaza
• Šest neurona
• 2-kratni koraci

Mreža će se nastaviti kao što je prikazano na slici ispod.

Mreža se naziva 'ponavljajuća' jer izvodi istu operaciju u svakom aktiviranom kvadratu. Mreža je izračunala težine ulaza i prethodnog izlaza prije korištenja aktivacijske funkcije.

Napomena o verziji: Kôd u ovom tutorialu cilja TensorFlow 1.x graph API. Na TensorFlow 2.x isti se skript i dalje izvršava nakon import tensorflow.compat.v1 as tf plus tf.disable_v2_behavior(), jer se rezervirana mjesta, sesije i modul rnn_cell sada nalaze pod tf.compat.v1Idiomatski 2.x ekvivalent je 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
    ])

Možemo izgraditi mrežu s rezerviranim mjestom za podatke, stadij koji se ponavlja i izlaz.

Definirajte rezervirano mjesto za podatke

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

Ovdje:

• Ništa: Nepoznato i uzet će veličinu serije
• n_timesteps: Broj puta kada će mreža poslati izlaz natrag neuronu
• n_inputs: Broj unosa po seriji

Definirajte rekurentnu mrežu

Kao što je spomenuto na gornjoj slici, mreža se sastoji od 6 neurona. Mreža će izračunati dva točkasta proizvoda:

• Ulazni podaci s prvim skupom težina (tj. 6: jednako broju neurona)
• Prethodni izlaz s drugim skupom težina (tj. 6: odgovara broju izlaza)

Imajte na umu da su, tijekom prvog feedforwarda, vrijednosti prethodnog izlaza jednake nulama jer nemamo nijednu dostupnu vrijednost.

Objekt za izgradnju RNN-a je tf.contrib.rnn.BasicRNNCell s argumentom num_units za definiranje broja ulaza

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

Sada kada je mreža definirana, možete izračunati izlaze i stanja

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

Ovaj objekt koristi unutarnju petlju za množenje matrica odgovarajući broj puta.

Imajte na umu da je rekurentni neuron funkcija svih ulaza iz prethodnih vremenskih koraka. Na taj način mreža gradi vlastitu memoriju. Informacije iz prethodnog vremena mogu se širiti u budućem vremenu. To je čarolija rekurentne neuronske mreže.

## 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]]

Radi objašnjenja, ispisujete vrijednosti prethodnog stanja. Gore ispisani izlaz prikazuje izlaz iz posljednjeg stanja. Sada ispišite cijeli izlaz, možete primijetiti da su stanja prethodni izlaz svake serije. To jest, prethodni izlaz sadrži informacije o cijelom nizu.

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)

Anotirani prikaz u nastavku raščlanjuje isti ispisani tenzor seriju po seriju.

Izlaz ima oblik (3, 2, 6):

• 3: Broj serija
• 2: Broj vremenskog koraka
• 6: Broj neurona

Optimizacija rekurentne neuronske mreže identična je tradicionalnoj neuronskoj mreži. Vidjet ćete detaljnije kako kodirati optimizaciju u sljedećem dijelu ovog vodiča za ponavljajuće neuronske mreže.

Primjene RNN-a

RNN ima višestruku upotrebu, posebno kada je u pitanju predviđanje budućnosti. U financijskoj industriji RNN može biti od pomoći u predviđanju cijena dionica ili predznaka smjera burze (tj. pozitivnog ili negativnog).

RNN je koristan za autonomni automobil jer može izbjeći prometnu nesreću predviđanjem putanje vozila.

RNN se široko koristi u analizi teksta, opisima slika, analizi osjećaja i strojnom prevođenju. Na primjer, možete upotrijebiti recenziju filma da biste razumjeli osjećaj koji je gledatelj osjetio nakon gledanja filma. Automatizacija ovog zadatka vrlo je korisna kada filmska tvrtka nema dovoljno vremena za pregled, označavanje, konsolidaciju i analizu recenzija. Stroj može obaviti posao s višom razinom točnosti.

Ograničenja RNN-a

U teoriji, RNN bi trebao prenositi informacije do vremena. Međutim, prilično je izazovno širiti sve te informacije kada je vremenski korak predug. Kada mreža ima previše dubokih slojeva, postaje nesposobna za obuku. Ovaj problem se zove: problem gradijenta koji nestaje. Ako se sjećate, neuronska mreža ažurira težinu pomoću algoritma gradijentnog spuštanja. Gradijenti se smanjuju kada mreža napreduje do nižih slojeva.

Zaključno, gradijenti ostaju konstantni, što znači da nema prostora za poboljšanje. Model uči iz promjene u gradijentu; ta promjena utječe na izlaz mreže. Međutim, ako je razlika u gradijentu premala (tj. težine se malo mijenjaju), mreža ne može ništa naučiti, pa tako ni izlaz. Stoga, mreža koja se suočava s problemom nestajućeg gradijenta ne može konvergirati prema dobrom rješenju.

Poboljšanje LSTM

Kako bi prevladali potencijalni problem nestajanja gradijenta s kojim se suočava RNN, tri istraživača, Hochreiter, Schmidhuber i Bengio, poboljšali su RNN arhitekturom nazvanom Duga kratkoročna memorija (LSTM). Ukratko, LSTM mreži pruža relevantne prošle informacije do novijeg vremena. Stroj koristi bolju arhitekturu za odabir i prijenos informacija natrag u kasnije vrijeme.

LSTM arhitektura je dostupna u TensorFlowu, tf.contrib.rnn.LSTMCell. LSTM nije obuhvaćen ovim vodičem. Možete se pozvati na službeni dokumentacija za daljnje informacije

Na TensorFlowu 2.x do te se ćelije dolazi kao tf.compat.v1.nn.rnn_cell.LSTMCell, dok novi kod obično koristi tf.keras.layers.LSTM ili s lakšim vratima tf.keras.layers.GRU, koji postiže usporedivu točnost s manje parametara.

RNN u vremenskoj seriji

U ovom TensorFlow RNN tutorialu, koristit ćete RNN s podacima vremenskih serija. Vremenske serije ovise o prethodnom vremenu, što znači da prošle vrijednosti uključuju relevantne informacije iz kojih mreža može učiti. Ideja iza predviđanja vremenskih serija je procjena buduće vrijednosti serije, recimo, cijene dionica, temperature, BDP-a i tako dalje.

Priprema podataka za Keras RNN i vremenske serije može biti malo nezgodna. Prije svega, cilj je predvidjeti sljedeću vrijednost niza, što znači da ćete koristiti prošle informacije za procjenu vrijednosti na t + 1. Oznaka je jednaka ulaznom nizu i pomaknuta za jedno razdoblje unaprijed. Drugo, broj unosa je postavljen na 1, tj. jedno promatranje po vremenu. Na kraju, vremenski korak je jednak nizu numeričke vrijednosti. Na primjer, ako postavite vremenski korak na 10, ulazni niz vratit će se deset uzastopnih puta.

Pogledajte grafikon u nastavku, mi smo predstavili podatke vremenske serije s lijeve strane i fiktivnu sekvencu unosa s desne strane. Kreirate funkciju za vraćanje skupa podataka s nasumičnim vrijednostima za svaki dan od siječnja 2001. do prosinca 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)

Izlaz

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()

Desni dio grafa prikazuje sve serije. Počelo je od 2001. i završava 2019. Nema smisla unositi sve podatke u mrežu, umjesto toga potrebno je stvoriti seriju podataka duljine jednake vremenskom koraku. Ova serija bit će varijabla X. Varijabla Y je ista kao X, ali pomaknuta za jedno razdoblje (tj. želite predvidjeti t+1).

Oba vektora imaju istu duljinu. Možete ga vidjeti u desnom dijelu gornjeg grafikona. Linija predstavlja deset vrijednosti unosa X, dok su crvene točke deset vrijednosti oznake Y. Imajte na umu da oznaka počinje jedno razdoblje ispred X i završava jedno razdoblje nakon.

Izgradite RNN za predviđanje vremenskih serija u TensorFlowu

Sada u ovoj obuci za RNN, vrijeme je da izgradite svoj prvi RNN za predviđanje gornje serije. Morate navesti neke hiperparametre (parametre modela, tj. broj neurona itd.) za model:

• Broj ulaza: 1
• Vremenski korak (prozori u vremenskoj seriji): 10
• Broj neurona: 120
• Broj izlaza: 1

Vaša će mreža učiti iz niza od 10 dana i sadržavati će 120 rekurentnih neurona. Modelu dajete jedan ulaz, tj. jedan dan. Slobodno promijenite vrijednosti kako biste vidjeli je li se model poboljšao.

Prije konstrukcije modela, potrebno je podijeliti skup podataka na skup za učenje i skup za testiranje. Cijeli skup podataka ima 222 podatkovne točke; prvih 201 točku koristit ćete za učenje modela, a posljednjih 21 točku za testiranje modela.

Nakon što definirate skup za učenje i testiranje, morate stvoriti objekt koji sadrži serije (batches). U tim serijama imate X vrijednosti i Y vrijednosti. Imajte na umu da su X vrijednosti s vremenskim zakašnjenjem od jednog perioda. Stoga koristite prvih 200 opažanja, a vremenski korak je jednak 10. Objekt X_batches trebao bi sadržavati 20 serija veličine 10*1. Y_batches ima isti oblik kao objekt X_batches, ali s jednim periodom ispred.

Korak 1) Kreirajte vlak i testirajte

Prije svega, seriju pretvarate u a numpy niz; zatim definirate prozore (tj. broj vremena iz kojih će mreža učiti), broj ulaza, izlaza i veličinu niza kao što je prikazano u primjeru TensorFlow RNN u nastavku.

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

Nakon toga jednostavno podijelite niz u dva skupa podataka.

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

Korak 2) Stvorite funkciju za vraćanje X_batches i y_batches

Da biste to olakšali, možete stvoriti funkciju koja vraća dva različita niza, jedan za X_batches i jedan za y_batches.

Napišimo funkciju RNN TensorFlow za konstruiranje serija.

Imajte na umu da X serije kasne za jedno razdoblje (uzimamo vrijednost t-1). Izlaz funkcije treba imati tri dimenzije. Prve dimenzije jednake su broju serija, druge veličini prozora, a posljednje broju unosa.

Teško je pravilno odabrati podatkovne točke. Za podatkovne točke X birate opažanja od t = 1 do t =200, dok za podatkovnu točku Y vraćate opažanja od t = 2 do 201. Nakon što imate točne podatkovne točke, jednostavno je preoblikovati serija.

Da biste konstruirali objekt sa serijama, trebate podijeliti skup podataka u deset grupa jednake duljine (tj. 20). Možete koristiti metodu preoblikovanja i proslijediti -1 tako da serija bude slična veličini serije. Vrijednost 20 je broj opažanja po seriji, a 1 je broj unosa.

Morate učiniti isti korak, ali za naljepnicu.

Imajte na umu da podatke trebate pomaknuti za broj puta koji želite predvidjeti. Na primjer, ako želite predvidjeti jedan dan unaprijed, pomaknite niz za 1. Ako želite predvidjeti dva dana, pomaknite podatke za 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

Sada kada je funkcija definirana, možete je pozvati za stvaranje serija kao što je prikazano u donjem primjeru RNN-a.

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

Možete ispisati oblik kako biste bili sigurni da su dimenzije točne.

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

Morate izraditi testni skup sa samo jednom serijom podataka i 20 opažanja.

Imajte na umu da, prognozirate dan za danom, to znači da će se druga predviđena vrijednost temeljiti na stvarnoj vrijednosti prvog dana (t+1) skupa testnih podataka. Zapravo, znat će se prava vrijednost.

Ako želite prognozirati t+2 (tj. dva dana unaprijed), trebate koristiti predviđenu vrijednost t+1; ako namjeravate predvidjeti t+3 (tri dana unaprijed), trebate koristiti predviđenu vrijednost t+1 i t+2. Logično je da je teško predvidjeti točno t+n dana unaprijed.

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)

U redu, veličina vaše serije je spremna, možete izgraditi RNN arhitekturu. Zapamtite, imate 120 ponavljajućih neurona.

Korak 3) Izgradite model

Za izradu modela potrebno je definirati tri dijela:

1. Varijabla s tenzorima
2. RNN
3. Gubitak i optimizacija

Korak 3.1) Varijable

Morate navesti varijable X i y s odgovarajućim oblikom. Ovaj korak je trivijalan. Tenzor ima istu dimenziju kao objekti X_batches i y_batches.

Na primjer, tenzor X je rezervirano mjesto (pogledajte tutorijal o Uvod u TensorFlow da osvježite svoje misli o deklaraciji varijabli) ima tri dimenzije:

• Napomena: veličina serije
• n_windows: Duljina prozora, tj. broj puta koliko se model osvrće unatrag
• n_input: Broj unosa

Rezultat je:

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])

Korak 3.2) Stvorite RNN

U drugom dijelu ovog primjera RNN TensorFlow trebate definirati arhitekturu mreže. Kao i prije, koristite objekt BasicRNNCell i dynamic_rnn iz TensorFlow procjenitelja.

## 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)   

Sljedeći dio je malo zahtjevniji, ali omogućuje brže računanje. Morate transformirati izlazni rezultat u gusti sloj, a zatim ga ponovno pretvoriti da ima istu dimenziju kao i ulaz.

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])  

Korak 3.3) Stvorite gubitak i optimizaciju

Optimizacija modela ovisi o zadatku koji izvršavate. U prethodnom tutorialu o CNN, vaš je cilj bio klasificirati slike, u ovom RNN tutorialu cilj je malo drugačiji. Od vas se traži da napravite predviđanje o kontinuiranoj varijabli u usporedbi s klasom.

Ova razlika je važna jer će promijeniti problem optimizacije. Problem optimizacije za kontinuiranu varijablu je minimiziranje srednje kvadratne pogreške. Da biste izradili ove metrike u TF-u, možete koristiti:

tf.reduce_sum(tf.square(outputs – y))

Ostatak RNN ​​koda je isti kao i prije; koristite Adamov optimizator za smanjenje gubitka (tj. MSE):

tf.train.AdamOptimizer(stopa_učenja=stopa_učenja)

optimizer.minimize(loss)

To je to, sve možete spakirati i vaš model je spreman za treniranje.

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() 

Uvježbat ćete model pomoću 1500 epoha i ispisati gubitak svakih 150 ponavljanja. Nakon što je model uvježban, procjenjujete model na testnom skupu i stvarate objekt koji sadrži predviđanja kao što je prikazano u donjem primjeru rekurentne neuronske mreže.

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

Napokon u ovom vodiču za RNN duboko učenje možete iscrtati stvarnu vrijednost niza s predviđenom vrijednošću. Ako je vaš model ispravljen, predviđene vrijednosti treba staviti iznad stvarnih vrijednosti.

Kao što vidite, model ima prostora za poboljšanje. Na vama je da promijenite hiperparametre poput prozora, veličine serije ili broja rekurentnih neurona.

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()

Predviđanje u odnosu na stvarno

Pitanja i odgovori