如何在用于时间序列预测的 LSTM 网络中使用时间步长

作者 Jason Brownlee 于 2020年8月28日发布在深度学习时间序列 165

Keras 中的长短期记忆（LSTM）网络支持时间步长。

这引出了一个问题，即是否可以将单变量时间序列的滞后观测值用作 LSTM 的时间步长，以及这是否能提高预测性能。

在本教程中，我们将研究在 Python 的 LSTM 模型中使用滞后观测值作为时间步长。

完成本教程后，您将了解：

如何开发一个测试框架来系统地评估时间序列预测中的 LSTM 时间步长。
使用不同数量的滞后观测值作为 LSTM 模型输入时间步长的影响。
使用不同数量的滞后观测值和匹配的神经元数量对 LSTM 模型的影响。

通过我的新书《深度学习时间序列预测》启动您的项目，其中包括分步教程以及所有示例的Python源代码文件。

让我们开始吧。

2019 年 4 月更新：更新了数据集链接。

How to Use Timesteps in LSTM Networks for Time Series Forecasting

如何在用于时间序列预测的 LSTM 网络中使用时间步长
照片由 YoTuT 提供，保留部分权利。

教程概述

本教程共分为 4 个部分。它们是：

洗发水销售数据集
实验测试框架
时间步长实验
时间步长和神经元实验

环境

本教程假定您已安装 Python SciPy 环境。您可以使用 Python 2 或 3。

本教程假定您已安装 Keras v2.0 或更高版本，并使用 TensorFlow 或 Theano 后端。

本教程还假定您已安装 scikit-learn、Pandas、NumPy 和 Matplotlib。

如果您需要帮助设置 Python 环境，请参阅此帖子

如何使用 Anaconda 设置用于机器学习和深度学习的 Python 环境

时间序列深度学习需要帮助吗？

立即参加我为期7天的免费电子邮件速成课程（附示例代码）。

点击注册，同时获得该课程的免费PDF电子书版本。

洗发水销售数据集

此数据集描述了 3 年期间洗发水月销量。

单位是销售计数，共有 36 个观测值。原始数据集归功于 Makridakis、Wheelwright 和 Hyndman (1998)。

下载数据集.

以下示例加载并创建加载数据集的图表。

# load and plot dataset
from pandas import read_csv
from pandas import datetime
from matplotlib import pyplot
# load dataset
def parser(x):
	return datetime.strptime('190'+x, '%Y-%m')
series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser)
# summarize first few rows
print(series.head())
# line plot
series.plot()
pyplot.show()

# 加载并绘制数据集

from pandas import read_csv

from pandas import datetime

from matplotlib import pyplot

# 加载数据集

def parser(x):

return datetime.strptime('190'+x, '%Y-%m')

series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser)

# 总结前几行

print(series.head())

# 线图

series.plot()

pyplot.show()

运行该示例将数据集作为 Pandas Series 加载并打印前 5 行。

Month
1901-01-01 266.0
1901-02-01 145.9
1901-03-01 183.1
1901-04-01 119.3
1901-05-01 180.3
Name: Sales, dtype: float64

月份

1901-01-01 266.0

1901-02-01 145.9

1901-03-01 183.1

1901-04-01 119.3

1901-05-01 180.3

名称：销售额，数据类型：float64

然后创建该系列的线图，显示出明显的上升趋势。

洗发水销售数据集的折线图

接下来，我们将看看实验中使用的LSTM配置和测试框架。

实验测试框架

本节将介绍本教程中使用的测试框架。

数据分割

我们将把洗发水销售数据集分为两部分：训练集和测试集。

前两年的数据将用于训练数据集，剩下的一年数据将用于测试集。

模型将使用训练数据集进行开发，并对测试数据集进行预测。

在测试数据集上的持久性预测（朴素预测）实现了136.761个月洗发水销量的误差。这为测试集上的性能提供了一个可接受的较低界限。

模型评估

将使用滚动预测方案，也称为向前验证模型。

测试数据集的每个时间步长都将被逐个进行。模型将用于预测时间步长，然后取测试集中实际期望值，并使其可供模型用于下一个时间步长的预测。

这模拟了现实世界场景，其中每个月都会有新的洗发水销售观察值，并用于预测下个月。

这将通过训练和测试数据集的结构进行模拟。

将收集测试数据集上的所有预测，并计算一个误差分数来总结模型的技能。将使用均方根误差（RMSE），因为它会惩罚较大的误差，并产生一个与预测数据单位相同的分数，即月度洗发水销量。

数据准备

在我们使用 LSTM 模型拟合数据集之前，我们必须转换数据。

在拟合模型和进行预测之前，对数据集执行以下三种数据转换。

转换时间序列数据使其平稳。具体来说，进行 lag=1 的差分以消除数据中不断增长的趋势。
将时间序列转换为监督学习问题。具体来说，将数据组织成输入和输出模式，其中前一个时间步长的观测值用作预测当前时间步长观测值的输入。
转换观测值以具有特定比例。具体来说，将数据重新缩放到-1到1之间的值，以满足LSTM模型的默认双曲正切激活函数。

在计算误差分数之前，这些转换将被应用于预测中，以将它们恢复到其原始尺度。

LSTM 模型

我们将使用一个基础的 stateful LSTM 模型，包含 1 个神经元，训练 500 个 epoch。

由于我们将使用向前滚动验证，并且对最后12个月的测试数据进行单步预测，因此需要批量大小为1。

批量大小为1意味着模型将使用在线训练（而不是批量训练或小批量训练）进行拟合。因此，预计模型拟合会存在一些方差。

理想情况下，会使用更多的训练epoch（例如1000或1500），但为了保持运行时间合理，这里截断到500。

模型将使用高效的ADAM优化算法和均方误差损失函数进行拟合。

实验运行

每个实验场景将运行10次。

这样做的原因是，LSTM网络的随机初始条件每次训练给定配置时都可能导致非常不同的结果。

让我们开始实验。

时间步长实验

我们将进行 5 次实验，每次实验使用不同的滞后观测值数量作为时间步长，从 1 到 5。

使用 1 个时间步长的表示将是使用 stateful LSTM 的默认表示。使用 2 到 5 个时间步长是人为设计的。希望的是，来自滞后观测值的附加上下文可以提高预测模型的性能。

在训练模型之前，单变量时间序列被转换为监督学习问题。表示中指定的时间步长数量决定了用于预测下一个时间步长 (y) 的输入变量 (X) 的数量。因此，对于表示中使用的每个时间步长，必须从数据集开头删除相应数量的行。这是因为对于数据集中的第一个值，没有先前的观测值可以用作时间步长。

测试 1 个时间步长的完整代码列表如下。

run() 函数中的 time_steps 参数在 5 次实验中分别从 1 到 5。此外，实验结束时结果将保存到文件，对于每个不同的实验运行，此文件名也必须更改；例如：experiment_timesteps_1.csv、experiment_timesteps_2.csv 等。

from pandas import DataFrame
from pandas import Series
from pandas import concat
from pandas import read_csv
from pandas import datetime
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from math import sqrt
import matplotlib
import numpy
from numpy import concatenate

# date-time parsing function for loading the dataset
def parser(x):
	return datetime.strptime('190'+x, '%Y-%m')

# frame a sequence as a supervised learning problem
def timeseries_to_supervised(data, lag=1):
	df = DataFrame(data)
	columns = [df.shift(i) for i in range(1, lag+1)]
	columns.append(df)
	df = concat(columns, axis=1)
	return df

# create a differenced series
def difference(dataset, interval=1):
	diff = list()
	for i in range(interval, len(dataset)):
		value = dataset[i] - dataset[i - interval]
		diff.append(value)
	return Series(diff)

# invert differenced value
def inverse_difference(history, yhat, interval=1):
	return yhat + history[-interval]

# scale train and test data to [-1, 1]
def scale(train, test):
	# fit scaler
	scaler = MinMaxScaler(feature_range=(-1, 1))
	scaler = scaler.fit(train)
	# transform train
	train = train.reshape(train.shape[0], train.shape[1])
	train_scaled = scaler.transform(train)
	# transform test
	test = test.reshape(test.shape[0], test.shape[1])
	test_scaled = scaler.transform(test)
	return scaler, train_scaled, test_scaled

# inverse scaling for a forecasted value
def invert_scale(scaler, X, yhat):
	new_row = [x for x in X] + [yhat]
	array = numpy.array(new_row)
	array = array.reshape(1, len(array))
	inverted = scaler.inverse_transform(array)
	return inverted[0, -1]

# fit an LSTM network to training data
def fit_lstm(train, batch_size, nb_epoch, neurons, timesteps):
	X, y = train[:, 0:-1], train[:, -1]
	X = X.reshape(X.shape[0], timesteps, 1)
	model = Sequential()
	model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True))
	model.add(Dense(1))
	model.compile(loss='mean_squared_error', optimizer='adam')
	for i in range(nb_epoch):
		model.fit(X, y, epochs=1, batch_size=batch_size, verbose=0, shuffle=False)
		model.reset_states()
	return model

# make a one-step forecast
def forecast_lstm(model, batch_size, X):
	X = X.reshape(1, len(X), 1)
	yhat = model.predict(X, batch_size=batch_size)
	return yhat[0,0]

# run a repeated experiment
def experiment(repeats, series, timesteps):
	# transform data to be stationary
	raw_values = series.values
	diff_values = difference(raw_values, 1)
	# transform data to be supervised learning
	supervised = timeseries_to_supervised(diff_values, timesteps)
	supervised_values = supervised.values[timesteps:,:]
	# split data into train and test-sets
	train, test = supervised_values[0:-12, :], supervised_values[-12:, :]
	# transform the scale of the data
	scaler, train_scaled, test_scaled = scale(train, test)
	# run experiment
	error_scores = list()
	for r in range(repeats):
		# fit the base model
		lstm_model = fit_lstm(train_scaled, 1, 500, 1, timesteps)
		# forecast test dataset
		predictions = list()
		for i in range(len(test_scaled)):
			# predict
			X, y = test_scaled[i, 0:-1], test_scaled[i, -1]
			yhat = forecast_lstm(lstm_model, 1, X)
			# invert scaling
			yhat = invert_scale(scaler, X, yhat)
			# invert differencing
			yhat = inverse_difference(raw_values, yhat, len(test_scaled)+1-i)
			# store forecast
			predictions.append(yhat)
		# report performance
		rmse = sqrt(mean_squared_error(raw_values[-12:], predictions))
		print('%d) Test RMSE: %.3f' % (r+1, rmse))
		error_scores.append(rmse)
	return error_scores

# execute the experiment
def run():
	# load dataset
	series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser)
	# experiment
	repeats = 10
	results = DataFrame()
	# run experiment
	timesteps = 1
	results['results'] = experiment(repeats, series, timesteps)
	# summarize results
	print(results.describe())
	# save results
	results.to_csv('experiment_timesteps_1.csv', index=False)

 # entry point
run()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

from pandas import DataFrame

from pandas import Series

从 pandas 导入 concat

from pandas import read_csv

from pandas import datetime

from sklearn.metrics import mean_squared_error

从 sklearn.预处理导入 MinMaxScaler

from keras.models import Sequential

from keras.layers import Dense

从 keras.layers 导入 LSTM

from math import sqrt

import matplotlib

import numpy

from numpy import concatenate

# 用于加载数据集的日期时间解析函数

def parser(x):

return datetime.strptime('190'+x, '%Y-%m')

# 将序列构造成监督学习问题

def timeseries_to_supervised(data, lag=1):

df = DataFrame(data)

columns = [df.shift(i) for i in range(1, lag+1)]

columns.append(df)

df = concat(columns, axis=1)

return df

# 创建差分序列

def difference(dataset, interval=1):

diff = list()

for i in range(interval, len(dataset)):

value = dataset[i] - dataset[i - interval]

diff.append(value)

return Series(diff)

# 反转差分值

def inverse_difference(history, yhat, interval=1):

return yhat + history[-interval]

# 将训练和测试数据缩放到 [-1, 1]

def scale(train, test):

# 拟合缩放器

scaler = MinMaxScaler(feature_range=(-1, 1))

scaler = scaler.fit(train)

# 转换训练集

train = train.reshape(train.shape[0], train.shape[1])

train_scaled = scaler.transform(train)

# 转换测试集

test = test.reshape(test.shape[0], test.shape[1])

test_scaled = scaler.transform(test)

return scaler, train_scaled, test_scaled

# 预测值的逆缩放

def invert_scale(scaler, X, yhat):

new_row = [x for x in X] + [yhat]

array = numpy.array(new_row)

array = array.reshape(1, len(array))

inverted = scaler.inverse_transform(array)

return inverted[0, -1]

# 训练一个 LSTM 网络

def fit_lstm(train, batch_size, nb_epoch, neurons, timesteps):

X, y = train[:, 0:-1], train[:, -1]

X = X.reshape(X.shape[0], timesteps, 1)

model = Sequential()

model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True))

model.add(Dense(1))

model.compile(loss='mean_squared_error', optimizer='adam')

for i in range(nb_epoch):

model.fit(X, y, epochs=1, batch_size=batch_size, verbose=0, shuffle=False)

model.reset_states()

return model

# 进行一步预测

def forecast_lstm(model, batch_size, X):

X = X.reshape(1, len(X), 1)

yhat = model.predict(X, batch_size=batch_size)

return yhat[0,0]

# 运行重复实验

def experiment(repeats, series, timesteps):

# 将数据转换为平稳

raw_values = series.values

diff_values = difference(raw_values, 1)

# 将数据转换为监督学习

supervised = timeseries_to_supervised(diff_values, timesteps)

supervised_values = supervised.values[timesteps:,:]

# 将数据分割成训练集和测试集

train, test = supervised_values[0:-12, :], supervised_values[-12:, :]

# 转换数据尺度

scaler, train_scaled, test_scaled = scale(train, test)

# 运行实验

error_scores = list()

for r in range(repeats):

# 拟合基础模型

lstm_model = fit_lstm(train_scaled, 1, 500, 1, timesteps)

# 预测测试数据集

predictions = list()

for i in range(len(test_scaled)):

# 预测

X, y = test_scaled[i, 0:-1], test_scaled[i, -1]

yhat = forecast_lstm(lstm_model, 1, X)

# 反转缩放

yhat = invert_scale(scaler, X, yhat)

# 反转差分

yhat = inverse_difference(raw_values, yhat, len(test_scaled)+1-i)

# 存储预测

predictions.append(yhat)

# 报告性能

rmse = sqrt(mean_squared_error(raw_values[-12:], predictions))

print('%d) Test RMSE: %.3f' % (r+1, rmse))

error_scores.append(rmse)

return error_scores

# 执行实验

def run():

# 加载数据集

series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser)

# 实验

repeats = 10

results = DataFrame()

# 运行实验

timesteps = 1

results['results'] = experiment(repeats, series, timesteps)

# 总结结果

print(results.describe())

# 保存结果

results.to_csv('experiment_timesteps_1.csv', index=False)

# 入口点

run()

为 5 个不同的时间步长运行 5 个不同的实验。

如果您有足够的内存和 CPU 资源，可以并行运行它们。这些实验不需要 GPU 资源，实验应该在几分钟到几十分钟内完成。

运行实验后，您应该会得到 5 个包含结果的文件，如下所示：

experiment_timesteps_1.csv
experiment_timesteps_2.csv
experiment_timesteps_3.csv
experiment_timesteps_4.csv
experiment_timesteps_5.csv

experiment_timesteps_1.csv

experiment_timesteps_2.csv

experiment_timesteps_3.csv

experiment_timesteps_4.csv

experiment_timesteps_5.csv

我们可以编写一些代码来加载和汇总这些结果。

具体来说，查看每次运行的描述性统计数据并使用箱形图和须形图比较每次运行的结果会很有用。

汇总结果的代码如下。

from pandas import DataFrame
from pandas import read_csv
from matplotlib import pyplot
# load results into a dataframe
filenames = ['experiment_timesteps_1.csv', 'experiment_timesteps_2.csv',
	'experiment_timesteps_3.csv','experiment_timesteps_4.csv','experiment_timesteps_5.csv']
results = DataFrame()
for name in filenames:
	results[name[11:-4]] = read_csv(name, header=0)
# describe all results
print(results.describe())
# box and whisker plot
results.boxplot()
pyplot.show()

from pandas import DataFrame

from pandas import read_csv

from matplotlib import pyplot

# 加载结果到数据框

filenames = ['experiment_timesteps_1.csv', 'experiment_timesteps_2.csv',

'experiment_timesteps_3.csv','experiment_timesteps_4.csv','experiment_timesteps_5.csv']

results = DataFrame()

for name in filenames:

results[name[11:-4]] = read_csv(name, header=0)

# 总结所有结果

print(results.describe())

# 箱线图

results.boxplot()

pyplot.show()

运行代码后，首先会为每组结果打印描述性统计信息。

注意：您的结果可能会有所不同，这取决于算法或评估过程的随机性，或者数值精度的差异。可以尝试运行几次示例并比较平均结果。

仅从平均性能来看，我们可以看出默认使用单个时间步产生了最佳性能。在查看中位数测试 RMSE（第 50 个百分位数）时也显示了这一点。

       timesteps_1  timesteps_2  timesteps_3  timesteps_4  timesteps_5
count    10.000000    10.000000    10.000000    10.000000    10.000000
mean    102.785197   127.308725   136.182907   146.277122   142.631684
std       6.299329    22.171668     7.760161     5.609412     6.611638
min      92.603903   106.124901   124.724903   138.845314   137.359503
25%      98.979692   114.100891   130.719154   141.906083   138.354265
50%     103.904185   114.519986   137.055840   145.865171   141.409855
75%     108.434727   144.328534   139.615541   150.729938   143.604275
max     110.270559   164.880226   150.497130   155.603461   159.948033

timesteps_1 timesteps_2 timesteps_3 timesteps_4 timesteps_5

count 10.000000 10.000000 10.000000 10.000000 10.000000

mean 102.785197 127.308725 136.182907 146.277122 142.631684

std 6.299329 22.171668 7.760161 5.609412 6.611638

min 92.603903 106.124901 124.724903 138.845314 137.359503

25% 98.979692 114.100891 130.719154 141.906083 138.354265

50% 103.904185 114.519986 137.055840 145.865171 141.409855

75% 108.434727 144.328534 139.615541 150.729938 143.604275

max 110.270559 164.880226 150.497130 155.603461 159.948033

还会创建一个比较结果分布的箱线图。

这张图与描述性统计结果传达的信息相同。随着时间步的增加，测试 RMSE 总体上呈现增加的趋势。

Box and Whisker Plot of Timesteps vs RMSE

时间步与 RMSE 的箱线图

至少在所选数据集和 LSTM 配置下，预期随着时间步增加而性能提升的现象并未出现。

这引出了一个问题，即网络的容量是否是限制因素。我们将在下一节中探讨这一点。

时间步长和神经元实验

LSTM 网络中的神经元数量（也称为块）决定了其学习容量。

在之前的实验中，使用一个神经元可能限制了网络的学习容量，使其无法有效地利用时间步的滞后观测值。

我们可以重复上述实验，并随着时间步的增加而增加 LSTM 中的神经元数量，看看这是否能提高性能。

这可以通过在实验函数中更改以下行来实现：

lstm_model = fit_lstm(train_scaled, 1, 500, 1, timesteps)

1	lstm_model = fit_lstm(train_scaled, 1, 500, 1, timesteps)

推广到

lstm_model = fit_lstm(train_scaled, 1, 500, timesteps, timesteps)

1	lstm_model = fit_lstm(train_scaled, 1, 500, timesteps, timesteps)

此外，我们可以通过在文件名中添加“_neurons”后缀，将结果与第一次实验的结果分开，例如更改：

results.to_csv('experiment_timesteps_1.csv', index=False)

1	results.to_csv('experiment_timesteps_1.csv', index=False)

推广到

results.to_csv('experiment_timesteps_1_neurons.csv', index=False)

1	results.to_csv('experiment_timesteps_1_neurons.csv', index=False)

使用这些更改重复相同的 5 个实验。

运行这些实验后，您应该会得到 5 个结果文件。

experiment_timesteps_1_neurons.csv
experiment_timesteps_2_neurons.csv
experiment_timesteps_3_neurons.csv
experiment_timesteps_4_neurons.csv
experiment_timesteps_5_neurons.csv

experiment_timesteps_1_neurons.csv

experiment_timesteps_2_neurons.csv

experiment_timesteps_3_neurons.csv

experiment_timesteps_4_neurons.csv

experiment_timesteps_5_neurons.csv

与之前的实验一样，我们可以加载结果、计算描述性统计信息并创建箱线图。完整的代码列表如下。

from pandas import DataFrame
from pandas import read_csv
from matplotlib import pyplot
# load results into a dataframe
filenames = ['experiment_timesteps_1_neurons.csv', 'experiment_timesteps_2_neurons.csv',
	'experiment_timesteps_3_neurons.csv','experiment_timesteps_4_neurons.csv','experiment_timesteps_5_neurons.csv']
results = DataFrame()
for name in filenames:
	results[name[11:-12]] = read_csv(name, header=0)
# describe all results
print(results.describe())
# box and whisker plot
results.boxplot()
pyplot.show()

from pandas import DataFrame

from pandas import read_csv

from matplotlib import pyplot

# 加载结果到数据框

filenames = ['experiment_timesteps_1_neurons.csv', 'experiment_timesteps_2_neurons.csv',

'experiment_timesteps_3_neurons.csv','experiment_timesteps_4_neurons.csv','experiment_timesteps_5_neurons.csv']

results = DataFrame()

for name in filenames:

results[name[11:-12]] = read_csv(name, header=0)

# 总结所有结果

print(results.describe())

# 箱线图

results.boxplot()

pyplot.show()

运行代码后，首先会打印来自 5 次实验的描述性统计信息。

注意：您的结果可能会有所不同，这取决于算法或评估过程的随机性，或者数值精度的差异。可以尝试运行几次示例并比较平均结果。

结果与具有一个神经元的 LSTM 的第一组实验类似。平均测试 RMSE 在神经元数量和时间步数量都设置为一时似乎最低。

       timesteps_1  timesteps_2  timesteps_3  timesteps_4  timesteps_5
count    10.000000    10.000000    10.000000    10.000000    10.000000
mean    109.484374   133.195856   133.432933   145.843701   149.854229
std       9.663732    36.328757    19.347675    19.389278    30.194324
min      91.803241    91.791014    87.739484   113.808683   103.612424
25%     104.757265   119.269854   127.937277   137.417983   131.278548
50%     108.464050   129.775765   134.076721   147.222168   151.999097
75%     114.265381   132.796259   147.557091   159.518828   164.741625
max     126.581011   226.396127   156.019616   171.570206   208.030615

timesteps_1 timesteps_2 timesteps_3 timesteps_4 timesteps_5

count 10.000000 10.000000 10.000000 10.000000 10.000000

mean 109.484374 133.195856 133.432933 145.843701 149.854229

std 9.663732 36.328757 19.347675 19.389278 30.194324

min 91.803241 91.791014 87.739484 113.808683 103.612424

25% 104.757265 119.269854 127.937277 137.417983 131.278548

50% 108.464050 129.775765 134.076721 147.222168 151.999097

75% 114.265381 132.796259 147.557091 159.518828 164.741625

max 126.581011 226.396127 156.019616 171.570206 208.030615

将创建箱线图以比较分布。

随着神经元数量和时间步的增加，范围和中位数性能的趋势几乎显示出测试 RMSE 的线性增加。

线性趋势可能表明网络容量的增加没有得到足够的时间来拟合数据。也许还需要增加训练的 epoch 数。

Box and Whisker Plot of Timesteps and Neurons vs RMSE

时间步和神经元与 RMSE 的箱线图

扩展

本节列出了一些可以进一步研究的领域，供您考虑。

滞后作为特征。使用滞后观测值作为时间步也引发了一个问题，即滞后观测值是否可以用作输入特征。目前尚不清楚 Keras LSTM 实现内部是否将时间步和特征视为相同方式。
诊断运行图。在给定实验的多次运行中，查看训练和测试 RMSE 随 epoch 的变化图可能很有帮助。这可能有助于区分过拟合或欠拟合的发生，进而找到解决它们的方法。
增加训练 epoch。在第二个实验中增加 LSTM 中的神经元数量可能需要增加训练 epoch 的数量。可以通过一些后续实验来探索这一点。
增加重复次数。使用 10 次重复会导致测试 RMSE 结果的总体相对较小。将重复次数增加到 30 或 100（甚至更高）可能会产生更稳定的结果。

您是否探索过这些扩展？
在下面的评论中分享您的发现；我很想听听您的结果。

总结

在本教程中，您学习了如何研究在 LSTM 网络中使用滞后观测值作为输入时间步。

具体来说，你学到了：

如何为 LSTM 中的输入表示开发稳健的测试框架。
如何使用滞后观测值作为时间步，用于 LSTM 的时间序列预测。
如何随着时间步的增加而增加网络的学习容量。

您发现，期望使用滞后观测值作为输入时间步并不能降低所选问题和 LSTM 配置的测试 RMSE。

你有什么问题吗？
请在下方评论中提问，我将尽力回答。

关于此主题的更多信息

如何在训练期间更新 LSTM 网络以进行时间序列预测

如何在 LSTM 网络中使用特征进行时间序列预测

165 条对“如何在 LSTM 网络中使用时间步进行时间序列预测”的回复

Hasan April 17, 2017 at 12:29 pm #

使用滞后值作为预测变量的问题在于，模型会错过通常由时间序列模型捕获的细微时间依赖性。

回复
- Jason Brownlee April 18, 2017 at 8:29 am #
  
  同意。LSTM 的承诺是学习时间依赖性。
  
  回复
  - Hasan April 19, 2017 at 7:52 pm #
    
    那么 LSTM 是否适用于所有类型的时间序列？
    
    回复
    - Jason Brownlee April 20, 2017 at 9:24 am #
      
      是的，但请尝试其他方法，并重点关注最适合您问题的解决方案。
      
      回复
  - Will March 15, 2018 at 4:06 am #
    
    只是想让您知道，这是对这些 LSTM 如何在底层工作的最清晰的解释。谢谢您。我购买了您的《机器学习实践》一书，其中包含 Excel 示例，那也很棒！我一定会努力传播这个信息。
    
    回复
    - Jason Brownlee March 15, 2018 at 6:35 am #
      
      谢谢。
      
      回复
  - Bibek Dhakal May 6, 2020 at 3:46 pm #
    
    嗨，Jason，
    非常感谢您的文章和帖子。它们帮助了我们所有人。
    我使用了前向验证，并将数据分为训练集和测试集。
    拆分后，我再次使用循环，为 X_train 设置了 60 个时间步，而 y_train 保持不变。
    在 Keras 中使用 LSTM 拟合模型时，我没有解决准确率的问题。它在所有 epoch 中都保持不变。
    
    在应用 LSTM 后，它也出现了过拟合。在新数据上效果不佳。
    我用 85% 的训练数据进行了训练。我在两个集合上都使用了缩放，但仍然无法找到解决方案。
    
    回复
    - Jason Brownlee May 7, 2020 at 6:39 am #
      
      不客气！
      
      通常，我们无法衡量回归问题的准确率，您必须使用误差指标。
      https://machinelearning.org.cn/faq/single-faq/how-do-i-calculate-accuracy-for-regression
      
      也许这里的一些建议可以帮助您提高模型性能。
      https://machinelearning.org.cn/start-here/#better
      
      回复
Kunpeng Zhang April 18, 2017 at 1:02 pm #

嗨，Jason，
您的帖子总是很有帮助。
现在，我有两个相似的数据集。我想使用 Keras 中的多任务模型来训练这些数据。具体来说，我有两个输入数据集，并希望在一个训练模型中分别获得两个输出。
在 Keras 中可能吗？我找到了一些内容。 https://keras.org.cn/getting-started/functional-api-guide/
但我还是没弄明白怎么做。您能给我一些建议吗？

回复
- Jason Brownlee April 19, 2017 at 7:49 am #
  
  几乎所有神经网络都可以有多个输出值。
  
  只需构建您的数据集，并在网络的输出层中设置所需的输出数量。
  
  回复
Kunpeng Zhang April 18, 2017 at 1:06 pm #

另一个问题。与 TensorFlow 相比，微调的 Keras 模型会得到更好的结果还是更差的结果？它们可以比较吗？

回复
- Jason Brownlee April 19, 2017 at 7:50 am #
  
  Keras 是构建在 TensorFlow 之上的。比较两者的结果没有意义（至少对我来说是这样）。
  
  回复
  - Kunpeng Zhang April 20, 2017 at 10:25 am #
    
    谢谢你的回复。
    祝您有美好的一天。
    
    回复
Jack Brown April 18, 2017 at 9:06 pm #

嗨，Jason，
您能详细解释一下这行代码吗？

train = train.reshape(train.shape[0], train.shape[1])

这不就是一样的吗？

回复
- Jason Brownlee April 19, 2017 at 7:52 am #
  
  看起来确实是这样，我可能太兴奋于所有的重塑操作了。试着去掉它，看看是否一切正常。
  
  回复
Jay Reynolds May 26, 2017 at 11:26 am #

“滞后作为特征。使用滞后观测值作为时间步也引发了一个问题，即滞后观测值是否可以用作输入特征。目前尚不清楚 Keras LSTM 实现内部是否将时间步和特征视为相同方式。”

对此有什么进一步的想法吗？
我有点不明白如何在某些输入特征滞后而另一些不滞后的情况下使用时间步。（说实话，我从根本上不理解为什么需要时间步，因为看起来任何滞后输入都应该被视为特征）。关于 LSTM 时间步的问题，互联网上的信息出奇地少……我也不记得在 Schmidhuber 等人的任何论文中遇到过时间步的概念（也许我没注意！）。

谢谢您提供的出色资源，并且继续分享。

回复
- Jason Brownlee June 2, 2017 at 11:52 am #
  
  是的，我错了。
  
  特征是加权的输入。时间步是特征随时间变化的离散输入。（这说得通吗？读起来很糟糕……）
  
  理解时间步的关键是 BPTT 算法。我有一篇关于此的帖子计划发布。
  
  回复
- John Jaro July 2, 2017 at 1:27 am #
  
  “我有点不明白如何在某些输入特征滞后而另一些不滞后的情况下使用时间步。（说实话，我从根本上不理解为什么需要时间步，因为看起来任何滞后输入都应该被视为特征）。关于 LSTM 时间步的问题，互联网上的信息出奇地少……”
  
  这是我 100% 的问题，我做了大量的谷歌搜索（并阅读了 Jason 的多篇文章），但仍然不理解这一点。无法弄清楚如何准备滞后时间步+特征以用于 LSTM。
  
  回复
  - Jason Brownlee July 2, 2017 at 6:33 am #
    
    滞后观测值是 LSTM 中的时间步。
    
    LSTM 输入是 3D 的：[样本，时间步，特征]。如果您的序列是单变量的，您将有多个时间步和一个特征。如果您想对一天的数据进行分类，您将有一个样本，25 个时间步和一个特征。
    
    这有帮助吗？
    
    回复
  - Nino Khukhunaishvili December 19, 2020 at 1:46 am #
    
    完全同意您的观点。
    
    回复
lawrance May 27, 2017 at 6:50 pm #

在您之前的博客（https://machinelearning.org.cn/time-series-prediction-lstm-recurrent-neural-networks-python-keras/）中，
您使用“trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))”（1），
而现在您使用“X = X.reshape(X.shape[0], timesteps, 1)”（2）。
如果第二个参数表示时间戳，那么在（1）中，您可能可以使用该文章中的“look_back”而不是 1。
如果第三个参数表示一个变量，那么在（1）中，您可能可以使用 1 而不是 trainX.shape[1]，因为 trainX.shape[1] 在本文中表示 look_back 或 timesteps。

回复
- Jason Brownlee June 2, 2017 at 12:01 pm #
  
  我建议在将过去观测值输入模型时使用它们作为时间步。
  
  回复
Birkey June 2, 2017 at 2:22 pm #

更多的神经元是否会导致过拟合？因为更多的神经元意味着更多的自由度，所以模型可以很好地（过度）拟合训练数据，但泛化能力较差。

如果真是这样，更多的 epoch 就无济于事了，我们需要更多训练数据。

回复
- Jason Brownlee June 3, 2017 at 7:19 am #
  
  是的，更多的神经元可能导致过拟合。
  
  回复
Roger July 9, 2017 at 1:16 am #

嗨 Jason – 感谢您的精彩内容。非常喜欢您的 ML Python 菜谱。我在理解 LSTM 的输入数据结构时遇到了一些麻烦，因为我看到的所有信息似乎都建议不同的方法。

我明白输入 X 的形状是 (样本, 时间步, 特征)。我的用例是我有大约 100 个时间序列，我试图将它们用作特征来预测另一个时间序列，每次预测 5 个时间步（在您在另一篇文章中详细介绍的滚动窗口方法中更新）。在我的情况下，X 的结构会是怎样的？我现在有类似这样的内容

