web-dev-qa-db-fra.com

Prédiction de séries chronologiques Pybrain à l'aide de réseaux récurrents LSTM

J'ai une question en tête qui concerne l'utilisation de pybrain pour faire la régression d'une série chronologique. Je prévois d'utiliser la couche LSTM de pybrain pour former et prédire une série chronologique.

J'ai trouvé un exemple de code ici dans le lien ci-dessous

Demande par exemple: Réseau de neurones récurrent pour prédire la valeur suivante d'une séquence

Dans l'exemple ci-dessus, le réseau est capable de prédire une séquence après son apprentissage. Mais le problème est que le réseau prend toutes les données séquentielles en les envoyant en une seule fois dans la couche d’entrée. Par exemple, si les données d'apprentissage ont chacune 10 caractéristiques, celles-ci seront simultanément introduites dans 10 noeuds d'entrée. 

A ma connaissance, ce n'est plus une prédiction de série chronologique, n'est-ce pas? Puisqu'il n'y a pas de différence en termes de temps, chaque fonctionnalité est introduite dans le réseau? Corrigez-moi si je me trompe à ce sujet. 

Par conséquent, ce que je cherche à obtenir, c’est un réseau récurrent qui ne comporte qu’UN noeud d’entrée et UN noeud de sortie. Le nœud d'entrée est l'endroit où toutes les données de la série temporelle seront alimentées séquentiellement à différents pas de temps. Le réseau sera formé pour reproduire l’entrée au noeud de sortie. 

Pourriez-vous s'il vous plaît me suggérer ou me guider dans la construction du réseau que j'ai mentionné? Merci beaucoup d'avance.

pythonneural-networktime-seriespredictionpybrain
15
dnth

Vous pouvez former un réseau LSTM avec un seul nœud d’entrée et un seul nœud de sortie pour effectuer une prédiction de série chronologique comme ceci:

Premièrement, à titre de bonne pratique, utilisons la fonction print de Python3:

from __future__ import print_function

Ensuite, faites une série chronologique simple:

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]

Placez maintenant cette série temporelle dans un jeu de données supervisé, où la cible de chaque échantillon est l'échantillon suivant:

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)

Construisez un réseau LSTM simple avec 1 nœud d'entrée, 5 cellules LSTM et 1 nœud de sortie:

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

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

Former le réseau:

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

Tracez les erreurs (notez que dans cet exemple de jouet simple, nous testons et formons le même jeu de données, ce qui n'est bien sûr pas ce que vous feriez pour un vrai projet!):

import matplotlib.pyplot as plt

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

Maintenant, demandez au réseau de prédire le prochain échantillon:

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

(Le code ci-dessus est basé sur le example_rnn.py et les exemples de la documentation PyBrain )

26
Jack Kelly

J'ai testé LSTM en prédisant une séquence temporelle avec Theano. J'ai trouvé que pour certaines courbes lisses, il peut être prédit correctement. Cependant pour certaines courbes en zigzag. C'est difficile à prédire. Les articles détaillés sont les suivants: Prédire la séquence temporelle avec LSTM

Le résultat prévu peut être présenté comme suit: http://www.fuzihao.org/blog/images/LSTM_predict.png

1
maple

Je pense qu'un meilleur exemple (plus simple/plus clair) à apprendre serait ici, vers le bas de la page:

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

Essentiellement, une fois configuré comme indiqué, il gardera automatiquement trace de l'historique des entrées (jusqu'à et sauf si vous appuyez sur reset). De la docs:

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

"Jusqu'à l'appel de .reset (), le réseau garde une trace de toutes les entrées précédentes et permet ainsi l'utilisation de connexions récurrentes et de couches qui remontent dans le temps."

Donc oui, pas besoin de présenter à nouveau toutes les entrées passées sur le réseau.

1
rossdavidh