Tutorial su RNN (Rete Neurale Ricorrente): Esempio di TensorFlow

Perché abbiamo bisogno di una rete neurale ricorrente (RNN)?

La rete neurale ricorrente (RNN) consente di modellare unità di memoria per persistere i dati e modellare dipendenze a breve termine. Viene utilizzato anche nelle previsioni di serie temporali per l'identificazione di correlazioni e modelli di dati. Aiuta anche a produrre risultati predittivi per dati sequenziali fornendo un comportamento simile a quello di un cervello umano.

La struttura di una rete neurale artificiale è relativamente semplice e riguarda principalmente la moltiplicazione di matrici. Durante la prima fase, gli input vengono moltiplicati per pesi inizialmente casuali e il bias viene trasformato con una funzione di attivazione e i valori di output vengono utilizzati per fare una previsione. Questo passaggio dà un'idea di quanto la rete sia lontana dalla realtà.

La metrica applicata è la perdita. Più alta è la funzione di perdita, più stupido è il modello. Per migliorare la conoscenza della rete è necessaria una certa ottimizzazione aggiustando i pesi della rete. La discesa del gradiente stocastico è il metodo utilizzato per modificare i valori dei pesi nella direzione giusta. Una volta effettuato l’adeguamento, la rete può utilizzare un’altra serie di dati per testare la sua nuova conoscenza.

L'errore, fortunatamente, è inferiore rispetto a prima, ma non abbastanza piccolo. La fase di ottimizzazione viene eseguita in modo iterativo finché l'errore non viene ridotto al minimo, ovvero non è possibile estrarre ulteriori informazioni.

Il problema con questo tipo di modello è che non ha memoria. Significa che l'input e l'output sono indipendenti. In altre parole, al modello non interessa ciò che è accaduto prima. Sorge qualche dubbio quando è necessario prevedere serie temporali o frasi perché la rete ha bisogno di informazioni sui dati storici o sulle parole passate.

Per superare questo problema, è stato sviluppato un nuovo tipo di architettura: la rete neurale ricorrente (di seguito RNN)

Cos'è una rete neurale ricorrente (RNN)?

A Rete neurale ricorrente (RNN) è una classe di Rete neurale artificiale in cui la connessione tra diversi nodi forma un grafo diretto a dare un comportamento dinamico temporale. Aiuta a modellare dati sequenziali derivati ​​da reti feedforward. Funziona in modo simile al cervello umano per fornire risultati predittivi.

Una rete neurale ricorrente è molto simile a una rete neurale tradizionale, tranne per il fatto che ai neuroni viene aggiunto uno stato di memoria. Il calcolo per includere una memoria è semplice.

Immagina un modello semplice con un solo neurone alimentato da un batch di dati. In una rete neurale tradizionale, il modello produce l'output moltiplicando l'input per il peso e la funzione di attivazione. Con un RNN, questo output viene rinviato a se stesso un certo numero di volte. Noi chiamiamo passo temporale la quantità di tempo in cui l'output diventa l'input della successiva moltiplicazione della matrice.

Ad esempio, nell'immagine qui sotto, puoi vedere che la rete è composta da un neurone. La rete calcola la moltiplicazione delle matrici tra l'input e il peso e aggiunge la non linearità con la funzione di attivazione. Diventa l'uscita a t-1. Questo output è l'input della seconda moltiplicazione di matrici.

Rete neurale ricorrente (RNN)
Rete neurale ricorrente (RNN)

Di seguito, codifichiamo un semplice RNN in TensorFlow per comprendere il passaggio e anche la forma dell'output.

La rete è composta da:

  • Quattro ingressi
  • Sei neuroni
  • 2 passaggi temporali

La rete procederà come illustrato nell'immagine seguente.

Rete neurale ricorrente (RNN)

La rete è detta 'ricorrente' perché esegue la stessa operazione in ogni casella attivata. La rete calcolava i pesi degli input e dell'output precedente prima di utilizzare una funzione di attivazione.

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

Possiamo costruire la rete con un segnaposto per i dati, la fase ricorrente e l'output.

  1. Definire il segnaposto per i dati
X = tf.placeholder(tf.float32, [None, n_timesteps, n_inputs])

Qui:

  • Nessuno: sconosciuto e avrà la dimensione del batch
  • n_timesteps: numero di volte in cui la rete invierà l'output al neurone
  • n_inputs: numero di input per batch
  1. Definire la rete ricorrente

Come accennato nell'immagine sopra, la rete è composta da 6 neuroni. La rete calcolerà il prodotto di due punti:

  • Inserisci i dati con il primo set di pesi (cioè 6: uguale al numero di neuroni)
  • Uscita precedente con un secondo set di pesi (cioè 6: corrispondente al numero di uscite)