X Y
[[t0, t1, t2], [[t3, t4]
[t1, t2, t3], [t4, t5]
…… ……

对于每个特征，然后我使用 np.stack() 将它们堆叠成 3D 形状。但似乎这是不正确的，因为时间步应该是 2，而不是 3？我的方法对吗？时间步/特征/滞后的混淆似乎在互联网上普遍存在。每个特征在不同的滞后/超前时可能具有更大的预测能力，这种 LSTM 设置会限制我的准确率吗？是否有更好的方法？谢谢！！

回复
- Jason Brownlee July 9, 2017 at 10:55 am #
  
  如果您有 5 个序列，那么就是 5 个特征。
  
  我建议将数据加载为 2D 矩阵，然后使用 reshape，可能使用 1 个样本。
  
  这有帮助吗？
  
  回复
Nihit August 8, 2017 at 8:35 pm #

嗨 Jason，很棒的帖子。
我一直在尝试在 R 中实现 Keras LSTM。我如何将我的单变量数据框重塑为 LSTM 在 R 中所需的输入形状？

回复
- Jason Brownlee August 9, 2017 at 6:28 am #
  
  抱歉，我没有关于在 R 中使用 Keras 的资料。
  
  回复
  - Nihit August 9, 2017 at 3:48 pm #
    
    哦，那太不幸了。虽然我确实在 Keras 中找到了 reshape 层，但我不确定它是否与 numpy.reshape 相同。
    另外，当我用它来训练模型时，它将训练集转换为 3D 数组，但现在我无法评估模型，因为我卡在了尝试将测试集转换为 3D 数组上。谢谢。
    
    回复
    - Jason Brownlee August 10, 2017 at 6:51 am #
      
      您收到什么错误？
      
      回复
Nihit August 10, 2017 at 5:05 pm #

我通过将训练集重塑为时间步为 1 的 3D 数组并包含滞后值作为输入，成功解决了这个问题。
但我无法将时间步设置为大于 1。
例如，我有一个数据集，时间间隔为 15 分钟。如果我设置时间步为 96（1 天）并构建一个 LSTM 模型，那么我将无法在测试集（1 个月）上进行预测，因为我只能得到（2880/96 = ）30 个值，而不是 2880 个值。

回复
Pablios September 22, 2017 at 6:38 pm #

嘿，非常感谢您的帖子！！
它们真的很有用。

回复
- Jason Brownlee September 23, 2017 at 5:37 am #
  
  很高兴听到这个消息。
  
  回复

Jussi October 20, 2017 at 1:32 am #

嗨 Jason，很棒的帖子。

我有点难以理解 timeseries_to_supervised 函数。它似乎会移动数据，使数据框的列顺序如下：[t, t-1, t-2, t-3, t-4, t+1]。T+1 将被用作 y，但据我理解，其余的列顺序是错误的（即，最新的数据点在前，反之亦然）……或者我错过了什么重要的东西？

bjuthjliu December 22, 2017 at 9:00 pm #

也许这里有一些 bug。

bjuthjliu December 22, 2017 at 9:05 pm #

def timeseries_to_supervised(data, lag=1):
    df = pd.DataFrame(data)
    columns = [df.shift(i) for i in reversed(range(1, lag+1))]
    columns.append(df)
    df = pd.concat(columns, axis=1)
    df.fillna(0, inplace=True)
    return df

def timeseries_to_supervised(data, lag=1):

df = pd.DataFrame(data)

columns = [df.shift(i) for i in reversed(range(1, lag+1)) ]

columns.append(df)

df = pd.concat(columns, axis=1)

df.fillna(0, inplace=True)

return df

我认为这个函数是这样的

Jason Brownlee 2017年12月23日上午5:17 #

在这里了解更多关于该函数的信息
https://machinelearning.org.cn/convert-time-series-supervised-learning-problem-python/

回复

Chris 2017年11月13日下午7:08 #

我用了一些打印来更好地理解我的问题。
前6行
0 -120.1
1 37.2
2 -63.8
3 61.0
4 -11.8
5 63.3

监督后的前6行
0 0 0
0 NaN NaN -120.1
1 -120.1 NaN 37.2
2 37.2 -120.1 -63.8
3 -63.8 37.2 61.0
4 61.0 -63.8 -11.8
5 -11.8 61.0 63.3

然后删除NaN
[[ 37.2 -120.1 -63.8]
[ -63.8 37.2 61. ]
[ 61. -63.8 -11.8]
[ -11.8 61. 63.3]
[ 63.3 -11.8 -7.3]
[ -7.3 63.3 -31.7]
[ -31.7 -7.3 -69.9]
.....]

然后缩放
[[ 0.04828702 -0.83250961 -0.496628 ]
[-0.496628 0.03130148 0.17669274]
[ 0.17669274 -0.52333882 -0.21607769]
[-0.21607769 0.1619989 0.1891017 ]
[ 0.1891017 -0.23778144 -0.1917993 ]
[-0.1917993 0.17462932 -0.32344214]
......]

然后分成X和y
X: [[ 0.04828702 -0.83250961]
[-0.496628 0.03130148]
[ 0.17669274 -0.52333882]
[-0.21607769 0.1619989 ]
[ 0.1891017 -0.23778144]
[-0.1917993 0.17462932]
.....]

y: [-0.496628 0.17669274 -0.21607769 0.1891017 -0.1917993 -0.32344214…]

然后重塑
[[[ 0.04828702]
[-0.83250961]]

[[-0.496628 ]
[ 0.03130148]]

[[ 0.17669274]
[-0.52333882]]

[[-0.21607769]
[ 0.1619989 ]]

[[ 0.1891017 ]
[-0.23778144]]

[[-0.1917993 ]
[ 0.17462932]]
....]

现在这是我的问题，我认为这与Jussi的帖子相同。

我不确定我是否正确，但如果我以第一个为例，我会使用
[[[ 0.04828702]
[-0.83250961]]]
对于X，以及
[-0.496628]
对于y，这样我就有t2,t1 -> t3
然后我认为，如果时间步是从上到下学习的，我将学到错误的顺序。
顺序不应该是这样的吗？
[[[-0.83250961]
[ 0.04828702]]]
对于X，以及
[-0.496628]
对于y，这样我就可以得到t1,t2 -> t3

我是否认为这是错误的？谢谢

回复
joseph 2018年1月18日下午4:26 #

你好 jason,

我遇到了这个错误：ValueError: time data ‘1901-Jan’ does not match format ‘%Y-%m’。这是有什么问题吗？

回复
- Jason Brownlee 2018年1月19日上午6:28 #
  
  确保您已从数据文件中删除页脚。
  
  回复
Swapnil Rai 2018年2月2日下午5:06 #

我对时间步长=1的情况有点困惑。使用时间步长=1不就是使用传统的神经网络吗？

回复
- Jason Brownlee 2018年2月3日上午8:34 #
  
  差不多。LSTM仍然具有内部状态。为了更好地利用BPTT，时间步长应大于1。
  https://machinelearning.org.cn/gentle-introduction-backpropagation-time/
  
  回复
ryan 2018年2月24日下午1:05 #

Jason您好，感谢您的精彩文章，我学到了很多。

我有一个关于差异的问题，是否有必要进行差分（使其平稳）？在时间序列分析中这是必要的，但在神经网络中为什么要这样做？

回复
- Jason Brownlee 2018年2月25日上午7:40 #
  
  通常，简化问题会使其更容易建模，从而提高预测的准确性。
  
  回复
David 2018年3月14日上午11:07 #

Jason您好，感谢您分享这篇文章。我正在进行类似的预测分析，并且非常喜欢阅读它。

我对预处理部分有一个问题。如果我遗漏了什么，请纠正我：我注意到所有特征（包括预测值y）都有时间偏移，并且这种方法也应用于测试集。从我看到的情况来看，您首先进行时间偏移，然后进行训练-测试分割，最后生成输入和输出，这将导致最后一个“实际值”输出的y(t-1)特征。

如果这正是我所想的，我认为测试集中不应该有时间偏移，因为在您预测该时间戳之前，输出值甚至不存在。这可能会导致测试集已经在其特征中包含要预测的实际值。

我想的是，您只能在测试集中逐步进行预测。首先生成第一个时间戳的预测，然后使用该预测来计算下一个时间戳的输出。

如果我遗漏了什么，请纠正我。这个问题已经在我脑海里困扰好几天了。

谢谢！

回复
- Jason Brownlee 2018年3月14日下午3:09 #
  
  是的，理想情况下，我们将使用前向验证来测试序列预测模型。
  https://machinelearning.org.cn/backtest-machine-learning-models-time-series-forecasting/
  
  回复
George Kibirige 2018年3月26日上午1:06 #

嗨，Jason，
感谢您的教程，非常有帮助。您是否有其他在相同领域但使用Keras中的卷积LSTM的教程？

回复
- Jason Brownlee 2018年3月26日上午10:03 #
  
  时间序列方面没有。
  
  回复
Steve A. 2018年4月16日下午9:24 #

Jason，

首先，感谢您的所有工作——没有这个网站，我不可能取得如此大的进步。

在您的帮助下，我已经运行了MLP、LSTM和双向LSTM。然而，我的LSTM都是单时间步长的，现在我想解决的是多时间步长的问题。

我一直在查看每个阶段的代码，看您如何构建数据，您让我很困惑。简而言之，在我看来，时间序列的顺序是错误的。

（借用上面Chris的帖子）

前6行
0 -120.1
1 37.2
2 -63.8
3 61.0
4 -11.8
5 63.3

监督后的前6行
0 0 0
0 NaN NaN -120.1
1 -120.1 NaN 37.2
2 37.2 -120.1 -63.8
3 -63.8 37.2 61.0
4 61.0 -63.8 -11.8
5 -11.8 61.0 63.3

然后删除NaN
[[ 37.2 -120.1 -63.8]
[ -63.8 37.2 61. ]
[ 61. -63.8 -11.8]
[ -11.8 61. 63.3]
[ 63.3 -11.8 -7.3]
[ -7.3 63.3 -31.7]
[ -31.7 -7.3 -69.9]
.....]

我的问题是，前三个时间步长的值是：-120.1, 37.2 和 -63.8，而第一个时间步长序列是：[ 37.2 -120.1 -63.8 ]，而我期望的是：[-120.1 37.2 -63.8 ]。

所有其他时间步长序列都遵循相同的模式（当然）。我是否完全误解了这一点（这当然是完全有可能的），如果是这样，应该遵循什么规则，尤其是在增加时间步长数量时？

再次感谢您提供了一个很棒的网站，并期待您的回复

此致，

Steve

回复
- Jason Brownlee 2018年4月17日上午5:58 #
  
  通常，神经网络在时间序列方面表现不佳。您可以在这里了解更多信息。
  https://machinelearning.org.cn/faq/single-faq/how-do-i-use-lstms-for-time-series-forecasting
  
  尽管如此，我有一个使用LSTM进行多步时间序列预测的例子，这可能有助于作为模板。
  https://machinelearning.org.cn/multi-step-time-series-forecasting-long-short-term-memory-networks-python/
  
  回复
Steve A. 2018年4月16日下午10:01 #

在我之前的帖子之后。如果我猜对了，而且我完全准备好接受错误……。

对timeseries_to_supervise函数的一个简单调整，将

columns = [df.shift(i) for i in range(1, lag+1)]

改为……

columns = [df.shift(i) for i in range(lag, 0, -1)]

……产生结果

[-120.1, 37.2, -63.8],
[ 37.2, -63.8, 61. ],
[ -63.8, 61. , -11.8],
[ 61. , -11.8, 63.3],
[ -11.8, 63.3, -7.3],
[ 63.3, -7.3, -31.7],

……对我来说，这似乎更合理，因为输入数据的原始顺序呈现了这些步骤。

另一个观察：这个结果是使用时间步长值为2生成的。一种更“易于理解”的方法可能是调整代码，在这种情况下，输出将使用时间步长值为3生成，但这只是我的强迫症：)

我期待您的回复，无论我是否正确——我只想学习预处理数据的正确方法，以便从我的LSTM模型中获得最佳性能。

此致，

Steve

回复
hadeer 2018年5月21日下午6:47 #

在RNN中使用时间步长（例如 N=3）有什么好处？以及 N=3 是否比使用时间步长 N=1 更好？

回复
- Jason Brownlee 2018年5月22日上午6:24 #
  
  这取决于问题。
  
  回复
aaron 2018年5月23日下午8:49 #

时间步长和展开LSTM网络有什么区别？当你看到一个展开LSTM的经典图片时，这与时间步长有关吗？

回复
- Jason Brownlee 2018年5月24日上午8:10 #
  
  您可以在这里了解更多关于展开的信息。
  https://machinelearning.org.cn/rnn-unrolling/
  
  回复
Toly 2018年6月1日上午1:57 #

您现在有什么建议？时间步长应该像n个额外特征的滞后变量一样，还是更倾向于Keras的LSTM网络的内部时间步长功能？希望我没有忽略这样的建议，但也许您可以给我一些清晰的解释。

回复
- Jason Brownlee 2018年6月1日上午8:23 #
  
  尝试两者，看看哪种最适合您的问题。
  
  另外，从MLP开始，只有当LSTM优于MLP时才使用LSTM。
  
  回复
Ansh 2018年7月18日上午6:49 #

我过去两个月一直在关注您的帖子。感谢您撰写如此出色的博客。

我只是在尝试理解滞后在LSTM模型中是如何工作的，您解释得很好。

当我阅读https://machinelearning.org.cn/multi-class-classification-tutorial-keras-deep-learning-library/帖子中您上面解释的内容时，我脑海中产生了一个问题。

如果我想为多分类时间序列问题创建滞后，并且我的预测变量中有三个类别。我需要先进行独热编码，然后在所有三个变量上创建时间滞后，还是需要先创建时间滞后，然后在预测变量上进行独热编码？

回复
- Jason Brownlee 2018年7月18日下午2:44 #
  
  在准备好滞后输入后对输出变量进行编码可能会更容易。
  
  这篇帖子可能有助于准备数据。
  https://machinelearning.org.cn/convert-time-series-supervised-learning-problem-python/
  
  回复
Nii Anyetei 2018年8月25日下午8:18 #

试图使用LSTM对时间序列数据集进行废物产生量预测。是否有有助于此的数据集，以及代码将不胜感激。

回复
- Jason Brownlee 2018年8月26日上午6:26 #
  
  我在这里列出了数据集。
  https://machinelearning.org.cn/time-series-datasets-for-machine-learning/
  
  回复
keras_tf 2018年9月17日上午2:55 #

假设我有一个包含1000行和6个特征的数据集，其中我想要进行预测。我想要找到每一行的回归值“y”。但我希望网络能够记住之前的10个观测值来做出下一个观测值。我应该如何改变数据？

[1000,1,5]
或者
[100,10,5]

回复
- Jason Brownlee 2018年9月17日上午6:31 #
  
  听起来您想要10个时间步长。第二个例子。
  
  回复
tmartin 2018年9月23日下午10:14 #

你好，Jason，

感谢那些关于LSTM的教程！

对我来说，仍然有几个地方不清楚。

以一个单变量的玩具例子来预测下一个温度，如果你决定包含滞后观测值

1.是将它们作为单个时间步长的一部分特征包含进去，还是将它们视为具有一个特征的多个时间步长？
2.对网络训练过程有什么影响？

提前感谢您的帮助！
此致

回复
- Jason Brownlee 2018年9月24日上午6:11 #
  
  LSTM可以读取多个时间步长作为输入。
  
  因此，我们可以向模型提供多个滞后观测值，并让它预测下一步。
  
  回复
Fredy 2018年10月12日上午2:41 #

嗨，Jason，
非常感谢您的这篇教程。我有一个关于滞后观测值的问题。对于序列分类的LSTM，是否可以应用滞后观测值？我的意思是，给定一个X=[X1, X2,…, Xn]输入序列，我想对当前的Xt进行分类，同时也要参考过去的观测值。

提前感谢

此致

回复
- Jason Brownlee 2018年10月12日上午6:43 #
  
  是的，滞后观测值作为时间步长输入到LSTM。
  
  回复
dy 2018年10月17日下午7:14 #

Jason您好，能否简要解释一下时间步长是什么？

回复
- Jason Brownlee 2018年10月18日上午6:26 #
  
  样本是一个序列。
  时间步长是可进行观测的点。
  特征是时间步长上的观测值。
  
  回复
Jaime 2018年10月20日下午11:22 #

您好，我最近在做一个时间序列预测系统。我想知道用于输入的“时间步长”是否可以改变为输出，例如输入10个时间步长，并优化3个时间步长的预测。
这有可能实现吗？
现在，如果我输入10个时间步长，我只能得到10个输出，我只能优化最后一个（return_sequences=False），或者优化所有（return_sequences=True）。
有没有办法只优化3个时间步长？

回复
- Jason Brownlee 2018年10月21日上午6:12 #
  
  我认为您指的是多步预测？
  
  我在这里有一些通用信息。
  https://machinelearning.org.cn/multi-step-time-series-forecasting/
  
  我有很多关于该主题的教程，例如。
  https://machinelearning.org.cn/how-to-develop-lstm-models-for-multi-step-time-series-forecasting-of-household-power-consumption/
  
  回复
Abderrahim 2018年11月16日下午9:46 #

嗨，Jason，
我非常感谢您的这篇教程，我有一个问题，我已经发布在SO上，如果您不介意的话，可以看一下，https://datascience.stackexchange.com/q/41305/33279，我的具体情况是，对于每个训练数据，在每个时间点，都有许多条目。每个都是一个学习条目，因此我无法对任何条目进行采样（分组）和求和、平均、最大或最小值。我的时间索引是根据年份和月份两列构建的，我想从其他特征以及这两列中学习。
非常感谢！

回复
- Jason Brownlee 2018年11月17日上午5:47 #
  
  也许您可以将您的问题总结为一两句话？
  
  回复
Kim 2018年11月25日下午7:13 #

你好，Jason。
您发布的LSTM帖子非常有帮助。
但是，由于无法打印模型的准确性，其可靠性值得怀疑。
数据仅在500到10000的范围内输出500到600个值。
您能否告诉我如何增加这些区域中的数据范围以及如何添加准确性的输出？

谢谢，杰森。

回复
- Jason Brownlee 2018年11月26日上午6:17 #
  
  分类准确性不适用于回归问题。相反，我们必须使用误差。
  
  我推荐阅读这篇。
  https://machinelearning.org.cn/classification-versus-regression-in-machine-learning/
  
  回复
Elton 2018年12月20日下午1:58 #

嗨，Jason，

感谢您又一篇出色的帖子，并与社区分享您的知识。

我在理解具有1个时间步长的LSTM和MLP之间的区别方面遇到了一些困难。尽管到目前为止我所读到的一切都表明它们应该具有相同的行为，但在我的实验结果中，具有1个时间步长的LSTM的性能明显优于MLP。此外，将时间步长增加到大于1的值并不能提高性能。

我正在用批量为128个样本、每个样本有126个特征来训练网络。LSTM训练的行为是否可能像时间步长等于批量大小一样？

感谢您的帮助！

回复
- Jason Brownlee 2018年12月20日下午2:03 #
  
  主要区别在于节点的内部结构以及单元在批次样本上的共享内部状态。
  
  回复
Yarong 2019年3月14日上午7:58 #

Jason您好，如果我的时间序列戳不是唯一的，该怎么办？例如，在某个特定的时间戳，我有不同的特征组合以及相应的输出。谢谢！

回复
- Jason Brownlee 2019年3月14日上午9:30 #
  
  也许可以对数据集进行归一化，这样在所有时间步长上您都有相同的特征，即使有些是0值？
  
  回复
Quentin 2019年5月24日凌晨12:28 #

嗨，Jason，

首先，非常感谢您提供如此出色的网站。尽管这是我第一次发表评论，但我已经使用过这里的许多资源很长时间了！

我有一个关于时间序列预测任务中的LSTM的问题。我的理解是，LSTM的一个优势是能够记住过去的例子，并用门控单元控制存储在内存中的内容。知道这一点，为什么我们还需要包含过去的特征，为什么我们不能只使用一个对应于我们拥有的最后一个时间步长的特征？我知道使用更大的时间步长可以提高性能，我的问题是为什么？

谢谢你

回复
- Jason Brownlee 2019年5月24日上午7:54 #
  
  时间步长定义了您提供给模型以供未来预测使用的过去。
  
  也许我不理解你的问题？
  
  回复
  - Quentin 2019年5月25日凌晨4:54 #
    
    我对LSTM和RNN如何处理数据的理解是有缺陷的，但现在我明白了为什么这是必要的。LSTM中唯一的时间概念是关于一个序列的。所有不同的序列如何组合在一起并不重要。
    
    但仍有一件事困扰着我：如果LSTM期望固定长度序列，我们如何处理可变长度序列？当然，我们可以使用填充，但我认为这更多的是一种变通方法，而不是真正的解决方案……有什么想法吗？
    
    回复
    - Jason Brownlee 2019年5月25日上午7:52 #
      
      LSTM可以动态使用，例如一次一个时间步长，但这非常慢。
      
      所以，我们将其数据矢量化为固定长度序列，使用填充，并使用掩码层来忽略填充值。
      
      回复
Guyomard 2019年6月26日下午8:29 #

你好！
我无法理解您的“timeseries_to_supervise函数”。
为什么时间步长是例如（t-1,t-2,t-3,t）而不是（t-3,t-2,t-1,t）？
我们的序列是这样的：在X中：（t-1,t-2,t-3），在y中：（t），这对我来说似乎很奇怪。
谢谢

回复
- Jason Brownlee 2019年6月27日上午7:50 #
  
  也许从这篇帖子开始。
  https://machinelearning.org.cn/convert-time-series-supervised-learning-problem-python/
  
  回复
Brunette 2019年7月3日凌晨1:54 #

嗨，Jason，
感谢您的这篇帖子，我有一个问题，我有一个用于预测能源消耗的时间序列LSTM模型，我认为我的模型很好，因为我的RMSE为0.005，但当我尝试计算R2分数时，我得到了0.44。您认为这是一个糟糕的模型，我应该更换它吗？还是应该尝试修改我的LSTM架构并调整我的模型？

回复
- Jason Brownlee 2019年7月3日上午8:37 #
  
  我建议将模型的技能与基线模型（如朴素的持续预测）进行比较。技能是相对于基线的。
  
  回复
tong 2019年8月7日上午11:36 #

当我们用训练好的LSTM模型进行测试时，测试时间步长是否需要与训练时间步长相同？

回复
- Jason Brownlee 2019年8月7日下午2:21 #
  
  不行。
  
  回复
Thiago 2019年8月20日上午5:03 #

你好，Jason。
感谢这篇帖子。
我不明白为什么要在循环中运行一个epoch 500次，而不是运行500个epoch。
如果我将循环激活函数更改为tanh（我认为默认是sigmoid），我可以运行500个epoch吗？
谢谢。

回复
- Thiago 2019年8月20日上午5:06 #
  
  当我说循环激活函数时，我指的是keras LSTM层的‘recurrent_activation’参数，它默认设置为‘hard_sigmoid’。
  谢谢。
  
  回复
- Jason Brownlee 2019年8月20日上午6:28 #
  
  它们是等效的。
  
  回复
kr_Jason 2019年12月20日上午7:53 #

我想知道为什么您在“X = X.reshape(X.shape[0], timesteps, 1)”中使用reshape。
如果您简单地为多个时间步长使用reshape，它似乎会丢失批次之间的时间依赖性，并且会破坏整个训练X数据集，因为它是有状态的学习，需要批次之间的时间依赖性……我认为，对于多个时间步长，需要使用窗口滑动来处理X，并为模型使用stateful=False。您对此怎么看？

回复
- Jason Brownlee 2019年12月20日下午1:03 #
  
  这可能有助于理解样本中时间步的性质。
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
David 2020年1月29日上午7:59 #

Jason您好。在搜索“LSTM时间序列预测输出滞后”后找到了您的网站。

我们构建数据集的方式似乎与您相同，其中输入特征和输出都有其t0输入特征以及它们的t+60值作为输入。

我们的一些模型似乎起作用了，但最近，所有的训练似乎都产生了一个滞后 t+60 的预测。这是我意思的示例输出。AI 正好在我们想要预测的事件发生 t+60 后捕捉到拐点。

数据： ______/
AI： ________/

这很常见吗？您如何指导神经网络恢复正常？

回复
- David 2020年1月29日上午8:00 #
  
  它删除了我的空格，并将我的 ascii 图形显示为它似乎工作正常……
  
  数据： ______/
  ……AI： ________/
  
  回复
  - David 2020年1月29日上午8:14 #
    
    而且，您是否在任何材料中涵盖了这个问题？
    谢谢
    
    回复
- Jason Brownlee 2020年1月29日下午1:45 #
  
  是的，这很常见，这表明模型不具备技能，请看这里
  https://machinelearning.org.cn/faq/single-faq/why-is-my-forecasted-time-series-right-behind-the-actual-time-series
  
  回复
David 2020年3月6日凌晨2:11 #

嘿 Jason，您做得太棒了，我有一个问题。
为什么我们需要在循环中运行 500 次一个 epoch，而不是 500 个 epoch。（来自 Thiago）

回复
- Jason Brownlee 2020年3月6日凌晨5:39 #
  
  谢谢。
  
  我们正在进行前向验证，以便在模型拟合后进行评估。
  
  回复
  - David 2020年3月6日下午2:34 #
    
    抱歉，我在深度学习和编程方面是新手，前向验证是如何工作的？它会提高我的模型性能吗？
    
    回复
    - Jason Brownlee 2020年3月7日凌晨7:11 #
      
      好问题，请看本教程
      https://machinelearning.org.cn/backtest-machine-learning-models-time-series-forecasting/
      
      回复
      - David 2020年3月7日下午2:14 #
        
        那么，准备数据的最佳方法是什么？
        首先
        输入输出
        1,2,3 4,5,6
        2,3,4 5,6,7
        3,4,5 6,7,8
        第二
        输入输出
        1,2,3 4,5,6
        1,2,3,4 5,6,7
        1,2,3,4,5 6,7,8
      - Jason Brownlee 2020年3月8日凌晨6:03 #
        
        可以尝试实验，看看哪种方法是合理的，或者说什么是可学习的。
      - David 2020年3月7日下午2:21 #
        
        抱歉，现在清楚了
        首先
        _输入_____输出
        __1,2,3_______4, 5,6
        __2,3,4_______5, 6,7
        __3,4,5_______6, 7,8
        第二
        _输入______输出
        __1,2,3________4,5,6
        __1,2,3,4______5,6,7
        __1,2,3,4,5____6,7,8
      - Jason Brownlee 2020年3月8日凌晨6:04 #
        
        你通常不会扩展你的输入形状，而是将其限制在一个固定的大小。
      - David 2020年3月8日上午8:09 #
        
        孩子，在此之后，我用一个有 10 个神经元的 LSTM 层和一个 3 个神经元的密集层构建了模型，这看起来正常吗？或者我应该做些改变吗？然后，我该如何拟合模型？我应该使用验证数据吗？抱歉问得这么多，正如我所说，我是编程和 R 语言的新手，所以我努力让你解释的一切都能在 R 中清晰地编码。
      - Jason Brownlee 2020年3月9日凌晨7:11 #
        
        “模型看起来好吗”取决于你的具体问题，这有助于诊断。
        https://machinelearning.org.cn/learning-curves-for-diagnosing-machine-learning-model-performance/
        
        如何提高性能——这是一个庞大的话题，你可以从这里开始
        https://machinelearning.org.cn/start-here/#better
        
        验证数据可以正常使用，但对于序列数据/时间序列数据来说，这很困难/不合理，因为你必须使用前向验证。
        https://machinelearning.org.cn/backtest-machine-learning-models-time-series-forecasting/
        
        我没有 R 语言深度学习的例子，也无法提供关于该主题的建议。
      - David 2020年3月9日下午3:53 #
        
        感谢您的所有帮助
      - Jason Brownlee 2020年3月10日凌晨5:39 #
        
        不客气。
David 2020年3月7日凌晨9:22 #

谢谢

回复
- Jason Brownlee 2020年3月8日凌晨6:00 #
  
  不客气。
  
  回复
Alaa 2020年4月29日下午1:24 #

尊敬的 Jason Brownlee 先生，
我非常喜欢您的博客，从中学习了很多。

您说您使用了类似这样的前向验证
https://machinelearning.org.cn/backtest-machine-learning-models-time-series-forecasting/

您能否澄清一下您在代码中使用了它在哪里？
谢谢你

回复
- Jason Brownlee 2020年4月29日下午1:31 #
  
  谢谢。
  
  完整代码示例的第 99 行，我们在其中遍历测试集。
  
  回复
  - Alaa 2020年4月29日下午1:36 #
    
    谢谢！
    您的博客非常有帮助！
    
    回复
Jazz 2020年6月2日下午7:58 #

你好 Jason，

我有一个问题
为什么我需要指定时间步长？LSTM 本身不就是利用前一个观测值的单元状态信息吗？

例如，如果我使用 time step = 1，LSTM 是否不使用前一个观测值的任何单元状态和隐藏状态信息？

回复
- Jason Brownlee 2020年6月3日凌晨7:59 #
  
  好问题，LSTM 期望输入以时间步长和特征的结构提供，您可以在这里了解更多信息
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
sana 2020年6月21日下午4:54 #

嗨，Jason，
感谢这篇富有洞察力的帖子。

那么，如果我们想使用滞后作为特征，因为问题的逻辑要求使用过去的特征，您会推荐使用带滞后特征的 MLP 还是带滞后特征的 LSTM？

回复
- Jason Brownlee 2020年6月22日凌晨6:11 #
  
  我建议测试一系列模型，例如线性方法、ML 方法、MLP、CNN、LSTM、混合模型，并找出最适合您特定数据集的方法。
  
  回复
ali 2020年7月11日下午10:29 #

嗨，jason
你为什么不绘制你的模型图？
我对模型感到很困惑，这是多对一还是多对多。

回复
- Jason Brownlee 2020年7月12日凌晨5:52 #
  
  你可以，调用 model.summary()
  
  回复
Venkat 2020年7月20日凌晨3:47 #

我有一个小疑问，当我有时间序列数据时，我记录了不同时间步长的不同长度的数据。例如，2020 年我有 10 条记录在不同的特征中，2010 年有 5 条记录，以此类推。因此，当我分割数据时，在新的时间步长特征中会出现较大的误差。如果我随机打乱序列并降低损失以获得更准确的预测，是否可以？

回复
- Jason Brownlee 2020年7月20日凌晨6:18 #
  
  您可以尝试使用零填充使所有输入样本的长度相同，然后使用掩码层来跳过填充的值。
  
  回复
David 2020年8月28日凌晨7:08 #

嗨 Jason，我在谈论前向验证时遇到了不同的例子，这让我产生了疑问。数据应该如何准备。
第一个例子。
______训练___________________测试
输入________输出______输入_______输出
_1,2,3__________4,5,6________4,5,6________7,8,9
_2,3,4__________5,6,7________5,6,7________8,9,10
_3,4,5__________6,7,8________6,7,8________9,10,11

第二个例子。
______训练
输入________输出
_1,2,3__________4,5,6
_2,3,4__________5,6,7
_3,4,5__________6,7,8

______测试
输入_______输出
_4,5,6_________7,8,9
_5,6,7_________8,9,10
_6,7,8_________9,10,11

回复
- Jason Brownlee 2020年8月28日上午8:00 #
  
  也许这段代码会有帮助
  https://machinelearning.org.cn/convert-time-series-supervised-learning-problem-python/
  
  回复
  - David 2020年8月28日上午11:19 #
    
    谢谢，又一次伟大的工作，但并没有完全澄清我的疑问。疑问的关键部分是关于测试或验证数据，它应该在每个窗口中吗？还是应该超出样本？或者也许这两种方式都可以称为前向验证？
    
    回复
    - Jason Brownlee 2020年8月28日下午1:40 #
      
      模型总是用样本外数据进行评估。
      
      对于时间序列，可以通过前向验证来实现这一点，该验证由训练集和测试集组成，其中测试集的每个步骤或窗口会逐渐成为训练集的一部分。没有验证数据集。
      
      也许我不明白你的问题，如果是这样，你能重新表述或详细说明一下吗？
      
      回复
      - David 2020年8月28日下午2:38 #
        
        再次感谢，这正是我想要的。那么，数据应该像第一个例子那样预处理吗？
David 2020年8月28日下午3:02 #

我重新读了一遍，发现问题不够清楚？抱歉。我将尝试更好地解释自己。
当我构建模型时，在实际应用之前，我应该如何测试其有效性？
示例
首先
训练一个窗口并用连续的窗口进行测试。预期的有效性应等于所有测试结果的平均值。
第二
使用一组窗口训练模型，并用连续的窗口样本进行测试。预期的有效性应等于测试结果的平均值。

回复
- Jason Brownlee 2020年8月29日凌晨7:57 #
  
  定义一个测试期，例如最后一周/月/年的数据。
  
  使用前向验证测试框架，并报告平均误差，例如 RMSE 或 MAE。窗口的大小可以是一个时间步长，或者任何最适合您的项目/数据集的大小。
  
  使用持久模型建立基线，任何比这更好的模型都具有技能。
  
  这有帮助吗？
  
  回复
  - David 2020年8月29日上午8:08 #
    
    是的，感谢您的所有精彩工作。
    
    回复
Jolomi Tosanwumi 2020年10月6日下午1:26 #

嗨 Jason，在使用 LSTM 模型对时间序列进行建模之前，我们是否一定要使其平稳化？

回复
- Jason Brownlee 2020年10月6日下午1:59 #
  
  不一定，但通常来说是个好主意（是的）。
  
  回复
Mina 2020年11月7日凌晨2:28 #

嗨，Jason，
如果我们有一个样本没有等效滞后的时间序列，我们该怎么办？两个连续样本之间的时间间隔是否相同很重要？
此致

回复
- Jason Brownlee 2020年11月7日凌晨6:30 #
  
  零填充到相同长度或截断到相同长度，更多信息请参见此处
  https://machinelearning.org.cn/data-preparation-variable-length-input-sequences-sequence-prediction/
  
  回复
  - Mina 2020年11月9日晚上7:56 #
    
    感谢您的回复。我正在使用的数据集包含罗马城市出租车 320 辆的轨迹。它有四列：“car id, time, latitude, longitude”。即使对于每辆车，两个连续样本之间的时间间隔也不相同。它从 1 秒到 20 秒不等。我阅读了上面链接中的信息，但这种填充在这里不起作用。您有什么建议吗？如果我考虑一个固定的时间戳，例如 10 秒，并去除额外的数据，您认为这是一个好主意，还是会丢失一些有用的信息？
    
    回复
    - Jason Brownlee 2020年11月10日凌晨6:40 #
      
      也许您可以使用模型将序列转换为固定大小，例如自动编码器。
      https://machinelearning.org.cn/lstm-autoencoders/
      
      回复
dk 2020年11月19日下午1:33 #

我有一个包含 1000 个样本、1 个时间步长和 1 个特征的数据集 (1000,1,1)。我看到很多讨论，它们创建子序列（通过使用某个 X 数字将一个时间步长列拆分为多个——例如：(100,10,1)）并将其用作 LSTM 自动编码器的输入，并认为 LSTM/自动编码器只能在数据具有多个时间步长时学习。但是，我仅用 1 个时间步长列就获得了良好的结果。这里正确的输入是什么？使用单变量 (1000,1,1) 输入是否错误？

回复
- Jason Brownlee 2020年11月19日下午1:42 #
  
  您必须找到最适合您特定模型和数据集的方法。
  
  回复
  - dk 2020年11月19日下午2:29 #
    
    感谢您的回复。那么，为 LSTM 自动编码器仅使用一个时间步长是否可以？它是否仍然学习时间依赖性？
    
    在这篇帖子（https://towardsdatascience.com/lstm-autoencoder-for-anomaly-detection-e1f4f2ee7ccf）中，作者使用了一个时间戳，但所有评论都与我之前的问题有关。
    
    回复
    - Jason Brownlee 2020年11月20日凌晨6:42 #
      
      如果您的模型在样本之间保持状态，则可以。
      
      我推荐这个教程
      https://machinelearning.org.cn/how-to-develop-lstm-models-for-time-series-forecasting/
      
      回复
      - dk 2020年11月20日上午9:13 #
        
        但我在您在此链接中将单变量时间步长拆分为子序列。
      - Jason Brownlee 2020年11月20日下午1:05 #
        
        是的，这被称为窗口方法，请参见此
        https://machinelearning.org.cn/time-series-forecasting-supervised-learning/
dk 2020年11月20日晚上11:28 #

那太好了！所以为了确保，如果您有 100 行（100,1）的单变量数据，您是否使用窗口方法转换它们并将张量保持为 (98,2,1)？

回复
- Jason Brownlee 2020年11月21日凌晨6:41 #
  
  那看起来是正确的，或者类似的东西。
  
  回复
Amir 2020年12月1日凌晨5:42 #

嗨，Jason，

感谢您的另一项精彩工作！

我仍然对时间步长作为滞后与时间步长=1 的滞后特征感到困惑。
为了澄清这一点，假设我有 3 个时间序列 x1、x2 和 x3 作为输入，y 作为输出。现在我想在 LSTM 模型中实现滞后。
场景 1 是我使用（样本，时间步长=滞后，特征=3）作为数据集的形状。
场景 2 是我使用滞后特征，如 x1(t-1)、x1(t-2)、x1(t-3)、x2(t-1)、x2(t-2)、x2(t-3)、x3(t-1)、x3(t-2)、x3(t-3) 作为输入，形状为（样本，时间步长=1，特征=9）。
对我来说，场景 1 更合理，因为 LSTM 的本质是记住先前输入步骤的模式来预测后续时间步长的输出。然而，场景 1 仅限于定义一个唯一的滞后值。如果我想为每个特征使用不同的滞后，例如 x1 的滞后=3，x2 的滞后=5，x3 的滞后=10，我不能使用场景 1，需要使用场景 2。然而，场景 2 就像一个带有滞后特征的 MLP 网络，并且不使用 LSTM 的模式识别能力。那么，在特征滞后不同的情况下，您会推荐什么？

提前感谢您！
此致，
Amir

回复
- Jason Brownlee 2020年12月1日凌晨6:22 #
  
  这可能很棘手，我建议阅读此
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
Lina 2021年2月16日凌晨3:42 #

您的解释不正确。
根据 API 实现，时间步长不会增加 LSTM 的能力。它只会降低可训练参数更新的频率。
这解释了为什么当时间步长较小时，精度会更高。
请在此处查看更多信息。
https://stats.stackexchange.com/questions/377091/time-steps-in-keras-lstm

回复
- Jason Brownlee 2021年2月16日凌晨6:09 #
  
  也许这会有帮助。
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
Antonio 2021年3月27日凌晨4:32 #

嗨 Jason，

很棒的博客，恭喜！

我一直在使用和研究 LSTM，现在我遇到了一个可以应用它的实际情况，但是在这里我有一个关于如何进行未来预测的疑问。

例如

1 – 我在 4 年的销售数据上训练了我的 LSTM 模型，按天、月和年分组，并对代表数量的特定字段进行了求和。

2 – 我使用了 30 个时间步长（代表 1 个月的数据）；

为了评估模型，我使用了 2020 年一年的数据，当我预测测试数据时，我需要这样做：

X_test = [] for i in range(30, 317): X_test.append(inputs[i - 30 : i, 0])
X_test = np.array(X_test) X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))

