Wie trainieren Sie ein RNN mit LSTM-Zellen für die zeitreihenvorhersage

Ich bin derzeit versuchen zu bauen ein einfaches Modell für die Vorhersage von Zeitreihen. Das Ziel wäre, um das Modell zu trainieren, mit einer Sequenz, so dass das Modell in der Lage ist, zur Prognose zukünftiger Werte.

Ich bin mit tensorflow und lstm-Zellen zu tun. Das Modell trainiert wird mit abgeschnitten, backpropagation through time. Meine Frage ist, wie die Struktur der Daten für das training.

Zum Beispiel nehmen wir an, wir wollen lernen, das gegebene Sequenz:

[1,2,3,4,5,6,7,8,9,10,11,...]

Und wir entrollen das Netzwerk für num_steps=4.

Option 1

input data               label     
1,2,3,4                  2,3,4,5
5,6,7,8                  6,7,8,9
9,10,11,12               10,11,12,13
...

Option 2

input data               label     
1,2,3,4                  2,3,4,5
2,3,4,5                  3,4,5,6
3,4,5,6                  4,5,6,7
...

Option 3

input data               label     
1,2,3,4                  5
2,3,4,5                  6
3,4,5,6                  7
...

Option 4

input data               label     
1,2,3,4                  5
5,6,7,8                  9
9,10,11,12               13
...

Jede mögliche Hilfe würde geschätzt.

InformationsquelleAutor der Frage Jakob | 2016-03-12

2

Nachdem ich mehrere LSTM-Einführung blogs z.B. Jakob Aungiers'option 3 scheint die richtige für Staatenlose LSTM.

Wenn Ihr LSTMs merken müssen Daten länger her als deine num_steps können Sie Ihre Bahn in einer effektiven Art und Weise - für eine Keras Beispiel sehen Philippe Remy ' s blog-post "Stateful LSTM in Keras". Philippe nicht zeigen ein Beispiel für die batch-Größe größer als eins ist, jedoch. Ich denke, dass in Ihrem Fall eine batch-Größe von vier mit stateful LSTM verwendet werden könnten, mit den folgenden Daten (geschrieben als input -> label):
```
batch #0:
1,2,3,4 -> 5
2,3,4,5 -> 6
3,4,5,6 -> 7
4,5,6,7 -> 8

batch #1:
5,6,7,8 -> 9
6,7,8,9 -> 10
7,8,9,10 -> 11
8,9,10,11 -> 12

batch #2:
9,10,11,12 -> 13
...
```
Durch diese, den Zustand z.B. der 2. Probe im batch - #0 ist richtig wiederverwendet, um weiterhin die Ausbildung mit der 2. Probe der charge #1.

Dies ist irgendwie ähnlich wie die option 4, Sie sind jedoch nicht über alle Etiketten vorhanden.

Update:

In Erweiterung zu meinem Vorschlag, wo batch_size entspricht der num_steps Alexis Huet eine Antwort gibt für den Fall der batch_size ein Teiler von num_stepsdie verwendet werden können, für größere num_steps. Er beschreibt es schön auf seinem blog.

InformationsquelleAutor der Antwort Robert Pollak

Ich bin gerade dabei, zu lernen, LSTMs in TensorFlow und versuchen, zu implementieren, ein Beispiel, das (zum Glück) versucht vorherzusagen einige Zeit-Serie /Nummer-Serie genereated durch eine einfache Mathematik-Funktion.

Aber ich bin mit einem anderen Weg, um die Struktur der Daten für training, motivierte Unüberwachtes Lernen von Video-Darstellungen mit LSTMs:

LSTM Zukunft Prädiktor-Modell

Option 5:

input data               label     
1,2,3,4                  5,6,7,8
2,3,4,5                  6,7,8,9
3,4,5,6                  7,8,9,10
...

Neben diesem Papier habe ich (versucht) zu nehmen inspiration von den gegebenen TensorFlow RNN Beispiele. Meine aktuelle komplette Lösung sieht wie folgt aus:

import math
import random
import numpy as np
import tensorflow as tf

LSTM_SIZE = 64
LSTM_LAYERS = 2
BATCH_SIZE = 16
NUM_T_STEPS = 4
MAX_STEPS = 1000
LAMBDA_REG = 5e-4


def ground_truth_func(i, j, t):
    return i * math.pow(t, 2) + j


def get_batch(batch_size):
    seq = np.zeros([batch_size, NUM_T_STEPS, 1], dtype=np.float32)
    tgt = np.zeros([batch_size, NUM_T_STEPS], dtype=np.float32)

    for b in xrange(batch_size):
        i = float(random.randint(-25, 25))
        j = float(random.randint(-100, 100))
        for t in xrange(NUM_T_STEPS):
            value = ground_truth_func(i, j, t)
            seq[b, t, 0] = value

        for t in xrange(NUM_T_STEPS):
            tgt[b, t] = ground_truth_func(i, j, t + NUM_T_STEPS)
    return seq, tgt


# Placeholder for the inputs in a given iteration
sequence = tf.placeholder(tf.float32, [BATCH_SIZE, NUM_T_STEPS, 1])
target = tf.placeholder(tf.float32, [BATCH_SIZE, NUM_T_STEPS])

fc1_weight = tf.get_variable('w1', [LSTM_SIZE, 1], initializer=tf.random_normal_initializer(mean=0.0, stddev=1.0))
fc1_bias = tf.get_variable('b1', [1], initializer=tf.constant_initializer(0.1))