Da notare che, durante il primo feedforward, i valori dell'output precedente sono pari a zero perché non abbiamo alcun valore a disposizione.

L'oggetto per costruire un RNN è tf.contrib.rnn.BasicRNNCell con l'argomento num_units per definire il numero di input

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

Ora che la rete è definita, puoi calcolare gli output e gli stati

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

Questo oggetto utilizza un ciclo interno per moltiplicare le matrici il numero appropriato di volte.

Si noti che il neurone ricorrente è una funzione di tutti gli input dei passaggi temporali precedenti. È così che la rete costruisce la propria memoria. Le informazioni del tempo precedente possono propagarsi nel tempo futuro. Questa è la magia della rete neurale ricorrente

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

A scopo esplicativo, si stampano i valori dello stato precedente. L'output stampato sopra mostra l'output dell'ultimo stato. Ora stampa tutto l'output, puoi notare che gli stati sono l'output precedente di ciascun batch. Cioè, l'output precedente contiene le informazioni sull'intera sequenza.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)

Rete neurale ricorrente (RNN)

L'output ha la forma di (3, 2, 6):

  • 3: Numero di lotti
  • 2: Numero del timestep
  • 6: Numero di neuroni

L'ottimizzazione di una rete neurale ricorrente è identica a quella di una rete neurale tradizionale. Vedrai più in dettaglio come codificare l'ottimizzazione nella parte successiva di questo tutorial sulla rete neurale ricorrente.

Applicazioni della RNN

La RNN ha molteplici usi, soprattutto quando si tratta di prevedere il futuro. Nel settore finanziario, l'RNN può essere utile per prevedere i prezzi delle azioni o il segno della direzione del mercato azionario (ovvero, positivo o negativo).

L'RNN è utile per un'auto autonoma poiché può evitare un incidente stradale anticipando la traiettoria del veicolo.

RNN è ampiamente utilizzato nell'analisi del testo, nei sottotitoli delle immagini, nell'analisi del sentiment e nella traduzione automatica. Ad esempio, si può utilizzare la recensione di un film per comprendere la sensazione che lo spettatore ha percepito dopo aver visto il film. Automatizzare questa attività è molto utile quando la società cinematografica non ha abbastanza tempo per rivedere, etichettare, consolidare e analizzare le recensioni. La macchina può svolgere il lavoro con un livello di precisione più elevato.

Limitazioni dell'RNN

In teoria, RNN dovrebbe trasportare le informazioni fino a volte. Tuttavia, è piuttosto impegnativo propagare tutte queste informazioni quando il passaggio temporale è troppo lungo. Quando una rete ha troppi strati profondi, diventa inaddestrabile. Questo problema si chiama: problema gradiente evanescente. Se ricordi, la rete neurale aggiorna il peso utilizzando l'algoritmo di discesa del gradiente. I gradienti si riducono quando la rete avanza verso gli strati inferiori.

In conclusione, i gradienti rimangono costanti, il che significa che non c’è spazio per miglioramenti. Il modello apprende da un cambiamento nel gradiente; questa modifica influisce sull'output della rete. Tuttavia, se la differenza nel gradiente è troppo piccola (cioè i pesi cambiano leggermente), la rete non può imparare nulla e così anche l'output. Pertanto, una rete che affronta un problema di gradiente nullo non può convergere verso una buona soluzione.

Miglioramento LSTM

Per superare il potenziale problema del gradiente evanescente affrontato dalla RNN, tre ricercatori, Hochreiter, Schmidhuber e Bengio hanno migliorato la RNN con un'architettura chiamata Long Short-Term Memory (LSTM). In breve, LSMT fornisce alla rete informazioni passate rilevanti fino a tempi più recenti. La macchina utilizza un'architettura migliore per selezionare e riportare le informazioni a tempi successivi.

L'architettura LSTM è disponibile in TensorFlow, tf.contrib.rnn.LSTMCell. LSTM è al di fuori dell'ambito del tutorial. Puoi fare riferimento al sito ufficiale documentazione per ulteriori informazioni

RNN in serie temporali

In questo tutorial su TensorFlow RNN utilizzerai un RNN con dati di serie temporali. Le serie temporali dipendono dal tempo precedente, il che significa che i valori passati includono informazioni rilevanti da cui la rete può imparare. L'idea alla base della previsione delle serie temporali è quella di stimare il valore futuro di una serie, diciamo il prezzo delle azioni, la temperatura, il PIL e così via.

