web-dev-qa-db-ja.com

時系列予測のためにLSTMセルでRNNをトレーニングする方法

私は現在、時系列を予測するための簡単なモデルを構築しようとしています。目標は、モデルが将来の値を予測できるように、シーケンスでモデルをトレーニングすることです。

私はそうするためにテンソルフローとLSTMセルを使用しています。モデルは、時間の経過とともに切り捨てられた逆伝播でトレーニングされます。私の質問は、トレーニング用のデータをどのように構成するかです。

たとえば、与えられたシーケンスを学びたいと仮定しましょう：

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

そして、num_steps=4。

オプション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
...

オプション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
...

オプション

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

オプション4

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

任意の助けをいただければ幸いです。

time-seriestensorflowpredictionlstm
21
Jakob

いくつかのLSTM紹介ブログを読んだ後 Jakob Aungiers ' 、オプション3はステートレスLSTMに適しているようです。

LSTMがnum_stepsよりも前にデータを記憶する必要がある場合、ステートフルな方法でトレーニングできます-Kerasの例については、 Philippe Remyのブログ投稿「Stateful LSTM in Keras」 を参照してください。ただし、Philippeはバッチサイズが1より大きい場合の例を示していません。あなたの場合、次のデータ（input -> labelとして記述）で、ステートフルLSTMを使用した4つのバッチサイズを使用できると思います。

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
...

これにより、例えばバッチ＃0の2番目のサンプルは正しく再利用され、バッチ＃1の2番目のサンプルでトレーニングを継続します。

これはオプション4と似ていますが、使用可能なすべてのラベルを使用しているわけではありません。

更新：

batch_sizeがnum_stepsと等しいという私の提案の拡張として、Alexis Huet 答えを与えるbatch_sizeがnum_stepsの約数である場合、これは、より大きなnum_stepsに使用できます。彼は うまく説明している 彼のブログで。

4
Robert Pollak

TensorFlowでLSTMを学習し、（幸いなことに）簡単な数学関数によって生成された時系列/数値系列を予測しようとする例を実装しようとしています。

しかし、私は LSTMを使用したビデオ表現の教師なし学習 ：によって動機付けられた、トレーニング用のデータの構造化に別の方法を使用しています。

LSTM将来予測モデル

オプション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
...

この論文に加えて、私は、与えられたTensorFlow RNNの例からインスピレーションをとろうと試みました。私の現在の完全なソリューションは次のようになります。

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

この出力例は次のようになります。

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

モデルは、それぞれ2層のLSTM-autoencoderです。

残念ながら、結果からわかるように、このモデルはシーケンスを適切に学習しません。私はどこかで悪い間違いをしているだけの場合もあれば、LSTMの場合は1000〜10000のトレーニングステップがほとんどない場合もあります。私が言ったように、私はLSTMを適切に理解/使用し始めたばかりです。しかし、うまくいけば、これにより実装に関するインスピレーションが得られるでしょう。

5
bsautermeister

オプション1は、/ 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)

ただし、別のオプションは、トレーニングシーケンスごとにデータ配列へのポインターをランダムに選択することです。

1
j314erre