其中 inputs 是我的整个数据集（训练+测试），问题是，例如，我该如何预测 2021 年？

能否获取预测数据并再次拟合到网络？

谢谢，

安东尼奥

回复
- Jason Brownlee 2021年3月29日凌晨5:56 #
  
  我建议使用前向验证来评估您的模型，这将有助于
  https://machinelearning.org.cn/backtest-machine-learning-models-time-series-forecasting/
  
  回复
Hoon 2021年6月14日下午4:47 #

你好，

我一直对 LSTM(RNN) 的以下参数感到好奇，

有“time step”参数。
它表示您需要多少历史数据来预测未来值。
如果 time step = 50，那么 RNN 循环将是 50

我想知道 time step=50 是否意味着短期依赖，而整个数据意味着长期依赖。

回复
- Jason Brownlee 2021年6月15日凌晨6:05 #
  
  这会有帮助
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
Prerana 2021年6月26日晚上10:45 #

嗨 Jason！感谢您的教程！

我正在处理一个问题，其中我有一个特征的未来值（例如 var2）。如何实现这一点来预测 var1(t)？

注意：var2 是不可预测的（例如假期），并且 var2 与 var1 的值相关。因此需要提供 var2(t) 作为输入。

在实际问题中，我使用了 7 个时间步长和 5 个特征，其中 2 个变量的 obs(t) 是已知的。

