Question

我正在尝试实施LSTM with Keras。

我知道Keras的LSTM需要一个形状为Options +FollowSymLinks -MultiViews RewriteEngine On RewriteRule ^app(?:/.*)?$ /$0 [L,NC]的3D张量作为输入。但是，我不完全确定输入在我的情况下应该是什么样子，因为我只有一个(nb_samples, timesteps, input_dim)观察每个输入的样本，而不是多个样本，即T。将每个输入分成长度为(nb_samples=1, timesteps=T, input_dim=N)的样本是否更好？ T/M对我来说是几百万的观察，那么在这种情况下每个样本应该多长时间，即我如何选择T？

另外，我是对的，这个张量看起来应该是这样的：

其中M和N如前所述定义，x对应于我将从上面讨论的分裂中获得的最后一个样本？

最后，给定一个pandas数据框，每列中有[[[a_11, a_12, ..., a_1M], [a_21, a_22, ..., a_2M], ..., [a_N1, a_N2, ..., a_NM]], [[b_11, b_12, ..., b_1M], [b_21, b_22, ..., b_2M], ..., [b_N1, b_N2, ..., b_NM]], ..., [[x_11, x_12, ..., a_1M], [x_21, x_22, ..., x_2M], ..., [x_N1, x_N2, ..., x_NM]]]个观察值，T列，每个输入一个，我如何创建这样的输入以提供给Keras？

Answer 1

以下是设置时间序列数据以训练LSTM的示例。模型输出是无稽之谈，因为我只是设置它来演示如何构建模型。

import pandas as pd
import numpy as np
# Get some time series data
df = pd.read_csv("https://raw.githubusercontent.com/plotly/datasets/master/timeseries.csv")
df.head()

时间序列数据框：

Date      A       B       C      D      E      F      G
0   2008-03-18  24.68  164.93  114.73  26.27  19.21  28.87  63.44
1   2008-03-19  24.18  164.89  114.75  26.22  19.07  27.76  59.98
2   2008-03-20  23.99  164.63  115.04  25.78  19.01  27.04  59.61
3   2008-03-25  24.14  163.92  114.85  27.41  19.61  27.84  59.41
4   2008-03-26  24.44  163.45  114.84  26.86  19.53  28.02  60.09

您可以将输入构建到向量中，然后使用pandas .cumsum()函数构建时间序列的序列：

# Put your inputs into a single list
df['single_input_vector'] = df[input_cols].apply(tuple, axis=1).apply(list)
# Double-encapsulate list so that you can sum it in the next step and keep time steps as separate elements
df['single_input_vector'] = df.single_input_vector.apply(lambda x: [list(x)])
# Use .cumsum() to include previous row vectors in the current row list of vectors
df['cumulative_input_vectors'] = df.single_input_vector.cumsum()

可以以类似的方式设置输出，但它将是单个向量而不是序列：

# If your output is multi-dimensional, you need to capture those dimensions in one object
# If your output is a single dimension, this step may be unnecessary
df['output_vector'] = df[output_cols].apply(tuple, axis=1).apply(list)

输入序列必须与通过模型运行它们的长度相同，因此您需要将它们填充为累积向量的最大长度：

# Pad your sequences so they are the same length
from keras.preprocessing.sequence import pad_sequences

max_sequence_length = df.cumulative_input_vectors.apply(len).max()
# Save it as a list   
padded_sequences = pad_sequences(df.cumulative_input_vectors.tolist(), max_sequence_length).tolist()
df['padded_input_vectors'] = pd.Series(padded_sequences).apply(np.asarray)

可以从数据框中提取训练数据并将其放入numpy数组中。 请注意，从数据框中输出的输入数据不会生成3D数组。它生成一个数组数组，这不是一回事。

您可以使用hstack和reshape来构建3D输入数组。

# Extract your training data
X_train_init = np.asarray(df.padded_input_vectors)
# Use hstack to and reshape to make the inputs a 3d vector
X_train = np.hstack(X_train_init).reshape(len(df),max_sequence_length,len(input_cols))
y_train = np.hstack(np.asarray(df.output_vector)).reshape(len(df),len(output_cols))

证明：

>>> print(X_train_init.shape)
(11,)
>>> print(X_train.shape)
(11, 11, 6)
>>> print(X_train == X_train_init)
False

获得训练数据后，您可以定义输入图层和输出图层的尺寸。

# Get your input dimensions
# Input length is the length for one input sequence (i.e. the number of rows for your sample)
# Input dim is the number of dimensions in one input vector (i.e. number of input columns)
input_length = X_train.shape[1]
input_dim = X_train.shape[2]
# Output dimensions is the shape of a single output vector
# In this case it's just 1, but it could be more
output_dim = len(y_train[0])

构建模型：

from keras.models import Model, Sequential
from keras.layers import LSTM, Dense

# Build the model
model = Sequential()

# I arbitrarily picked the output dimensions as 4
model.add(LSTM(4, input_dim = input_dim, input_length = input_length))
# The max output value is > 1 so relu is used as final activation.
model.add(Dense(output_dim, activation='relu'))

model.compile(loss='mean_squared_error',
              optimizer='sgd',
              metrics=['accuracy'])

最后，您可以训练模型并将训练日志保存为历史记录：

# Set batch_size to 7 to show that it doesn't have to be a factor or multiple of your sample size
history = model.fit(X_train, y_train,
              batch_size=7, nb_epoch=3,
              verbose = 1)

输出：

Epoch 1/3
11/11 [==============================] - 0s - loss: 3498.5756 - acc: 0.0000e+00     
Epoch 2/3
11/11 [==============================] - 0s - loss: 3498.5755 - acc: 0.0000e+00     
Epoch 3/3
11/11 [==============================] - 0s - loss: 3498.5757 - acc: 0.0000e+00

就是这样。使用model.predict(X) X格式相同（样本数除外）为X_train，以便从模型中进行预测。

Answer 2

张量形状

你是对的，Keras期待LSTM神经网络的3D张量，但我认为你缺少的是Keras希望每个观察可以有多个维度。

例如，在Keras中，我使用单词向量来表示自然语言处理的文档。文档中的每个单词都由一个n维数字向量表示（因此如果n = 2单词'cat'将由[0.31, 0.65]）表示。为了表示单个文档，单词向量按顺序排列（例如'The cat sat。'= [[0.12, 0.99], [0.31, 0.65], [0.94, 0.04]]）。文档将是Keras LSTM中的单个样本。

这类似于您的时间序列观察。文档就像一个时间序列，一个单词就像你的时间序列中的单个观察，但在你的情况下，你的观察的表示只是n = 1维。

因此，我认为你的张量应该是[[[a1], [a2], ... , [aT]], [[b1], [b2], ..., [bT]], ..., [[x1], [x2], ..., [xT]]]，其中x对应nb_samples，timesteps = T和input_dim = 1，因为每个你的观察结果只有一个数字。

批量大小

应根据Cross Validated post将批量大小设置为最大化吞吐量，而不会超出计算机上的内存容量。据我所知，您的输入不需要是批量大小的倍数，也不能在训练模型和从中进行预测时。

<强>实施例

如果您正在寻找示例代码，请在Keras Github上使用LSTM和其他具有排序输入的网络类型的示例。

神经网络LSTM从数据帧输入形状

2 个答案: