python - 如何用Python构建LSTM时间序列预测模型？

Question

我正在尝试构建一个 LSTM 模型，数据由日期时间和一些数值组成。在拟合模型时，它得到了

"ValueError: Error when checking input: expected lstm_1_input to have 3 dimensions, but got array with shape (10, 1)" error.

示例数据:“date.csv”看起来像:

Date

06/13/2018 07:20:04 PM

06/13/2018 07:20:04 PM

06/13/2018 07:20:04 PM

06/13/2018 07:22:12 PM

06/13/2018 07:22:12 PM

06/13/2018 07:22:12 PM

06/13/2018 07:26:20 PM

06/13/2018 07:26:20 PM

06/13/2018 07:26:20 PM

06/13/2018 07:26:20 PM

“tasks.csv”看起来像:

Tasks

2

1

2

1

4

2

3

2

3

4

    date = pd.read_csv('date.csv')
    task = pd.read_csv('tasks.csv')
    model = Sequential()
    model.add(LSTM(24,return_sequences=True,input_shape=(date.shape[0],1)))
    model.add(Dense(1))
    model.compile(loss="mean_squared_error", optimizer="adam")
    model.fit(date, task,  epochs=100,  batch_size=1,  verbose=1)

如何预测结果？

Answer 1

此代码示例存在一些问题。缺乏预处理、标签编码、目标编码和错误的损失函数。我简要描述了可能的解决方案，但有关更多信息和示例，您可以阅读 tutorial关于时间序列和预测。

解决生成此 ValueError 的具体问题是:LSTM 需要三维输入。它的形状是(batch_size，input_length，dimension)。因此，它需要至少输入一些值 (batch_size, 1, 1) - 但 date.shape 是 (10, 1) 。如果你这样做

date = date.values.reshape((1, 10, 1)) 

-它将解决这一问题，但会带来大量其他问题:

date = date.values.reshape((1, 10, 1))

model = Sequential()
model.add(LSTM(24, return_sequences=True, input_shape=(date.shape[1], 1)))
print(model.layers[-1].output_shape)
model.add(Dense(1))
model.compile(loss="mean_squared_error", optimizer="adam")
model.fit(date, task,  epochs=100,  batch_size=1,  verbose=1)

ValueError: Input arrays should have the same number of samples as target arrays. Found 1 input samples and 10 target samples.

不幸的是，由于缺乏信息，其他问题没有答案。但一些通用的建议。

预处理
不幸的是，你可能不能仅仅 reshape ，因为预测并不那么复杂。您应该根据您对下一个任务的预测来选择某个时期。好消息是，有定期测量，但每次都有多个任务，这使得任务更难解决。

功能
你应该有一个功能来预测某些事情。目前尚不清楚这种情况下的特征是什么，但可能不是日期和时间。即使前一个任务也可以是一个特征，但你不能只使用任务 ID，它需要一些嵌入，因为它不是连续的数值，而是一个标签。

嵌入
有一个keras.layers.Embedding用于在 keras 中嵌入某些内容。

如果任务数量为 4 (1, 2, 3, 4) 并且输出向量的形状为，则可以使用以下方式:

model = Sequential()
model.add(Embedding(4 + 1, 10, input_length=10))  # + 1 to deal with non-zero indexing
# ... the reso of the code is omitted

-第一个参数是嵌入项的数量，第二个参数是输出形状，后者是输入长度(10 只是一个示例值)。

标签编码
任务标签可能只是一个标签，它们之间没有合理的距离或度量 - 即你不能说 1 比 4 更接近 2 等等。这种情况 mse 是无用，但幸运的是存在一个名为 categorical cross-entropy 的概率损失函数这有助于预测一类数据。

要使用它，您应该对标签进行二值化:

import numpy as np

def binarize(labels):
    label_map = dict(map(reversed, enumerate(np.unique(labels))))
    bin_labels = np.zeros((len(labels), len(label_map)))
    bin_labels[np.arange(len(labels)), [label_map[label] for label in labels]]  = 1
    return bin_labels, label_map