var1(t-1) var2(t-1) var3(t-1) var2(t) var1(t)
1 50.0 0.0 23 1 51
2 51.0 1.0 24 2 52
3 52.0 2.0 25 3 53
4 53.0 3.0 26 4 54
5 54.0 4.0 27 5 55
6 55.0 5.0 28 6 56
7 56.0 6.0 29 7 57
8 57.0 7.0 30 8 58
9 58.0 8.0 31 9 59

回复
- Jason Brownlee 2021年6月27日凌晨4:38 #
  
  您对模型的输入和输出拥有完全的控制权。
  
  设计您的预测问题和模型，使其在预测时仅使用您可用的数据。
  
  回复
Prerana 2021年6月26日晚上10:50 #

抱歉，现在可读了。

|————————输入————————|—-输出—-|
—-var1(t-1) –var2(t-1) –var3(t-1) –var2(t) —–var1(t)
1 –50.0 ———-0.0 ———-23 ———-1 ———–51
2 –51.0 ———-1.0 ———-24 ———-2 ———–52
3 –52.0 ———-2.0 ———-25 ———-3 ———–53
4 –53.0 ———-3.0 ———-26 ———-4 ———–54
5 –54.0 ———-4.0 ———-27 ———-5 ———–55
6 –55.0 ———-5.0 ———-28 ———-6 ———–56
7 –56.0 ———-6.0 ———-29 ———-7 ———–57
8 –57.0 ———-7.0 ———-30 ———-8 ———–58
9 –58.0 ———-8.0 ———-31 ———-9 ———–59

