Prédiction des séries temporelles de Pybrain à l'aide de moustiquaires récurrentes LSTM

J'ai une question à l'esprit ce qui a trait à l'utilisation de pybrain faire de régression d'une série chronologique. J'ai l'intention d'utiliser la LSTM couche dans pybrain de former et de prévoir un temps de la série.

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

Demander par exemple: réseau de neurones Récurrent pour la prédiction de la valeur suivante dans une séquence

Dans l'exemple ci-dessus, le réseau est en mesure de prévoir une séquence après ses cours de formation. Mais la question est, le réseau prend dans tous les séquentielle de données par l'alimentation d'un seul coup à la couche d'entrée. Par exemple, si les données d'apprentissage a 10 fonctions de chacun, les 10 fonctionnalités seront simultanément introduits dans 10 nœuds d'entrée à la fois.

À partir de ma compréhension, ce n'est plus une prédiction de séries temporelles suis-je droit? Depuis il n'y a pas de différence en termes de temps, chaque fonctionnalité est injectée dans le réseau? Corrigez-moi si je me trompe sur ce point.

Donc, ce que je suis en train de réaliser est un réseau récurrent qui n'a qu'UN seul nœud d'entrée, et UN nœud de sortie. Le nœud d'entrée est l'endroit où toutes les séries de données seront transmises de manière séquentielle à différents pas de temps. Le réseau sera formé pour reproduire l'entrée du nœud de sortie.

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

source d'informationauteur dnth

  1. 25

    Vous pouvez former un LSTM réseau avec un seul nœud d'entrée et un seul nœud de sortie pour faire de la prévision de séries chronologiques comme ceci:

    D'abord, tout comme une bonne pratique, nous allons utiliser Python3 la fonction imprimer:

    from __future__ import print_function

    Ensuite, faire une simple série de temps:

    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]

    Maintenant, mettez ce timeseries dans une supervisé dataset, où la cible pour chaque échantillon 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)

    Construire un simple LSTM réseau avec 1 nœud d'entrée, 5 LSTM cellules 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])

    Tracer les erreurs (à noter que dans ce jouet simple exemple, nous faisons des essais et de formation sur le même ensemble de données, ce qui n'est évidemment pas ce que vous feriez pour un projet réel!):

    import matplotlib.pyplot as plt

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

    Demandez maintenant le réseau de prédire l'échantillon suivant:

    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 PyBrain documentation)

  2. 1

    Je pense que le meilleur (la plus simple/plus clair) exemple pour apprendre à partir de serait ici, vers le bas de la page:

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

    Essentiellement, une fois mis en place, comme indiqué, il va automatiquement suivre les entrées le passé (jusqu'à ce que et à moins que vous frappez reset). À partir de la documentation:

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

    "Jusqu'à ce que .reset() est appelée, le réseau conserve la trace de toutes les précédentes entrées et permet ainsi l'utilisation de connexions récurrentes et les couches qui regarder en arrière dans le temps."

    Donc oui, pas besoin de re-présenter toutes les dernières entrées pour le réseau à chaque fois.

  3. 1

    J'ai testé LSTM la prédiction de certains de l'ordre du temps avec Théano. J'ai trouvé que, pour certains courbe lisse, il peut être prédit correctement. Cependant, pour certains en zigzag de la courbe . C'est difficile à prévoir. L'article détaillé sont comme ci-dessous:
    Prédire la Séquence de Temps, avec LSTM

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