Question

我在为Keras准备RNN的输入数据时遇到了麻烦。

目前，我的培训数据维度为：(6752, 600, 13)

6752：培训数据的数量
600：时间步数
13：特征向量的大小（向量处于浮动状态）

X_train和Y_train都属于这个维度。

我想准备将这些数据输入Keras的SimpleRNN。假设我们正在经历时间步骤，从步骤＃0到步骤＃599。假设我想使用input_length = 5，这意味着我想使用最近的5个输入。（例如步骤＃10，＃11，＃12，＃13，＃14 @步骤＃14）。

我应该如何重塑X_train？

应该是(6752, 5, 600, 13)还是应该是(6752, 600, 5, 13)？

Y_train应该采用什么形状？

应该是(6752, 600, 13)还是(6752, 1, 600, 13)还是(6752, 600, 1, 13)？

Answer 1

如果您只想使用最近的5个输入预测输出，则无需提供任何训练样本的完整600个时间步长。我的建议是以下列方式传递培训数据：

             t=0  t=1  t=2  t=3  t=4  t=5  ...  t=598  t=599
sample0      |---------------------|
sample0           |---------------------|
sample0                |-----------------
...
sample0                                         ----|
sample0                                         ----------|
sample1      |---------------------|
sample1           |---------------------|
sample1                |-----------------
....
....
sample6751                                      ----|
sample6751                                      ----------|

训练序列的总数将总结为

(600 - 4) * 6752 = 4024192    # (nb_timesteps - discarded_tailing_timesteps) * nb_samples

每个训练序列由5个时间步骤组成。在每个序列的每个时间步，您都会传递特征向量的所有13个元素。随后，训练数据的形状将是（4024192,5,13）。

此循环可以重塑您的数据：

input = np.random.rand(6752,600,13)
nb_timesteps = 5

flag = 0

for sample in range(input.shape[0]):
    tmp = np.array([input[sample,i:i+nb_timesteps,:] for i in range(input.shape[1] - nb_timesteps + 1)])

    if flag==0:
        new_input = tmp
        flag = 1

    else:
        new_input = np.concatenate((new_input,tmp))

Answer 2

这是一个快速过程，可从无循环的2D数据开始为LSTN / RNN创建3D数据

import numpy as np
from skimage.util.shape import view_as_windows

## create dummy data
n_sample = 2000
n_features = 6

X = np.tile(np.arange(n_sample), (n_features,1)).T # (n_sample, n_features)
y = np.arange(n_sample) # (n_sample,)
print(X.shape, y.shape)

## train test split
train_split = 0.8
train_size = int(n_sample*train_split)

X_train = X[:train_size] # (train_size, n_features)
X_test = X[train_size:] # (n_sample-train_size, n_features)
print(X_train.shape, X_test.shape) 
y_train = y[:train_size] # (train_size,)
y_test = y[train_size:] # (n_sample-train_size,)
print(y_train.shape, y_test.shape)

如果领先一步

look_back = 5
y_train = y_train[look_back:] # (train_size-look_back,)
y_test = y_test[look_back:] # ((n_sample-train_size),)
print(y_train.shape, y_test.shape)
X_train = view_as_windows(X_train, (look_back,n_features))[:-1,0] # (train_size-look_back, look_back, n_features)
X_test = view_as_windows(X_test, (look_back,n_features))[:-1,0] # ((n_sample-train_size)-look_back, look_back, n_features)
print(X_train.shape, X_test.shape)

生成的数据示例：

X: [[0, 0, 0, 0, 0, 0],
    [1, 1, 1, 1, 1, 1],
    [2, 2, 2, 2, 2, 2],
    [3, 3, 3, 3, 3, 3],
    [4, 4, 4, 4, 4, 4]],

   [[1, 1, 1, 1, 1, 1],
    [2, 2, 2, 2, 2, 2],
    [3, 3, 3, 3, 3, 3],
    [4, 4, 4, 4, 4, 4],
    [5, 5, 5, 5, 5, 5]]

y: [5, 6]

如果多步预测

look_back = 5
look_ahead = 6
y_train = view_as_windows(y_train[look_back:,None], (look_ahead,1))[:,0] # (train_size-look_back-look_ahead+1, look_ahead, 1)
y_test = view_as_windows(y_test[look_back:,None], (look_ahead,1))[:,0] # ((n_sample-train_size)-look_back-look_ahead+1, look_ahead, 1)
print(y_train.shape, y_test.shape)
X_train = view_as_windows(X_train, (look_back,n_features))[:-look_ahead,0] # (train_size-look_back-look_ahead+1, look_back, n_features)
X_test = view_as_windows(X_test, (look_back,n_features))[:-look_ahead,0] # ((n_sample-train_size)-look_back-look_ahead+1, look_back, n_features)
print(X_train.shape, X_test.shape)

生成的数据示例：

X: [[0, 0, 0, 0, 0, 0],
    [1, 1, 1, 1, 1, 1],
    [2, 2, 2, 2, 2, 2],
    [3, 3, 3, 3, 3, 3],
    [4, 4, 4, 4, 4, 4]],

   [[1, 1, 1, 1, 1, 1],
    [2, 2, 2, 2, 2, 2],
    [3, 3, 3, 3, 3, 3],
    [4, 4, 4, 4, 4, 4],
    [5, 5, 5, 5, 5, 5]]

y: [[ 5],
    [ 6],
    [ 7],
    [ 8],
    [ 9],
    [10]],

   [[ 6],
    [ 7],
    [ 8],
    [ 9],
    [10],
    [11]]

Keras：我应该如何为RNN准备输入数据？

2 个答案: