用于人类活动识别时间序列分类的长短期记忆神经网络

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

人类活动识别是指将由专用安全带或智能手机记录的加速度计数据序列分类为已知的、定义明确的运动的问题。

该问题的经典方法是基于固定大小的窗口从时间序列数据中手工提取特征，并训练机器学习模型，例如决策树的集成。难点在于这种特征工程需要该领域的深厚专业知识。

最近，诸如长短期记忆（LSTM）之类的循环神经网络（RNN）以及利用一维卷积神经网络（CNN）的变体，已被证明在具有很少或没有数据特征工程的具有挑战性的活动识别任务上能提供最先进的结果，而是利用原始数据进行特征学习。

在本教程中，您将发现三种用于对活动识别时间序列分类问题进行建模的循环神经网络架构。

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

如何为人类活动识别开发长短期记忆循环神经网络。
如何开发一维卷积神经网络LSTM，或称为CNN-LSTM模型。
如何为相同的问题开发一维卷积LSTM，或称为ConvLSTM模型。

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

让我们开始吧。

How to Develop RNN Models for Human Activity Recognition Time Series Classification

如何为人类活动识别时间序列分类开发RNN模型
照片作者：Bonnie Moreland，部分权利保留。

教程概述

本教程分为四个部分；它们是

使用智能手机数据集进行活动识别
开发LSTM网络模型
开发CNN-LSTM网络模型
开发ConvLSTM网络模型

使用智能手机数据集进行活动识别

人类活动识别，简称HAR，是根据传感器记录的人体运动轨迹预测其正在做什么的问题。

一个标准的人类活动识别数据集是2012年发布的“使用智能手机进行人类活动识别数据集”。

该数据集由意大利热那亚大学的Davide Anguita等人准备并提供，并在他们2013年的论文“用于利用智能手机进行人类活动识别的公共领域数据集”中得到了充分描述。该数据集是在题为“使用多类硬件友好型支持向量机在智能手机上进行人类活动识别”的2012年论文中用机器学习算法建模的。

该数据集已发布，可从UCI机器学习库免费下载

使用智能手机数据集进行人类活动识别，UCI 机器学习存储库

该数据收集了30名年龄在19至48岁之间的受试者，他们在穿着系在腰部的智能手机并记录运动数据的情况下执行六种标准活动。记录了每个受试者执行活动的视频，并根据这些视频手动标记了运动数据。

下面是受试者执行活动并记录运动数据的示例视频。

执行的六项活动如下：

步行
上楼梯
下楼梯
坐着
站立
躺着

记录的运动数据是智能手机（特别是三星Galaxy S II）的x、y和z加速度计数据（线性加速度）和陀螺仪数据（角速度）。观测值以50 Hz（即每秒50个数据点）记录。每位受试者执行两次活动序列；一次设备佩戴在左侧，一次设备佩戴在右侧。

无法获取原始数据。而是提供了一个预处理版本的数据集。预处理步骤包括

使用噪声滤波器预处理加速度计和陀螺仪。
将数据划分为2.56秒（128个数据点）的固定窗口，重叠率为50%。将加速度计数据划分为重力（总）和身体运动分量。

对窗口数据应用特征工程，并提供了一份包含这些工程特征的数据副本。

从每个窗口中提取了人类活动识别领域常用的时间和频率特征。结果是生成了一个包含561个元素的特征向量。

数据集根据受试者的数据分为训练集（70%）和测试集（30%），例如21名受试者用于训练，9名受试者用于测试。

与针对智能手机使用的支持向量机（例如固定点算术）的实验结果相比，在测试数据集上实现了89%的预测准确率，与未修改的SVM实现的性能相似。

该数据集可免费从UCI机器学习库下载。

数据以一个大小约为58兆字节的zip文件提供。直接下载链接如下：

UCI HAR Dataset.zip

下载数据集，并将所有文件解压缩到当前工作目录中的一个名为“HARDataset”的新目录中。

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

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

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

开发LSTM网络模型

在本节中，我们将为人类活动识别数据集开发一个长短期记忆（LSTM）网络模型。

LSTM网络模型是一种循环神经网络，能够学习和记忆长序列的输入数据。它们旨在用于包含长序列数据（最多200至400个时间步）的数据。它们可能是解决此问题的合适选择。

该模型可以支持多个并行输入的序列数据，例如加速度计和陀螺仪数据的每个轴。模型学习从观测序列中提取特征以及如何将内部特征映射到不同的活动类型。

使用LSTM进行序列分类的好处在于，它们可以直接从原始时间序列数据中学习，因此不需要领域专业知识来手动工程化输入特征。该模型可以学习时间序列数据的内部表示，并有望在拟合了经过工程化特征的数据集版本上的模型方面取得可比的性能。

本节分为四个部分；它们是

加载数据
拟合和评估模型
总结结果
完整示例

加载数据

第一步是将原始数据集加载到内存中。

原始数据中有三种主要的信号类型：总加速度、身体加速度和身体陀螺仪。每种都有3个数据轴。这意味着每个时间步总共有九个变量。

此外，每个数据系列都已划分为重叠窗口，窗口包含2.56秒的数据，或128个时间步。这些数据窗口对应于上一节中手工工程化特征的窗口（行）。

这意味着一行数据包含（128 * 9），或1,152个元素。这比上一节中的561个元素向量的大小略少于两倍，并且可能存在一些冗余数据。

信号存储在train和test子目录下的/Inertial Signals/目录中。每个信号的每个轴都存储在一个单独的文件中，这意味着每个train和test数据集都有九个输入文件需要加载，一个输出文件需要加载。由于目录结构和文件命名约定的一致性，我们可以将这些文件的加载批量处理。

输入数据是CSV格式，列由空格分隔。这些文件都可以加载为NumPy数组。下面的load_file()函数加载给定文件路径的数据集，并返回加载的数据作为NumPy数组。

# load a single file as a numpy array
def load_file(filepath):
	dataframe = read_csv(filepath, header=None, delim_whitespace=True)
	return dataframe.values

# 将单个文件加载为numpy数组

def load_file(filepath):

dataframe = read_csv(filepath, header=None, delim_whitespace=True)

return dataframe.values

然后，我们可以将给定组（train或test）的所有数据加载到一个单一的三维NumPy数组中，该数组的维度为[样本数，时间步数，特征数]。

为了更清楚地说明，有128个时间步和九个特征，其中样本数是任何给定原始信号数据文件中的行数。

下面的load_group()函数实现了此功能。 dstack() NumPy函数允许我们将每个加载的3D数组堆叠成一个单一的3D数组，其中变量在第三个维度（特征）上分开。

# load a list of files into a 3D array of [samples, timesteps, features]
def load_group(filenames, prefix=''):
	loaded = list()
	for name in filenames:
		data = load_file(prefix + name)
		loaded.append(data)
	# stack group so that features are the 3rd dimension
	loaded = dstack(loaded)
	return loaded

#将一组文件加载到三维数组[样本数、时间步长、特征数]中

def load_group(filenames, prefix=''):

loaded = list()

for name in filenames:

data = load_file(prefix + name)

loaded.append(data)

# 堆叠组，使特征成为第三维度

loaded = dstack(loaded)

return loaded

我们可以使用此函数加载给定组的所有输入信号数据，例如train或test。

下面的load_dataset_group()函数使用目录之间一致的命名约定，加载单个组的所有输入信号数据和输出数据。

# load a dataset group, such as train or test
def load_dataset_group(group, prefix=''):
	filepath = prefix + group + '/Inertial Signals/'
	# load all 9 files as a single array
	filenames = list()
	# total acceleration
	filenames += ['total_acc_x_'+group+'.txt', 'total_acc_y_'+group+'.txt', 'total_acc_z_'+group+'.txt']
	# body acceleration
	filenames += ['body_acc_x_'+group+'.txt', 'body_acc_y_'+group+'.txt', 'body_acc_z_'+group+'.txt']
	# body gyroscope
	filenames += ['body_gyro_x_'+group+'.txt', 'body_gyro_y_'+group+'.txt', 'body_gyro_z_'+group+'.txt']
	# load input data
	X = load_group(filenames, filepath)
	# load class output
	y = load_file(prefix + group + '/y_'+group+'.txt')
	return X, y

# 加载数据集组，例如训练集或测试集

def load_dataset_group(group, prefix=''):

filepath = prefix + group + '/Inertial Signals/'

# 将所有9个文件加载为单个数组

filenames = list()

# 总加速度

filenames += ['total_acc_x_'+group+'.txt', 'total_acc_y_'+group+'.txt', 'total_acc_z_'+group+'.txt']

# 身体加速度

filenames += ['body_acc_x_'+group+'.txt', 'body_acc_y_'+group+'.txt', 'body_acc_z_'+group+'.txt']

# 身体陀螺仪

filenames += ['body_gyro_x_'+group+'.txt', 'body_gyro_y_'+group+'.txt', 'body_gyro_z_'+group+'.txt']

# 加载输入数据

X = load_group(filenames, filepath)

# 加载类别输出

y = load_file(prefix + group + '/y_'+group+'.txt')

return X, y

最后，我们可以加载每个train和test数据集。

输出数据被定义为类别的整数。我们必须对这些类整数进行独热编码，以便数据适合拟合神经网络多类分类模型。我们可以通过调用to_categorical() Keras函数来实现这一点。

下面的load_dataset()函数实现了此功能，并返回训练和测试的X和y元素，这些元素已准备好进行拟合和评估定义的模型。

# load the dataset, returns train and test X and y elements
def load_dataset(prefix=''):
	# load all train
	trainX, trainy = load_dataset_group('train', prefix + 'HARDataset/')
	print(trainX.shape, trainy.shape)
	# load all test
	testX, testy = load_dataset_group('test', prefix + 'HARDataset/')
	print(testX.shape, testy.shape)
	# zero-offset class values
	trainy = trainy - 1
	testy = testy - 1
	# one hot encode y
	trainy = to_categorical(trainy)
	testy = to_categorical(testy)
	print(trainX.shape, trainy.shape, testX.shape, testy.shape)
	return trainX, trainy, testX, testy

#加载数据集，返回train和test的X和y元素

def load_dataset(prefix=''):

# 加载所有训练数据

trainX, trainy = load_dataset_group('train', prefix + 'HARDataset/')

print(trainX.shape, trainy.shape)

# 加载所有测试数据

testX, testy = load_dataset_group('test', prefix + 'HARDataset/')

print(testX.shape, testy.shape)

# 零偏移类别值

trainy = trainy - 1

testy = testy - 1

# 独热编码y

trainy = to_categorical(trainy)

testy = to_categorical(testy)

print(trainX.shape, trainy.shape, testX.shape, testy.shape)

return trainX, trainy, testX, testy

拟合和评估模型

现在我们已将数据加载到内存中，为建模做好了准备，我们可以定义、拟合和评估LSTM模型。

我们可以定义一个名为evaluate_model()的函数，该函数接受训练和测试数据集，在训练数据集上拟合模型，在测试数据集上进行评估，并返回模型性能的估计值。

首先，我们必须使用Keras深度学习库定义LSTM模型。该模型需要一个三维输入，格式为[样本数，时间步数，特征数]。

这正是我们加载数据的方式，其中一个样本是时间序列数据的一个窗口，每个窗口有128个时间步，而一个时间步有九个变量或特征。

模型的输出将是一个六个元素的向量，包含给定窗口属于六种活动类型之一的概率。

在拟合模型时需要这些输入和输出维度，我们可以从提供的训练数据集中提取它们。

n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]

1	n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]

模型被定义为一个简单的Sequential Keras模型。

我们将模型定义为一个具有单个LSTM隐藏层。之后是一个用于减少模型对训练数据过拟合的dropout层。最后，使用一个全连接的dense层来解释LSTM隐藏层提取的特征，然后使用一个最终的输出层进行预测。

我们将使用随机梯度下降的有效Adam版本来优化网络，并使用分类交叉熵损失函数，因为我们正在学习一个多类分类问题。

模型的定义如下所示。

model = Sequential()
model.add(LSTM(100, input_shape=(n_timesteps,n_features)))
model.add(Dropout(0.5))
model.add(Dense(100, activation='relu'))
model.add(Dense(n_outputs, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

model = Sequential()

model.add(LSTM(100, input_shape=(n_timesteps,n_features)))

model.add(Dropout(0.5))

model.add(Dense(100, activation='relu'))

model.add(Dense(n_outputs, activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

模型将训练15个时期，并且每次将使用64个样本的批次大小，即模型权重更新之前，将向模型暴露64个数据窗口。

模型训练完成后，将在测试数据集上进行评估，并返回拟合模型在测试数据集上的准确率。

注意：在拟合LSTM时，通常不对序列数据进行混洗。这里我们确实在训练期间混洗输入数据的窗口（默认设置）。在此问题中，我们有兴趣利用LSTM在窗口内的时间步之间进行学习和提取特征的能力，而不是在窗口之间。

完整的 evaluate_model() 函数如下所示。

# fit and evaluate a model
def evaluate_model(trainX, trainy, testX, testy):
	verbose, epochs, batch_size = 0, 15, 64
	n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]
	model = Sequential()
	model.add(LSTM(100, input_shape=(n_timesteps,n_features)))
	model.add(Dropout(0.5))
	model.add(Dense(100, activation='relu'))
	model.add(Dense(n_outputs, activation='softmax'))
	model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
	# fit network
	model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)
	# evaluate model
	_, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)
	return accuracy

# 拟合和评估模型

def evaluate_model(trainX, trainy, testX, testy):

verbose, epochs, batch_size = 0, 15, 64

n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]

model = Sequential()

model.add(LSTM(100, input_shape=(n_timesteps,n_features)))

model.add(Dropout(0.5))

model.add(Dense(100, activation='relu'))

model.add(Dense(n_outputs, activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# 拟合网络

model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)

# 评估模型

_, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)

return accuracy

网络结构或超参数的选择没有什么特别之处，它们只是针对此问题的一个起点。

总结结果

我们无法通过单次评估来判断模型的技能。

这样做的原因是神经网络是随机的，这意味着当在相同数据上训练相同的模型配置时，会产生一个不同的特定模型。

这是网络的一个特性，它赋予了模型适应能力，但需要一种稍微复杂一点的模型评估方式。

我们将重复评估模型多次，然后总结模型在每次运行中的性能。例如，我们可以调用evaluate_model()总共10次。这将产生一个必须被汇总的模型评估分数种群。

# repeat experiment
scores = list()
for r in range(repeats):
	score = evaluate_model(trainX, trainy, testX, testy)
	score = score * 100.0
	print('>#%d: %.3f' % (r+1, score))
	scores.append(score)

# 重复实验

scores = list()

for r in range(repeats):

score = evaluate_model(trainX, trainy, testX, testy)

score = score * 100.0

print('>#%d: %.3f' % (r+1, score))

scores.append(score)

我们可以通过计算和报告性能的平均值和标准差来总结分数样本。平均值给出模型在数据集上的平均准确率，而标准差给出准确率相对于平均值的平均方差。

下面的summarize_results()函数总结了运行结果。

# summarize scores
def summarize_results(scores):
	print(scores)
	m, s = mean(scores), std(scores)
	print('Accuracy: %.3f%% (+/-%.3f)' % (m, s))

# 总结得分

def summarize_results(scores):

print(scores)

m, s = mean(scores), std(scores)

print('Accuracy: %.3f%% (+/-%.3f)' % (m, s))

我们可以将重复评估、收集结果和总结结果打包到一个名为run_experiment()的实验主函数中，如下所示。

默认情况下，模型将评估10次，然后报告模型的性能。

# run an experiment
def run_experiment(repeats=10):
	# load data
	trainX, trainy, testX, testy = load_dataset()
	# repeat experiment
	scores = list()
	for r in range(repeats):
		score = evaluate_model(trainX, trainy, testX, testy)
		score = score * 100.0
		print('>#%d: %.3f' % (r+1, score))
		scores.append(score)
	# summarize results
	summarize_results(scores)

# 运行一个实验

def run_experiment(repeats=10):

# 加载数据

trainX, trainy, testX, testy = load_dataset()

# 重复实验

scores = list()

for r in range(repeats):

score = evaluate_model(trainX, trainy, testX, testy)

score = score * 100.0

print('>#%d: %.3f' % (r+1, score))

scores.append(score)

# 总结结果

summarize_results(scores)

完整示例

现在我们有了所有组件，我们可以将它们整合到一个工作示例中。

完整的代码列表如下。

# lstm model
from numpy import mean
from numpy import std
from numpy import dstack
from pandas import read_csv
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Flatten
from keras.layers import Dropout
from keras.layers import LSTM
from keras.utils import to_categorical
from matplotlib import pyplot

# load a single file as a numpy array
def load_file(filepath):
	dataframe = read_csv(filepath, header=None, delim_whitespace=True)
	return dataframe.values

# load a list of files and return as a 3d numpy array
def load_group(filenames, prefix=''):
	loaded = list()
	for name in filenames:
		data = load_file(prefix + name)
		loaded.append(data)
	# stack group so that features are the 3rd dimension
	loaded = dstack(loaded)
	return loaded

# load a dataset group, such as train or test
def load_dataset_group(group, prefix=''):
	filepath = prefix + group + '/Inertial Signals/'
	# load all 9 files as a single array
	filenames = list()
	# total acceleration
	filenames += ['total_acc_x_'+group+'.txt', 'total_acc_y_'+group+'.txt', 'total_acc_z_'+group+'.txt']
	# body acceleration
	filenames += ['body_acc_x_'+group+'.txt', 'body_acc_y_'+group+'.txt', 'body_acc_z_'+group+'.txt']
	# body gyroscope
	filenames += ['body_gyro_x_'+group+'.txt', 'body_gyro_y_'+group+'.txt', 'body_gyro_z_'+group+'.txt']
	# load input data
	X = load_group(filenames, filepath)
	# load class output
	y = load_file(prefix + group + '/y_'+group+'.txt')
	return X, y

# load the dataset, returns train and test X and y elements
def load_dataset(prefix=''):
	# load all train
	trainX, trainy = load_dataset_group('train', prefix + 'HARDataset/')
	print(trainX.shape, trainy.shape)
	# load all test
	testX, testy = load_dataset_group('test', prefix + 'HARDataset/')
	print(testX.shape, testy.shape)
	# zero-offset class values
	trainy = trainy - 1
	testy = testy - 1
	# one hot encode y
	trainy = to_categorical(trainy)
	testy = to_categorical(testy)
	print(trainX.shape, trainy.shape, testX.shape, testy.shape)
	return trainX, trainy, testX, testy

# fit and evaluate a model
def evaluate_model(trainX, trainy, testX, testy):
	verbose, epochs, batch_size = 0, 15, 64
	n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]
	model = Sequential()
	model.add(LSTM(100, input_shape=(n_timesteps,n_features)))
	model.add(Dropout(0.5))
	model.add(Dense(100, activation='relu'))
	model.add(Dense(n_outputs, activation='softmax'))
	model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
	# fit network
	model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)
	# evaluate model
	_, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)
	return accuracy

# summarize scores
def summarize_results(scores):
	print(scores)
	m, s = mean(scores), std(scores)
	print('Accuracy: %.3f%% (+/-%.3f)' % (m, s))

# run an experiment
def run_experiment(repeats=10):
	# load data
	trainX, trainy, testX, testy = load_dataset()
	# repeat experiment
	scores = list()
	for r in range(repeats):
		score = evaluate_model(trainX, trainy, testX, testy)
		score = score * 100.0
		print('>#%d: %.3f' % (r+1, score))
		scores.append(score)
	# summarize results
	summarize_results(scores)

# run the experiment
run_experiment()

100

# lstm 模型

from numpy import mean

from numpy import std

from numpy import dstack

from pandas import read_csv

from keras.models import Sequential

from keras.layers import Dense

from keras.layers import Flatten

从 keras.layers 导入 Dropout

从 keras.layers 导入 LSTM

from keras.utils import to_categorical

from matplotlib import pyplot

# 将单个文件加载为numpy数组

def load_file(filepath):

dataframe = read_csv(filepath, header=None, delim_whitespace=True)

return dataframe.values

# 加载文件列表并以3d numpy数组的形式返回

def load_group(filenames, prefix=''):

loaded = list()

for name in filenames:

data = load_file(prefix + name)

loaded.append(data)

# 堆叠组，使特征成为第三维度

loaded = dstack(loaded)

return loaded

# 加载数据集组，例如训练集或测试集

def load_dataset_group(group, prefix=''):

filepath = prefix + group + '/Inertial Signals/'

# 将所有9个文件加载为单个数组

filenames = list()

# 总加速度

filenames += ['total_acc_x_'+group+'.txt', 'total_acc_y_'+group+'.txt', 'total_acc_z_'+group+'.txt']

# 身体加速度

filenames += ['body_acc_x_'+group+'.txt', 'body_acc_y_'+group+'.txt', 'body_acc_z_'+group+'.txt']

# 身体陀螺仪

filenames += ['body_gyro_x_'+group+'.txt', 'body_gyro_y_'+group+'.txt', 'body_gyro_z_'+group+'.txt']

# 加载输入数据

X = load_group(filenames, filepath)

# 加载类别输出

y = load_file(prefix + group + '/y_'+group+'.txt')

返回 X, y

#加载数据集，返回train和test的X和y元素

def load_dataset(prefix=''):

# 加载所有训练数据

trainX, trainy = load_dataset_group('train', prefix + 'HARDataset/')

print(trainX.shape, trainy.shape)

# 加载所有测试数据

testX, testy = load_dataset_group('test', prefix + 'HARDataset/')

print(testX.shape, testy.shape)

# 零偏移类别值

trainy = trainy - 1

testy = testy - 1

# 独热编码y

trainy = to_categorical(trainy)

testy = to_categorical(testy)

print(trainX.shape, trainy.shape, testX.shape, testy.shape)

return trainX, trainy, testX, testy

# 拟合和评估模型

def evaluate_model(trainX, trainy, testX, testy):

verbose, epochs, batch_size = 0, 15, 64

n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]

model = Sequential()

model.add(LSTM(100, input_shape=(n_timesteps,n_features)))

model.add(Dropout(0.5))

model.add(Dense(100, activation='relu'))

model.add(Dense(n_outputs, activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# 拟合网络

model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)

# 评估模型

_, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)

return accuracy

# 总结得分

def summarize_results(scores):

print(scores)

m, s = mean(scores), std(scores)

print('Accuracy: %.3f%% (+/-%.3f)' % (m, s))

# 运行一个实验

def run_experiment(repeats=10):

# 加载数据

trainX, trainy, testX, testy = load_dataset()

# 重复实验

scores = list()

for r in range(repeats):

score = evaluate_model(trainX, trainy, testX, testy)

score = score * 100.0

print('>#%d: %.3f' % (r+1, score))

scores.append(score)

# 总结结果

summarize_results(scores)

# 运行实验

run_experiment()

运行示例首先打印加载的数据集的形状，然后打印训练和测试集的形状以及输入和输出元素。这确认了样本数、时间步数和变量数，以及类别数。

接下来，创建并评估模型，并为每个模型打印调试消息。

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

最后，打印分数的样本，然后是平均值和标准差。我们可以看到模型表现良好，在原始数据集上训练，准确率约为89.7%，标准差约为1.3。

考虑到原始论文在经过大量领域特定特征工程的数据集上训练的模型结果为89%，而这个结果是在原始数据集上获得的，这是一个不错的结果。

(7352, 128, 9) (7352, 1)
(2947, 128, 9) (2947, 1)
(7352, 128, 9) (7352, 6) (2947, 128, 9) (2947, 6)

>#1: 90.058
>#2: 85.918
>#3: 90.974
>#4: 89.515
>#5: 90.159
>#6: 91.110
>#7: 89.718
>#8: 90.295
>#9: 89.447
>#10: 90.024

[90.05768578215134, 85.91788259246692, 90.97387173396675, 89.51476077366813, 90.15948422124194, 91.10960298608755, 89.71835765184933, 90.29521547336275, 89.44689514760775, 90.02375296912113]

Accuracy: 89.722% (+/-1.371)

(7352, 128, 9) (7352, 1)

(2947, 128, 9) (2947, 1)

(7352, 128, 9) (7352, 6) (2947, 128, 9) (2947, 6)

>#1: 90.058

>#2: 85.918

>#3: 90.974

>#4: 89.515

>#5: 90.159

>#6: 91.110

>#7: 89.718

>#8: 90.295

>#9: 89.447

>#10: 90.024

[90.05768578215134, 85.91788259246692, 90.97387173396675, 89.51476077366813, 90.15948422124194, 91.10960298608755, 89.71835765184933, 90.29521547336275, 89.44689514760775, 90.02375296912113]

准确率：89.722% (+/-1.371)

现在我们已经看到了如何为时间序列分类开发LSTM模型，接下来我们将研究如何开发一个更复杂的CNN LSTM模型。

开发CNN-LSTM网络模型

CNN LSTM架构包括使用卷积神经网络（CNN）层来提取输入数据的特征，并结合LSTM来支持序列预测。

CNN LSTM是为视觉时间序列预测问题以及从图像序列（例如视频）生成文本描述的应用而开发的。具体来说，是以下问题：

活动识别：为图像序列中演示的活动生成文本描述。
图像描述：为单个图像生成文本描述。
视频描述：为图像序列生成文本描述。

您可以在以下文章中了解有关CNN LSTM架构的更多信息

CNN 长短期记忆网络

要了解有关结合这些模型的后果的更多信息，请参阅论文

卷积、长短期记忆、全连接深度神经网络, 2015.

CNN LSTM模型将主序列的子序列作为块读入，从每个块中提取特征，然后允许LSTM解释从每个块中提取的特征。

实现此模型的一种方法是将每个128时间步的窗口分割成子序列供CNN模型处理。例如，每个窗口中的128个时间步可以分割成四个32时间步的子序列。

# reshape data into time steps of sub-sequences
n_steps, n_length = 4, 32
trainX = trainX.reshape((trainX.shape[0], n_steps, n_length, n_features))
testX = testX.reshape((testX.shape[0], n_steps, n_length, n_features))

# 将数据重塑为子序列的时间步

n_steps, n_length = 4, 32

trainX = trainX.reshape((trainX.shape[0], n_steps, n_length, n_features))

testX = testX.reshape((testX.shape[0], n_steps, n_length, n_features))

然后，我们可以定义一个CNN模型，该模型期望接收长度为32个时间步和9个特征的序列。

整个CNN模型可以包装在TimeDistributed层中，允许相同的CNN模型读取窗口中的每个子序列。然后将提取的特征展平并提供给LSTM模型读取，该模型提取自己的特征，然后最终映射到活动。

# define model
model = Sequential()
model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3, activation='relu'), input_shape=(None,n_length,n_features)))
model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3, activation='relu')))
model.add(TimeDistributed(Dropout(0.5)))
model.add(TimeDistributed(MaxPooling1D(pool_size=2)))
model.add(TimeDistributed(Flatten()))
model.add(LSTM(100))
model.add(Dropout(0.5))
model.add(Dense(100, activation='relu'))
model.add(Dense(n_outputs, activation='softmax'))

# 定义模型

model = Sequential()

model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3, activation='relu'), input_shape=(None,n_length,n_features)))

model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3, activation='relu')))

model.add(TimeDistributed(Dropout(0.5)))

model.add(TimeDistributed(MaxPooling1D(pool_size=2)))

model.add(TimeDistributed(Flatten()))

model.add(LSTM(100))

model.add(Dropout(0.5))

model.add(Dense(100, activation='relu'))

model.add(Dense(n_outputs, activation='softmax'))

通常使用两个连续的CNN层，然后是dropout和最大池化层，这在CNN LSTM模型中是简单的结构。

更新后的evaluate_model()如下所示。

# fit and evaluate a model
def evaluate_model(trainX, trainy, testX, testy):
	# define model
	verbose, epochs, batch_size = 0, 25, 64
	n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]
	# reshape data into time steps of sub-sequences
	n_steps, n_length = 4, 32
	trainX = trainX.reshape((trainX.shape[0], n_steps, n_length, n_features))
	testX = testX.reshape((testX.shape[0], n_steps, n_length, n_features))
	# define model
	model = Sequential()
	model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3, activation='relu'), input_shape=(None,n_length,n_features)))
	model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3, activation='relu')))
	model.add(TimeDistributed(Dropout(0.5)))
	model.add(TimeDistributed(MaxPooling1D(pool_size=2)))
	model.add(TimeDistributed(Flatten()))
	model.add(LSTM(100))
	model.add(Dropout(0.5))
	model.add(Dense(100, activation='relu'))
	model.add(Dense(n_outputs, activation='softmax'))
	model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
	# fit network
	model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)
	# evaluate model
	_, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)
	return accuracy

# 拟合和评估模型

def evaluate_model(trainX, trainy, testX, testy):

# 定义模型

verbose, epochs, batch_size = 0, 25, 64

n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]

# 将数据重塑为子序列的时间步

n_steps, n_length = 4, 32

trainX = trainX.reshape((trainX.shape[0], n_steps, n_length, n_features))

testX = testX.reshape((testX.shape[0], n_steps, n_length, n_features))

# 定义模型

model = Sequential()

model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3, activation='relu'), input_shape=(None,n_length,n_features)))

model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3, activation='relu')))

model.add(TimeDistributed(Dropout(0.5)))

model.add(TimeDistributed(MaxPooling1D(pool_size=2)))

model.add(TimeDistributed(Flatten()))

model.add(LSTM(100))

model.add(Dropout(0.5))

model.add(Dense(100, activation='relu'))

model.add(Dense(n_outputs, activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# 拟合网络

model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)

# 评估模型

_, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)

return accuracy

我们可以像上一节中的LSTM模型一样评估此模型。

完整的代码列表如下。

# cnn lstm model
from numpy import mean
from numpy import std
from numpy import dstack
from pandas import read_csv
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Flatten
from keras.layers import Dropout
from keras.layers import LSTM
from keras.layers import TimeDistributed
from keras.layers.convolutional import Conv1D
from keras.layers.convolutional import MaxPooling1D
from keras.utils import to_categorical
from matplotlib import pyplot

# load a single file as a numpy array
def load_file(filepath):
	dataframe = read_csv(filepath, header=None, delim_whitespace=True)
	return dataframe.values

# load a list of files and return as a 3d numpy array
def load_group(filenames, prefix=''):
	loaded = list()
	for name in filenames:
		data = load_file(prefix + name)
		loaded.append(data)
	# stack group so that features are the 3rd dimension
	loaded = dstack(loaded)
	return loaded

# load a dataset group, such as train or test
def load_dataset_group(group, prefix=''):
	filepath = prefix + group + '/Inertial Signals/'
	# load all 9 files as a single array
	filenames = list()
	# total acceleration
	filenames += ['total_acc_x_'+group+'.txt', 'total_acc_y_'+group+'.txt', 'total_acc_z_'+group+'.txt']
	# body acceleration
	filenames += ['body_acc_x_'+group+'.txt', 'body_acc_y_'+group+'.txt', 'body_acc_z_'+group+'.txt']
	# body gyroscope
	filenames += ['body_gyro_x_'+group+'.txt', 'body_gyro_y_'+group+'.txt', 'body_gyro_z_'+group+'.txt']
	# load input data
	X = load_group(filenames, filepath)
	# load class output
	y = load_file(prefix + group + '/y_'+group+'.txt')
	return X, y

# load the dataset, returns train and test X and y elements
def load_dataset(prefix=''):
	# load all train
	trainX, trainy = load_dataset_group('train', prefix + 'HARDataset/')
	print(trainX.shape, trainy.shape)
	# load all test
	testX, testy = load_dataset_group('test', prefix + 'HARDataset/')
	print(testX.shape, testy.shape)
	# zero-offset class values
	trainy = trainy - 1
	testy = testy - 1
	# one hot encode y
	trainy = to_categorical(trainy)
	testy = to_categorical(testy)
	print(trainX.shape, trainy.shape, testX.shape, testy.shape)
	return trainX, trainy, testX, testy

# fit and evaluate a model
def evaluate_model(trainX, trainy, testX, testy):
	# define model
	verbose, epochs, batch_size = 0, 25, 64
	n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]
	# reshape data into time steps of sub-sequences
	n_steps, n_length = 4, 32
	trainX = trainX.reshape((trainX.shape[0], n_steps, n_length, n_features))
	testX = testX.reshape((testX.shape[0], n_steps, n_length, n_features))
	# define model
	model = Sequential()
	model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3, activation='relu'), input_shape=(None,n_length,n_features)))
	model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3, activation='relu')))
	model.add(TimeDistributed(Dropout(0.5)))
	model.add(TimeDistributed(MaxPooling1D(pool_size=2)))
	model.add(TimeDistributed(Flatten()))
	model.add(LSTM(100))
	model.add(Dropout(0.5))
	model.add(Dense(100, activation='relu'))
	model.add(Dense(n_outputs, activation='softmax'))
	model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
	# fit network
	model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)
	# evaluate model
	_, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)
	return accuracy

# summarize scores
def summarize_results(scores):
	print(scores)
	m, s = mean(scores), std(scores)
	print('Accuracy: %.3f%% (+/-%.3f)' % (m, s))

# run an experiment
def run_experiment(repeats=10):
	# load data
	trainX, trainy, testX, testy = load_dataset()
	# repeat experiment
	scores = list()
	for r in range(repeats):
		score = evaluate_model(trainX, trainy, testX, testy)
		score = score * 100.0
		print('>#%d: %.3f' % (r+1, score))
		scores.append(score)
	# summarize results
	summarize_results(scores)

# run the experiment
run_experiment()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

# cnn lstm 模型

from numpy import mean

from numpy import std

from numpy import dstack

from pandas import read_csv

from keras.models import Sequential

from keras.layers import Dense

from keras.layers import Flatten

从 keras.layers 导入 Dropout

从 keras.layers 导入 LSTM

from keras.layers import TimeDistributed

from keras.layers.convolutional import Conv1D

from keras.layers.convolutional import MaxPooling1D

from keras.utils import to_categorical

from matplotlib import pyplot

# 将单个文件加载为numpy数组

def load_file(filepath):

dataframe = read_csv(filepath, header=None, delim_whitespace=True)

return dataframe.values

# 加载文件列表并以3d numpy数组的形式返回

def load_group(filenames, prefix=''):

loaded = list()

for name in filenames:

data = load_file(prefix + name)

loaded.append(data)

# 堆叠组，使特征成为第三维度

loaded = dstack(loaded)

return loaded

# 加载数据集组，例如训练集或测试集

def load_dataset_group(group, prefix=''):

filepath = prefix + group + '/Inertial Signals/'

# 将所有9个文件加载为单个数组

filenames = list()

# 总加速度

filenames += ['total_acc_x_'+group+'.txt', 'total_acc_y_'+group+'.txt', 'total_acc_z_'+group+'.txt']

# 身体加速度

filenames += ['body_acc_x_'+group+'.txt', 'body_acc_y_'+group+'.txt', 'body_acc_z_'+group+'.txt']

# 身体陀螺仪

filenames += ['body_gyro_x_'+group+'.txt', 'body_gyro_y_'+group+'.txt', 'body_gyro_z_'+group+'.txt']

# 加载输入数据

X = load_group(filenames, filepath)

# 加载类别输出

y = load_file(prefix + group + '/y_'+group+'.txt')

返回 X, y

#加载数据集，返回train和test的X和y元素

def load_dataset(prefix=''):

# 加载所有训练数据

trainX, trainy = load_dataset_group('train', prefix + 'HARDataset/')

print(trainX.shape, trainy.shape)

# 加载所有测试数据

testX, testy = load_dataset_group('test', prefix + 'HARDataset/')

print(testX.shape, testy.shape)

# 零偏移类别值

trainy = trainy - 1

testy = testy - 1

# 独热编码y

trainy = to_categorical(trainy)

testy = to_categorical(testy)

print(trainX.shape, trainy.shape, testX.shape, testy.shape)

return trainX, trainy, testX, testy

# 拟合和评估模型

def evaluate_model(trainX, trainy, testX, testy):

# 定义模型

verbose, epochs, batch_size = 0, 25, 64

n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]

# 将数据重塑为子序列的时间步

n_steps, n_length = 4, 32

trainX = trainX.reshape((trainX.shape[0], n_steps, n_length, n_features))

testX = testX.reshape((testX.shape[0], n_steps, n_length, n_features))

# 定义模型

model = Sequential()

model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3, activation='relu'), input_shape=(None,n_length,n_features)))

model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3, activation='relu')))

model.add(TimeDistributed(Dropout(0.5)))

model.add(TimeDistributed(MaxPooling1D(pool_size=2)))

model.add(TimeDistributed(Flatten()))

model.add(LSTM(100))

model.add(Dropout(0.5))

model.add(Dense(100, activation='relu'))

model.add(Dense(n_outputs, activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# 拟合网络

model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)

# 评估模型

_, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)

return accuracy

# 总结得分

def summarize_results(scores):

print(scores)

m, s = mean(scores), std(scores)

print('Accuracy: %.3f%% (+/-%.3f)' % (m, s))

# 运行一个实验

def run_experiment(repeats=10):

# 加载数据

trainX, trainy, testX, testy = load_dataset()

# 重复实验

scores = list()

for r in range(repeats):

score = evaluate_model(trainX, trainy, testX, testy)

score = score * 100.0

print('>#%d: %.3f' % (r+1, score))

scores.append(score)

# 总结结果

summarize_results(scores)

# 运行实验

run_experiment()

运行示例后，将打印模型每次拟合和评估的性能。在运行结束时，将显示对模型最终性能的总结。

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

我们可以看到，该模型在此问题上表现稳定，准确率约为90.6%，标准差约为1%。

>#1: 91.517
>#2: 91.042
>#3: 90.804
>#4: 92.263
>#5: 89.684
>#6: 88.666
>#7: 91.381
>#8: 90.804
>#9: 89.379
>#10: 91.347

[91.51679674244994, 91.04173736002714, 90.80420766881574, 92.26331862911435, 89.68442483881914, 88.66644044791313, 91.38106549032915, 90.80420766881574, 89.37902952154734, 91.34713267729894]

Accuracy: 90.689% (+/-1.051)

>#1: 91.517

>#2: 91.042

>#3: 90.804

>#4: 92.263

>#5: 89.684

>#6: 88.666

>#7: 91.381

>#8: 90.804

>#9: 89.379

>#10: 91.347

[91.51679674244994, 91.04173736002714, 90.80420766881574, 92.26331862911435, 89.68442483881914, 88.66644044791313, 91.38106549032915, 90.80420766881574, 89.37902952154734, 91.34713267729894]

准确率：90.689% (+/-1.051)

开发ConvLSTM网络模型

CNN LSTM概念的进一步扩展是将CNN的卷积（例如CNN如何读取输入序列数据）作为LSTM的一部分来执行。

这种组合称为卷积LSTM，或简称ConvLSTM，并且与CNN LSTM一样，也用于时空数据。

与直接读取数据以计算内部状态和状态转换的LSTM，以及解释CNN模型输出的CNN LSTM不同，ConvLSTM直接将卷积作为读取LSTM单元输入的一部分。

有关 ConvLSTM 在 LSTM 单元内如何计算的方程的更多信息，请参阅论文：

卷积 LSTM 网络：一种用于降水临近预报的机器学习方法, 2015.

Keras库提供了ConvLSTM2D类，支持2D数据的ConvLSTM模型。它可以配置为1D多元时间序列分类。

ConvLSTM2D 类默认期望输入数据的形状为

(samples, time, rows, cols, channels)

1	(样本数，时间步数，行数，列数，通道数)

其中每个时间步的数据被定义为（行数 * 列数）数据点的图像。

在上一节中，我们将给定的数据窗口（128个时间步）分成四段32个时间步的子序列。我们可以在定义ConvLSTM2D输入时使用相同的子序列方法，其中时间步数是窗口中的子序列数，行数是1（因为我们处理的是一维数据），而列数代表子序列中的时间步数，在本例中为32。

对于这个问题选择的框架，ConvLSTM2D 的输入因此将是：

样本数：n，表示数据集中窗口的数量。
时间步数：4，表示我们将128个时间步的窗口分割成的四个子序列。
行数：1，表示每个子序列的一维形状。
列数：32，表示输入子序列中的32个时间步。
通道数：9，表示九个输入变量。

现在我们可以准备 ConvLSTM2D 模型的数据了。

n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]
# reshape into subsequences (samples, time steps, rows, cols, channels)
n_steps, n_length = 4, 32
trainX = trainX.reshape((trainX.shape[0], n_steps, 1, n_length, n_features))
testX = testX.reshape((testX.shape[0], n_steps, 1, n_length, n_features))

n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]

# 重塑为子序列（样本数，时间步数，行数，列数，通道数）

n_steps, n_length = 4, 32

trainX = trainX.reshape((trainX.shape[0], n_steps, 1, n_length, n_features))

testX = testX.reshape((testX.shape[0], n_steps, 1, n_length, n_features))

ConvLSTM2D类需要配置CNN和LSTM。这包括指定过滤器数量（例如64）、二维核大小，在本例中为（1行和3列的子序列时间步），以及激活函数，在本例中为ReLU（修正线性单元）。

与CNN或LSTM模型一样，输出必须展平为单个长向量，然后才能由密集层进行解释。

# define model
model = Sequential()
model.add(ConvLSTM2D(filters=64, kernel_size=(1,3), activation='relu', input_shape=(n_steps, 1, n_length, n_features)))
model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(100, activation='relu'))
model.add(Dense(n_outputs, activation='softmax'))

# 定义模型

model = Sequential()

model.add(ConvLSTM2D(filters=64, kernel_size=(1,3), activation='relu', input_shape=(n_steps, 1, n_length, n_features)))

model.add(Dropout(0.5))

model.add(Flatten())

model.add(Dense(100, activation='relu'))

model.add(Dense(n_outputs, activation='softmax'))

我们可以像之前的LSTM和CNN LSTM模型一样评估该模型。

完整的示例如下所示。

# convlstm model
from numpy import mean
from numpy import std
from numpy import dstack
from pandas import read_csv
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Flatten
from keras.layers import Dropout
from keras.layers import LSTM
from keras.layers import TimeDistributed
from keras.layers import ConvLSTM2D
from keras.utils import to_categorical
from matplotlib import pyplot

# load a single file as a numpy array
def load_file(filepath):
	dataframe = read_csv(filepath, header=None, delim_whitespace=True)
	return dataframe.values

# load a list of files and return as a 3d numpy array
def load_group(filenames, prefix=''):
	loaded = list()
	for name in filenames:
		data = load_file(prefix + name)
		loaded.append(data)
	# stack group so that features are the 3rd dimension
	loaded = dstack(loaded)
	return loaded

# load a dataset group, such as train or test
def load_dataset_group(group, prefix=''):
	filepath = prefix + group + '/Inertial Signals/'
	# load all 9 files as a single array
	filenames = list()
	# total acceleration
	filenames += ['total_acc_x_'+group+'.txt', 'total_acc_y_'+group+'.txt', 'total_acc_z_'+group+'.txt']
	# body acceleration
	filenames += ['body_acc_x_'+group+'.txt', 'body_acc_y_'+group+'.txt', 'body_acc_z_'+group+'.txt']
	# body gyroscope
	filenames += ['body_gyro_x_'+group+'.txt', 'body_gyro_y_'+group+'.txt', 'body_gyro_z_'+group+'.txt']
	# load input data
	X = load_group(filenames, filepath)
	# load class output
	y = load_file(prefix + group + '/y_'+group+'.txt')
	return X, y

# load the dataset, returns train and test X and y elements
def load_dataset(prefix=''):
	# load all train
	trainX, trainy = load_dataset_group('train', prefix + 'HARDataset/')
	print(trainX.shape, trainy.shape)
	# load all test
	testX, testy = load_dataset_group('test', prefix + 'HARDataset/')
	print(testX.shape, testy.shape)
	# zero-offset class values
	trainy = trainy - 1
	testy = testy - 1
	# one hot encode y
	trainy = to_categorical(trainy)
	testy = to_categorical(testy)
	print(trainX.shape, trainy.shape, testX.shape, testy.shape)
	return trainX, trainy, testX, testy

# fit and evaluate a model
def evaluate_model(trainX, trainy, testX, testy):
	# define model
	verbose, epochs, batch_size = 0, 25, 64
	n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]
	# reshape into subsequences (samples, time steps, rows, cols, channels)
	n_steps, n_length = 4, 32
	trainX = trainX.reshape((trainX.shape[0], n_steps, 1, n_length, n_features))
	testX = testX.reshape((testX.shape[0], n_steps, 1, n_length, n_features))
	# define model
	model = Sequential()
	model.add(ConvLSTM2D(filters=64, kernel_size=(1,3), activation='relu', input_shape=(n_steps, 1, n_length, n_features)))
	model.add(Dropout(0.5))
	model.add(Flatten())
	model.add(Dense(100, activation='relu'))
	model.add(Dense(n_outputs, activation='softmax'))
	model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
	# fit network
	model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)
	# evaluate model
	_, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)
	return accuracy

# summarize scores
def summarize_results(scores):
	print(scores)
	m, s = mean(scores), std(scores)
	print('Accuracy: %.3f%% (+/-%.3f)' % (m, s))

# run an experiment
def run_experiment(repeats=10):
	# load data
	trainX, trainy, testX, testy = load_dataset()
	# repeat experiment
	scores = list()
	for r in range(repeats):
		score = evaluate_model(trainX, trainy, testX, testy)
		score = score * 100.0
		print('>#%d: %.3f' % (r+1, score))
		scores.append(score)
	# summarize results
	summarize_results(scores)

# run the experiment
run_experiment()

100

101

102

103

104

105

106

107

108

109

# convlstm 模型

from numpy import mean

from numpy import std

from numpy import dstack

from pandas import read_csv

from keras.models import Sequential

from keras.layers import Dense

from keras.layers import Flatten

从 keras.layers 导入 Dropout

从 keras.layers 导入 LSTM

from keras.layers import TimeDistributed

from keras.layers import ConvLSTM2D

from keras.utils import to_categorical

from matplotlib import pyplot

# 将单个文件加载为numpy数组

def load_file(filepath):

dataframe = read_csv(filepath, header=None, delim_whitespace=True)

return dataframe.values

# 加载文件列表并以3d numpy数组的形式返回

def load_group(filenames, prefix=''):

loaded = list()

for name in filenames:

data = load_file(prefix + name)

loaded.append(data)

# 堆叠组，使特征成为第三维度

loaded = dstack(loaded)

return loaded

# 加载数据集组，例如训练集或测试集

def load_dataset_group(group, prefix=''):

filepath = prefix + group + '/Inertial Signals/'

# 将所有9个文件加载为单个数组

filenames = list()

# 总加速度

filenames += ['total_acc_x_'+group+'.txt', 'total_acc_y_'+group+'.txt', 'total_acc_z_'+group+'.txt']

# 身体加速度

filenames += ['body_acc_x_'+group+'.txt', 'body_acc_y_'+group+'.txt', 'body_acc_z_'+group+'.txt']

# 身体陀螺仪

filenames += ['body_gyro_x_'+group+'.txt', 'body_gyro_y_'+group+'.txt', 'body_gyro_z_'+group+'.txt']

# 加载输入数据

X = load_group(filenames, filepath)

# 加载类别输出

y = load_file(prefix + group + '/y_'+group+'.txt')

返回 X, y

#加载数据集，返回train和test的X和y元素

def load_dataset(prefix=''):

# 加载所有训练数据

trainX, trainy = load_dataset_group('train', prefix + 'HARDataset/')

print(trainX.shape, trainy.shape)

# 加载所有测试数据

testX, testy = load_dataset_group('test', prefix + 'HARDataset/')

print(testX.shape, testy.shape)

# 零偏移类别值

trainy = trainy - 1

testy = testy - 1

# 独热编码y

trainy = to_categorical(trainy)

testy = to_categorical(testy)

print(trainX.shape, trainy.shape, testX.shape, testy.shape)

return trainX, trainy, testX, testy

# 拟合和评估模型

def evaluate_model(trainX, trainy, testX, testy):

# 定义模型

verbose, epochs, batch_size = 0, 25, 64

n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]

# 重塑为子序列（样本数，时间步数，行数，列数，通道数）

n_steps, n_length = 4, 32

trainX = trainX.reshape((trainX.shape[0], n_steps, 1, n_length, n_features))

testX = testX.reshape((testX.shape[0], n_steps, 1, n_length, n_features))

# 定义模型

model = Sequential()

model.add(ConvLSTM2D(filters=64, kernel_size=(1,3), activation='relu', input_shape=(n_steps, 1, n_length, n_features)))

model.add(Dropout(0.5))

model.add(Flatten())

model.add(Dense(100, activation='relu'))

model.add(Dense(n_outputs, activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# 拟合网络

model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)

# 评估模型

_, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)

return accuracy

# 总结得分

def summarize_results(scores):

print(scores)

m, s = mean(scores), std(scores)

print('Accuracy: %.3f%% (+/-%.3f)' % (m, s))

# 运行一个实验

def run_experiment(repeats=10):

# 加载数据

trainX, trainy, testX, testy = load_dataset()

# 重复实验

scores = list()

for r in range(repeats):

score = evaluate_model(trainX, trainy, testX, testy)

score = score * 100.0

print('>#%d: %.3f' % (r+1, score))

scores.append(score)

# 总结结果

summarize_results(scores)

# 运行实验

run_experiment()

与之前的实验一样，运行模型后，将打印每次拟合和评估的模型性能。最后将显示运行结束时模型性能的摘要。

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

我们可以看到，该模型在此问题上表现稳定，准确率约为90%，可能比大型CNN LSTM模型占用的资源更少。

>#1: 90.092
>#2: 91.619
>#3: 92.128
>#4: 90.533
>#5: 89.243
>#6: 90.940
>#7: 92.026
>#8: 91.008
>#9: 90.499
>#10: 89.922

[90.09161859518154, 91.61859518154056, 92.12758737699356, 90.53274516457415, 89.24329826942655, 90.93993892093654, 92.02578893790296, 91.00780454699695, 90.49881235154395, 89.92195453003053]

Accuracy: 90.801% (+/-0.886)

>#1: 90.092

>#2: 91.619

>#3: 92.128

>#4: 90.533

>#5: 89.243

>#6: 90.940

>#7: 92.026

>#8: 91.008

>#9: 90.499

>#10: 89.922

[90.09161859518154, 91.61859518154056, 92.12758737699356, 90.53274516457415, 89.24329826942655, 90.93993892093654, 92.02578893790296, 91.00780454699695, 90.49881235154395, 89.92195453003053]

准确率：90.801% (+/-0.886)

扩展

本节列出了一些您可能希望探索的扩展本教程的想法。

数据准备。考虑探索简单的缩放方案是否可以进一步提升模型性能，例如归一化、标准化和幂变换。
LSTM变体。LSTM架构存在一些变体，它们可能会在此问题上获得更好的性能，例如堆叠LSTM和双向LSTM。
超参数调整。考虑探索模型超参数的调整，例如单元数量、训练时期数、批次大小等。

如果您探索了这些扩展中的任何一个，我很想知道。

进一步阅读

如果您想深入了解，本节提供了更多关于该主题的资源。

论文

文章

总结

在本教程中，您发现了三种用于对活动识别时间序列分类问题进行建模的循环神经网络架构。

具体来说，你学到了：

如何为人类活动识别开发长短期记忆循环神经网络。
如何开发一维卷积神经网络LSTM，或称为CNN LSTM模型。
如何为相同的问题开发一维卷积LSTM，或称为ConvLSTM模型。

你有什么问题吗？
在下面的评论中提出你的问题，我会尽力回答。

关于此主题的更多信息

用于人类活动识别的1D卷积神经网络模型

用于人类活动识别的深度学习模型

LSTM用于人类活动识别时间序列分类的419条回复

Tin 2018年9月28日 9:20 am #

嗨，Jason，

所以请愉快地阅读您的内容，非常有帮助。既然我们可以使用CNN+LSTM来预测时空数据，我们能否反转架构为LSTM+CNN来做同样的事情？有没有LSTM + CNN的例子？

回复
- Jason Brownlee 2018年9月28日 2:59 pm #
  
  据我所知没有。您具体想用什么应用？序列到图像？
  
  回复
- fahad 2019年5月21日 1:09 am #
  
  嗨，Jason，
  我正在处理一个时间序列数据，其中包含1200个不同长度的时间序列，它们都属于4个类别之一。我的目标是使用LSTM对它们进行分类，我真的不明白如何将这些输入到LSTM模型中。你能帮帮我吗？
  
  回复
  - Jason Brownlee 2019年5月21日 6:37 am #
    
    也许使用填充和掩码层
    https://machinelearning.org.cn/data-preparation-variable-length-input-sequences-sequence-prediction/
    
    回复
Akilesh 2018年10月29日 12:40 pm #

嗨，Jason，
你能否解释一下LSTM网络的参数选择？
特别是LSTM层和密集层？
数字100代表什么？

回复
- Jason Brownlee 2018年10月29日 2:14 pm #
  
  模型是通过反复试验配置的。
  
  没有分析方法可以计算如何配置神经网络模型，更多细节请参阅此文
  https://machinelearning.org.cn/faq/single-faq/how-many-layers-and-nodes-do-i-need-in-my-neural-network
  
  回复
  - Kiran 2019年4月3日 12:33 am #
    
    Jason你好，我只是想理解一下，如果我说错了请纠正我，LSTM层中的这个100等于输入层中的100个LSTM单元吗？并且每一层LSTM都以长度为128（时间步）的序列作为输入，对吗？
    
    回复
    - Jason Brownlee 2019年4月3日 6:44 am #
      
      是的，100是指并行单元或节点的数量。它与时间步数无关。
      
      每个节点获得完整的输入序列，而不是每一层。
      
      回复
      - Kiran 2019年4月3日 6:57 pm #
        
        感谢您的澄清，我还有最后一个关于密集层的问题。密集层接收的输入是什么（是时间序列本身还是最后一个时间步）？如果密集层的节点数与LSTM的节点数不相等会怎么样（我的意思是，密集层可以有更多的节点吗）？
      - Jason Brownlee 2019年4月4日上午7:46 #
        
        LSTM 从整个输入序列创建内部表示/提取特征。
      - Jaroslaw Goslinski 2019年8月2日上午2:32 #
        
        “LSTM单元”这个术语非常具有误导性。当我们说到单元数量时，我们实际上是在谈论内部状态向量的大小（无论是隐藏状态、输入状态还是遗忘状态），所以最终它只是一个数学概念。我认为不应该称之为并行，因为一切都在同一个地方同时发生（简单的矩阵-向量乘法，由于“LSTM单元”的数量，两者都会在维度上扩展）。顺便说一句，这是一个非常好的教程
      - Jason Brownlee 2019年8月2日上午6:53 #
        
        谢谢！
        
        也许“节点”更合适？
      - Jaroslaw Goslinski 2019年8月2日下午10:04 #
        
        绝对是！
      - Jason Brownlee 2019年8月3日上午8:04 #
        
        请注意，我采用了原始LSTM论文中的“单元”命名法，并在本网站和我的书中一直使用它
        https://www.bioinf.jku.at/publications/older/2604.pdf
  - Najoua 2020年2月21日上午7:13 #
    
    Jason你好。你能解释一下LSTM方法中第一个密集层的目的吗？是因为它前面的dropout层吗？谢谢。
    
    回复
    - Jason Brownlee 2020年2月21日上午8:31 #
      
      也许是为了解释LSTM层的输出。
      
      回复
Amir 2018年10月31日下午8:13 #

感谢如此全面的教程
我尝试了一下，结果正如教程中所述。

现在，我将尝试将其用于我的数据，这些数据来自单轴加速度计。这意味着我只有一个特征，所以不需要3D数组，而是需要2D数组。
您提到“模型（RNN LSTM）需要一个三维输入，格式为[样本，时间步，特征]。这正是我们加载数据的方式。”
那么，这意味着它不能与2D数组一起工作吗？或者我可以考虑一个3D数组，但第三个维度只有一个成员？

我的第二个问题是
我需要一个用于实时分类的模型，所以需要训练一次，然后保存模型并在我的Web应用程序中使用它。
训练后如何保存模型并使用它？

回复
- Jason Brownlee 2018年11月1日上午6:05 #
  
  是的，即使第三个维度只有1个参数，它仍然是3D数组。
  
  您可以调用model.save()来保存模型。
  
  回复
Daniel Aguilera Garcia 2018年11月21日上午10:24 #

你好，Jason。

在我的案例中，我有2个来自脑电图的时间序列，我需要设计一个模型来将信号分为两类。我不太明白应该如何重塑数据。

频率是每秒256个值，所以我可以像你之前那样将它们分成窗口。问题是我不知道如何放置第三个特征维度。每个窗口有7个特征，而不是每个时刻都有（最大值、最小值、标准差、FFT带宽、FFT质心、Arima 1、Arima 2）

请问，在我的情况下，我该如何理解你说的“[样本，时间步，特征]”？

回复
- Jason Brownlee 2018年11月21日下午2:10 #
  
  也许这7个特征就是7个特征。
  
  如果您每段有256个样本，您可以选择使用多少个样本/秒作为时间步，并通过平均或删除样本来更改分辨率。
  
  回复
  - Daniel Aguilera Garcia 2018年11月21日下午9:16 #
    
    我们来看一个简单的例子
    
    通道1（一秒内的值）=2,5,6,8,54,2,8,4,7,8,…,5,7,8（总共256个值/秒）
    
    通道2（一秒内的值）=2,5,6,8,54,2,8,4,7,8,…,5,7,8（总共256个值/秒）
    
    7种不同的特征
    
    [样本,时间步,特征]=[2, 256, 7]？
    
    还有其他问题，比如平均特征
    
    通道1
    
    feat_mean[0]=2
    feat_mean[1]=(2+5)/2=3.5
    feat_mean[2]=(2+5+6)/3=4.33
    等等…
    
    这是正确的吗？我的理解是，我必须为每个时刻减去特征？
    
    回复
    - Jason Brownlee 2018年11月22日上午6:24 #
      
      是的，对于一秒钟的观测，这看起来是正确的。
      
      您可以使用Pandas来对序列进行上采样/下采样。
      https://machinelearning.org.cn/resample-interpolate-time-series-data-python/
      
      回复
coolyj 2018年11月22日下午5:21 #

“561维特征向量”在哪里适用？

回复
- Jason Brownlee 2018年11月23日上午7:44 #
  
  该向量是预处理过的数据，由研究作者准备，我们在此教程中未使用。
  
  回复
Daniel Aguilera Garcia 2018年11月26日下午8:29 #

你好Jason！

我们应该归一化每个特征吗？？

回复
- Jason Brownlee 2018年11月27日上午6:33 #
  
  可以尝试一下并评估它对模型性能的影响。
  
  回复
  - Asif Nawaz 2019年5月21日上午3:09 #
    
    Batch Normalization层起到同样的作用吗？
    
    回复
    - Jason Brownlee 2019年5月21日上午6:39 #
      
      不完全是，它用于在层之间对激活批进行归一化。
      
      回复
Leon 2018年12月3日上午7:05 #

Jason你好，感谢这篇精彩的文章。
我注意到在你加载数据的部分，你可能指的是2.56秒而不是2.65秒，因为128（时间步）* 1/50（记录采样率）= 2.56。

回复
- Jason Brownlee 2018年12月3日下午2:31 #
  
  谢谢，是的，那是一个错字。已修复。
  
  回复
Daniel Aguilera Garcia 2018年12月12日下午11:06 #

你好 Jason，

为什么Conv LSTM的kernel_size是（1,3）？我不明白。

回复
- Jason Brownlee 2018年12月13日上午7:53 #
  
  对于1行3列。
  
  回复
  - Daniel Aguilera Garcia 2018年12月14日上午6:53 #
    
    在这个例子中，这代表什么？
    
    回复
    - Jason Brownlee 2018年12月14日下午2:34 #
      
      我们将每个序列分割成子序列。也许重新阅读“开发ConvLSTM网络模型”一节，并注意选择这些参数的配置。
      
      回复
  - Asif Nawaz 2019年5月9日上午3:47 #
    
    为什么我们使用1行？为什么我们使用convLSTM2D？我们不能像Conv1D那样来建模这个问题吗？
    
    回复
    - Jason Brownlee 2019年5月9日上午6:47 #
      
      并非必须使用convlstm2d，本教程演示了如何为时间序列分类创建不同类型的模型。
      
      回复
beomyoung 2019年1月3日下午5:37 #

在数据集文件中，没有标签文件（关于y）。我能获得那些文件吗？？

回复
- Jason Brownlee 2019年1月4日上午6:27 #
  
  它们在一个单独的文件中，文件名中包含“y”。
  
  回复
beomyoung 2019年1月7日下午5:02 #

我找到了，谢谢！！

回复
- Jason Brownlee 2019年1月8日上午6:45 #
  
  很高兴听到。
  
  回复
  - beomyoung 2019年1月8日下午1:31 #
    
    谢谢您回答我的问题。我还有最后一个问题！您在此实验中有30位受试者，所以在处理数据时，例如在‘body_acc_x_train’中，是否将所有30位受试者的数据合并了？
    
    回复
    - Jason Brownlee 2019年1月9日上午8:37 #
      
      是的。
      
      另外请注意，我没有进行实验，我只是分析了可自由获取的数据。
      
      回复
      - beomyoung 2019年1月9日下午1:05 #
        
        哦，谢谢。最近，我正在使用RNN&CRNN进行稀有活动检测任务。
        例如，我想检测刮擦活动和非刮擦活动。但在我的实验中，刮擦和非刮擦窗口的比例不平衡（刮擦非常罕见……）那么如何输入我的输入？您能给我一些建议吗？
      - Jason Brownlee 2019年1月10日上午7:43 #
        
        也许您可以过采样稀有事件？例如，在稀有情况下训练更多？
Jemshit 2019年1月17日下午7:41 #

Jason你好，我有一个关于将特征数据馈送到LSTM的问题。我没有使用CNN，但是如果我使用常规的自编码器（三明治结构）而不是CNN进行特征提取，并且我将LSTM的时间步定义为例如128，
1）我应该从每个时间步提取特征并将其连接起来形成一个窗口，然后馈送到LSTM，还是
2）我应该从窗口本身提取特征并将其向量馈送到LSTM？

谢谢

回复
- Jason Brownlee 2019年1月18日上午5:33 #
  
  CNN必须从一系列观测（多个时间步）中提取特征，而不是从单个观测（时间步）中提取。
  
  回复
  - Jemshit 2019年1月18日上午6:18 #
    
    但是LSTM会解释每个时间步的特征，而不是整个窗口，对吧？
    
    回复
Kiran Krishna 2019年2月11日下午11:28 #

嗨，Jason，

感谢您提供如此出色的材料。我的问题是关于数据预处理。我有一个每5秒带有时间戳的压力数据序列。如何将2D数据框（样本，特征）转换为3D（样本，时间步，特征）？

回复
- Jason Brownlee 2019年2月12日上午8:04 #
  
  好问题，您可以在这里开始
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
P.Y Lee 2019年2月12日下午1:57 #

嗨，Jason，

在CNN LSTM模型部分，为什么我们需要将128个时间步分割成4个32个时间步的子序列？
我们不能直接用128个时间步来做这个模型吗？

谢谢你

回复
- Jason Brownlee 2019年2月12日下午2:00 #
  
  不可以，因为这个特定的模型期望输入是序列的序列。
  
  回复

imGaboy 2019年2月19日下午11:48 #

你好，

我有一个关于您的第一个模型的问题。

您将batch_size设置为64。
当我运行您的模型（verbose = 1）时，我得到了这个
Epoch 1/15
7352/7352 [==============================] – 12s 2ms/step – loss: 1.2669 – acc: 0.4528

这意味着7352 * 64？

我问这个问题，是因为我想覆盖您使用fit_generator的示例，而且我没有得到相同的结果。

这是我的代码

………………

def train_generator(df,n):
    while True:
        # For item i in a range that is a length of df,
        for i in range(0, len(df[0]), n):
            # Create an index range for df of n items:
            yield df[0][i:i+n], df[1][i:i+n]           
                
def test_generator(df,n):
    while True:
        # For item i in a range that is a length of df,
        for i in range(0, len(df[2]), n):
            # Create an index range for df of n items:
            yield df[2][i:i+n], df[3][i:i+n]    

# fit and evaluate a model
def evaluate_model(df):
    
    n_timesteps, n_features, n_outputs = None, 9, 6
    model = Sequential()
    model.add(LSTM(100, input_shape=(n_timesteps,n_features)))
    model.add(Dropout(0.5))
    model.add(Dense(100, activation='relu'))
    model.add(Dense(n_outputs, activation='softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    monitor = EarlyStopping(monitor='loss', min_delta=1e-3, patience=5, verbose=1, mode='auto')
    # fit network
    model.fit_generator(train_generator(df,100),steps_per_epoch=74, epochs=15,callbacks=[monitor])
    # evaluate model
    _, accuracy = model.evaluate_generator(test_generator(df,100),steps=30, verbose=0)
    return accuracy

# run an experiment
def run_experiment(repeats=10):
	# load data
	df = load_dataset()
	# repeat experiment
	scores = list()
	for r in range(repeats):
		score = evaluate_model(df)
		score = score * 100.0
		print('>#%d: %.3f' % (r+1, score))
		scores.append(score)
	# summarize results
	summarize_results(scores)

# run the experiment
run_experiment()

def train_generator(df,n):

while True:

# 对于df的长度范围内的每个项i，

for i in range(0, len(df[0]), n):

# 创建df的n项索引范围：

yield df[0][i:i+n], df[1][i:i+n]

def test_generator(df,n):

while True:

# 对于df的长度范围内的每个项i，

for i in range(0, len(df[2]), n):

# 创建df的n项索引范围：

yield df[2][i:i+n], df[3][i:i+n]

# 拟合和评估模型

def evaluate_model(df):

n_timesteps, n_features, n_outputs = None, 9, 6

model = Sequential()

model.add(LSTM(100, input_shape=(n_timesteps,n_features)))

model.add(Dropout(0.5))

model.add(Dense(100, activation='relu'))

model.add(Dense(n_outputs, activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

monitor = EarlyStopping(monitor='loss', min_delta=1e-3, patience=5, verbose=1, mode='auto')

# 训练网络

model.fit_generator(train_generator(df,100),steps_per_epoch=74, epochs=15,callbacks=[monitor])

# 评估模型

_, accuracy = model.evaluate_generator(test_generator(df,100),steps=30, verbose=0)

return accuracy

# 运行一个实验

def run_experiment(repeats=10):

# 加载数据

df = load_dataset()

# 重复实验

scores = list()

for r in range(repeats):

score = evaluate_model(df)

score = score * 100.0

print('>#%d: %.3f' % (r+1, score))

scores.append(score)

# 总结结果

summarize_results(scores)

# 运行实验

run_experiment()

Jason Brownlee 2019年2月20日上午8:08 #

抱歉，我不记得了，也许可以检查数据文件以确认实例数量？

回复

cora 2019年3月22日上午5:30 #

没有人能加载数据吗？救命，我认为我遵循了指南，解压并在工作目录中重命名。

回复
- cora 2019年3月22日上午5:49 #
  
  解决了，是我的错。
  
  回复
  - Jason Brownlee 2019年3月22日上午8:42 #
    
    很高兴听到这个消息！
    
    回复
- Jason Brownlee 2019年3月22日上午8:40 #
  
  听到这个消息我很遗憾，具体是什么问题？
  
  回复
Adim 2019年4月11日下午11:35 #

嗨，Jason，

感谢这个教程。我对加载数据集有点困惑。为什么我们要read_csv，因为数据集中没有CVS文件？抱歉问这个问题，因为我对此主题是新手。此外，我应用了（load_group）、（load_dataset_group）和（load_dataset）的代码？您能告诉我是否需要添加什么吗？

回复
- Jason Brownlee 2019年4月12日上午7:47 #
  
  在本教程中，我们从CSV文件中加载数据集，多个文件。
  
  回复
Manisha 2019年4月12日下午4:40 #

先生，LSTM(100)是否意味着有100个LSTM单元，每个单元都有遗忘门、输入门和输出门，并且每个LSTM单元将输出发送给其他LSTM单元，最后每个单元都会给出一个100维向量作为输出？我说的对吗？

回复
- Jason Brownlee 2019年4月13日上午6:23 #
  
  100个单元意味着每个单元接收输出并为下一层创建激活。
  
  一个层中的单元之间不进行通信。
  
  回复
  - Manisha 2019年4月13日上午6:48 #
    
    抱歉先生，我没明白。
    
    1：这100个LSTM单元是否相互通信？
    
    2：如果说我们有7352个样本，每个样本有128个时间步和9个特征，我的批大小是64，那么我是否可以说，在时间=1时，我们将前64个样本的第一个时间步输入给所有100个LSTM单元，然后在时间=2时，我们将64个样本的第二个时间步输入，依此类推，直到我们在时间=128时输入64个样本的第128个时间步，然后进行BPTT，并且每个LSTM从时间=1到时间=128都保留其状态？
    
    回复
    - Jason Brownlee 2019年4月13日上午6:53 #
      
      不，同一层中的单元之间不进行通信。
      
      不，每个样本是逐个处理的，在时间步1，所有100个单元都会接收到具有所有9个特征的数据的第一个时间步。
      
      BPTT是指批次结束时更新模型权重的过程。一种思考方式是，将每个单元随时间展开成一个深度网络，更多内容请看这里
      https://machinelearning.org.cn/rnn-unrolling/
      
      回复
      - Manisha 2019年4月13日上午7:17 #
        
        “不，每个样本是逐个处理的，在时间步1，所有100个单元都会接收到具有所有9个特征的数据的第一个时间步”
        
        先生，批大小意味着在权重更新之前向网络展示多少个样本。
        
        如果我的批大小是64……那么是在时间步1，所有100个单元都会接收到每个64个数据点的第一个时间步和所有9个特征？然后，在下一个时间步=2，所有10个单元都将接收到每个64个数据点的第二个时间步，依此类推。
        
        还是说，在时间步1，所有单元都接收一个数据点的第一个时间步和所有9个特征，然后到了时间步=2，所有单元都接收该数据点的第二个时间步，当该数据点的所有128个时间步都馈送到网络后，我们计算损失，然后对剩余的63个数据点执行相同操作，然后更新权重？
        
        我对于批大小在这里如何工作感到困惑……我是在哪里可视化错误的？
      - Jason Brownlee 2019年4月13日下午1:42 #
        
        如果批大小是64，那么在更新权重和重置状态之前，会向网络显示64个样本。
        
        在一个批次中，样本是逐个处理的，例如，样本1的所有时间步，然后是样本2的所有时间步，等等。
        
        我强烈建议阅读这个
        https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
Manisha 2019年4月12日下午6:31 #

另外，我们在这里在LSTM 100之后使用dropout，这意味着只有50个值会传递到密集100层，对吗，先生？

回复
- Jason Brownlee 2019年4月13日上午6:25 #
  
  平均来说，是的，100个激活。
  
  回复
Avani Pitre 2019年4月13日午夜12:19 #

你好
我是一个初学者，谢谢您提供的精彩教程。
我想尝试您的LSTM和CNN RNN示例，我已经下载了HARDataset，但是
我在这里有一个简单的问题，如何在开始时输入CSV文件？
我需要生成那个文件吗？如果需要，如何生成？

# 将单个文件加载为numpy数组
def load_file(filepath)
dataframe = read_csv(filepath, header=None, delim_whitespace=True)
return dataframe.values

请帮助我
先谢谢了

回复
- Jason Brownlee 2019年4月13日上午6:33 #
  
  您可以按照教程学习如何加载CSV文件。
  
  回复
- MELIKA 2020年12月17日上午5:32 #
  
  你得到答案了吗？
  
  回复
Manisha 2019年4月13日上午8:12 #

先生，我打印了CNN_LSTM输出维度的模型摘要，对于timeDistributed，输出是4维的，如(None,None,30,64)…它是4D是因为我们将窗口分割成了4个32大小的子窗口吗？

这里的None,None代表什么……30,64我知道那是第一次卷积后的输出

回复
- Jason Brownlee 2019年4月13日下午1:43 #
  
  “None”大小的维度意味着提供的数据集将定义其他维度。
  
  回复
Manisha 2019年4月13日上午9:02 #

先生，https://machinelearning.org.cn/cnn-long-short-term-memory-networks/ 你在这里提到……

“在这两种情况下，从概念上讲，有一个CNN模型和一系列LSTM模型，每个时间步一个。我们希望将CNN模型应用于每个输入图像，并将每个输入图像的输出作为单个时间步传递给LSTM。”

所以在这里我们是将128个时间步分割成4个子块……我们将每个块一次性地提供给CNN，我们的CNN模型将提供输出特征。

这意味着我们已经将128个时间序列转换成了4个时间序列，现在我们要将它们馈送到我们的LSTM模型。

所以我们之前是将128个时间步馈送到LSTM（在简单的LSTM中），而现在我们要馈送4个……我说的对吗？

回复
- Jason Brownlee 2019年4月13日下午1:47 #
  
  是的，但“4个时间步”是通过CNN模型从更多的实际时间步中提炼出来的。
  
  回复
  - Manisha 2019年4月13日下午5:50 #
    
    CNN会并行处理每个32个窗口，还是会先处理第一个32大小的窗口并馈送到LSTM，然后是另一个32，依此类推？
    
    回复
    - Jason Brownlee 2019年4月14日上午5:45 #
      
      CNN层中的每个窗口数据都通过n个滤波器并行处理——如果你的意思是这样的话。
      
      回复
      - Manisha 2019年4月14日上午8:35 #
        
        是的，先生，我明白了……非常感谢。
Manisha 2019年4月14日上午9:07 #

先生，意思是来自一个128时间步窗口的四个32大小的窗口是否被CNN并行处理，然后在时间步1，我们会将什么输入到我们的LSTM？

就像在普通的LSTM中，有128个时间步，我们输入第一个时间步（9个特征），然后是第二个时间步，依此类推……

在这里，由于我们并行处理了4个时间步，我们将输入什么给LSTM？

回复
- Jason Brownlee 2019年4月15日上午7:49 #
  
  LSTM接收CNN激活（特征图）作为输入。您可以通过model.summary()输出查看每个层的输出形状。
  
  回复
  - Manisha 2019年4月15日下午12:20 #
    
    先生，我这样做了，但有点困惑……这是摘要
    
    None,None,30,64….第一个卷积
    None,None,28,64….第二个卷积
    None,None,28,64…dropout
    None,None,896…maxpool
    None,100…lstm 100
    None,100…dropout
    None,100…dense 100
    None,6…softmax
    
    先生，我的疑问是，我们输入32大小的窗口，从128大小的原始窗口到LSTM……那么这里的LSTM是否将每个32大小的窗口预测为活动，将其视为一个时间序列？
    
    回复
  - Alex Szameitat 2020年3月16日上午10:24 #
    
    亲爱的Brownlee先生，
    
    我也在试图理解CNN-LSTM模型中数据流动的概念，可惜我还没有完全理解。我阅读了评论部分，发现了一些有用的问题和答案！不过，我仍然卡在Flatten层和LSTM层之间的这一点。来自最大池化层的展平（不变）特征究竟是如何馈送到LSTM层的？
    
    我尝试深入挖掘并进行了一些额外的互联网研究。在那里我发现了这三篇文章
    
    https://stackoverflow.com/questions/43237124/what-is-the-role-of-flatten-in-keras
    
    https://medium.com/smileinnovation/how-to-work-with-time-distributed-data-in-a-neural-network-b8b39aa4ce00
    
    https://datascience.stackexchange.com/questions/24909/the-model-of-lstm-with-more-than-one-unit
    
    这三篇文章帮助我可视化了网络中的数据流。我是否完全理解正确了……所以Keras会将输入逐步分发到LSTM单元。这意味着它将首先将第一个子序列的不变展平层呈现给LSTM，然后是第二个子序列的特征……
    
    为了清楚地说明我的意思，我制作了这张可视化图，其中还包含了一个较小的子序列的前向传播的简短数值示例
    
    https://filebin.net/0kywmitsq5u0qgy5
    
    在数值示例中，我取了前两个子序列，并展示了它们如何从输入到第一个和第二个卷积（这里我只选择了一些随机数字），然后是最大池化操作和展平操作（请注意，在这里我试图正确地对前一个卷积层的随机数字进行最大池化。我还展平了最大池化后的特征，根据第二个链接的文章，它们应该如何展平）。
    我可视化的这些内容是否易于理解和正确？
    
    还有其他问题。如果我将展平的特征馈送到100个LSTM单元（它们都在一个层中，这意味着它们没有堆叠或相互连接之类的），那么使用多个LSTM单元与使用单个LSTM单元相比，有什么确切的好处？
    
    回复
    - Jason Brownlee 2020年3月16日下午1:30 #
      
      关于理解模型输入，这将有所帮助
      https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
      
      关于LSTM层如何处理输入，这将有所帮助
      https://machinelearning.org.cn/faq/single-faq/how-is-data-processed-by-an-lstm
      
      关于CNN-LSTM中的展平层，我们需要展平CNN的特征图。也许可以查看模型的summary()函数的输入或绘制模型及其输出形状以查看过渡。
      https://machinelearning.org.cn/visualize-deep-learning-neural-network-model-keras/
      
      关于TimeDistributed层
      https://machinelearning.org.cn/timedistributed-layer-for-long-short-term-memory-networks-in-python/
      
      希望这能作为第一步有所帮助。
      
      回复
      - Alex Szameitat 2020年3月16日下午9:01 #
        
        嘿！
        
        感谢您快速回复。我必须说，我已经阅读了那些文章，但它们都没有真正解释CNN层展平特征如何馈送到LSTM层的具体细节……所以，正如我之前解释的，我试图做一些更多的研究（包括您的文章），现在我认为我已经找到了正确的解决方案，我在这里可视化了它
        
        https://filebin.net/0kywmitsq5u0qgy5
        
        我只是想问您，您是否愿意看看那并告诉我是否正确。
        
        另外，与使用单个LSTM单元相比，使用多个LSTM单元并行有什么好处？
        
        先谢谢您，并致以最美好的祝愿，
        Alex
      - Jason Brownlee 2020年3月17日上午8:15 #
        
        抱歉，我没有能力审查代码/文档/数据。我每天收到数百个类似的请求。
        
        层中的并行LSTM单元（如MLP中的并行节点）为模型提供了更多的“容量”。
        https://machinelearning.org.cn/how-to-control-neural-network-model-capacity-with-nodes-and-layers/
      - Alex Szameitat 2020年3月17日下午6:58 #
        
        好的，我明白了！非常感谢您的所有努力和到目前为止的回答！
Sàçha 2019年4月30日下午9:40 #

您是否了解使用ECOC算法的多类分类？

我们可以将其用于无监督分类（聚类）吗？

回复
- Jason Brownlee 2019年5月1日上午7:05 #
  
  什么是ECOC算法？
  
  回复
  - Sàçha 2019年5月2日下午7:11 #
    
    纠错输出编码（ECOC）算法
    
    回复
    - Jason Brownlee 2019年5月3日上午6:18 #
      
      感谢分享。
      
      回复
Asif Nawaz 2019年5月16日下午11:15 #

在convlstm层之后使用dropout和maxpooling，就像我们在CNN中那样，有意义吗？

回复
- Jason Brownlee 2019年5月17日上午5:54 #
  
  嗯，也许吧。
  
  始终进行测试，并使用能提供最佳性能的配置。
  
  回复
Alicia 2019年5月21日下午11:56 #

嗨，Jason，

感谢这个教程。
为什么在训练神经网络之前必须进行信号分窗？
我们可以考虑整个信号吗？

回复
- Jason Brownlee 2019年5月22日上午8:09 #
  
  我们必须将序列转化为一个监督学习问题。
  https://machinelearning.org.cn/time-series-forecasting-supervised-learning/
  
  回复
  - Alicia 2019年5月22日下午7:12 #
    
    假设原始信号是表示一个人行走的加速度，目标是确定该人是否摔倒在地。
    假设原始信号由属于类别1的1000个样本组成。信号被处理并分成N个数据点的固定窗口：现在我有标记为类别1的子信号。即使跌倒的峰值只出现在其中一个窗口中，是否可以考虑不同的窗口？
    
    回复
    - Jason Brownlee 2019年5月23日上午5:58 #
      
      也许吧。有许多方法可以构建给定的预测问题，也许可以尝试几种方法，看看哪种最适合您的特定数据集？
      
      回复
Khan 2019年5月26日上午3:09 #

在convlstm中，LSTM单元是否发挥了作用？convlstm层的参数与CNN相似，但看不出与LSTM相关的任何东西。在LSTM模型中，使用了100个LSTM单元。在这种情况下，我们如何看待convlstm？

回复
- Jason Brownlee 2019年5月26日上午6:48 #
  
  我不确定我是否理解您的问题，您能详细说明一下吗？
  
  回复
  - Khan 2019年5月26日下午6:22 #
    
    以下是三种模型使用的输入层。
    
    model.add(LSTM(100, input_shape=(n_timesteps,n_features)))
    model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3, activation=’relu’), input_shape=(None,n_length,n_features)))
    model.add(ConvLSTM2D(filters=64, kernel_size=(1,3), activation=’relu’, input_shape=(n_steps, 1, n_length, n_features)))
    
    我相信ConvLSTM2D层应该是CNN和LSTM的混合体。convlstm层中的所有参数都是CNN的参数，如滤波器数量、滤波器大小、激活函数等。独立的LSTM使用100个LSTM单元。我的问题是，convlstm模型将使用多少个LSTM单元？我相信convlstm只使用一个LSTM单元？
    
    回复
    - Jason Brownlee 2019年5月27日上午6:48 #
      
      我相信每个滤波器是一个单元——这两种概念背后的思想是融合的。
      
      回复
Riddy 2019年6月4日上午1:27 #

我正在生成正弦和余弦曲线进行分类。但是，我不确定是否需要预处理数据，还是直接将其加载到模型中。我的理解因您帖子中的以下说明而进一步模糊：“此外，每条数据系列已被分割成重叠的窗口，包含2.56秒的数据，即128个时间步”。

回复
- Jason Brownlee 2019年6月4日上午7:54 #
  
  是的，也许这篇文章会更清楚。
  https://machinelearning.org.cn/time-series-forecasting-supervised-learning/
  
  回复
Amy 2019年6月7日上午11:12 #

Jason，非常感谢您的精彩教程。

我想将您的方法用于我的问题。但是我的数据集与您在这里使用的略有不同。
我有75个时间序列。每个时间序列显示两个类。从时间0到时间t（每个时间序列不同）是类别1的数据，从时间t到时间序列结束是类别2。然后，对于测试时间序列，我想预测类别从1变为2的时间，或者在每个时间点类别是1还是2。您能告诉我如何将您的方法用于我的问题吗？

回复
- Jason Brownlee 2019年6月7日下午2:33 #
  
  也许您可以将每个时间序列填充到相同的长度，并使用掩码层来忽略填充值。
  
  这个可能会有帮助
  https://machinelearning.org.cn/data-preparation-variable-length-input-sequences-sequence-prediction/
  
  回复
  - Amy 2019年6月7日下午11:48 #
    
    谢谢Jason，但是不同之处在于每个时间序列有两个类。但是，您使用的时间序列每个都只有一个类。
    
    回复
    - Jason Brownlee 2019年6月8日上午6:59 #
      
      您是指每个序列被分类两次，例如 {A,B} 和 {C,D}。
      
      如果是这样，也许使用两个模型或者两个输出层，一个用于每次分类？
      
      回复
Amy 2019年6月8日下午10:32 #

我的意思是每个时间序列都显示两个类，健康和不健康，针对一个系统。从时间0到时间t，它显示健康状态，从时间t到系统故障，它显示不健康状态。我们有75个这样的时间序列，它们的长度对于这两个类都不同。现在我们想确定一个测试系统从健康状态切换到不健康状态的时间。

谢谢

回复
- Jason Brownlee 2019年6月9日上午6:21 #
  
  也许您可以预测每个输入时间步的类值，如果您有数据的话。
  
  回复
  - Amy 2019年6月9日上午10:42 #
    
    您能再详细解释一下吗？您认为我可以使用您的方法吗？
    
    回复
    - Jason Brownlee 2019年6月10日上午7:35 #
      
      我建议也许可以尝试将问题建模为一个一对一的映射，这样每个输入时间步都有一个分类。
      
      更多关于序列预测的内容请看这里
      https://machinelearning.org.cn/models-sequence-prediction-recurrent-neural-networks/
      
      回复
      - Christian Post 2019年9月7日午夜12:19 #
        
        我将您的教程应用到了与Amy（我猜测）类似的数据上，我尝试预测疾病事件，在训练和验证中使用了疾病事件发生前的n天，并作为比较使用了没有疾病事件的个体的n天，并将每个窗口分类为1（生病）或0（健康）。
        模型表现还可以，AUC大于0.85，但我不确定如何在实践中应用它，因为用于验证数据的时间窗口是基于先验知识设计的。
        在实际应用中，每次都需要构造一个新的输入向量，而且我认为这些向量的分类不会那么好。但我还没有尝试过。
        
        我不明白的是，我如何应用您文章中的一对一映射？您说一对一的方法不适合RNN，因为它不能捕捉时间点之间的依赖关系。
        
        @Amy，您可以研究一下心率分类与神经网络，我认为这是一个类似的问题。
      - Jason Brownlee 2019年9月7日上午5:35 #
        
        我不确定我是否完全理解这个问题。
        
        一般来说，您必须围绕模型预期使用的方式来构建问题，然后在该约束条件下进行评估。如果您基于在实践中无法使用的框架来构建/评估模型，那么评估将近乎无用。
        
        在框架中使用训练信息或领域知识是可以的，只要您期望它能够泛化。同样，这也可能受到实验的挑战。
        
        如果我错过了重点，也许您可以详细说明一下，或者给我发邮件？
        https://machinelearning.org.cn/contact/
  - Amy 2019年6月9日上午10:43 #
    
    您能再详细解释一下吗？
    
    回复
vinodh 2019年6月21日下午2:55 #

你好，先生，
很棒的教程，如何对这些数据进行归一化或标准化。

回复
- Jason Brownlee 2019年6月22日上午6:29 #
  
  我在这里展示如何做
  https://machinelearning.org.cn/machine-learning-data-transforms-for-time-series-forecasting/
  
  回复
Simon 2019年6月22日下午9:05 #

亲爱的Brownlee先生，

我是一名来自德国的学生，首先，感谢您精彩的博客！它比我参加过的所有讲座都要好得多！

我有一个关于3D数组的问题，希望您能帮助我。假设我们有以下案例，这与您示例中的案例相似

我们在一个小时内以50 Hz的频率测量三个维度的速度（x、y、z方向）。我们总共测量了5个人的速度。

– 3D数组的形式是这样的：(5*60*50; 1 ; 3)？

– 您在“[样本，时间步，特征]”中提到的时间步是什么意思？

– 3D数组的形式与我们LSTM模型的批大小有关吗？

提前感谢。我真的很感激您的帮助，因为我现在被卡住了……

此致，
Simon

回复
- Jason Brownlee 2019年6月23日上午5:34 #
  
  很棒的问题，我相信这会让 samples/timesteps/features 更清晰
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
  - Simon 2019年6月24日下午4:57 #
    
    亲爱的Brownlee先生，
    
    感谢您的回复和对 FAQ 页面的引用。
    
    我还是对 FAQ 页面的示例有点困惑。也许有问题？
    
    我指的是关于 604,800 秒的那个例子。您说输入形状是 [604800, 60, 2]，因为有 60 个时间步，但难道不应该是 [10080, 60, 2] 吗？
    
    您能给我一个提示，说明 RNN 如何处理输入中的不同时间步吗？
    
    提前感谢您！
    
    此致，
    Simon
    
    回复
    - Jason Brownlee 2019年6月25日上午6:12 #
      
      我认为您关于 FAQ 的说法是正确的，已修复。
      
      我们通常会对数据进行向量化和填充，以便每个输入序列具有相同数量的时间步和特征，有关填充的更多信息请参见此处
      https://machinelearning.org.cn/data-preparation-variable-length-input-sequences-sequence-prediction/
      
      回复
jai 2019年7月3日下午6:18 #

那 561 个特征有什么用？

回复
- Jason Brownlee 2019年7月4日上午7:41 #
  
  你具体指的是什么？
  
  回复
jai 2019年7月3日下午6:29 #

如果在这 128*9 的数据中，64*9 代表站立，另外 64*9 代表行走，那么我该如何标记这 128*9 的数据？

回复
- Jason Brownlee 2019年7月4日上午7:43 #
  
  您可以将问题建模为序列分类问题，并尝试不同长度的序列输入，看看哪种最适合您的特定数据集。
  
  回复
jonniej393 2019年8月9日下午7:21 #

太棒了！

但是如何用额外的、新的数据来训练网络？我正在做一个项目，用于从监控视频中检测可疑活动。

我不知道如何准备这样的数据集。感谢您的帮助！

回复
- Jason Brownlee 2019年8月10日上午7:14 #
  
  您可以保存模型，之后再加载并更新/训练新数据或新旧混合数据。或者丢弃模型并重新拟合。
  
  也许可以尝试不同的方法并比较结果。
  
  回复
nisha 2019年8月28日下午9:46 #

嗨，Jason，

您有训练好的模型链接吗？我想快速检查一下它在我的数据上运行得如何。

另外，您的模型有多大？我正在寻找模型尺寸较小的模型，以便能够部署到边缘设备。

回复
- Jason Brownlee 2019年8月29日上午6:07 #
  
  抱歉，我不分享训练好的模型。
  
  也许可以尝试自己拟合模型，这只需要几分钟。
  
  回复
Tommy 2019年9月2日下午1:45 #

加载文件时，“prefix”的目的是什么？

回复
- Jason Brownlee 2019年9月2日下午1:52 #
  
  以防您的数据位于其他位置，需要指定该位置。
  
  回复
Shivamani Patil 2019年9月3日下午9:32 #

嗨，Jason，

如果我将此模型导出到 Android 应用程序，是否需要对来自移动传感器的输入数据进行任何预处理？

回复
- Jason Brownlee 2019年9月4日上午5:58 #
  
  抱歉，我不知道 Android 应用程序。
  
  回复
Tommy 2019年9月14日下午5:11 #

嗨，Jason，
第一个 LSTM 示例，您提到由于随机原因进行了多次评估。但是，您是如何获得最佳性能参数权重的？

回复
- Jason Brownlee 2019年9月15日上午6:18 #
  
  我们没有获得最佳权重，我们评估的是模型的平均性能。
  
  我们可以使用集成方法来减少给定模型的预测方差。
  https://machinelearning.org.cn/start-here/#better
  
  回复
Pranav Gundewar 2019年9月18日上午7:59 #

Jason，您好，感谢这篇很棒的文章。我目前正在进行人体活动识别（Kinetics-600）的研究，并希望将 LSTM 与 3D ResNet 头部连接起来进行动作预测。您能告诉我如何使用最后一个图层的 1024 个向量来喂入 RNN-LSTM 进行动作预测吗？

谢谢你。

回复
- Jason Brownlee 2019年9月18日下午2:08 #
  
  我无法立即回答这个问题，除非编写自定义代码/深入研究您的数据，但我无法做到。
  
  也许这会给您一些关于如何调整数据以适应 LSTM 的想法。
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
Tanveer 2019年10月7日下午10:08 #

model = Sequential()
model.add(LSTM(100, input_shape=(n_timesteps,n_features)))
model.add(Dropout(0.5))
model.add(Dense(100, activation=’relu’))
model.add(Dense(n_outputs, activation=’softmax’))
model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
在这段代码中，我遇到了这个回溯

回溯（最近一次调用）
File “C:\Users\Tanveer\AppData\Local\Programs\Python\Python37-32\HARUP.py”, line 54, in
model = Sequential()
NameError: name ‘Sequential’ is not defined
我该如何解决这个问题？请指导我。

回复
- Jason Brownlee 2019年10月8日上午8:02 #
  
  您可能跳过了一些来自完整示例的代码行。
  
  回复
  - Tanveer 2019年12月19日下午8:06 #
    
    尊敬的先生，我没有跳过上面提供的任何代码，但这个问题仍然存在，请给我一些指导或提示来解决这个问题。
    
    回复
    - Jason Brownlee 2019年12月20日上午6:43 #
      
      我建议复制完整的代码示例，而不是部分代码示例。
      
      回复
AGGELOS PAPOUTSIS 2019年10月18日下午11:44 #

嗨 Jason。我正在运行这里 (https://medium.com/@curiousily/human-activity-recognition-using-lstms-on-android-tensorflow-for-hackers-part-vi-492da5adef64) 的代码，在 Anaconda、Notebook 和 PyCharm 中使用 TensorFlow 1.4 版本（我不得不降级，因为作者使用的是与 TensorFlow 2 不兼容的占位符）和 Python 3.6。这里的问题是我总是得到训练损失：nan。

您能否就此提出一些建议，因为我找不到任何有用的信息？

回复
- Jason Brownlee 2019年10月19日上午6:40 #
  
  抱歉，我不熟悉那个教程，也许可以联系作者？
  
  回复
Dhiren 2019年11月12日下午6:50 #

你好 Jason，
精彩的教程。我正在做一些与此类似的事情。我的问题是：“如果给我一组 128 个时间步、9 个特征的数据，即形状为 (128,9) 的 ndarray，我该如何使用 model.predict() 方法来预测这 128 个时间步的数据？” 目前当我执行 model.predict(形状为 (128, 9) 的 ndarray) 时，我会收到错误：“expected lstm_1_input to have 3 dimensions, but got array with shape (128, 9)”。根据我的理解，我将获得一个时间步数据及其特征值，并且我需要预测其类别。为什么数据会是 3D 的，而我只需要预测一个样本？
谢谢你

回复
- Jason Brownlee 2019年11月13日上午5:38 #
  
  是的，一个样本的形状应该是 [1, 128, 9]。
  
  有关这方面的更多信息，请参见
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
Alex 2019年11月17日晚上11:58 #

嘿 Jason，

感谢有用的教程 :)

我不太明白数据是如何被塑造成窗口大小为 128 的。我知道这里数据已经被塑形了，但我想知道您是否有关于如何为分类问题完成这种塑形的教程？

谢谢，

回复
- Jason Brownlee 2019年11月18日上午6:46 #
  
  这种塑形无法对表格数据进行分类问题，它只适用于序列预测问题。
  
  回复
  - Alex 2019年11月21日早上6:18 #
    
    那么我该如何为分类问题塑形我的数据？是否有类似问题的教程？
    
    回复
    - Jason Brownlee 2019年11月21日早上6:23 #
      
      您只需要一个表格，行是示例，列是特征。
      
      存储在 CSV 文件中。
      
      这有帮助吗？
      
      回复
      - Alex 2019年11月21日早上9:04 #
        
        我的问题是如何制作滑动窗口？
        我有一个 csv 文件，我有一个目标，有两个类别 1 和 0。我每天都有读数。
        我想制作一个 5 天的滑动窗口。这是否适用于我的问题？
        如果适用，当我对窗口进行塑形时，是否应该包含目标变量，还是排除它？
        滑动窗口是通过 to_supervised 函数中的 shift() 完成的，还是仅使用 reshape 就足够了？
        
        谢谢，
      - Jason Brownlee 2019年11月21日下午1:28 #
        
        本教程将向您展示如何操作
        https://machinelearning.org.cn/time-series-forecasting-supervised-learning/
        
        本教程将为您提供代码。
        https://machinelearning.org.cn/convert-time-series-supervised-learning-problem-python/
      - Alex 2019年11月21日下午2:15 #
        
        非常感谢 Jason :)
      - Jason Brownlee 2019年11月22日上午5:57 #
        
        不客气。
john 2019年11月22日上午5:13 #

你好，

您认为您的 CNN+LSTM 示例对于姿态估计会取得好结果吗？为了实现这一点需要进行哪些必要的更改？提前感谢！

回复
- Jason Brownlee 2019年11月22日上午6:13 #
  
  或许可以试试看？
  
  回复
Marvi Waheed 2019年12月3日下午8:36 #

你好，
我的数据集维度是 (170,200,9)，我想给一个样本/窗口的 200 个时间步分配一个类标签，而不是给一个窗口内的每个 200 个时间步分配单独的标签。
我该如何做到这一点？所以我的目标类输出的维度是 (170,1)。

回复
- Jason Brownlee 2019年12月4日上午5:35 #
  
  是的，这称为时间序列分类。
  
  上述教程就是这么做的。
  
  回复

John 2019年12月7日下午5:45 #

你好，
您能告诉我下面的代码中需要加载哪些文件来进行堆叠吗？

def load_group(filenames, prefix=''):
	loaded = list()
	for name in filenames:
		data = load_file(prefix + name)
		loaded.append(data)
	# stack group so that features are the 3rd dimension
	loaded = dstack(loaded)
	return loaded

def load_group(filenames, prefix=''):

loaded = list()

for name in filenames:

data = load_file(prefix + name)

loaded.append(data)

# 堆叠组，使特征成为第三维度

loaded = dstack(loaded)

return loaded

谢谢。

Jason Brownlee 2019年12月8日上午6:08 #

抱歉，我不明白您的问题。您能详细说明一下吗？

回复

John 2019年12月8日上午10:48 #

我的意思是，数据集中的哪些文件需要加载和堆叠，才能使特征为 3 维？

# load a list of files into a 3D array of [samples, timesteps, features]
def load_group(filenames, prefix=''):
	loaded = list()
	for name in filenames:
		data = load_file(prefix + name)
		loaded.append(data)
	# stack group so that features are the 3rd dimension
	loaded = dstack(loaded)
	return loaded

#将一组文件加载到三维数组[样本数、时间步长、特征数]中

def load_group(filenames, prefix=''):

loaded = list()

for name in filenames:

data = load_file(prefix + name)

loaded.append(data)

# 堆叠组，使特征成为第三维度

loaded = dstack(loaded)

return loaded

也就是说，在应用上面的 NumPy 的 dstack 函数时，应该加载数据集中的哪些文件？

提前感谢。

Jason Brownlee 2019年12月9日上午6:43 #

教程中的示例准确地展示了如何调用此函数来堆叠数据集。

无需发明任何东西——只需复制完整的代码示例。

回复

Devon 2019年12月8日下午1:42 #

你好，

您能告诉我为什么我们在下面的代码中减去 1 吗？

# zero-offset class values
trainy = trainy – 1
testy = testy – 1

谢谢你。

回复
- Jason Brownlee 2019年12月9日上午6:45 #
  
  正如注释所示，将类标签的整数更改为从 0 开始，而不是从 1 开始。
  
  回复
Ahmed Mubarak 2020年1月5日凌晨12:18 #

Jason，您好。祝您有美好的一天。

感谢您的教程。我有一个问题。我有关于在线学习学生的数据，我想为 CNN LSTM 准备数据，数据格式为 (学生, 周, 每周视频, 视频特征)。现在，我想制作输入数据 (样本, n_steps, n_length, 特征)，其中 n_length 是可变长度，例如 (第一周 8 个视频，第二周 13 个视频，依此类推)。这些数据作为输入数据馈送到 CNN，然后是 LSTM。类似于 CNN-LSTM。请问，您能指导我如何准备这些数据吗？我特别想问的是，如何使 n_length 成为可变长度？

回复
- Jason Brownlee 2020年1月5日上午7:05 #
  
  这个可能会有帮助
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
Charles Yu 2020年1月25日上午7:14 #

嗨，Jason，

我使用了这个教程来做我的时间序列分类/预测。
基本上，我只使用了这个教程的第一部分，即 LSTM。
预测结果应该是 0、1 或 2。

我将 Y 分为 3 类，整数值为 0、1、2。
所以调用 to_categorical() 后，它将是
0 –> [1, 0, 0]
1 –> [0, 1, 0]
2 –> [0, 0, 1]

然而，在我进行如下函数调用后
yhat = model.predict(test_X, verbose=verbose)

我得到了这样的值：
…
[0.95416844 0.00828072 0.03755087]
[0.9620431 0.00921117 0.02874582]
[0.9660313 0.01018358 0.02378514]
[0.9682437 0.01118453 0.02057172]
[0.96942824 0.01226482 0.01830701]
[0.9697388 0.01347514 0.0167861 ]
…

您能否对此进行一些阐述，如何将我的预测值转换回 one-hot 形式或整数形式？

非常感谢

回复
- Jason Brownlee 2020年1月25日上午8:46 #
  
  计算 argmax() 以获取每个预测样本中概率最大的类别标签的索引。
  
  回复
  - Charles Yu 2020年1月26日下午12:27 #
    
    非常感谢。它解决了我的问题。
    不过，我还有第二个问题。
    
    对于这种预测结果：
    [0.95416844 0.00828072 0.03755087]
    [0.9620431 0.00921117 0.02874582]
    [0.9660313 0.01018358 0.02378514]
    [0.9682437 0.01118453 0.02057172]
    [0.96942824 0.01226482 0.01830701]
    [0.9697388 0.01347514 0.0167861 ]
    
    如果我使用 argmax()，所有的事件都会被归类为类别 1，即“0”。
    
    我想知道我的模型是否有问题？
    model.add(LSTM(100, input_shape=(train_X.shape[1], train_X.shape[2])))
    model.add(Dropout(0.5))
    model.add(Dense(100, activation=’relu’))
    model.add(Dense(n_outputs, activation=’softmax’))
    model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
    
    或者我在数据预处理方面有什么需要做的？
    例如，这是我正在预测特征的原始数据片段：
    0
    0
    0
    0
    0
    1
    0
    0
    0
    0
    0
    1
    0
    0
    0
    0
    0
    0
    0
    0
    0
    0
    2
    0
    0
    0
    0
    0
    0
    1
    0
    0
    0
    0
    0
    1
    0
    0
    0
    0
    0
    0
    0
    0
    0
    0
    2
    0
    
    回复
    - Charles Yu 2020年1月26日下午3:21 #
      
      顺便说一下，这似乎是一个更复杂的“不平衡数据分类”问题？
      
      回复
    - Jason Brownlee 2020年1月27日上午7:01 #
      
      干得好。
      
      是的，我建议测试一系列模型、配置和预处理方法，以发现最适合您特定数据集的方法。
      
      回复
    - Robin 2020年9月11日下午6:01 #
      
      嘿，您能分享一下您用于 Argmax() 的代码吗？提前感谢：)
      
      回复
      - Jason Brownlee 2020年9月12日上午6:05 #
        
        这会有帮助
        https://machinelearning.org.cn/argmax-in-machine-learning/
AGGELOS PAPOUTSIS 2020年1月26日凌晨2:50 #

尊敬的先生，

如果我们想在新的数据上测试 LSTM 模型，比如来自 (https://sensor.informatik.uni-mannheim.de/#dataset_realworld) 这里，那么程序是怎样的？

1. 我们将在训练后停止，然后评估新数据 (model.evaluate(new_data))，是否无需任何预处理？

2. 或者我们必须将数据转换为我们的 LSTM 模型可以理解的格式？

非常感谢您给我提问的机会。

回复
- Jason Brownlee 2020年1月26日上午5:25 #
  
  您必须以相同的方式准备所有数据，包括测试数据和进行预测时的新数据。
  
  回复
  - AGGELOS PAPOUTSIS 2020年1月26日晚上8:56 #
    
    感谢您的回复，
    
    当模型在测试数据上表现良好但在新数据上表现不佳时，您认为是什么原因？
    
    这取决于新数据的质量，或者某些超参数的变化会导致更高的准确率吗？
    
    回复
    - Jason Brownlee 2020年1月27日上午7:05 #
      
      也许测试数据集太小或不能代表问题。
      
      回复
      - AGGELOS PAPOUTSIS 2020年1月27日下午6:36 #
        
        非常感谢您的回答。
      - Jason Brownlee 2020年1月28日上午7:51 #
        
        不客气。
AGGELOS PAPOUTSIS 2020年2月5日凌晨1:05 #

由于在网站上找不到，我在这里问。传感器信号降采样程序是什么？

假设我们有一个具有相同列的数据框，如

acticity, accx, accy, accz, gurx, gury, gurz

采样频率是 100hz。如何将其降采样到 50 Hz？

我找到了 pandas replace，但没有看到它如何应用。

回复
- Jason Brownlee 2020年2月5日上午8:17 #
  
  我相信 pandas 提供了可能有帮助的采样方法。
  https://machinelearning.org.cn/resample-interpolate-time-series-data-python/
  
  回复
Simon 2020年2月13日凌晨4:24 #

你好，

我有一个分类问题，其中从一个状态到下一个状态的转换非常突然。我可以用上面的例子很好地对序列进行分类，但有没有办法准确地识别系统何时从一个状态改变到另一个状态？

谢谢

回复
- Jason Brownlee 2020年2月13日上午5:43 #
  
  好问题。
  
  我建议研究一下时间序列中的“状态变化”模型。
  
  回复
Pritam 2020年2月16日晚上10:49 #

你好先生，
运行您的 LSTM 代码会得到一个形状为
(7352, 128, 1) (7352, 1)
(2947, 128, 1) (2947, 1)
(7352, 128, 1) (7352, 6) (2947, 128, 1) (2947, 6)

而不是

(7352, 128, 9) (7352, 1)
(2947, 128, 9) (2947, 1)
(7352, 128, 9) (7352, 6) (2947, 128, 9) (2947, 6)..
您能解释一下原因吗？

回复
- Jason Brownlee 2020年2月17日上午7:48 #
  
  也许确认您已按顺序遵循了教程的步骤。
  
  另请参阅此
  https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
  
  回复
Aggelos Papoutsis 2020年2月17日上午5:19 #

你好，

当加速度计或陀螺仪数据的信号没有被正确捕获时（例如尖锐的峰值、边缘、直线等），您认为自动编码器 LSTM 网络可以摆脱这些排列吗？

回复
- Jason Brownlee 2020年2月17日上午7:53 #
  
  它可能会使它们平滑。也许可以测试一下？
  
  回复
AGGELOS PAPOUTSIS 2020年2月25日晚上10:57 #

嗨，Jason，

感谢您对我之前帖子的回答。

我是否可以使用此处 (https://machinelearning.org.cn/diagnose-overfitting-underfitting-lstm-models/) 的建议

来检查过拟合或欠拟合？以及如何决定训练过程中的验证集拆分数量？

回复
- Jason Brownlee 2020年2月26日上午8:20 #
  
  是的，但您可能需要手动创建曲线。
  
  这取决于问题以及您想验证的内容。例如，也许可以尝试不同大小的验证集，看看哪个最稳定。
  
  回复
  - AGGELOS PAPOUTSIS 2020年2月26日下午5:06 #
    
    谢谢 Jason。您所说的手动创建曲线是什么意思？我通常使用这段代码
    
    def plot_learningCurve(history, epochs)
    # Plot training & validation accuracy values
    epoch_range = range(1, epochs+1)
    plt.plot(epoch_range, history.history[‘accuracy’])
    plt.plot(epoch_range, history.history[‘val_accuracy’])
    plt.title(‘Model accuracy’)
    plt.ylabel(‘Accuracy’)
    plt.xlabel(‘Epoch’)
    plt.legend([‘Train’, ‘Val’], loc=’upper left’)
    plt.show()
    
    # Plot training & validation loss values
    plt.plot(epoch_range, history.history[‘loss’])
    plt.plot(epoch_range, history.history[‘val_loss’])
    plt.title(‘Model loss’)
    plt.ylabel(‘Loss’)
    plt.xlabel(‘Epoch’)
    plt.legend([‘Train’, ‘Val’], loc=’upper left’)
    plt.show()
    
    回复
    - Jason Brownlee 2020年2月27日上午5:39 #
      
      但是通过 fit() 计算验证准确率可能不正确，相反，我们可能需要使用前向验证来估计它。
      
      回复
      - AGGELOS PAPOUTSIS 2020年2月27日上午6:11 #
        
        好的，谢谢，我会尝试您的建议。
      - Jason Brownlee 2020年2月27日下午1:30 #
        
        不客气。
AGGELOS PAPOUTSIS 2020年2月26日凌晨1:56 #

你好，

如果有人省略了这个层 model.add(Dense(100, activation=’relu’)) 会发生什么？

我正在对记录 (加速度计、陀螺仪信号，100Hz) 的数据集进行不同的实验。

当我不用上述图层时，准确率会提高到 1.00，所有类别都能正确分类。

当我使用该图层时，准确率会下降到 78%，并且像坐着这样的某些静态活动无法分类。

您认为是什么原因？

回复
- Jason Brownlee 2020年2月26日上午8:25 #
  
  Dense 层解释了 LSTM 的输出。
  
  尝试其他配置，看看是否能提高模型的技能。
  
  回复
  - AGGELOS PAPOUTSIS 2020年2月26日下午5:11 #
    
    好的，我明白了，谢谢。所以，在最终的预测密集层之前，必须有一个密集层？
    
    回复
    - Jason Brownlee 2020年2月27日上午5:39 #
      
      不，有些人使用全局池化层。
      
      回复
      - AGGELOS PAPOUTSIS 2020年2月27日上午6:01 #
        
        哦，我以为全局池化层只用于 CNN。
        
        谢谢，我会去搜索一下。
AGGELOS PAPOUTSIS 2020年2月26日下午6:21 #

嗨，

再问一个问题，拜托

您如何决定隐藏单元的数量？

model.add(LSTM(100, input_shape=(n_timesteps,n_features)))

为什么是 100 而不是 200 或 50 等？您知道任何讨论这个问题的论文吗？

回复
- Jason Brownlee 2020年2月27日上午5:40 #
  
  好问题，我在这里回答
  https://machinelearning.org.cn/faq/single-faq/how-many-layers-and-nodes-do-i-need-in-my-neural-network
  
  回复
PRIYANKA 2020年3月3日晚上8:20 #

我想构建一个模型来检测驾驶员的打哈欠。我想知道如何以及使用什么算法来做到这一点？

回复
- Jason Brownlee 2020年3月4日上午5:53 #
  
  好问题，请看这个
  https://machinelearning.org.cn/faq/single-faq/what-algorithm-config-should-i-use
  
  回复
zohre 2020年3月6日上午10:34 #

杰森，干得好！

我正在使用 Keras (v.2.3.1) 进行视频分类以进行动作检测。我的模型是 CNN 和 LSTM。我的数据集由 3-7 秒的视频组成，每个视频代表一个特定的动作。我使用 OpenCv 从每个视频中获取帧。但是由于视频长度不同，我为每个视频获得的帧数也不同。然而，我需要为 LSTM 层提供相同数量的帧。我搜索了一下，似乎填充和掩码层应该可以做到，但我无法弄清楚如何用 Keras 来实现。您能否提供一些关于如何实现这一点的线索？

回复
- Jason Brownlee 2020年3月6日下午1:22 #
  
  也许可以尝试对帧序列进行零填充。
  
  回复
Anon 2020年3月9日上午3:56 #

是否可以对边界框检测到的活动进行分类？

回复
- Anon 2020年3月9日上午7:16 #
  
  为了详细说明我上面的评论：
  
  如何构建一个模型来分类多类视频序列？而不是像您在上面的教程中所展示的那样对整个视频进行分类。
  
  例如，假设我们有一个包含 4 个不同时钟的视频，它们以不同的速度移动。我的文件夹如下：
  
  文件夹 1：视频中的 1000 个多时钟
  
  文件夹 2：1000 个相应的带注释的 JSON/XML 文件，包含时钟的坐标及其各自的标签（“慢速”、“正常速度”、“快速”、“变化速度”）。
  
  如何构建一个模型来分类这样的视频？
  
  回复
  - Jason Brownlee 2020年3月9日上午7:19 #
    
    抱歉，我没有处理视频的示例。
    
    回复
    - Anon 2020年3月9日上午8:22 #
      
      Jason，您好，我发现您有
      
      https://machinelearning.org.cn/how-to-develop-rnn-models-for-human-activity-recognition-time-series-classification/
      
      是否有对该教程的扩展，以便不是对整个视频进行识别，而是在同一视频中对多个活动进行识别？例如，带边界框的慢速，带边界框的正常速度等……
      
      仅进行“对象识别”将不足以完成此任务，因为它需要后续帧来预测时钟速度。
      
      我在网上找到的一些方法是：
      
      1) 3D CNN
      2) ConvNets + RNN
      3) ConvNets + MLP
      4) 双流卷积网络
      
      您是否在您的书中涵盖了这些方法中的任何一种，也许还有视频示例？
      
      感谢您的及时回复，感谢您所有出色的工作。
      
      回复
      - Jason Brownlee 2020年3月9日上午11:06 #
        
        我没有处理视频的示例。
- Jason Brownlee 2020年3月9日上午7:18 #
  
  在图像中？是的，这称为“对象识别”。
  https://machinelearning.org.cn/object-recognition-with-deep-learning/
  
  回复
Tanveer 2020年3月29日凌晨1:57 #

您好，

我想绘制单个活动的的时间序列图。

例如，
def plot_activity(activity, df)
data = df[df[‘activity’] == activity][[‘x-axis’, ‘y-axis’, ‘z-axis’]][:200]
axis = data.plot(subplots=True, figsize=(16, 12),
title=activity)
我可以使用 HARDataset 来绘制这个图吗？
请指导我。

回复
- Jason Brownlee 2020年3月29日上午6:01 #
  
  本教程将向您展示如何绘制时间序列。
  https://machinelearning.org.cn/time-series-data-visualization-with-python/
  
  回复
  - Tanveer 2020年3月29日晚上10:56 #
    
    亲爱的 Jason，非常感谢您的回复，但我想要绘制时间序列图，即 https://3qeqpr26caki16dnhd19sv6by6v-wpengine.netdna-ssl.com/wp-content/uploads/2016/12/Minimum-Daily-Temperature-Yearly-Line-Plots.png
    仅针对单个活动绘制 (X, Y, 和 Z) 轴，使用 HARDataset。
    请提供代码，我对 Python 不太熟悉。
    
    回复
    - Jason Brownlee 2020年3月30日上午5:34 #
      
      抱歉，我无法为您编写自定义代码。
      
      回复
Tanveer 2020年3月30日晚上10:44 #

好的，亲爱的，您能给我一些提示吗？HARDataset 有很多文件，我如何与它们关联，以便能够解决上述问题？

回复
- Jason Brownlee 2020年3月31日上午8:10 #
  
  也许这个教程会有帮助
  https://machinelearning.org.cn/how-to-model-human-activity-from-smartphone-data/
  
  回复
  - Tanveer 2020年3月31日晚上11:46 #
    
    谢谢，亲爱的。
    
    回复
aggelos 2020年4月1日晚上6:59 #

嗨，Jason，

您是否有任何示例来同步和插值加速度计和陀螺仪数据？

假设我们有一个数据框
activity timestamp accx accy accz timestamp gurx gury gurz
0 walking 1585564269527 -0.625122 -0.343262 0.357971 1585564269513 10.785061 3.288872 -5.015244

两个传感器的时戳不在同一尺度上。

回复
- Jason Brownlee 2020年4月2日上午5:48 #
  
  也许您可以改编这里的示例。
  https://machinelearning.org.cn/resample-interpolate-time-series-data-python/
  
  回复
aggelos 2020年4月2日上午7:19 #

是的，我已经看到了。首先，我必须将 unix 时间转换为日期和时间，然后使用示例。

谢谢 Jason

回复
Kinjal 2020年4月13日凌晨3:13 #

嗨，Jason，
解释得很好，一如既往。我有一个疑问，如何对多个视频执行相同的操作（视频分类）？我的意思是，有没有关于一个视频一个标签的建议？

回复
- Jason Brownlee 2020年4月13日上午6:20 #
  
  也许可以为这类问题探索 CNN-LSTM 和 ConvLSTM。
  
  回复
Kinjal 2020年4月13日晚上10:39 #

您能推荐任何好的资源/教程吗？

回复
- Jason Brownlee 2020年4月14日上午6:19 #
  
  也许从这里开始
  https://machinelearning.org.cn/start-here/#deep_learning_time_series
  
  回复
Ahmad 2020年4月16日凌晨1:32 #

你好 Jason，

感谢您的教程。实际上我有一个问题。

我可以看到滑动窗口的大小是 128。我也看到滑动窗口在数据中移动了 64 个值（50% 重叠）。所以在新窗口中，有 128 / 2 = 64 个冗余数据。您对选择 50% 有何解释？选择其他选项有什么影响？

谢谢您的回答。

回复
- Jason Brownlee 2020年4月16日上午6:02 #
  
  分帧的选择是任意的。找到最适合您特定模型和数据集的方法。
  
  回复
Thilan 2020年4月16日凌晨1:37 #

先生，这如何用于实时数据？

回复
- Jason Brownlee 2020年4月16日上午6:03 #
  
  首先在所有可用数据上拟合模型，然后通过调用 model.predict() 来预测新数据。
  
  回复
Alex 2020年4月23日晚上6:26 #

嗨，Jason，

我也很喜欢这篇文章。我目前正在做一个类似的项目，我想知道在时间序列分类问题中，滑动窗口是否总是必需的，其思想是预测一个多元时间序列数据的类别？
具体来说，假设我有 9 个受试者，每个受试者有 22 个提取的特征，并且从测量值中我为每个特征获得 376 个数据点，这使得每个人的数据点为 22*376=8272。每个受试者属于类别 1、2、3 或 4。我如何决定窗口大小以及为什么需要这样做？事实上，我也阅读了您关于如何将时间序列转换为监督学习问题的文章，但我没有看到它如何应用于我的问题。

非常感谢！

回复
- Jason Brownlee 2020年4月24日上午5:38 #
  
  是的，这是必需的。
  
  根据能够使您的数据模型表现最佳的大小来选择窗口大小。
  
  回复
zitoun 2020年5月2日晚上6:50 #

很棒的教程，

是否可以将 CNN 部分的 CNN-LSTM 模型（如 VGG、ResNet、Inception 等）应用于迁移学习，以进行时间序列分类？

回复
- Jason Brownlee 2020年5月3日上午6:07 #
  
  可以。我不记得写过完全相同的示例，抱歉。
  
  回复
Shida 2020年5月8日凌晨3:17 #

Jason，您好，我在加载数据时卡住了。我应该包含工作区的目录，例如 C:\Users\… 吗？我做了一切，但数据集就是无法加载。
提前感谢您！

回复
- Jason Brownlee 2020年5月8日上午6:40 #
  
  是的，将数据集和代码放在同一个目录中。
  
  回复
khandu 2020年5月9日下午5:46 #

先生，我正在改编您的示例使用我的数据。我有 4 个输入特征和 1 个目标。

目标值是 0 和 1，y= [0,1,0]

并且输入形状是 (timestep, features) [7,4]，输出是 [1]，因为我只有一个目标，即 num_y-signals。

提议的模型是：
model.add(LSTM(100, activation=’relu’, return_sequences=True,
input_shape=(X_train.shape[1], X_train.shape[2])))

model.add(Dense(num_y_signals, activation=’softmax’))

我遇到了以下错误：
ValueError: A target array with shape (14388, 1) was passed for an output of shape (None, 7, 1) while using as loss binary_crossentropy.
This loss expects targets to have the same shape as the output.

您能帮我看看我哪里出错了，请？

回复
- Jason Brownlee 2020年5月10日上午5:59 #
  
  很抱歉听到您遇到的问题，准备 LSTM 输入可能会很棘手。也许这会有所帮助。
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
khandu 2020年5月10日下午12:57 #

先生，
感谢您的回复。

我有 y 个类别，值为 0 和 1，如何获得相应特征的预测标签类别？

我得到了这个输出，但不知道如何解释。

# 定义向量
probs = np.array(yhat)
print(probs.shape)
# get argmax
labels = np.argmax(probs, axis=-1)
print(labels)

输出
(3592, 7, 2)
[[1 1 1 … 1 1 1]
[1 1 1 … 1 1 1]
[1 1 1 … 1 1 1]
…
[1 1 1 … 1 1 1]
[1 1 1 … 1 1 1]
[1 1 1 … 1 1 1]]

谢谢你

回复
- Jason Brownlee 2020年5月10日下午4:09 #
  
  您可以使用 predict() 和 argmax 来处理结果。
  https://machinelearning.org.cn/argmax-in-machine-learning/
  
  或者可以使用 predict_classes() 直接获取类标签。
  https://machinelearning.org.cn/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/
  
  回复
kGao 2020年5月18日上午6:59 #

嗨，Jason，

感谢这篇很棒的教程。

我想尝试基于 CNN 的模型来制作一个排名列表。我有一个班级的学生资料（20 名学生），我想创建一个模型，该模型能够对班级进行排名。
学生资料只有一行，包含 10 个特征（来自不同课程的成绩和成就）。

您有什么想法或建议吗？

回复
- Jason Brownlee 2020年5月18日下午1:24 #
  
  是的，也许这个框架会有所帮助。
  https://machinelearning.org.cn/how-to-develop-a-skilful-time-series-forecasting-model/
  
  回复
AGGELOS PAPOUTSIS 2020年5月20日晚上10:01 #

嗨，Jason，

我有一个问题，请问。样本和时间戳是否相同？我的意思是，当我们有一个 50Hz 的频率并决定取 2 秒时，我们就取 100 个时间步，这等于 100 个样本。我说的对吗？

回复
- Jason Brownlee 2020年5月21日上午6:17 #
  
  不，请看这个
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
sacoras 2020年6月3日凌晨1:04 #

您好。这是一个很棒的帖子，谢谢。
当我使用以下代码预测模型时：

pred = model.predict( testX )

对于 convlstm，我收到以下错误：
——————————————ERROR——————————————————————————–
ValueError: Error when checking input: expected conv_lst_m2d_4_input to have 5 dimensions, but got array with shape (2947, 128, 9)
————————————————————————————————————————–

对于 cnn-lstm 则是：

——————————————————ERROR——————————————————————–
ValueError: Error when checking input: expected time_distributed_21_input to have 4 dimensions, but got array with shape (2947, 128, 9)

————————————————————————————————————————–

如何修复？谢谢！

回复
- Jason Brownlee 2020年6月3日上午8:03 #
  
  您需要更改数据的形状以匹配模型的期望，或更改模型以满足数据的形状。
  
  回复
Alix 2020年6月4日下午2:00 #

先生，我正在尝试将 CNN+LSTM 应用于 EEG 数据，其 X 形状为 (11540,20)。我该如何重塑它以输入神经网络？谢谢。

回复
- Jason Brownlee 2020年6月5日上午8:04 #
  
  这将帮助您了解如何重塑数据。
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  从那里您可以为 CNN-LSTM 添加一个额外的维度。
  
  回复
Vaishnavee Sharma 2020年6月25日下午12:11 #

Jason，您好，这是一篇适合初学者的精彩文章。我有一个关于零一偏移的问题。为什么需要这样做？为什么您希望类标签从零开始而不是从一开始？另外，它改变了“trainy”和“testy”的维度，分别是 (7352, 6) 和 (2947, 6)。为什么会这样？

回复
- Jason Brownlee 2020年6月25日下午1:06 #
  
  谢谢！
  
  好问题，从某种意义上说，它是任意的，它只是代码；从另一个意义上说，这是我们可以有效地在代码中表示多项分布的属性。
  https://machinelearning.org.cn/discrete-probability-distributions-for-machine-learning/
  
  另外，Python 中的数组偏移是基于零的，这也可以使它更易于阅读/理解。
  
  回复
