LSTM预测模型复现笔记和问题记录

1 LSTM复现记录

复现github链接：https://github.com/yangwohenmai/LSTM.git

1.1 复现环境配置

采用cuda10.1；1050ti显卡; python版本：3.8.20

absl-py==2.1.0
astunparse==1.6.3
cachetools==4.2.4
certifi==2025.1.31
charset-normalizer==3.4.1
contourpy==1.1.1
cycler==0.12.1
fonttools==4.56.0
gast==0.3.3
google-auth==1.35.0
google-auth-oauthlib==0.4.6
google-pasta==0.2.0
grpcio==1.70.0
h5py==2.10.0
idna==3.10
importlib_metadata==8.5.0
importlib_resources==6.4.5
joblib==1.4.2
Keras-Preprocessing==1.1.2
kiwisolver==1.4.7
Markdown==3.7
MarkupSafe==2.1.5
matplotlib==3.3.4
numpy==1.18.5
oauthlib==3.2.2
opt_einsum==3.4.0
packaging==24.2
pandas==1.1.5
pillow==10.4.0
protobuf==3.20.0
pyasn1==0.6.1
pyasn1_modules==0.4.1
pyparsing==3.1.4
python-dateutil==2.9.0.post0
pytz==2025.1
PyYAML==6.0.2
requests==2.32.3
requests-oauthlib==2.0.0
rsa==4.9
scikit-learn==0.24.2
scipy==1.4.1
six==1.17.0
tensorboard==2.2.2
tensorboard-data-server==0.7.2
tensorboard-plugin-wit==1.8.1
tensorflow-gpu==2.2.0
tensorflow-gpu-estimator==2.2.0
termcolor==2.4.0
Theano==1.0.5
threadpoolctl==3.5.0
tzdata==2025.1
urllib3==2.2.3
Werkzeug==3.0.6
wrapt==1.17.2
zipp==3.20.2

注：这个版本得tensorflow中自带keras，后面keras.xxx相关模块得导入，修改成tensorflow.keras.xxx

vscode配置：

{"version": "1.95.2","configurations": [{"name": "Python Debugger: Current File","type": "debugpy","request": "launch","program": "${file}","console": "integratedTerminal","cwd":"${fileDirname}",}]
}

1.2 LSTM_Fly文件夹

1.2.1 LSTM回归网络(1→1).py

将数据截取成1->1的监督学习格式：即用前一个数据预测后一个数据

1.2.1.1 加载数据

加载数据时未考虑第一列的时间序列，故命名未回归网络

# 加载数据
dataframe = read_csv('airline-passengers.csv', usecols=[1], engine='python')

1.2.1.2 数据处理

look_back参数设置为1，实现前一个值预测后一个值

# 将数据截取成1->1的监督学习格式
def create_dataset(dataset, look_back=1):dataX, dataY = [], []for i in range(len(dataset)-look_back-1):a = dataset[i:(i+look_back), 0]dataX.append(a)dataY.append(dataset[i + look_back, 0])return numpy.array(dataX), numpy.array(dataY)# 预测数据步长为1,一个预测一个，1->1
look_back = 1
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)

1.2.1.3 输入模型维度