La preparazione dei dati per Keras RNN e le serie temporali può essere un po' complicata. Prima di tutto, l'obiettivo è prevedere il valore successivo della serie, ovvero utilizzerai le informazioni passate per stimare il valore t + 1. L'etichetta è uguale alla sequenza di input e spostata in avanti di un periodo. In secondo luogo, il numero di input è impostato su 1, ovvero un'osservazione alla volta. Infine, il passo temporale è uguale alla sequenza del valore numerico. Ad esempio, se imposti l'intervallo temporale su 10, la sequenza di input restituirà dieci volte consecutive.

Guarda il grafico qui sotto, abbiamo rappresentato i dati della serie temporale a sinistra e una sequenza di input fittizia a destra. Crei una funzione per restituire un set di dati con valore casuale per ogni giorno da gennaio 2001 a dicembre 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)

Uscita

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 nelle serie temporali

La parte destra del grafico mostra tutte le serie. È iniziato nel 2001 e termina nel 2019. Non ha senso alimentare tutti i dati in rete, occorre invece creare un batch di dati di lunghezza pari al passo temporale. Questo batch sarà la variabile X. La variabile Y è uguale a X ma spostata di un periodo (ovvero, si desidera prevedere t+1).

Entrambi i vettori hanno la stessa lunghezza. Puoi vederlo nella parte destra del grafico sopra. La linea rappresenta i dieci valori dell'input X, mentre i punti rossi sono i dieci valori dell'etichetta Y. Nota che l'etichetta inizia un periodo prima di X e termina un periodo dopo.

Crea un RNN per prevedere le serie temporali in TensorFlow

Ora, in questo corso di formazione RNN, è il momento di costruire il tuo primo RNN per prevedere la serie di cui sopra. È necessario specificare alcuni iperparametri (i parametri del modello, ad esempio il numero di neuroni, ecc.) per il modello:

  • Numero di ingressi: 1
  • Passo temporale (finestre nella serie temporale): 10
  • Numero di neuroni: 120
  • Numero di uscite: 1

La tua rete imparerà da una sequenza di 10 giorni e conterrà 120 neuroni ricorrenti. Alimenti il ​​modello con un input, ovvero un giorno. Sentiti libero di modificare i valori per vedere se il modello è migliorato.

Prima di costruire il modello, è necessario dividere il set di dati in un set di treni e un set di test. Il set di dati completo ha 222 punti dati; utilizzerai i primi 201 punti per addestrare il modello e gli ultimi 21 punti per testare il tuo modello.

Dopo aver definito un set di training e test, è necessario creare un oggetto contenente i batch. In questi batch, hai valori X e valori Y. Ricordare che i valori X sono ritardati di un periodo. Pertanto, si utilizzano le prime 200 osservazioni e l'intervallo temporale è uguale a 10. L'oggetto X_batches deve contenere 20 batch di dimensione 10*1. L'oggetto y_batches ha la stessa forma dell'oggetto X_batches ma con un punto avanti.

Passo 1) Crea il treno e prova

Prima di tutto, converti la serie in a numpy array; quindi si definiscono le finestre (ovvero il numero di volte in cui la rete apprenderà), il numero di input, output e la dimensione del train set come mostrato nell'esempio TensorFlow RNN riportato di seguito.

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

Successivamente, dividi semplicemente l'array in due set di dati.

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

Passo 2) Crea la funzione per restituire X_batches e y_batches

Per semplificare, puoi creare una funzione che restituisca due array diversi, uno per X_batches e uno per y_batches.

Scriviamo una funzione RNN TensorFlow per costruire i batch.

Si noti che i batch X sono in ritardo di un periodo (prendiamo il valore t-1). L'output della funzione dovrebbe avere tre dimensioni. La prima dimensione è uguale al numero di batch, la seconda alla dimensione delle finestre e l'ultima al numero di input.

La parte difficile è selezionare correttamente i punti dati. Per i punti dati X, scegli le osservazioni da t = 1 a t = 200, mentre per il punto dati Y, restituisci le osservazioni da t = 2 a 201. Una volta che hai i punti dati corretti, è semplice rimodellare la serie.

Per costruire l'oggetto con i lotti, è necessario dividere il set di dati in dieci lotti di uguale lunghezza (cioè 20). È possibile utilizzare il metodo di rimodellamento e passare -1 in modo che la serie sia simile alla dimensione del batch. Il valore 20 è il numero di osservazioni per batch e 1 è il numero di input.

Devi fare lo stesso passaggio ma per l'etichetta.

