Previsione delle serie temporali di Pybrain utilizzando le reti ricorrenti LSTM

Question

Ho una domanda in mente relativa all'utilizzo di pybrain per eseguire la regressione di una serie storica. Ho intenzione di utilizzare lo strato LSTM in pybrain per addestrare e prevedere una serie temporale.

ho trovato un esempio di codice qui nel link qui sotto

Request for example: Recurrent neural network for predicting next value in a sequence

Nell'esempio precedente, la rete è in grado di prevedere una sequenza dopo il suo essere addestrati. Ma il problema è che la rete acquisisce tutti i dati sequenziali alimentandola in un unico passaggio nel livello di input. Ad esempio, se i dati di allenamento presentano 10 funzioni ciascuna, le 10 funzionalità saranno simultaneamente inserite in 10 nodi di input contemporaneamente.

Dalla mia comprensione, questa non è più una previsione di serie temporali, ho ragione? Poiché non vi è alcuna differenza in termini di tempo in cui ciascuna funzionalità viene inserita nella rete? Correggimi se sbaglio su questo.

Pertanto, quello che sto cercando di ottenere è una rete ricorrente che ha solo un nodo di input e un nodo di output. Il nodo di input è il punto in cui tutti i dati delle serie temporali verranno alimentati in sequenza in fasi temporali differenti. La rete verrà addestrata per riprodurre l'input nel nodo di output.

Potresti suggerire o guidarmi nella costruzione della rete che ho menzionato? Grazie mille in anticipo.

Answer 1

È possibile addestrare una rete LSTM con un singolo nodo di ingresso e un unico nodo di uscita per fare Serie storiche di previsione momento come questo:

In primo luogo, proprio come una buona pratica, usiamo funzione di stampa del python3:

from __future__ import print_function 

Poi, fare una semplice serie temporale:

data = [1] * 3 + [2] * 3 
data *= 3 
print(data) 

[1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2]

ora messo questa timeseries in un set di dati supervisionato, dove l'obiettivo per ciascun campione è il campione successivo:

from pybrain.datasets import SequentialDataSet 
from itertools import cycle 

ds = SequentialDataSet(1, 1) 
for sample, next_sample in zip(data, cycle(data[1:])): 
    ds.addSample(sample, next_sample) 

Costruire una semplice rete LSTM con 1 nodo di ingresso, 5 celle LSTM e 1 nodo di uscita:

from pybrain.tools.shortcuts import buildNetwork 
from pybrain.structure.modules import LSTMLayer 

net = buildNetwork(1, 5, 1, 
        hiddenclass=LSTMLayer, outputbias=False, recurrent=True) 

addestrare la rete:

from pybrain.supervised import RPropMinusTrainer 
from sys import stdout 

trainer = RPropMinusTrainer(net, dataset=ds) 
train_errors = [] # save errors for plotting later 
EPOCHS_PER_CYCLE = 5 
CYCLES = 100 
EPOCHS = EPOCHS_PER_CYCLE * CYCLES 
for i in xrange(CYCLES): 
    trainer.trainEpochs(EPOCHS_PER_CYCLE) 
    train_errors.append(trainer.testOnData()) 
    epoch = (i+1) * EPOCHS_PER_CYCLE 
    print("\r epoch {}/{}".format(epoch, EPOCHS), end="") 
    stdout.flush() 

print() 
print("final error =", train_errors[-1]) 

Plot gli errori (si noti che in questo semplice giocattolo esempio, stiamo testando e formazione sullo stesso set di dati, che è, naturalmente, non è quello che farebbe per un vero e proprio progetto):!

import matplotlib.pyplot as plt 

plt.plot(range(0, EPOCHS, EPOCHS_PER_CYCLE), train_errors) 
plt.xlabel('epoch') 
plt.ylabel('error') 
plt.show() 

Ora richiedere alla rete di prevedere il campione successivo:

for sample, target in ds.getSequenceIterator(0): 
    print("    sample = %4.1f" % sample) 
    print("predicted next sample = %4.1f" % net.activate(sample)) 
    print(" actual next sample = %4.1f" % target) 
    print() 

(il codice precedente si basa sulla example_rnn.py e gli esempi dal PyBrain documentation)

Answer 2

Penso che un migliore (più semplice chiaro /) esempio per imparare da sarebbe qui, verso il fondo della pagina:

http://pybrain.org/docs/tutorial/netmodcon.html

In sostanza, una volta istituito, come mostrato, non mancherà di tenere automaticamente traccia della cronologia passata degli input (fino a quando non si preme reset). Dalla documentazione:

http://pybrain.org/docs/api/structure/networks.html?highlight=recurrentnetwork#pybrain.structure.networks.RecurrentNetwork

"Fino .Reset() viene chiamato, la rete tiene traccia di tutti gli ingressi precedenti e consente quindi l'utilizzo di connessioni ricorrenti e strati che guardano indietro nel tempo."

Quindi sì, non è necessario ripresentare tutti gli input passati alla rete ogni volta.

Answer 3

ho testato LSTM prevedere una sequenza di tempo con Theano. Ho scoperto che per alcune curve morbide, può essere previsto correttamente. Tuttavia per alcune curve a zigzag. È difficile da prevedere. L'articolo dettagliato è come qui sotto: Predict Time Sequence with LSTM

Il risultato previsto può essere indicato come segue: http://www.fuzihao.org/blog/images/LSTM_predict.png