binarized_task, label_map = binarize(task)
binarized_task
Out:
array([[0., 1., 0., 0.],
        [1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [1., 0., 0., 0.],
        [0., 0., 0., 1.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.]]
label_map
Out:
{1: 0, 2: 1, 3: 2, 4: 3}

- 二值化标签和“任务在二值标签中的位置”的集合。
当然，您应该在具有二值化标签的模型中使用交叉熵损失。另外，最后一层应该使用 Softmax 激活函数(在关于交叉熵的教程中进行了解释；很快，您将处理标签的概率，因此，应该将其求和最多为 1，softmax 根据此要求修改前一层值):

model.add(Dense(4, activation='softmax'))
model.compile(loss="categorical_crossentropy", optimizer="adam")
model.fit(date, binarized_task, epochs=100, batch_size=1,  verbose=1)

“完整”，但可能是毫无意义的示例
此示例使用了上面列出的所有内容，但它并不假装完整或有用 - 但我希望它至少具有解释性。

import datetime
import numpy as np
import pandas as pd
import keras
from keras.models import Sequential
from keras.layers import Dense, LSTM, Flatten, Embedding

# Define functions

def binarize(labels):
    """
    Labels of shape (size,) to {0, 1} array of the shape (size, n_labels)
    """
    label_map = dict(map(reversed, enumerate(np.unique(labels))))
    bin_labels = np.zeros((len(labels), len(label_map)))
    bin_labels[np.arange(len(labels)), [label_map[label] for label in labels]]  = 1
    return bin_labels, label_map


def group_chunks(df, chunk_size):
    """
    Group task date by periods, train on some columns and use lask ('Tasks') as the target. Function uses 'Tasks' as a features.
    """
    chunks = []
    for i in range(0, len(df)-chunk_size):
        chunks.append(df.iloc[i:i + chunk_size]['Tasks'])  # slice period, append 
        chunks[-1].index = list(range(chunk_size))
    df_out = pd.concat(chunks, axis=1).T  
    df_out.index = df['Date'].iloc[:(len(df) - chunk_size)]
    df_out.columns = [i for i in df_out.columns[:-1]] + ['Tasks']
    return df_out


# I modify this date for simlicity - now it's a single entry for each datetime
date = pd.DataFrame({
    "Date" : [
        "06/13/2018 07:20:00 PM",
        "06/13/2018 07:20:01 PM",
        "06/13/2018 07:20:02 PM",
        "06/13/2018 07:20:03 PM",
        "06/13/2018 07:20:04 PM",
        "06/13/2018 07:20:05 PM",
        "06/13/2018 07:20:06 PM",
        "06/13/2018 07:20:07 PM",
        "06/13/2018 07:20:08 PM",
        "06/13/2018 07:20:09 PM"]
})

task = pd.DataFrame({"Tasks": [2, 1, 2, 1, 4, 2, 3, 2, 3, 4]})
date['Tasks'] = task['Tasks']
date['Date'] = date['Date'].map(lambda x: datetime.datetime.strptime(x, "%m/%d/%Y %I:%M:%S %p"))  # formatting datetime as datetime


chunk_size = 4
df = group_chunks(date, chunk_size)
# print(df)
"""
                     0  1  2  Tasks
Date                               
2018-06-13 19:20:00  2  1  2      1
2018-06-13 19:20:01  1  2  1      4
2018-06-13 19:20:02  2  1  4      2
2018-06-13 19:20:03  1  4  2      3
2018-06-13 19:20:04  4  2  3      2
2018-06-13 19:20:05  2  3  2      3

"""
# extract the train data and target
X = df[list(range(chunk_size-1))].values
y, label_map = binarize(df['Tasks'].values)

# Create a model, compile, fit
model = Sequential()
model.add(Embedding(len(np.unique(X))+1, 24, input_length=X.shape[-1]))
model.add(LSTM(24, return_sequences=True, input_shape=(date.shape[1], 1)))
model.add(Flatten())
model.add(Dense(4, activation='softmax'))
model.compile(loss="categorical_crossentropy", optimizer="adam")
history = model.fit(X, y,  epochs=100,  batch_size=1,  verbose=1)
Out:
Epoch 1/100
6/6 [==============================] - 1s 168ms/step - loss: 1.3885
Epoch 2/100
6/6 [==============================] - 0s 5ms/step - loss: 1.3811
Epoch 3/100
6/6 [==============================] - 0s 5ms/step - loss: 1.3781
...

-等等。以某种方式起作用，但我再次建议:阅读上面链接的教程(或任何其他预测教程)。因为，例如，我在此示例中没有涵盖测试/验证区域。