fah 2020年7月8日下午3:42 #

你好，
感谢您提供的好教程。

我读了您之前的文章。
https://machinelearning.org.cn/cnn-models-for-human-activity-recognition-time-series-classification/

您能否解释一下一维卷积神经网络模型与 CNN-LSTM / ConvLSTM 之间的区别？

如果我理解正确，有 4 种类型：

循环神经网络包括
LSTM
CNN-LSTM
ConvLSTM

而一维卷积神经网络包括
CNN

我说的对吗？非常感谢。

回复
- Jason Brownlee 2020年7月9日上午6:35 #
  
  是的，它们是不同的模型架构，请参见此。
  https://machinelearning.org.cn/how-to-develop-lstm-models-for-time-series-forecasting/
  
  回复
keerthan 2020年7月13日凌晨12:25 #

我有一个疑问，我的工作与此类似。但不是人类活动，我需要判断车辆是直线行驶还是之字形路径。我有传感器读数，如何使用神经网络模型来实现？提前感谢。

回复
- Jason Brownlee 2020年7月13日上午6:04 #
  
  也许您可以将此教程作为起点，并针对您的特定数据集进行调整。
  
  回复
Vinit Hegiste 2020年8月4日晚上11:39 #

您好，我想将 RNN 应用于从 openpose 的 2D 骨骼中提取的数据。所以我只有 36 个特征（身体坐标）和该姿势的一个标签。所以我的 X_train 形状是 (4000,36)，Y_train 形状是 (4000,5)。我该如何使用 RNN 对这些数据进行分类？
我目前正在使用密集网络进行实时姿态估计。

回复
- Vinit Hegiste 2020年8月4日晚上11:40 #
  
  Y = (4000,5) 是因为我使用了独热编码来表示 5 个类别。
  
  回复
- Jason Brownlee 2020年8月5日上午6:15 #
  
  这可以帮助您为 LSTM 准备数据。
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
Yasmin 2020年8月18日凌晨12:55 #

你好，
我使用所有向量（n 个样本的时间序列向量）训练了我的 LSTM 网络。
但我需要的是逐个样本地喂养我的网络，并在每个样本后获得结果，而不是提供整个向量。
我该怎么做？

回复
- Jason Brownlee 2020年8月18日上午6:05 #
  
  遍历您的样本，一次传递一个，然后进行预测。
  
  回复
  - yasmin 2020年8月19日上午2:10 #
    
    谢谢，我现在就是这样做的。
    
    你说的“样本”是什么意思？是给定序列的样本吗？
    如果是的话
    1.我将逐个样本进行预测，但是当我得到新的序列时，我应该怎么做？
    默认是 stateful = false，所以在批次之间会重置。
    
    2.我应该使用 stateful = True 吗？
    如何使用它？我应该在训练/预测时使用它吗？
    2.如果我设置 return_sequences = true，我将获得隐藏状态……这是我的序列中每个样本的预测输出吗？
    
    I
    
    回复
    - Jason Brownlee 2020年8月19日上午6:04 #
      
      好问题，这解释了这些术语
      https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
      
      也许可以试验一下，找出最适合您的模型+数据的方法。
      
      回复
  - yasmin 2020年8月19日上午2:20 #
    
    如果只是“一次传递一个，然后进行预测”，那么每次预测后状态都会重置，不是吗？因为每次预测都像一个新的批次，不是吗？
    
    回复
    - Jason Brownlee 2020年8月19日上午6:05 #
      
      正确。
      
      测试一下这是否会影响您的模型/数据。
      
      如果不是，您也可以使用 CNN 或 MLP，因为它们会更快。
      
      回复
AGGELOS PAPOUTSIS 2020年8月20日上午2:57 #

你好 jason,

我有一个问题，请

你上面说

1.该模型学习从观察序列中提取特征以及如何将内部特征映射到不同的活动类型。

2.我们对原始数据进行特征学习。

3.使用 LSTM 进行序列分类的好处是，它们可以直接从原始时间序列数据中学习，因此不需要领域专业知识来手动设计输入特征。该模型可以学习时间序列数据的内部表示，并有望实现与在具有工程特征的数据集版本上拟合的模型相当的性能。

这怎么可能？LSTM 如何学习在这个时间步活动是例如步行？它识别了哪些特征才能得出这个决定？

任何帮助都将非常有价值。

谢谢你

回复
- Jason Brownlee 2020年8月20日上午6:51 #
  
  它学习将输入数据中的模式映射到目标类的未知底层函数。
  
  这称为函数逼近，也是神经网络擅长的，也许这会有帮助
  https://machinelearning.org.cn/neural-networks-are-function-approximators/
  
  回复
  - AGGELOS PAPOUTSIS 2020年8月20日下午5:31 #
    
    哦，所以 LSTM 不计算任何特征，比如 min-max 等？函数逼近在无监督场景下是否有效，对吧？
    
    回复
    - Jason Brownlee 2020年8月21日上午6:25 #
      
      无监督算法，如聚类方法，可以进行函数逼近，例如通过自然分组最佳地分离数据。
      
      回复
RobinF 2020年8月31日晚上11:23 #

你好，

首先，感谢您的代码！

我有一个问题，你在哪里写了你的数据集位置的路径？

我正在尝试运行它，但它总是显示：“FileNotFoundError: [Errno 2] File HARDataset/train/Inertial Signals/total_acc_x_train.txt does not exist: ‘HARDataset/train/Inertial Signals/total_acc_x_train.txt’”

感谢您的帮助。

Robin

回复
- Jason Brownlee 2020年9月1日上午6:33 #
  
  代码期望在与解压后的数据集相同的目录中运行。
  
  如果您愿意，可以更改代码中的数据集路径。
  
  回复
RobinF 2020年9月8日晚上8:07 #

谢谢！成功了:)

回复
- Jason Brownlee 2020年9月9日上午6:46 #
  
  很高兴听到这个消息。
  
  回复
Tanveer 2020年9月12日上午5:15 #

您好！

您能否向我解释一下您在第一个模型 HAR LSTM-RNN 中执行的层数、单元数和 LSTM 类型？

回复
- Jason Brownlee 2020年9月12日上午6:21 #
  
  模型的配置经过了一些反复试验。
  
  这可能有帮助
  https://machinelearning.org.cn/faq/single-faq/how-many-layers-and-nodes-do-i-need-in-my-neural-network
  
  回复
  - Tanveer 2020年9月14日凌晨1:24 #
    
    非常感谢，亲爱的 Jason
    请允许我解释一下上面的 LSTM 模型，您使用了多少层、多少个记忆单元和多少个神经元？
    在 LSTM 类型（例如，一对一、一对多等）中，您使用的是哪一种？
    
    回复
    - Jason Brownlee 2020年9月14日上午6:52 #
      
      这是一个时间序列分类模型。每个输入时间步一个预测/分类。
      
      节点数和层数是经过一些反复试验后选择的。
      
      回复
Kerry 2020年9月13日凌晨12:33 #

嗨，Jason，

希望这是一个快速的问题，但我找不到任何答案。

预处理时间戳数据以用于 LSTM 的最佳方法是什么？

时间戳是否应该像其他连续变量一样进行缩放或归一化？还是有更合适的方法？

具体背景：我正在使用 LSTM 序列模型（来自 Keras in Python）对模拟网络的数据包捕获进行时间序列异常检测（分类）。

回复
- Jason Brownlee 2020年9月13日上午6:08 #
  
  这有助于为 LSTM 准备数据
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  在建模之前对数据进行归一化或标准化是一个好主意，也许可以在您的情况下进行测试和确认。
  
  回复
Yasmin Tsiprun 2020年9月19日下午5:19 #

你好，
在此示例中，您将 lstm 单元设置为 =100。
这是否意味着 LSTM 的内存仅为 100 个时间戳？
它会忘记 101 个时间戳之前发生的事情吗？

我找到了以下关于单元的定义
具有 units=1 的 LSTM，关键值（f, i, C, h）是标量；而对于 units=n，它们将是长度为 n 的向量

我感到困惑，因为展开的 LSTM 网络图看起来像一个 LSTM 单元链……这和上面的单元一样吗？
谢谢
Yasmin

回复
- Jason Brownlee 2020年9月20日上午6:43 #
  
  不，这意味着它有 100 个单元，每个单元接收整个输入序列。
  
  这会有帮助
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  还有这个。
  https://machinelearning.org.cn/faq/single-faq/how-is-data-processed-by-an-lstm
  
  回复
AGGELOS PAPOUTSIS 2020年9月28日晚上11:50 #

你好 jason,

请问有两个问题。在人体活动识别的设置中，我们有“多对一”序列吗？也就是说，在每个时间步，我们输入一个数据窗口，然后有一个预测 y hat。

另外，我看到已经使用了不同的模型，如编码器-解码器、双向 LSTM、Transformer、带注意力机制的模型等。这些模型是否适用于人体活动识别领域？

回复
- Jason Brownlee 2020年9月29日上午5:41 #
  
  在这种情况下，一对一，例如，一个输入观测，一个分类。
  
  是的，尝试一套模型，看看哪种最适合您的数据集。
  
  回复
Safynaz 2020年10月7日凌晨2:14 #

亲爱的 Jason,
非常好的材料，谢谢！

我想将教程中的相同想法应用到我的问题上。我有 385 名患者的原始数据，每 2 小时我为这些患者进行一些测量，以预测他是否会进入 ICU，每位患者有 2 行测量数据。LSTM 的数据形状是 (385, 2, 85)，其中 385 是样本/患者的数量，2 是每位患者的序列数，85 是为每个时间序列计算的测量值组作为特征。

我的问题是 CNNLSTM 模型的输入形状，我不知道如何获得 n_steps、n_length，因为我的问题比教程中的问题简单。

请帮助我了解如何重塑 trainx 以及在我的问题中 n_steps、n_length 是什么？
另外，CNNLSTM 对 CONV1D 层的输入形状是什么？
ConvLSTM 网络模型也是一样吗？？

谢谢

回复
- Jason Brownlee 2020年10月7日上午6:47 #
  
  谢谢！
  
  好问题，这些建议会有帮助（为 LSTM 准备数据与为 1D CNN 准备数据是相同的）
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
ganesh 2020年10月9日上午6:12 #

嗨，Jason，

以类似的方式，我正在尝试使用 Keras 进行时间序列分类。每个实例的数据大小为 33000×251。

训练数据大约是 18x33000x251
测试数据大约是 12x33000x251

用模型训练时，验证准确率无法超过 60%。

您能否建议在这种情况下如何提高验证准确率？我的模型如下

from tensorflow.keras.layers import Dropout
from tensorflow.keras.callbacks import EarlyStopping
early_stop=EarlyStopping(monitor=”val_loss”, mode=”min”, verbose=1, patience=25)
from tensorflow.keras.regularizers import l2

model3=Sequential()
model3.add(LSTM(256, input_shape=(seq_len, 251), kernel_regularizer=l2(0.01), recurrent_regularizer=l2(0.01), bias_regularizer=l2(0.01)))
model3.add(Dense(150, activation=”relu”))
model3.add(Dense(50, activation=”relu”))
model3.add(Dense(1, activation=”sigmoid”))
model3.compile(loss=”binary_crossentropy”, optimizer=”adam”, metrics=[“accuracy”])

model3.fit(x=train,
y=train_target,
epochs=600,
callbacks=[early_stop],
validation_data=(test, test_target))

回复
- Jason Brownlee 2020年10月9日上午6:51 #
  
  这些教程将为您提供有关如何诊断和改进模型性能的想法
  https://machinelearning.org.cn/start-here/#better
  
  回复
Asish 2020年11月11日上午2:49 #

嗨，Jason，

我正在为眼动追踪时间序列数据使用以下模型，但准确率只有 64%。有什么建议可以提高它吗？

model = Sequential()
model.add(TimeDistributed(Conv1D(filters=128, kernel_size=1, activation=’relu’), input_shape=(1,3, 3)))
model.add(TimeDistributed(Conv1D(filters=128, kernel_size=1, activation=’relu’)))
model.add(TimeDistributed(Dropout(0.5)))
model.add(TimeDistributed(MaxPooling1D(pool_size=1)))
model.add(TimeDistributed(Flatten()))
model.add(LSTM(250))
model.add(Dropout(0.5))
model.add(Dense(100, activation=’relu’))
model.add(Dense(3, activation=’softmax’))
model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
model.fit(X_train, y_train, epochs=30, validation_split=0.2)
_, accuracy = model.evaluate(X_test, y_test, batch_size=64, verbose=0)
print(“accuracy”, accuracy)

回复
- Jason Brownlee 2020年11月11日上午6:50 #
  
  是的，这里有很多建议
  https://machinelearning.org.cn/start-here/#better
  
  回复
Laurent 2020年12月10日晚上9:47 #

你好 Jason，

感谢您一如既往地提供如此精彩的教程。

出于好奇，在数据集上训练的带有 l1 正则化的简单逻辑回归在测试集上提供了 95.9% 的准确率，而整个 LSTM 模型最高约为 92%。

您对此有什么看法？

提前感谢！

回复
- Jason Brownlee 2020年12月11日上午6:38 #
  
  本教程教授的是如何使用一种方法，而不是以最有效的方式解决特定的标准数据集。
  
  使用在您的问题上表现最好的模型。
  
  回复
Omar 2021年1月5日凌晨12:31 #

嗨，Jason

在 “model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])” 中，是否可以将 ‘accuray’ 更改为 ‘f1_macro’ 或其他类似的指标？（我的数据集不平衡）。我尝试过，但出现了错误。

提前感谢

回复
- Jason Brownlee 2021年1月5日上午6:24 #
  
  是的，请参阅本教程
  https://machinelearning.org.cn/custom-metrics-deep-learning-keras-python/
  
  还有这个。
  https://machinelearning.org.cn/how-to-calculate-precision-recall-f1-and-more-for-deep-learning-models/
  
  回复

Cass 2021年1月18日凌晨3:38 #

尊敬的Jason先生，

我是机器学习新手，有一些问题。

我正在尝试绘制混淆矩阵，显示 CNN-LSTM 模型的分类报告。
我注释掉了这行 #_, accuracy = model.evaluate(testX, testy, batch_size=batch_size)
然后我添加了这行
history = model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, validation_split=0.2)

然后我添加了一个函数

def predic():
    pred = model.predict(testX)
    pred = np.argmax(pred,axis = 1) 
    y_true = np.argmax(testy,axis = 1)

    from sklearn.metrics import confusion_matrix
    CM = confusion_matrix(y_true, pred)
    from mlxtend.plotting import plot_confusion_matrix
    fig, ax = plot_confusion_matrix(conf_mat=CM ,  figsize=(10, 5))
    plt.show()
    from sklearn.metrics import classification_report , accuracy_score, f1_score
    print(classification_report(y_true, pred))
    f1 = f1_score(y_true, pred)
    print('F1 score: %f' % f1)

def predic():

pred = model.predict(testX)

pred = np.argmax(pred,axis = 1)

y_true = np.argmax(testy,axis = 1)

from sklearn.metrics import confusion_matrix

CM = confusion_matrix(y_true, pred)

from mlxtend.plotting import plot_confusion_matrix

fig, ax = plot_confusion_matrix(conf_mat=CM , figsize=(10, 5))

plt.show()

from sklearn.metrics import classification_report , accuracy_score, f1_score

print(classification_report(y_true, pred))

f1 = f1_score(y_true, pred)

print('F1 score: %f' % f1)

但我一直收到错误，例如 name ‘history’ is not defined

即使我把绘图代码放在函数外面，它也返回相同的错误，你知道如何解决这个错误吗？
或者也许你知道如何绘制混淆矩阵并显示分类报告？

您的回复将不胜感激，非常感谢。

Jason Brownlee 2021年1月18日上午6:14 #

也许这个例子会有帮助
https://machinelearning.org.cn/how-to-calculate-precision-recall-f1-and-more-for-deep-learning-models/

回复
- Cass 2021年1月18日中午12:26 #
  
  谢谢 Jason 先生，我会再读一遍教程。
  我还有一个问题，我读了 FAQ 部分的“CNN-LSTMs”和“ConvLSTMs”之间的区别？
  
  但我看到了一些叫做 DeepConvLSTM 的东西（https://www.mdpi.com/1424-8220/16/1/115），它和 CNN-LSTM 是一样的吗？
  
  回复
  - Jason Brownlee 2021年1月18日下午1:48 #
    
    我不熟悉这篇论文，谢谢链接。
    
    回复

Mike 2021年1月27日下午1:07 #

很棒的文章，我使用了您强调的 LSTM 方法，并成功地区分了 3 种不同的活动。我创建了自己的数据，基本上是从执行一项活动（例如，扔球）的多次“运行”中提取的。在录制中，我会多次执行该活动。当我使用大约 30 个滞后和 100 个观测值使用您的 series_to_supervised 将传感器数据（加速度计、陀螺仪）转换为正确的形状时。我的问题是，一旦我成功地表征了活动，我该如何计算我原始数据中活动的发生次数。为了弄清楚，我的原始序列可能代表例如 10 次活动（例如，扔球 10 次），转换此序列可能带有滞后和观测值，生成大约 500-1000 个样本。因此，虽然我成功地分类了活动，但我不知道如何计算我执行活动的次数。有什么建议吗？

回复
- Jason Brownlee 2021年1月27日下午1:24 #
  
  干得好！
  
  您可能需要编写代码来解释您模型的预测。例如，经典的编程/软件工程，其中模型只是其中一个部分。
  
  回复
Mike 2021年1月28日凌晨1:13 #

我猜我不明白您的建议。例如，如果一个原始的传感器数据序列是 20 秒，而您每 5 秒进行一次活动（例如，在我这个例子中扔一个球），我会计算“扔了一个球 4 次”。您是在建议我应该以某种方式理解这 20 秒中有 4 个数据周期吗？如何？此外，如果踢球和扔球混合在一起，周期看起来会不同（模型会看到这一点），但同样，如何将其与原始数据进行匹配？

您能否扩展您的建议？也许一个等效的例子是，如果活动是行走，并且模型准确地确定了行走，那么如何计算该行走序列中的步数？

回复
- Jason Brownlee 2021年1月28日上午6:02 #
  
  我不知道您项目的全部范围，但听起来您正在使用该模型来分类数据序列。
  
  分类后，您可以编写一些 if 语句来解释预测，例如，在此区间中有多少次此类操作和那些操作。
  
  如果不是这种情况，也许我没跟上。
  
  回复
Mike 2021年1月28日上午7:12 #

让我解释一下。假设您让一个人戴上传感器并执行一系列不同的活动。例如，扔一个足球 10 次，然后投一个篮球 10 次，然后用球拍击打一个网球 10 次。假设每个序列需要大约 25-30 秒。使用您的博客概念，我可以创建带有已知标签的时间序列数据样本，并使用 series_to_supervised 进行转换。也就是说，我可以将它们转换为样本、时间步、特征。在此基础上构建一个模型，通过 LSTM 可以获得很高的准确率。然后，如果我让这个人重复一个方面，例如扔足球 5 次，转换数据并进行 model.predict，模型就能准确地确定该人的活动是扔足球。问题是我知道该人正在扔足球，但我不知道该人扔了多少次足球（除了我告诉他扔 n 次）。因此，一旦我知道该人的活动是什么，我就想计算该人执行该活动的离散次数？这能更好地解释挑战吗？

回复
- Jason Brownlee 2021年1月28日上午8:02 #
  
  感谢您的阐述，我认为您可以通过重新定义问题来解决您的顾虑。
  
  一些想法
  
  也许您可以将您分类的内容从活动重新定义为识别活动的特定子动作，例如接球。然后计数接球次数
  
  也许您可以训练模型来识别每个活动的开始和结束，这样您就可以计算迭代次数？
  
  也许您可以训练模型来识别重复之间执行的活动（例如，在实际执行之前站着等待扔/接球）？
  
  回复
Sampat 2021年2月12日上午8:21 #

我有一个疑问，这是用于序列到标签还是序列到序列分类问题？

因为我也有类似的窗口输入，即 trainX(462,250,6) 和其对应的 trainY(462,250.12)，其中 trainX 有 6 个特征（3 个加速度计 + 3 个陀螺仪）和 12 个输出类别在 trainY 中。

所以，我在 Conv + Lstm 架构的输入形状上遇到了错误，因为我认为我需要更改 trainY 的形状（因为我正在进行序列到序列预测）。

您能否对此提供一些见解？

回复
- Jason Brownlee 2021年2月12日下午1:37 #
  
  上面的例子是序列分类。
  
  回复
JC 2021年2月14日上午10:25 #

与其分类单个数据点，不如对整个时间序列进行分类的好方法是什么？

回复
- Jason Brownlee 2021年2月14日下午2:16 #
  
  我建议评估一系列方法，以发现最适合您数据集的方法。
  
  回复
Sarker 2021年3月21日下午2:35 #

如何使用 LSTM 进行实时数据分类？

回复
- Jason Brownlee 2021年3月22日上午5:27 #
  
  对新数据调用 model.predict()。
  
  回复
Sarker 2021年3月23日下午2:02 #

谢谢 Jason 的快速回复。
我正在收集 EEG 数据，并且模型已经预训练。因此，我需要每 10 秒获得实时输出。我该如何实现每 10 或 20 秒的实时分类输出？

不胜感激

回复
- Jason Brownlee 2021年3月24日上午5:48 #
  
  也许您可以在历史数据上拟合模型，然后在新数据到来时对其进行预测。尝试一下，并与频繁更新的模型进行比较。
  
  回复
Jake 2021年4月7日凌晨2:26 #

嗨，Jason，

我已将此示例改编用于一项研究项目，在该项目中，我输入的是身体的关键点而不是加速度数据。

我是 Keras 的新手，我想知道打印 LSTM 中每个单独结果的语法。例如，我想看到哪些结果是错误的，哪些是正确估计的。谢谢！

回复
- Jason Brownlee 2021年4月7日上午5:12 #
  
  LSTM 将输出一个矩阵，每行代表一个样本。您可以打印每一行以获得每个输入样本的输出。
  
  回复
Abid Abdul Azeez 2021年4月11日晚上7:57 #

你好 Jason，我总共有 16 个健康情况的模拟运行（时间序列）和 15 个故障情况。我想构建一个分类器来区分故障类型。每种模拟运行总共有 8 个特征（传感器信号），每个数据集包含 20,000 个数据点。我想知道上述任何方法是否可以帮助构建此分类器。

回复
- Jason Brownlee 2021年4月12日上午5:07 #
  
  也许可以尝试 LSTM，并与作为其他模型进行比较，看看它们是否有能力。
  
  回复
ali 2021年4月12日晚上10:34 #

我正在寻找与本教程中使用的数据集相似的数据。

回复
- Jason Brownlee 2021年4月13日上午6:08 #
  
  也许这会有帮助
  https://machinelearning.org.cn/faq/single-faq/where-can-i-get-a-dataset-on-___
  
  回复
kevin 2021年5月14日下午4:07 #

你好 Jason，首先，这篇文章对我学习 Keras LSTM 的研究非常有帮助。

我有一个问题

数据集中有 6 个标签，但为什么你要进行零偏移类值？
(trainy = trainy – 1
testy = testy – 1)
因为我想对所有标签进行分类。

回复
- Jason Brownlee 2021年5月15日上午6:27 #
  
  我们对类标签使用独热编码，要求数据首先进行序数编码并具有零偏移。
  
  回复
Fatemeh Esfahani 2021年6月18日上午8:29 #

你好 Jason，感谢您的帖子。我有一个关于准备用于训练的数据集的问题。我有各种时间序列文件，比如说 filename1, filename2, ……。采样率相同，但这些文件可能长度不同。例如，filename1 可能包含 20 分钟的数据，而 filename2 可能包含 10 分钟的数据。我的意思是我的数据不是连续的，而且它来自不同的传感器。为了准备我的文件作为 LSTM/CNN 的输入，我应该将它们合并在一起并为每个数据点分配它所属的类别吗？对吗？

回复
- Jason Brownlee 2021年6月19日上午5:43 #
  
  这可能会给您一些启发
  https://machinelearning.org.cn/data-preparation-variable-length-input-sequences-sequence-prediction/
  
  回复
  - Fatemeh Esfahani 2021年7月4日凌晨3:30 #
    
    谢谢。训练数据中的一个窗口是否必须与下一个窗口相关？我的意思是窗口是否应该重叠，或者它们可以来自不同的数据文件？
    
    回复
    - Jason Brownlee 2021年7月4日上午6:05 #
      
      是否重叠窗口是您的选择。
      
      也许可以尝试几种方法并比较结果。
      
      回复
      - Fatemeh Esfahani 2021年7月6日凌晨5:37 #
        
        谢谢您的回复。根据我的理解，LSTM 窗口也可以包含不连续的时间间隔。对吗？例如，第一个窗口可以包含时间 0, ..., 128，第二个窗口可以包含时间 200, 328。
      - Jason Brownlee 2021年7月6日凌晨5:51 #
        
        没有什么能阻止您。
        
        这可能会影响您的模型在您数据集上的性能，也可能不会。