回复
Hakan 2021年10月20日上午6:46 #

你好，Jason！

在我阅读本页关于 LSTM 的内容时，我遇到了以下解释（https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input），但有些地方对我来说仍然不是 100% 清楚。
我对于只有一个时间步的 LSTM 和 MLP 之间的区别感到很困惑。它们之间有什么不同？只有一个时间步的 LSTM 能够学习样本之间的时间相关性吗？如果我们用这个 LSTM 模型对 100 个连续样本进行预测，它会更好地预测最后的测试样本吗，它会获得有意义的隐藏状态来改进下一个样本的预测吗？或者它会和我们分别预测每个时间步的情况一样（这实际上是 MLP 的预测行为）？

非常感谢您提供富有启发性的解答。

谢谢，
Hakan

回复
- Adrian Tam 2021年10月20日上午10:38 #
  
  当只有一个时间步时，网络中没有时间相关性。因此 LSTM 无法学习它。然而，MLP 和 LSTM 的不同之处在于 LSTM 有隐藏状态 H 和内部单元 C，所以它比 MLP 复杂得多。但如果只有一个时间步，你可能没有充分利用 LSTM。
  
  回复
  - Paolo 2023年12月18日晚上9:20 #
    
    你好 Adrian，
    感谢您的精彩解释（也感谢 Jason 的精彩帖子，其结果令我非常惊讶）。
    我的理解是，对于使用的数据集，如果我们只设置一个时间步（并像 Jason 在代码中那样，使用单个样本批次在每个 epoch 重置模型），那么在“从过去学习”方面，MLP 和 LSTM 之间没有任何区别，模型之间唯一的区别在于它们的结构（即有多少权重，权重如何连接，LSTM 的结构更复杂，等等）。
    你说“如果只有一个时间步，你可能没有充分利用 LSTM”，但 Jason 的实验表明，对于洗发水数据集，以及选择的“好坏”指标（RMSE），增加时间步长超过 1 没有意义。因此，使用 LSTM 没有意义，而 MLP 的正确超参数选择可能会提供可比的结果。
    我的推理是正确的吗？
    非常感谢，再次恭喜您的精彩工作。
    
    回复
Hakan 2021年10月28日晚上7:56 #

感谢您的回复！

但是如果我们有多个神经元（“单元”）和一个时间步呢？例如，层“LSTM(32, input_shape=(num_timesteps=1, num_features=10))”。当我们只输入 1 个时间步的数据时， 32 个隐藏单元能带来什么样的优势？更多的单元是否能从时间相关的角度提高模型性能，即使我们有多个时间步，或者它是否会影响学习时间相关性的能力？

回复
- Adrian Tam 2021年10月29日凌晨2:00 #
  
  每个 LSTM 单元都是一个对输入的矩阵乘法。从宏观上看，你可以认为它试图从输入中提取一个特定的特征。因此，更多的单元意味着你试图寻找更多的信息，并基于这些大量信息做出预测。
  
  回复
saad 2021年11月22日晚上11:31 #

你好，我一直在做一个项目，它有些相似但更复杂，我不是预测洗发水销量，而是试图预测客户下个月的花费。我已经将数据准备成样本（每个客户的 CSV 文件包含发票日期和当天的总花费）。我的第一个想法是使用 LSTM，现在仍然是，但我仍然在想，一个 LSTM 如何能处理数千个客户？您有什么有用的想法吗？不过还是谢谢您，您的文章在我数据科学的整个旅程中都在指导我：)

回复
- Adrian Tam 2021年11月23日晚上1:36 #
  
  一个 LSTM 可能不够——这取决于数据的性质。但如果客户行为同质，那么你的预测就会相当准确。
  
  回复
Syed Hasnat 2022年9月5日下午3:05 #

嗨，Jason
如果增加回溯/时间步长不影响损失，我能得出什么结论？
我的数据是每小时负荷数据，我尝试了不同的回溯长度，从 3、6、12、24、48、72、120、144、168，但 MAPE 都在 2% 到 3% 之间。

回复
- James Carmichael 2022年9月6日上午7:22 #
  
  嗨 Syed…您可能会发现以下内容很有趣
  
  https://machinelearning.org.cn/get-the-most-out-of-lstms/
  
  回复

导航

如何在用于时间序列预测的 LSTM 网络中使用时间步长

教程概述

环境

时间序列深度学习需要帮助吗？

洗发水销售数据集

实验测试框架

数据分割

模型评估

数据准备

LSTM 模型

实验运行

时间步长实验

时间步长和神经元实验

扩展

总结

立即开发时间序列深度学习模型！

在几分钟内开发您自己的预测模型

最终将深度学习应用于您的时间序列预测项目

关于此主题的更多信息

165 条对“如何在 LSTM 网络中使用时间步进行时间序列预测”的回复

留下回复点击此处取消回复。

导航

教程概述

环境

时间序列深度学习需要帮助吗？

洗发水销售数据集

实验测试框架

数据分割

模型评估

数据准备

LSTM 模型

实验运行

时间步长实验

时间步长和神经元实验

扩展

总结

立即开发时间序列深度学习模型！

在几分钟内开发您自己的预测模型

最终将深度学习应用于您的时间序列预测项目

关于此主题的更多信息

165 条对“如何在 LSTM 网络中使用时间步进行时间序列预测”的回复

留下回复 点击此处取消回复。

留下回复点击此处取消回复。