# ENCODER
with tf.variable_scope('ENC_LSTM'):
    lstm = tf.nn.rnn_cell.LSTMCell(LSTM_SIZE)
    multi_lstm = tf.nn.rnn_cell.MultiRNNCell([lstm] * LSTM_LAYERS)
    initial_state = multi_lstm.zero_state(BATCH_SIZE, tf.float32)
    state = initial_state
    for t_step in xrange(NUM_T_STEPS):
        if t_step > 0:
            tf.get_variable_scope().reuse_variables()

        # state value is updated after processing each batch of sequences
        output, state = multi_lstm(sequence[:, t_step, :], state)

learned_representation = state

# DECODER
with tf.variable_scope('DEC_LSTM'):
    lstm = tf.nn.rnn_cell.LSTMCell(LSTM_SIZE)
    multi_lstm = tf.nn.rnn_cell.MultiRNNCell([lstm] * LSTM_LAYERS)
    state = learned_representation
    logits_stacked = None
    loss = 0.0
    for t_step in xrange(NUM_T_STEPS):
        if t_step > 0:
            tf.get_variable_scope().reuse_variables()

        # state value is updated after processing each batch of sequences
        output, state = multi_lstm(sequence[:, t_step, :], state)
        # output can be used to make next number prediction
        logits = tf.matmul(output, fc1_weight) + fc1_bias

        if logits_stacked is None:
            logits_stacked = logits
        else:
            logits_stacked = tf.concat(1, [logits_stacked, logits])

        loss += tf.reduce_sum(tf.square(logits - target[:, t_step])) /BATCH_SIZE

reg_loss = loss + LAMBDA_REG * (tf.nn.l2_loss(fc1_weight) + tf.nn.l2_loss(fc1_bias))

train = tf.train.AdamOptimizer().minimize(reg_loss)

with tf.Session() as sess:
    sess.run(tf.initialize_all_variables())

    total_loss = 0.0
    for step in xrange(MAX_STEPS):
        seq_batch, target_batch = get_batch(BATCH_SIZE)

        feed = {sequence: seq_batch, target: target_batch}
        _, current_loss = sess.run([train, reg_loss], feed)
        if step % 10 == 0:
            print("@{}: {}".format(step, current_loss))
        total_loss += current_loss

    print('Total loss:', total_loss)

    print('### SIMPLE EVAL: ###')
    seq_batch, target_batch = get_batch(BATCH_SIZE)
    feed = {sequence: seq_batch, target: target_batch}
    prediction = sess.run([logits_stacked], feed)
    for b in xrange(BATCH_SIZE):
        print("{} -> {})".format(str(seq_batch[b, :, 0]), target_batch[b, :]))
        print(" `-> Prediction: {}".format(prediction[0][b]))

Beispiel-Ausgabe dieser sieht wie folgt aus:

### SIMPLE EVAL: ###
# [input seq] -> [target prediction]
#  `-> Prediction: [model prediction]  
[  33.   53.  113.  213.] -> [  353.   533.   753.  1013.])
 `-> Prediction: [ 19.74548721  28.3149128   33.11489105  35.06603241]
[ -17.  -32.  -77. -152.] -> [-257. -392. -557. -752.])
 `-> Prediction: [-16.38951683 -24.3657589  -29.49801064 -31.58583832]
[ -7.  -4.   5.  20.] -> [  41.   68.  101.  140.])
 `-> Prediction: [ 14.14126873  22.74848557  31.29668617  36.73633194]
...

Modell ist ein LSTM-autoencoder mit 2 Ebenen jeder.

Leider, wie Sie sehen können, in die Ergebnisse dieses Modells nicht lernen, die Reihenfolge richtig. Ich könnte der Fall sein, bin ich gerade dabei ein böser Fehler irgendwo, oder 1000-10000 training Schritte ist einfach viel zu wenig für eine LSTM. Wie gesagt, ich bin auch gerade erst anfangen zu verstehen/verwenden LSTMs richtig.
Aber ich hoffe, dies kann Ihnen einige inspiration bei der Umsetzung.

InformationsquelleAutor der Antwort bsautermeister

Glaube ich Option 1 am nächsten an der Referenz-Implementierung in /tensorflow/models/rnn/ptb/reader.py

def ptb_iterator(raw_data, batch_size, num_steps):
  """Iterate on the raw PTB data.

  This generates batch_size pointers into the raw PTB data, and allows
  minibatch iteration along these pointers.

  Args:
    raw_data: one of the raw data outputs from ptb_raw_data.
    batch_size: int, the batch size.
    num_steps: int, the number of unrolls.

  Yields:
    Pairs of the batched data, each a matrix of shape [batch_size, num_steps].
    The second element of the tuple is the same data time-shifted to the
    right by one.

  Raises:
    ValueError: if batch_size or num_steps are too high.
  """
  raw_data = np.array(raw_data, dtype=np.int32)

  data_len = len(raw_data)
  batch_len = data_len //batch_size
  data = np.zeros([batch_size, batch_len], dtype=np.int32)
  for i in range(batch_size):
    data[i] = raw_data[batch_len * i:batch_len * (i + 1)]

  epoch_size = (batch_len - 1) //num_steps

  if epoch_size == 0:
    raise ValueError("epoch_size == 0, decrease batch_size or num_steps")

  for i in range(epoch_size):
    x = data[:, i*num_steps:(i+1)*num_steps]
    y = data[:, i*num_steps+1:(i+1)*num_steps+1]
    yield (x, y)

Allerdings, eine andere Option zu wählen ist ein Zeiger in Ihre Daten-array nach dem Zufallsprinzip für jede Trainingseinheit.

InformationsquelleAutor der Antwort j314erre

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.