समय श्रृंखला पूर्वानुमान

Question

के लिए एलएसटीएम कोशिकाओं के साथ आरएनएन को प्रशिक्षित करने के लिए मैं वर्तमान में समय श्रृंखला की भविष्यवाणी करने के लिए एक साधारण मॉडल बनाने की कोशिश कर रहा हूं। लक्ष्य मॉडल को एक अनुक्रम के साथ प्रशिक्षित करना होगा ताकि मॉडल भविष्य के मूल्यों की भविष्यवाणी कर सके।

मैं ऐसा करने के लिए tensorflow और 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 
... 

विकल्प 3

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

किसी भी मदद की सराहना की जाएगी।

Answer 1

मेरा मानना ​​है कि विकल्प 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) 

बहरहाल, एक अन्य विकल्प प्रत्येक के लिए बेतरतीब ढंग से अपने डेटा सरणी में एक सूचक का चयन करने के लिए है प्रशिक्षण अनुक्रम।

Answer 2

मैं बस टेंसरफ्लो में एलएसटीएम सीखने वाला हूं और एक उदाहरण लागू करने की कोशिश करता हूं जो (सौभाग्य से) एक साधारण गणित-फक्शन द्वारा लिखित कुछ समय-श्रृंखला/संख्या-श्रृंखला की भविष्यवाणी करने का प्रयास करता है।

लेकिन मैं प्रशिक्षण के लिए डेटा की संरचना करने के लिए एक अलग तरीके, Unsupervised Learning of Video Representations using LSTMs से प्रेरित उपयोग कर रहा हूँ:

LSTM Future Predictor Model

विकल्प 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 आरएनएन उदाहरणों से प्रेरणा लेने के लिए। मेरे वर्तमान पूर्ण समाधान इस तरह दिखता है:

इस के

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

मॉडल एक LSTM-autoencoder 2 परतों प्रत्येक चल रहा है।

दुर्भाग्यवश, जैसा कि आप परिणामों में देख सकते हैं, यह मॉडल अनुक्रम को सही तरीके से नहीं सीखता है।मैं यह मामला हो सकता हूं कि मैं कहीं और खराब गलती कर रहा हूं, या 1000-10000 प्रशिक्षण कदम एलएसटीएम के लिए कुछ ही रास्ता है। जैसा कि मैंने कहा, मैं बस एलएसटीएम को सही ढंग से समझने/उपयोग करने शुरू कर रहा हूं। लेकिन उम्मीद है कि यह आपको कार्यान्वयन के संबंध में कुछ प्रेरणा दे सकता है।