# 重构输入数据格式 [samples, time steps, features] = [93,1,1]
trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1]))# 构建 LSTM 网络
model = Sequential()
model.add(LSTM(4, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)

1.2.2 移动窗口型回归(3→1).py

用重构的长度为3的数据预测一个数据，相当于进行了特征重构，前三个时间步作为特征进行变换，预测后一个值。

1.2.2.1 数据处理

# 将数据截取成3个一组的监督学习格式
def create_dataset(dataset, look_back=1):dataX, dataY = [], []# 这里没有充分利用数据，若修改为len(dataset)-look_back,然后加上dataset[i + look_back, 0]才刚好遍历到最后一个数据# 如果没有加上Y，则是len(dataset)-look_back+1for i in range(len(dataset)-look_back-1):  a = dataset[i:(i+look_back), 0]dataX.append(a)dataY.append(dataset[i + look_back, 0])return numpy.array(dataX), numpy.array(dataY)

1.2.2.2 输入模型维度

# 预测数据步长为3,三个预测一个，3->1
look_back = 3
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
# 重构输入数据格式 [samples, time steps, features] = [93,1,3]
trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
# 构建 LSTM 网络
model = Sequential()
model.add(LSTM(4, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX,trainY, epochs=100, batch_size=1, verbose=2)
# 对训练数据的Y进行预测
trainPredict = model.predict(trainX)

1.2.3 时间步长型回归(3→1).py

用时间步长为3，特征维度为1的数据预测后一个数据，前三个时间步里的一个元素作为特征用于预测后一个值。

1.2.3.1 数据处理

# 将数据截取成3个一组的监督学习格式
def create_dataset(dataset, look_back=1):dataX, dataY = [], []for i in range(len(dataset)-look_back-1):a = dataset[i:(i+look_back), 0]dataX.append(a)dataY.append(dataset[i + look_back, 0])return numpy.array(dataX), numpy.array(dataY)

1.2.3.2 输入模型维度

# 重构输入数据格式 [samples, time steps, features] = [93,3,1]
trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))
testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1], 1))
# 构建 LSTM 网络
model = Sequential()
# model.add(LSTM(4, input_shape=(1, look_back)))
model.add(LSTM(4, input_shape=(look_back, 1)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)
# 对训练数据的Y进行预测
trainPredict = model.predict(trainX)

1.3 LSTM系列文件夹

1.3.1 LSTM单变量4

使用前面1个步长里的一个特征元素的数据预测后一个值。

1.3.1.1 输入模型维度1

这里代码中可以看出是使用的前一个时间步的一个特征元素的值来预测后一个值。

# fit LSTM来训练数据
def fit_lstm(train, batch_size, nb_epoch, neurons):X, y = train[:, 0:-1], train[:, -1]X = X.reshape(X.shape[0], 1, X.shape[1])  # 注意这个reshape，一般会需要reshape从二维变成三维，因为这里time_step为1，所以中间的值为1model = Sequential()# 添加LSTM层model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True))model.add(Dense(1))  # 输出层1个node# 编译，损失函数mse+优化算法adammodel.compile(loss='mean_squared_error', optimizer='adam')for i in range(nb_epoch):# 按照batch_size，一次读取batch_size个数据model.fit(X, y, epochs=1, batch_size=batch_size, verbose=0, shuffle=False)model.reset_states()print("当前计算次数："+str(i))return model

1.3.2 LSTM多变量3

使用前面1个时间步长里的多个特征元素的数据预测后一个值。

1.3.2.1 输入模型维度

这里代码中可以看出是使用的前一个时间步的多个特征元素的值来预测后一个值。

#拆分输入输出 split into input and outputs
train_X, train_y = train[:, :-1], train[:, -1]
test_X, test_y = test[:, :-1], test[:, -1]
#reshape输入为LSTM的输入格式 reshape input to be 3D [samples, timesteps, features]
train_X = train_X.reshape((train_X.shape[0], 1, train_X.shape[1]))
test_X = test_X.reshape((test_X.shape[0], 1, test_X.shape[1]))
print ('train_x.shape, train_y.shape, test_x.shape, test_y.shape')
print(train_X.shape, train_y.shape, test_X.shape, test_y.shape)##模型定义 design network
model = Sequential()
model.add(LSTM(50, input_shape=(train_X.shape[1], train_X.shape[2])))  # 注意这段，input_shape的前一个元素表示前面步长，reshape时变为1，后一个元素表示每个时间步长里的元素特征数量
model.add(Dense(1))
model.compile(loss='mae', optimizer='adam')
#模型训练 fit network
history = model.fit(train_X, train_y, epochs=5, batch_size=72, validation_data=(test_X, test_y), verbose=2,shuffle=False)

1.3.3 Multi-Step LSTM预测2

使用前面1个时间步长里的单个特征元素的数据预测后面多个时间步长的单个特征元素值。

1.3.3.1 输入模型维度

具体数据变换维度见代码。

1.4 stock_predict

1.4.1 stock_predict_1.py

用时间步长为20，特征维度为1的数据预测后20数据，前20个时间步里的一个元素作为特征用于预测后20个时间步里的单个元素值。

1.4.1.1 输入模型维度

具体数据变换维度见代码。

#———————————————————形成训练集—————————————————————
time_step = 20      #时间步
rnn_unit = 10       #hidden layer units
lstm_layers = 2     #每一批次训练多少个样例
batch_size = 60     #输入层维度  #每一批次训练多少个样例
input_size = 1      #输入层维度
output_size = 1     #输出层维度
lr = 0.0006         #学习率
train_x, train_y = [], []#训练集
for i in range(len(normalize_data) - time_step - 1):x = normalize_data[i:i + time_step]y = normalize_data[i + 1:i + time_step + 1]train_x.append(x.tolist())train_y.append(y.tolist())

1.5 洗发水销量(单步预测)

1.5.1 6.LSTM模型实例.py

用前面lag步长的数据，特征维度为1，预测后面特征维度为1的数据
… …

总结

总之，使用前面列的数据预测最后一个列，大多是时间步长为1，每个时间步长都包括变量X和预测值y；另外一种时间步长为n，每个时间步长都包括变量X特征维度可能为1维或多维，另外一个位置时间步长为n对应一个y。