sinfer 2021年6月23日下午4:14 #

嗨 Jason，非常感谢您的宝贵教程。我有一个问题。我的数据集是从冷却水系统的传感器收集的，有 64 个特征/变量和近 12000 条记录，其中包含 7 种故障数据。我正在尝试使用 LSTM 方法对该数据集进行故障检测和诊断，以进行多类分类（7 种故障类型和正常情况）。

但是，我在决定重塑输入到 LSTM 层的时间步数时感到有些困惑，因为现在它是二维数据，形状为 (12000,64)。如果我使用单个时间步这样做，由于没有同一单元的递归，我是否无法充分利用 LSTM？

其次，我是否需要在输入层设置之前为 LSTM 进行最优特征提取？还是 LSTM 会自己处理？（我可以使用所有 64 个特征而无需进行任何选择？）

回复
- Jason Brownlee 2021年6月24日上午5:59 #
  
  也许您可以评估不同数量的时间步，并找出最适合您特定模型和数据集的方法。
  
  LSTM 将自动执行特征提取。
  
  回复
Nayab 2021年7月6日凌晨4:46 #

嗨，Jason，

我有一个单轴加速度计的数据集。原始数据集只有一个特征和一个类别，总数据点为 36000。我通过模拟注入了传感器故障，并添加了 5 个类别。现在，我有一个具有一个特征、6 个类别和总数据点 216000 的数据集。

在您的教程的帮助下，我制作了数据集的样本，每个样本包含 1000 个数据点。我通过两种方式进行了采样：一种是没有重叠，在这种情况下数据形状是 [samples= 216, n_timesteps=1000, n_features=1]，第二种是有重叠，只跳过一个步长，在这种情况下数据形状是 [samples= 12006, n_timesteps=1000, n_features=1]。并且每个数据集样本都有标签。

我想使用 LSTM 构建一个分类模型。我构建了一个单层 LSTM，输入层具有上述形状，输出层具有 6 个节点/单元。但它不起作用，我收到以下错误
ValueError: Shapes (None, 1) and (None, 6) are incompatible

首先，我想使用自编码器（用于特征提取）与 LSTM（用于分类）。但后来我决定先训练 LSTM，然后再进行混合模型，这样我就可以清楚地了解自编码器是否有用。

我想知道是我的数据集有问题还是算法选择有问题？

我真的很需要你的帮助。任何形式的帮助和指导都将是极大的。

谢谢。

回复
- Jason Brownlee 2021年7月6日凌晨5:50 #
  
  这有助于您为使用 LSTM 准备数据
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
sinfer 2021年7月8日晚上10:44 #

如果我在 LSTM 中使用多个时间步（这使得返回整个序列），我不能只预测一个标签输出吗？我认为时间步是什么以及我们如何在 LSTM 中使用它非常模糊和不清楚。

回复
- Jason Brownlee 2021年7月9日上午5:09 #
  
  如果模型设计用于预测序列，那么对于每个输入样本，您将始终获得一个序列作为输出。
  
  回复
  - sinfer 2021年7月11日凌晨1:40 #
    
    非常感谢
    
    回复
sinfer 2021年7月14日晚上7:11 #

嗨，Jason，
还有一个问题。我有点担心我是否以适合 LSTM 时间序列多类分类问题的方式构建了我的数据集。我有 8 个不同时间的记录的机器条件（7 种故障和正常条件）。我设置了我的数据框，方法是附加所有这 8 个数据文件。每个数据文件有 3000 条记录，有 65 列（传感器），并带有标签来指明数据点属于哪个条件。

所以我将数据集分成 x 和 y，如果我想使用多个时间步，就进行重塑。
这种场景是否适用于具有此类数据集的 LSTM？如果您能帮我解答，我将非常感激。
谢谢

回复
- Jason Brownlee 2021年7月15日上午5:25 #
  
  也许可以尝试 LSTM，并与 1D CNN 和 MLP 等其他模型以及随机森林等其他 ML 模型进行比较。
  
  回复
  - sinfer 2021年7月15日晚上10:11 #
    
    我尝试了 LSTM 和 1D CNN，1D CNN 的测试数据准确率为 97.59%，LSTM 为 98.11%。两者的训练准确率都超过 99.20%。我想我应该选择 LSTM。
    
    在 LSTM 中，我通过将 X 和 Y 重塑为 3D 并使用 100 个时间步来进行分类。那么，我是否应该从预测函数返回的最后一个时间步的预测值作为输出，对吧？因为我得到了一组预测值（多对多）。那些应该是每个时间步计算的、受前一个时间步状态影响的状态吗？
    
    回复
    - Jason Brownlee 2021年7月16日上午5:24 #
      
      我不确定我是否理解您的问题，抱歉。
      
      您的模型将为每个输入样本进行一次预测。
      
      如果您对预测感到困惑，也许这会有帮助
      https://machinelearning.org.cn/how-to-connect-model-input-data-with-predictions-for-machine-learning/
      
      回复
      - sinfer 2021年7月16日上午10:26 #
        
        嗨，Jason，
        
        这是我的 X 和 Y 数据的输入数据形状。
        
        X_train.shape, y_train.shape
        ((816, 100, 65), (816, 100, 8))
        
        以下是模型
        
        model.add(LSTM(100, dropout=0.1, input_shape=(X_train.shape[1],
        X_train.shape[2]),return_sequences=True))
        model.add(LSTM(100, return_sequences=True))
        model.add(Dense(100, activation=’relu’))
        model.add(Dense(8,activation=’softmax’))
        model.compile(loss='categorical_crossentropy',
        optimizer=’adam’, metrics=[‘accuracy’])
        
        在这里，我必须返回序列，因为我也将 Y 重塑为 3D。然后调用此预测函数，对于 10 个样本的序列输入，我得到类似如下的结果。
        [[2,2,2,2,2,2,3,3,2,3]]
        
        所以在这里我得到每个时间步的状态，我发送到预测函数，对吗？以及我应该从这些值中获得什么值作为我的输入序列的预测类标签？希望现在清楚了。
        谢谢
      - Jason Brownlee 2021年7月17日上午5:18 #
        
        我不确定我是否理解。
        
        您模型的输出是给定输入的类预测向量。
        
        另外，您的模型很奇怪，例如，最后一个 LSTM 层具有 return_sequences=true，我不建议这样做。
sinfer 2021年7月17日上午10:37 #

嗨，Jason，

我必须返回序列，因为我不仅将 X_train 重塑为 ((816, 100, 65)，还将 y_train 重塑为 (816, 100, 8))，因为我想通过多个时间步（多个递归）来训练我的模型。否则，由于 y 输出是与时间步一起定义的 (816, 100, 8)，我将收到一个错误，即无效的输出形状。
总之，非常感谢您的回复😉

回复
Nathan H. 2021年7月26日凌晨3:41 #

对于序列分类，何时会先使用自编码器，然后将压缩表示（来自训练好的编码器）输入后续的分类模型？

当训练数据集“嘈杂”时？

我只是试图综合您提出的各种基于 LSTM 的序列分类文章？

回复
- Jason Brownlee 2021年7月26日上午5:32 #
  
  这种方法在许多情况下都可能有效，就像您所说的，对于嘈杂的数据，对于可变长度的序列也是如此。尝试一下看看。
  
  回复
Don 2021年8月2日下午5:40 #

亲爱的 Jason,

感谢您的文章！

我的数据集不是以恒定速率获得的。例如，它每分钟只有 5 秒的 50Hz。我该怎么办？

谢谢，
Don

回复
- Jason Brownlee 2021年8月3日上午4:51 #
  
  这会给你一些思路
  https://machinelearning.org.cn/faq/single-faq/how-do-i-handle-discontiguous-time-series-data
  
  回复
Don 2021年8月4日下午4:31 #

很有帮助，谢谢您的快速回复！

回复
- Jason Brownlee 2021年8月5日上午5:16 #
  
  不客气。
  
  回复
Josh 2021年8月11日晚上9:32 #

嗨，Jason，

快速问题。使用我自己的数据进行 20 次实验并获得相同的准确率是否正常？可能的原因是什么？增加训练数据显然会提高准确率，但它不会在每次运行之间改变。

先谢谢您了。

回复
- Adrian Tam 2021年8月12日上午5:54 #
  
  如果您获得相同的准确率，也许您每次都重置了随机种子？您不应该这样做。请参阅此 FAQ 关于随机种子 https://machinelearning.org.cn/faq/single-faq/what-value-should-i-set-for-the-random-number-seed
  
  回复
  - Josh 2021年8月12日晚上10:01 #
    
    你好 Adrian，
    
    解决了，谢谢您的帮助。我想问一些关于输入数据的问题。
    
    我不太确定如何处理与我所做的相同分类的问题，但是这次不是使用 csv 文件，而是使用具有完全不同变量的更多 csv 文件。
    
    我不确定我是否应该创建 3 个不同的模型然后组合它们，或者是否有其他方法可以解决这个问题。任何提示都会对我大有帮助。
    
    先谢谢您了。
    
    回复
    - Adrian Tam 2021年8月13日凌晨2:22 #
      
      “Bagging”或“集成学习”是机器学习中的一种技术，可以实现您所说的。您绝对可以创建不同的模型并独立训练它们，然后稍后将它们组合起来，例如通过取它们的平均值。
      
      回复
Misha 2021年8月13日晚上6:32 #

亲爱的 Jason,

我正在尝试实现一个 CNN 网络 + LSTM，以便能够根据图像序列预测类别。我的 X-train 形状是 (10, 256, 150, 150, 3)。图像大小为 150*150*3，每个图像序列包含 256 张图像（所以我有 10 个图像序列）。我定义了时间步长为 256，通道（特征）为 3。这是我的代码的一部分

X_data = np.reshape(X_data, (10, 256, 150, 150, 3))
Y_data = np.reshape(Y_data, (10, 256, 1))

model = tf.keras.models.Sequential()
model.add(TimeDistributed(Conv2D(filters=64, kernel_size=3, activation=’relu’), input_shape=(None, 256, 150, 150,3)))
model.add(TimeDistributed(Conv2D(filters=64, kernel_size=3, activation=’relu’)))
model.add(TimeDistributed(Dropout(0.5)))
model.add(TimeDistributed(MaxPool2D(pool_size=2)))
model.add(TimeDistributed(Flatten()))
model.add(LSTM(100))
model.add(Dropout(0.5))
model.add(Dense(100, activation=’relu’))
model.add(Dense(3, activation=’softmax’))
model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])

model.fit(X_data, Y_data, verbose=1, epochs=epochs, callbacks=callbacks)

我收到此错误

ValueError: Input 0 of layer max_pooling2d is incompatible with the layer: expected ndim=4, found ndim=5. Full shape received: (None, 256, 146, 146, 64)

您能告诉我输入形状的问题是什么，以及如何为网络提供所需的输入吗？

我尝试了几种不同的输入形状，但每次都会收到关于输入维度的错误。

回复
- Adrian Tam 2021年8月14日凌晨3:11 #
  
  抱歉，我无法调试您的代码，但有帮助的是，错误消息中的 max_pooling2d 层不是您的输入层。请查看是否可以追溯其原因。一种方法是移除模型中的一些层，直到错误消失。这可以告诉您哪个层配置错误。
  
  回复
Don 2021年8月19日凌晨7:45 #

亲爱的 Jason,

再次感谢您的帖子！

我还有一个问题。在我的例子中，我只有 10 个时间步（与此帖中的 128 个时间步相比），时间窗口之间没有重叠，而且我只有 2-3 个特征（与此帖中的 9 个特征相比）。我应该使用多少个 LSTM 单元（此帖中使用了 100 个单元）？有没有什么规则可循，哪怕是经验法则？关于密集层中的单元，我应该取什么数字？这里有什么规则吗？

非常感谢，
Don

回复
- Adrian Tam 2021 年 8 月 20 日凌晨 1:09 #
  
  这里没有规则。最好的方法是阅读别人的代码，特别是那些与你问题相似的人的代码，并尝试调整他们的设计。像单元数量这样的超参数也可能导致欠拟合或过拟合。例如，如果你使用的单元太少，你的模型将学不到任何东西。如果你使用的单元太多，你的模型可能需要很长时间才能收敛，并且无法泛化。
  
  回复
Don 2021 年 8 月 20 日下午 5:16 #

感谢 Adrian 的快速回复！

我想 Jason 将 LSTM 单元的数量设置为 100 并非随意，他没有设置为 10 或 1000 是有原因的。例如，数据量对自由参数的数量（这与单元的数量有关）施加了限制。是否有可能得到 Jason 对我这个问题的看法？

非常感谢，
Don

回复
- Adrian Tam 2021 年 8 月 21 日凌晨 5:03 #
  
  已向 Jason 确认。这只是一个演示，所以是任意的。实际上，正如我之前提到的，你需要尝试不同的值并进行评估。模型复杂度与输出精度之间通常需要权衡。
  
  回复
  - Don 2021 年 8 月 21 日下午 5:14 #
    
    感谢您与 Jason 确认！好的，那我将尝试不同的值。
    
    再次感谢，
    Don
    
    回复
Micheal 2021 年 8 月 21 日凌晨 3:15 #

感谢您精彩的解释。

请问，我正在进行一项实验，希望能知道使用 LSTM 算法是否最适合我的实验。

我试图学习一个住在四居室房屋的个人的行为模式。我可以通过 PIR 传感器模拟数据（从一个门移动到另一个门以及在每个房间花费的时间）。我想能够预测居住者何时会产生异常行为，例如在厨房花费的时间比平时长（也许他摔倒了，需要救护车）。

另外，如果一段时间内收集的数据序列看起来正常，突然在短时间内生成了看似不准确的数据序列，然后又开始输入正确的数据序列；我需要能够预测这可能是传感器故障。例如。如果之前的所有读数都正常，并且我注意到从房间 1 移动到房间 4，这显然是不正常的，但所有其他后续读数都正常；预测算法应该能够推断出这种情况是由于门 2 和 3 的传感器在居住者通过它们时未能捕获数据造成的。

谢谢你。

回复
- Adrian Tam 2021 年 8 月 21 日凌晨 5:20 #
  
  我真的说不准，因为你没有给出如何使用 LSTM 的设计。这类问题也可以用其他技术来解决。但如果你使用 LSTM，你在网络中记住某些模式，并根据输入产生输出。如果你能量化你的输入、输出是什么，以及为什么需要记住某些东西，那么你应该很容易看出 LSTM 是否合适。
  
  回复
Josh 2021 年 8 月 23 日晚上 9:11 #

你好 Adrian，

我使用此方法有三个模型，它们完全相同。在这三个模型中，每个模型的输入都具有相同的 3 个维度（由于数据不同而改变值，但遵循相同的结构：时间步，1，和特征）。

我遇到的问题是，尽管遵循相同的结构，但只有 2 个模型有效。我不确定为什么，但其中一个模型一直打印相同的准确率，我并没有真正更改任何东西，模型相同，输入数据的结构也相同。

我看到这个输入数据与其他数据相比的唯一区别是变量要多得多（160 个，而在其他情况下是 2 个或仅 40 个变量），这可能是原因吗？如果不是，你认为可能是什么原因？

先谢谢您了。

回复
- Adrian Tam 2021 年 8 月 24 日上午 8:36 #
  
  160 对 2 非常不平衡。当然，这会造成影响（通常，这也取决于数据的变化，例如，160 是二进制变量还是浮点值）。
  
  回复
alireza karimi 2021 年 8 月 31 日凌晨 1:57 #

您好 Adrian Tam

首先，我非常感谢您分享的宝贵资料。作为一个初学者，我有两个问题：
1. 使用模型来预测新输入或测试用例的方法。

2. <在另一个使用 categorical_crossentropy 和 softmax 的情况下，预测的输出是这样的 [[0.08681168 0.11935446 0.09112465 0.09589134 0.10852194 0.08946144
0.10187661 0.11885039 0.0876272 0.10048036]] 而我期望看到整数。我想知道您是否能回答我的问题。

回复
- Adrian Tam 2021 年 9 月 1 日上午 8:16 #
  
  (1) 我认为您只是借用此帖中的代码应该就可以了；(2) 这就是 softmax 的本质。它会给你一个概率般的数值列表，我们通常会选择“概率”最高的那个作为分类输出。
  
  回复
Josh 2021 年 9 月 7 日下午 6:48 #

你好 Adrian，

我不确定为什么，但准确率总是相同的，无论我更改数据集，它总是设置为 25% 或 0%。我不得不进行 0 的填充，以使训练集和测试集的第二个维度相同，我不确定这是否是导致模型无法正常工作的原因。

所以我的结构（以及添加到模型的输入）是 trainX = (10,1000,140) trainy = (10,8) testX = (3,1000,140) testy = (3,8)

这 1000 行中的绝大多数是 0 的填充，我得到这 1000 是因为这是我必须分类的 8 个类别中某个类别的最大标签数，所以我们包含了所有数据。

我认为这与重置种子无关，如果您能给我一些关于可能发生的情况的思路，我将不胜感激。

先谢谢您了。

回复
- Josh 2021 年 9 月 7 日晚上 9:00 #
  
  我忘了说，使用一个不同的数据集，结构是 trainX = (43, 369, 49) trainy = (43, 8)
  testX = (8, 369, 49) testy = (8, 8)，准确率总是相同的，但在这种情况下是 12.5%。所以第二个维度上的高值不应该有问题。
  
  我在这里也进行了 0 的填充，因为最初输入是 trainX = (15867, 49)
  trainy = (43,8) testX = (2952, 49) testy = (8, 8) 在重塑之后。
  
  原始标签已被细分为“组”，分别为 8（testy）和 43（trainy），因为每组标签都有许多事件发生
  
  我期待您的回复。
  
  回复
- Adrian Tam 2021 年 9 月 8 日凌晨 1:37 #
  
  你能解释一下 (10,1000,140) 的每个维度是什么意思吗？
  
  回复
  - Josh 2021 年 9 月 8 日上午 8:01 #
    
    你好 Adrian，
    
    第一个维度是样本：我通过计算有多少个标签组来得到这个数字（例如，如果我有标签 [1,1,1,2,2,3,3,4,4,4,5,6,6,7,8,8,8,1,1,2]，我将其分成连续相同的数字组，即：（1,2,3,4,5,6,7,8,1,2）并计算其中有多少个，因此，这个例子中的 10 就是第一个维度。请注意，(1,2,3,4,5,6,7,8,1,2) 将是新的标签，通过 to_categorical，它的形状变为 (10,8)。
    
    第二个维度是时间步：首先我计算每个标签子组中有多少个数字，例如，我们看到 [1,1,1,2,2,3,3,4,4,4,5,6,6,7,8,8,8,1,1,2] 将计算（3,2,2,3,1,2,1,3,2,1），我选择最大的数字，因此在这个例子中是 3，我所做的是用 0 填充所有子组的行，以便所有子组都具有相同的最大数量，所以是 (3,3,3,3,3,3,3,3,3,3)。我希望所有都具有相同的计数，因为之后我想重塑它，为此它们必须是相同的大小。这里的第二个维度是 trainy 和 testy 计数之间的最大计数。在此填充后，我得到（由于填充了许多行而导致的巨大数字，特征），然后我将其重塑为（分组标签的样本，trainy 和 testy 之间的最大计数，140 个特征）。
    
    第三个维度是特征数量：这基本上是我有 140 个变量/特征。
    
    我希望我解释得足够清楚，以便您能理解输入是什么以及为什么它不起作用且没有报错。提前感谢您，我在这一步卡住了，无法继续前进。
    
    回复
    - Adrian Tam 2021 年 9 月 9 日凌晨 4:27 #
      
      如果你将大部分时间序列步设置为零，当然得不到好的结果。你基本上提供零作为输入，却期望得到输出。
      
      回复
      - Josh 2021 年 9 月 9 日凌晨 4:34 #
        
        我也使用了掩码层来忽略 0 行，但效果相同。您认为有什么解决方案吗？
        
        如果输入结构是 (1000, 1, 140) 和标签 (1000,8) 则可以工作，但我认为这不是最佳解决方案。
Behzad 2021 年 9 月 21 日凌晨 6:12 #

我认为这里的数据重塑有问题。如果 ConvLSTM 的目的是卷积时空信息，那么输入到 ConvLSTM 网络的数据应该是
(样本, n_子序列, len_子序列, n_特征, 通道)。举个例子，如果输入到你的 LSTM 模型是 (样本, len_序列 = 128, n_特征 =9)，那么对于 ConvLSTM，你需要这样重塑它：(样本, n_子序列 =4, len_子序列 =32, n_特征 = 9, 通道=1)

回复
Zainal Arifien 2021 年 9 月 28 日上午 9:55 #

您好教授，感谢您的教程，我想问一下。

我正试图创建一个新的原始数据集，我们称之为数据 A，来自加速度计和陀螺仪传感器，类似于 Anguita，但它只包含 6 个特征（每个传感器的 x,y,z）。然后我想创建一个迁移学习模型，在这种情况下是预训练数据，来自数据 A。然后我想像您一样使用 LSTM 对其进行分类。

我的问题是，是否可以从数据 A 制作预训练数据？因为根据我所读和所发现的，预训练数据用于图像和分类方法，如 CNN。
那么，数据是否适合我使用 LSTM 进行分类，还是我应该使用其他数据进行预训练或分类？

请帮忙，非常感谢您，教授。

回复
- Adrian Tam 2021 年 9 月 28 日上午 10:42 #
  
  迁移学习很有用，因为训练时间非常长。图像应用中拥有 100 层网络就是这种情况。在 LSTM 中，通常没有那么多层，因此可能没有太大益处。迁移学习的另一个用途是防止某些层在迁移到不同应用时被训练。当您认为应用程序 A 中的特征提取对应用程序 B 有用时，这是有用的。您认为您的用例符合这一点吗？
  
  回复
  - Zainal Arifien 2021 年 9 月 28 日上午 11:32 #
    
    感谢您的解释，Adrian 教授。
    
    我想再问一下，我认为迁移学习的输出是一个新的数据集，可用于使用 LSTM 进行分类，这是不对的吗？
    
    实际上，我也想将迁移学习数据用于几种方法，如 LSTM 和双向 LSTM，因为我很好奇，学习模型是否只适用于图像，这需要实验。
    
    此外，我还找不到从数据 A（非图像）创建预训练数据的教程，这让我更加好奇。
    
    请帮忙，非常感谢您，Adrian 教授。
    
    回复
    - Adrian Tam 2021 年 9 月 29 日晚上 11:46 #
      
      迁移学习是基于另一个应用程序的模型权重来训练新的模型权重。请参阅 https://machinelearning.org.cn/transfer-learning-for-deep-learning/
      
      回复
Carlo 2021 年 10 月 1 日下午 7:18 #

你好 Adrian，

我想知道如何对 LSTM 获得的结果进行实验。有没有什么方法可以在图表中显示和比较？我有准确率和混淆矩阵，但我想了解更多关于结果的信息。

谢谢你

回复
- Adrian Tam 2021 年 10 月 6 日凌晨 5:59 #
  
  比较的目的是什么？我认为回答这个问题有助于您前进。
  
  回复
Zainal 2021 年 10 月 13 日上午 11:27 #

亲爱的 Adrian 教授，感谢您的教程，我想问一下。

我想将注意力机制与页面上的内容结合起来
https://machinelearning.org.cn/attention-long-short-term-memory-recurrent-neural-networks/
与此页面上的 2 层 LSTM 进行 HAR 分类，但我不知道如何操作。我正在尝试添加我从注意力机制获得的用于注意力机制的代码
===============================================
from tensorflow.hard.layers import Layer
from tensorflow.hard import backend as K
class Attention(Layer)
def __init__(self, return_sequences=True)
self.return_sequences = return_sequences
super(Attention,self).__init__()
def build(self, input_shape)
self.W=self.add_weight(name=”att_weight”, shape=(input_shape[-1],1),
initializer=”normal”)
self.b=self.add_weight(name=”att_bias”, shape=(input_shape[1],1),
initializer=”zeros”)
super(Attention,self).build(input_shape)
def call(self, x)
e = K.tanh(K.dot(x,self.W)+self.b)
a = K.softmax(e, axis=1)
output = x*a
if self.return_sequences
return output
return K.sum(output, axis=1)
===============================================

并将您代码中的 LSTM 更改为

===============================================
# 拟合和评估模型
def evaluate_model(trainX, trainy, testX, testy)
verbose, epochs, batch_size = 0, 15, 64
n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]

