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 umjetne neuronske mreže je relativno jednostavna i uglavnom se odnosi na množenje matrice. Tijekom prvog koraka, ulazi se množe s inicijalno nasumičnim težinama, a pristranost, transformirana aktivacijskom funkcijom i izlazne vrijednosti koriste se za izradu predviđanja. Ovaj korak daje ideju o tome koliko je mreža daleko 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.

Greška je, srećom, manja nego prije, ali nedovoljno mala. Korak optimizacije provodi se iterativno sve dok se pogreška ne smanji na najmanju moguću mjeru, tj. ne može se izvući više informacija.

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

A Rekurentna neuronska mreža (RNN) je klasa od Umjetna neuronska mreža u kojem veza između različitih čvorova tvori usmjereni graf koji daje vremensko dinamičko ponašanje. Pomaže u modeliranju sekvencijalnih podataka koji su izvedeni iz mreža s unaprijednim prijenosom podataka. Djeluje slično ljudskom mozgu kako bi dao 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 sa samo jednim neuronom koji se hrani serijom podataka. 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 nekoliko puta. Mi zovemo vremenski korak koliko vremena izlaz postaje ulaz sljedećeg matričnog množenja.

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

Rekurentna neuronska mreža (RNN)

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.

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.

  1. 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
  1. 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 prethodnih vremenskih koraka. Ovako mreža gradi vlastitu memoriju. Informacije iz prethodnog vremena mogu se prenositi u buduće vrijeme. Ovo je čar 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]]

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

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)

Rekurentna neuronska mreža (RNN)

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 mjesta za poboljšanje. Model uči iz promjene u gradijentu; ova promjena utječe na mrežni izlaz. 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 nestajanja 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 Dugo kratkoročno pamćenje (LSTM). Ukratko, LSMT mreži pruža relevantne informacije iz prošlosti do novijeg vremena. Stroj koristi bolju arhitekturu za odabir i prijenos informacija u kasnije vrijeme.

LSTM arhitektura dostupna je u TensorFlowu, tf.contrib.rnn.LSTMCell. LSTM je izvan opsega vodiča. Možete se obratiti službenoj osobi dokumentacija za daljnje informacije

RNN u vremenskoj seriji

U ovom vodiču za TensorFlow RNN koristit ćete RNN s podacima vremenske serije. 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 vremenske serije je procijeniti buduću vrijednost serije, recimo, cijene dionice, 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()

RNN u vremenskoj seriji

Desni dio grafikona prikazuje sve serije. Započelo je 2001. i završava 2019. Nema smisla unositi sve podatke u mrežu, umjesto toga morate stvoriti skup podataka duljine jednake vremenskom koraku. Ova serija će biti X varijabla. Varijabla Y ista je kao X, ali pomaknuta za jedno razdoblje (tj. želite prognozirati 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 mreža će učiti iz niza od 10 dana i sadržavat će 120 ponavljajućih neurona. Model hranite jednim unosom, tj. jednim danom. Slobodno promijenite vrijednosti da vidite je li se model poboljšao.

Prije nego što konstruirate model, trebate podijeliti skup podataka u niz i testni skup. Cijeli skup podataka ima 222 podatkovne točke; prvu 201 točku ćete koristiti za obuku modela, a posljednju 21 točku za testiranje vašeg modela.

Nakon što definirate vlak i testni skup, morate stvoriti objekt koji sadrži serije. U ovim serijama imate X vrijednosti i Y vrijednosti. Imajte na umu da su X vrijednosti zaostale za jedno razdoblje. Stoga koristite prvih 200 promatranja, 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 jednom točkom ispred.

Korak 1) Kreirajte vlak i testirajte

Prije svega, seriju pretvarate u a kvrgav 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 morate pomaknuti podatke na broj puta koji želite prognozirati. Na primjer, ako želite predvidjeti jedno vrijeme 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 vodič na Uvod u Tenzor protok da osvježite svoje misli o deklaraciji varijabli) ima tri dimenzije:

  • Napomena: veličina serije
  • n_windows: Duljina prozora. tj. koliko puta model gleda 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 obavljate. U prethodnom vodiču o CNN, vaš je cilj bio klasificirati slike, u ovom vodiču za RNN cilj je malo drugačiji. Od vas se traži da napravite predviđanje kontinuirane varijable 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 mjesta za napredak. Na vama je da promijenite hiperparametre kao što su prozori, veličina serije broja ponavljajućih 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

Predviđanje u odnosu na stvarno

rezime

Ponavljajuća neuronska mreža robusna je arhitektura za rad s vremenskim serijama ili analizom teksta. Izlaz prethodnog stanja je povratna informacija za očuvanje memorije mreže tijekom vremena ili niza riječi.

U TensorFlowu možete koristiti sljedeće kodove za treniranje TensorFlow rekurentne neuronske mreže za vremenske serije:

Parametri modela

n_windows = 20   
n_input =  1
n_output = 1
size_train = 201

Definirajte model

X = tf.placeholder(tf.float32, [None, n_windows, n_input])   
y = tf.placeholder(tf.float32, [None, n_windows, n_output])

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

Konstruirajte optimizaciju

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)                                          

Uvježbajte model

init = tf.global_variables_initializer() 
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})