Tieni presente che devi spostare i dati sul numero di volte che desideri effettuare la previsione. Ad esempio, se vuoi prevedere un tempo in anticipo, sposta la serie di 1. Se vuoi prevedere due giorni, sposta i dati di 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

Ora che la funzione è definita, puoi chiamarla per creare i batch come mostrato nell'esempio RNN seguente.

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

È possibile stampare la forma per assicurarsi che le dimensioni siano corrette.

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

È necessario creare il set di test con un solo batch di dati e 20 osservazioni.

Tieni presente che, se esegui previsioni giorno dopo giorno, significa che il secondo valore previsto sarà basato sul valore reale del primo giorno (t+1) del set di dati di test. In effetti, il vero valore sarà noto.

Se si desidera prevedere t+2 (ovvero due giorni in anticipo), è necessario utilizzare il valore previsto t+1; se intendi pronosticare t+3 (tre giorni in anticipo), devi utilizzare il valore previsto t+1 e t+2. È logico che sia difficile prevedere con precisione con t+n giorni di anticipo.

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)

Bene, la dimensione del tuo batch è pronta, puoi costruire l'architettura RNN. Ricorda, hai 120 neuroni ricorrenti.

Passo 3) Costruisci il modello

Per creare il modello è necessario definire tre parti:

  1. La variabile con i tensori
  2. La RNN
  3. La perdita e l'ottimizzazione

Passo 3.1) Variabili

È necessario specificare le variabili X e y con la forma appropriata. Questo passaggio è banale. Il tensore ha la stessa dimensione degli oggetti X_batches e y_batches.

Ad esempio, il tensore X è un segnaposto (consulta il tutorial su Introduzione a tensorflow per rinfrescarti la mente sulla dichiarazione delle variabili) ha tre dimensioni:

  • Nota: dimensione del lotto
  • n_windows: lunghezza delle finestre, ovvero il numero di volte in cui il modello guarda indietro
  • n_input: numero di input

Il risultato è:

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

Passo 3.2) Creare la RNN

Nella seconda parte di questo esempio RNN TensorFlow, devi definire l'architettura della rete. Come prima, usi l'oggetto BasicRNNCell e dynamic_rnn da TensorFlow estimator.

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

La parte successiva è un po' più complicata ma consente calcoli più rapidi. È necessario trasformare l'output della corsa in uno strato denso e quindi convertirlo nuovamente per avere la stessa dimensione dell'input.

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

Passo 3.3) Creare la perdita e l'ottimizzazione

L'ottimizzazione del modello dipende dall'attività che stai eseguendo. Nel tutorial precedente su CNN, il tuo obiettivo era classificare le immagini, in questo tutorial RNN l'obiettivo è leggermente diverso. Ti viene chiesto di fare una previsione su una variabile continua rispetto ad una classe.

Questa differenza è importante perché cambierà il problema di ottimizzazione. Il problema di ottimizzazione per una variabile continua è minimizzare l’errore quadratico medio. Per costruire queste metriche in TF, puoi utilizzare:

  • tf.reduce_sum(tf.square(uscite – y))

Il resto del codice RNN è lo stesso di prima; usi un ottimizzatore Adam per ridurre la perdita (ad esempio, MSE):

  • tf.train.AdamOptimizer(learning_rate=learning_rate)
  • ottimizzatore.minimizzare(perdita)

Questo è tutto, puoi mettere tutto insieme e il tuo modello è pronto per l'addestramento.

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

Addestrerai il modello utilizzando 1500 epoche e stamperai la perdita ogni 150 iterazioni. Una volta addestrato il modello, valutalo sul set di test e crea un oggetto contenente le previsioni come mostrato nell'esempio di rete neurale ricorrente riportato di seguito.

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

Finalmente in questo tutorial sull'RNN Deep Learning, puoi tracciare il valore effettivo della serie con il valore previsto. Se il modello viene corretto, i valori previsti dovrebbero essere messi sopra i valori effettivi.

Come puoi vedere, il modello ha margini di miglioramento. Sta a te cambiare gli iperparametri come le finestre, la dimensione del batch del numero di neuroni ricorrenti.

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()
Previsione vs Effettivo

Previsione vs Effettivo

Sommario

Una rete neurale ricorrente è un'architettura robusta per gestire serie temporali o analisi di testo. L'output dello stato precedente è un feedback per preservare la memoria della rete nel tempo o nella sequenza di parole.

In TensorFlow, puoi utilizzare i seguenti codici per addestrare una rete neurale ricorrente TensorFlow per le serie temporali:

Parametri del modello

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

Definisci il modello

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

Costruire l'ottimizzazione

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)                                          

Allena il modello

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