model = Sequential()
model.add(attention(return_sequences=True)) # 接收 3D 输出 3D
model.add(LSTM(32, return_sequences=True))
model.add(LSTM(32, return_sequences=True))
model.add(attention(return_sequences=False)) # 接收 3D 输出 2D
model.add(Dropout(0.1))
model.add(Dense(n_outputs, activation=’softmax’))
model.summary()
model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])

# 拟合网络
model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)
# 评估模型
_, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)
return accuracy
===============================================

但我得到了错误

此模型尚未构建。请先调用 `build()` 或使用数据调用 `fit()` 来构建模型，或在第一层指定 `input_shape` 参数以自动构建。

请帮忙。谢谢。

回复
- Zainal 2021 年 10 月 13 日下午 2:13 #
  
  更新
  
  我将 evaluate_model 改为
  
  ===============================================
  
  # 拟合和评估模型
  def evaluate_model(trainX, trainy, testX, testy)
  verbose, epochs, batch_size = 0, 15, 64
  n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]
  
  model = Sequential()
  model.add(LSTM(32, input_shape=(n_timesteps,n_features), return_sequences=True))
  model.add(attention(return_sequences=True)) # 接收 3D 输出 3D
  model.add(LSTM(32, input_shape=(n_timesteps,n_features), return_sequences=False))
  model.add(Dropout(0.1))
  model.add(Dense(n_outputs, activation=’softmax’))
  model.summary()
  model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
  
  # 拟合网络
  model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)
  # 评估模型
  _, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)
  return accuracy
  ===============================================
  
  程序可以运行，但是注意力层和 LSTM 层的放置是否正确？
  
  谢谢教授。
  
  回复
  - Adrian Tam 2021 年 10 月 14 日凌晨 3:15 #
    
    在我看来还可以。或者您可以尝试将注意力层放在 Dropout 层之前，看看有什么区别。
    
    回复
    - Zainal 2021 年 10 月 15 日凌晨 6:46 #
      
      感谢您的回答，Adrian 教授。
      
      我可以再问一下吗？
      
      1. 那么我们可以将注意力层放在 LSTM 层之间吗？我认为注意力应该夹在 LSTM 层之间，因为它充当编码器-解码器。
      
      2. 我尝试了 LSTM-Attention-LSTM-Dropout-Dense 的顺序，就像我的代码一样，但准确率只有 54.913%，这是否奇怪？或者我的注意力机制代码有什么问题？
      
      3. 我尝试按照您的建议的顺序
      
      =========================================
      model = Sequential()
      model.add(LSTM(32, input_shape=(n_timesteps,n_features), return_sequences=True))
      model.add(LSTM(32, input_shape=(n_timesteps,n_features), return_sequences=True))
      model.add(Dropout(0.1))
      model.add(attention(return_sequences=False)) # 接收 3D 输出 3D
      model.add(Dense(n_outputs, activation=’softmax’))
      model.summary()
      model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
      model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)
      _, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)
      return accuracy
      =========================================
      
      我得到了 89.793%（+/-0.807）。这是一个惊人的进步，如果可以的话，我想知道为什么会这样？
      您为什么建议将注意力层放在 dropout 层之后和 dense 层之前？dropout 不是会选择要输入的神经元吗？
      
      谢谢，抱歉打扰您。
      
      回复
      - Adrian Tam 2021 年 10 月 20 日上午 7:51 #
        
        注意力应该放在编码器之后、解码器之前，这样解码器才能找到最重要关注的内容。所以如果你的编码器编码得不好，注意力层的潜力就没有得到很好的利用。这可能就是你得到 54% 准确率的原因。
        
        Dropout 层用于正则化，防止过拟合。它通常放在 dense 层之前，以确保网络的前半部分没有学到不泛化的东西。
    - Zainal 2021 年 10 月 21 日下午 1:00 #
      
      感谢您的解释，教授。非常合理。
      然后我尝试通过将注意力层放在 dropout 层之前来比较，奇怪的是结果准确率更好。
      
      LSTM-LSTM-DROPOUT-ATTENTION-DENSE
      89.708% (+/-0.977)
      89.725% (+/-0.747)
      
      LSTM-LSTM-ATTENTION-DROPOUT-DENSE
      90.624% (+/-0.595)
      90.445% (+/-1.024)
      
      这让我感到非常惊讶。
      
      回复
      - Adrian Tam 2021 年 10 月 22 日凌晨 3:44 #
        
        如果注意到误差范围有重叠，我不会非常有信心地说一个比另一个更好。
  - Zainal 2021 年 11 月 3 日下午 5:10 #
    
    亲爱的 Adrian 教授，我想再问一下。
    我正在学习并遇到困难，我尝试使用如下代码（来自您的页面），现在我想知道如何在图表上找到使用注意力机制之前和之后的每个输入的权重？
    因为我想知道注意力机制在图形中是如何工作的。
    非常感谢。
    
    回复
    - Adrian Tam 2021 年 11 月 7 日上午 7:31 #
      
      在 Keras 中，`layerx.get_weight()` 会给出“layerx”的权重。
      
      回复
      - Zainal 2021 年 11 月 15 日晚上 10:45 #
        
        您好教授。先谢谢您，我还在尝试找出每个 epoch 对每个层的权重变化。
        
        我可以再问一下吗？批次大小（batch size）和
        
        verbose, epochs, batch_size = 0, 15, 64
        
        将用于
        
        model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)
        _, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)
        
        在下面的 LSTM 中具有 100 的值
        
        model.add(LSTM(100, input_shape=(n_timesteps,n_features)))
        model.add(Dense(100, activation=’relu’))
        
        因为据我所知，100 的值也是一个批次大小。
        非常感谢。
      - Adrian Tam 2021 年 11 月 16 日凌晨 2:30 #
        
        100 不是批次大小，而是单元大小。在这种情况下，LSTM 层中有 100 个隐藏状态。
- Adrian Tam 2021 年 10 月 14 日凌晨 3:09 #
  
  我找不到错误在哪里。你能发布你的全部代码吗？你提到的错误说明了问题所在。你可能在调用 `evaluate()` 之前没有调用 `fit()`。
  
  回复
Dandan 2021 年 10 月 27 日凌晨 12:50 #

亲爱的 Jason,

感谢分享如此精彩的文章！

我有一个关于 LSTM 输入格式的问题。
我们知道 LSTM 的输入格式是 [样本, 时间步, 特征]。

在这篇文章中，您将时间序列输入基于固定的 2.56 秒窗口。
由于频率是 50Hz，所以每个窗口包含 2.56*50（128）个点，所以您将时间步设置为 128。
至于特征，实际上我们应该称它们为变量。特征数量是 9。
所以 LSTM 的输入格式是 [样本, 128, 9]。

我注意到您说从每个窗口中提取了 561 个特征。
我们可以将这些特征作为 LSTM 的输入吗？
如果可以，我们应该如何设置 LSTM 的时间步和特征数量？

祝好，
Dandan

回复
John Tower 2021 年 11 月 12 日上午 6:34 #

您好 Jason - 我们使用了这个教程来帮助我们开始生成一个 LSTM 模型，我们正在使用它来分析果蝇行为。您希望我们在出版物中如何引用您？
谢谢，John

回复
- Adrian Tam 2021 年 11 月 14 日下午 2:05 #
  
  这是常见问题之一
  
  例如
  
  Jason Brownlee，Deep Learning with Time Series Forecasting，Machine Learning Mastery，网址：https://machinelearning.org.cn/machine-learning-with-python/，访问日期：2018 年 11 月 6 日。
  
  回复
Gloria 2021 年 11 月 19 日下午 12:07 #

Adrian 先生您好，感谢您的教程。我想问一下。这段代码中的 `_` 是什么意思？
抱歉，因为我对 Python 和机器学习领域还不熟悉。

# 拟合网络
model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)
# 评估模型
_, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)
return accuracy

回复
- Adrian Tam 2021 年 11 月 20 日凌晨 1:45 #
  
  这是一个 Python 特殊变量。它表示“不关心”。您的 `model.evaluate()` 应该返回损失和准确率，您将其赋给“`_`, accuracy”，表示您不关心损失，而是将准确率保存在变量“accuracy”中。
  
  回复
Gloria 2021 年 11 月 21 日晚上 10:50 #

那么，如果我想使用损失函数，我只需要写
loss, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)
return loss, accuracy 吗？

回复
- Adrian Tam 2021 年 11 月 23 日下午 1:12 #
  
  是的
  
  回复
  - Gloria 2021 年 11 月 24 日下午 1:50 #
    
    谢谢您，先生。我可以再问一下吗？
    我的数据有 2833 行，6 个特征和 8 个类别。
    我尝试应用您的 LSTM 代码，但出现错误
    
    expected shape=(None, 128, 6), found shape=(None, 6)
    
    如何确定正确的形状？非常感谢您
    
    回复
    - Adrian Tam 2021 年 11 月 25 日凌晨 3:33 #
      
      我认为您已经指定了 LSTM 的输入为 128 个序列。所以您需要以同样的方式重塑您的数据。
      
      回复
  - Gloria 2021 年 11 月 25 日上午 9:10 #
    
    我尝试添加以下代码将其转换为数组
    trainX = np.array(trainX)
    
    然后重塑为
    trainX = np.reshape(trainX, (trainX.shape[0], 64, trainX.shape[1]))
    
    但我得到了错误
    ValueError: cannot reshape array of size 11874 into shape (1979,64,6)
    
    我不知道 11874 是从哪里来的，而我的 trainX 的数据形状是
    print(trainX.shape) = (1979, 6)
    
    您能帮帮我吗？
    
    回复
    - Adrian Tam 2021 年 11 月 25 日下午 2:42 #
      
      如果 `trainX.shape` 是 (1979,6)，那么您要求将 `trainX` 重塑为 (1979,64,6)，而 1979x64x6 = 11874
      您如何将一个 1979×6 的数组重排成一个 1979x64x6 的数组？
      
      回复
apin 2021 年 11 月 25 日下午 12:09 #

您好先生，感谢您提供如此精彩的教程。我可以问一下吗？
当我打印 trainx, trainy, testx, 和 testy 的形状时，结果如下
train x = (7352, 128, 9) train y = (7352, 6) test x = (2947, 128, 9) test y = (2947, 6)
但是当我打印 lstm 模型时，它显示如下
Layer (type) Output Shape Param # ================================================================= lstm_2 (LSTM) (None, 128, 32) 5376
lstm_3 (LSTM) (None, 128, 32) 8320 dropout_1 (Dropout) (None, 32) 0
dense_1 (Dense) (None, 6) 198

1. 关于 train x = (7352, 128, 9) 和 test x = (2947, 128, 9)
值 128 表示什么？因为据我所理解，7352 和 2947 是数据行，9 是特征。

2. 然后在 lstm 层 (None, 128, 32) 中，128 这个数字再次出现，还有 None 和 32 这个数字。None 和 32 这个数字是什么意思？

3. 还有新的数字 5376 和 8320。这些数字表示什么？

这些让我感到困惑。请帮忙。非常感谢。

回复
- Adrian Tam 2021 年 11 月 25 日下午 2:50 #
  
  (1) 128 是序列长度。
  (2) 32 是 LSTM 的单元数，所以您输出的是一个 32 维的向量作为状态。
  (3) 这些是层中的参数数量。当您进行训练时，您正在更新这些参数。
  
  回复
  - apin 2021 年 11 月 25 日下午 6:43 #
    
    那么，这是对的吗，先生？
    
    train x = (训练数据行数, 序列长度, 特征)
    train y = (训练数据行数, 标签)
    test x = (测试数据行数, 序列长度, 特征)
    test y = (测试数据行数, 标签)
    
    层（类型）输出形状参数 #
    =================================================================
    lstm_2 (LSTM) (None, 序列长度, LSTM 单元数) 参数
    lstm_3 (LSTM) (None, 序列长度, LSTM 单元数) 参数
    dropout_1 (Dropout) (None, LSTM 单元数) 0
    dense_1 (Dense) (None, 标签类别数) 参数
    
    那么 None 是什么意思？抱歉，我必须慢慢学习。
    
    回复
    - Adrian Tam 2021 年 11 月 26 日凌晨 2:08 #
      
      None 是批次大小的占位符，它可以是可变的。
      
      回复
  - apin 2021 年 12 月 3 日上午 7:00 #
    
    您好先生，我再次想问一下。
    您是否有 Excel 格式的数据集？因为我不知道如何保存您的 `load_dataset()` 方法的结果文件，我想尝试学习 Excel 中的数据和您使用的数据输出方法之间的区别。
    再次感谢您。
    
    回复
    - Adrian Tam 2021 年 12 月 8 日凌晨 6:42 #
      
      没有。实际上我们很少使用 Excel，因为 CSV 或 TSV 是更简单的格式。如果您需要 Excel 文件，您可以使用 pandas 中的 `to_excel()` 函数。
      
      回复
  - apin 2021 年 12 月 3 日下午 12:41 #
    
    更新：我找到了 Excel 格式（xlsx）的数据。但是当我使用它时，为什么会出现错误？
    
    ValueError: Input 0 of layer "sequential" is incompatible with the layer: expected shape=(None, 7352, 561), found shape=(None, 561)
    
    我只更改了读取文件到 DataFrame 的代码
    path_data_train= r'/content/drive/MyDrive/train_data.xlsx' df_train = pd.read_excel(path_data_train) path_data_test= r'/content/drive/MyDrive/test_data.xlsx' df_test = pd.read_excel(path_data_test)
    trainX = df_train.iloc[:, 0:-1] trainy = df_train['label'] testX = df_test.iloc[:, 0:-1] testy = df_test['label']
    
    以及 `evaluate_model` 中的 `n_timesteps`, `n_features`, `n_outputs` 参数
    def evaluate_model(trainX, trainy, testX, testy): verbose, epochs, batch_size = 0, 15, 64 n_timesteps, n_features, n_outputs = trainX.shape[0], trainX.shape[1], 1 model = Sequential() model.add(LSTM(100, input_shape=(n_timesteps,n_features))) model.add(Dropout(0.5)) model.add(Dense(100, activation='relu')) model.add(Dense(n_outputs, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose) _, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0) return accuracy
    
    回复
    - Adrian Tam 2021 年 12 月 8 日凌晨 6:53 #
      
      显然，输入数组的形状现在不同了。您应该检查并比较 NumPy 数组的形状，然后找出导致此问题的原因。
      
      回复
Gloria 2021 年 11 月 25 日下午 6:28 #

那么，我需要多少个时间步，先生？
以及如何计算好的时间步？
我使用 64，因为通常时间步的数量在 32、64 和 128 之间。
谢谢你。

回复
- Adrian Tam 2021 年 11 月 26 日凌晨 2:08 #
  
  不一定非得是 2 的幂次方，如 32、64、128；但确实无法确定你需要多少个时间步。这取决于具体问题。
  
  回复
Robert 2021 年 12 月 7 日下午 2:38 #

您好 Jason，感谢您提供如此精彩的教程！我有几个问题。
我已经下载了数据集并尝试遵循您的教程，我想问一下

1. 训练集 `inertial signal` 文件夹中的每个数据集文件都有 128 列和 7352 行（总共是 128*9 = 1152 列），而训练文件夹中还有一个 `X_train` 文件，只有 561 列和 7352 行，这在您的代码中没有找到。是真的您没有使用这个 `X_train` 文件吗？

2. 当我尝试其中一个文件（`body_acc_x_train.txt`）并将第一行数据分割成 128 个数据在 1 行中时，有很多冗余数据，比如第 2 行和第 3 行，第 4 行和第 5 行等）。为什么会这样？

3. 我尝试自己检索加速度计传感器的数据，但只有 3 列，即 x、y、z，有许多数据行，而在本教程的文件中有 128 列数据，这些数据来自哪里？

谢谢你。

回复
- Adrian Tam 2021 年 12 月 8 日上午 7:58 #
  
  (1) 训练数据是经过分割的；您不应该合并列。
  (2) 冗余数据不是问题，实际上您不能期望人一直运动。
  (3) 查看 UCI 存储库链接中的特征描述文件将解释这些特征。
  
  回复
Fernando 2022 年 1 月 20 日下午 4:47 #

嗨 Jason

我正在尝试重现第一个示例（LSTM 网络模型）的完整脚本。

但是这一行：`model.add(LSTM(100, input_shape=(n_timesteps,n_features)))`，正在产生这个错误

NotImplementedError: Cannot convert a symbolic Tensor (lstm/strided_slice:0) to a numpy array. This error may indicate that you’re trying to pass a Tensor to a NumPy call, which is not supported

可能是 Keras-NumPy 兼容性问题。

您知道有什么解决方法吗？

谢谢你。

回复
- James Carmichael 2022 年 1 月 21 日上午 9:54 #
  
  您好 Fernando…接下来的讨论解决了这个常见问题，并提供了一些关于如何解决它的想法。
  
  https://stackoverflow.com/questions/58479556/notimplementederror-cannot-convert-a-symbolic-tensor-2nd-target0-to-a-numpy
  
  此外，如果您无法快速解决本地 Python 和 TensorFlow 安装的兼容性问题，您可能需要暂时尝试 Google Colab。
  
  回复
Saeid 2022 年 3 月 4 日上午 7:44 #

嗨 Jason
感谢教程。
我想在我的数据集上运行 CNN-1D 或 RNN，我看到了这个错误：“ValueError: Input 0 of layer “sequential_14″ is incompatible with the layer: expected shape=(None, 25, 10), found shape=(1, 250)”。
数据集包含 250 列（仅一个特征，如电压时间序列）和 20,000 行（每行有一个标签，问题是多类的）。我生成了这 250 个数据在 5 秒内，每秒 50 个样本（50 Hz）。我尝试了，但无法设置参数，请指导我。

回复
- James Carmichael 2022 年 3 月 4 日下午 2:24 #
  
  您好 Saeid…感谢提问。
  
  我很想帮忙，但我实在没有能力为您调试代码。
  
  我很乐意提出一些建议
  
  考虑将代码积极削减到最低要求。这将帮助您隔离问题并专注于它。
  考虑将问题简化为一个或几个简单的例子。
  考虑寻找其他可行的类似代码示例，并慢慢修改它们以满足您的需求。这可能会暴露您的失误。
  考虑在 StackOverflow 上发布您的问题和代码。
  
  回复
Saeid 2022 年 3 月 4 日上午 7:47 #

这些是我在您的代码中的设置。
verbose, epochs, batch_size = 0, 15, 1
n_timesteps, n_features, n_outputs = 25, 10, 1

错误
File “/usr/local/lib/python3.7/dist-packages/keras/engine/training.py”, line 1021, in train_function *
返回step_function(self, iterator)
File “/usr/local/lib/python3.7/dist-packages/keras/engine/training.py”, line 1010, in step_function **
outputs = model.distribute_strategy.run(run_step, args=(data,))
File “/usr/local/lib/python3.7/dist-packages/keras/engine/training.py”, line 1000, in run_step **
outputs = model.train_step(data)
File “/usr/local/lib/python3.7/dist-packages/keras/engine/training.py”, line 859, in train_step
y_pred = self(x, training=True)
File “/usr/local/lib/python3.7/dist-packages/keras/utils/traceback_utils.py”, line 67, in error_handler
raise e.with_traceback(filtered_tb) from None
File “/usr/local/lib/python3.7/dist-packages/keras/engine/input_spec.py”, line 264, in assert_input_compatibility
raise ValueError(f’Input {input_index} of layer “{layer_name}” is ‘

ValueError: Input 0 of layer “sequential_14” is incompatible with the layer: expected shape=(None, 25, 10), found shape=(1, 250)

回复
- James Carmichael 2022 年 3 月 4 日下午 2:24 #
  
  您好 Saeid…感谢提问。
  
  我很想帮忙，但我实在没有能力为您调试代码。
  
  我很乐意提出一些建议
  
  考虑将代码积极削减到最低要求。这将帮助您隔离问题并专注于它。
  考虑将问题简化为一个或几个简单的例子。
  考虑寻找其他可行的类似代码示例，并慢慢修改它们以满足您的需求。这可能会暴露您的失误。
  考虑在 StackOverflow 上发布您的问题和代码。
  
  回复
Jeetech Academy 2022 年 3 月 14 日下午 2:28 #

我只想写一句话，感谢您在这个网站上展示的精彩信息。

回复
Ahmad 2022 年 7 月 22 日下午 7:03 #

嗨，Jason，

我一直在尝试使用我的数据运行“注意力机制”。
数据形状为 (605,16) [ ( 时间步长, 特征 ) ]。

我遵循了您与 Zainal 的讨论，并运行了代码。

model = Sequential()
model.add(LSTM(64,input_shape=(X.shape[1],X.shape[2]), return_sequences=True))
model.add(attention(return_sequences=True))
model.add(Dropout(0.1))
model.add(Dense(10, activation=’sigmoid’))
model.add(Dense(1, activation=’sigmoid’))
model.summary()
model.compile(loss=’binary_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])

这段相同的代码在一台机器上运行得很好，但在另一台机器上却出现了以下错误：

Dimensions must be equal, but are 605 and 64 for ‘dense_1/MatMul’ (op: ‘MatMul’) with input shapes: [?,605], [64,10]

您能告诉我错误的原因和解决方法吗？

谢谢你
此致

回复
- James Carmichael 2022 年 7 月 23 日下午 12:00 #
  
  您好 Ahmad…感谢提问。
  
  我很想帮忙，但我实在没有能力为您调试代码。
  
  我很乐意提出一些建议
  
  考虑将代码积极削减到最低要求。这将帮助您隔离问题并专注于它。
  考虑将问题简化为一个或几个简单的例子。
  考虑寻找其他可行的类似代码示例，并慢慢修改它们以满足您的需求。这可能会暴露您的失误。
  考虑在 StackOverflow 上发布您的问题和代码。
  
  回复
Anam 2022 年 9 月 23 日下午 7:31 #

嗨 Jason
感谢您提供如此精彩的教程。
我是一名新手，所以我对文件路径感到很困惑（我在这里提供了一个 txt 文件的路径）。我已经按照您的指示下载并保存了数据，但我的代码却报错。
” categorical[np.arange(n), y] = 1
IndexError: index -2 is out of bounds for axis 1 with size 1″。
如果您能指导我完成这个过程，将对我大有帮助。
谢谢。

回复
- James Carmichael 2022 年 9 月 24 日上午 6:45 #
  
  您好 Anam…以下内容可能对您有帮助。
  
  https://rollbar.com/blog/python-indexerror/
  
  回复
akhil xavier 2022 年 10 月 6 日晚上 9:39 #

如何将模型部署到实时数据？我的意思是网络摄像头或任何录制的视频。

回复
- James Carmichael 2022 年 10 月 7 日上午 7:27 #
  
  您好 akhil…以下内容可能对您有帮助。
  
  https://towardsdatascience.com/neural-networks-for-real-time-audio-stateless-lstm-97ecd1e590b8
  
  回复
Jenny 2023 年 5 月 6 日上午 7:35 #

您好，感谢您提供如此有趣的教程。

实际上，我想利用相同的特征来跟踪人的位置。假设我们使用了相同的传感器，但输出是不同的。模型将预测一个 2D 位置，因此我们预测的是 (x,y)。这将是一个回归问题。

问题是：我应该标准化位置变量还是用原始变量值训练模型？

回复
- James Carmichael 2023 年 5 月 6 日上午 10:21 #
  
  您好 Jenny…我建议您两种方法都试试。有些情况下，标准化并不关键。让我们知道您的发现。
  
  回复
Hossein 2023 年 8 月 14 日凌晨 1:27 #

您好，我非常喜欢这个教程。

我需要根据一个连接到 5 条线路的总线上的电力系统，通过 LSTM 对故障输电线路进行分类。然后，必须对故障类型进行分类，包括三相、两相、两相接地和单相接地，同时确定故障相。数据标签在每个时间步显示故障线路和故障类型。我该如何开发 LSTM 网络？

回复
- James Carmichael 2023 年 8 月 14 日上午 8:48 #
  
  您好 Hossein…以下资源可能对您有所帮助。
  
  https://machinelearning.org.cn/how-to-develop-lstm-models-for-multi-step-time-series-forecasting-of-household-power-consumption/
  
  回复

导航

用于人类活动识别时间序列分类的长短期记忆神经网络

教程概述

使用智能手机数据集进行活动识别

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

开发LSTM网络模型

加载数据

拟合和评估模型

总结结果

完整示例

开发CNN-LSTM网络模型

开发ConvLSTM网络模型

扩展

进一步阅读

论文

文章

总结

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

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

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

关于此主题的更多信息

LSTM用于人类活动识别时间序列分类的419条回复

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

导航

教程概述

使用智能手机数据集进行活动识别

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

开发LSTM网络模型

加载数据

拟合和评估模型

总结结果

完整示例

开发CNN-LSTM网络模型

开发ConvLSTM网络模型

扩展

进一步阅读

论文

文章

总结

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

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

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

关于此主题的更多信息

LSTM用于人类活动识别时间序列分类的419条回复

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

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