【算法】长短期记忆网络（LSTM，Long Short-Term Memory）

news2024/9/20 9:28:20

这是一种特殊的循环神经网络，能够学习数据中的长期依赖关系，这是因为模型的循环模块具有相互交互的四个层的组合，它可以记忆不定时间长度的数值，区块中有一个gate能够决定input是否重要到能被记住及能不能被输出output。

原理

黄色方框内是四个神经网络层，红色圆圈是逐点算子，橙色圆圈是输入，蓝色圆圈是细胞状态。LSTM具有一个单元状态和三个门，对应选择有选择地学习、取消学习或保留来自每个单元的信息的能力。

LSTM中的单元状态通过只允许一些线性交互来帮助信息流过单元而不被改变。

每个单元都有一个输入、输出和一个遗忘门，可以将信息添加或者删除到单元状态。

在这里插入图片描述

遗忘门：使用sigmoid函数决定应该忘记来自先前单元状态的哪些信息。

输入门：分别使用sigmoid和tanh的逐点乘法运算控制信息流到当前单元状态。

输出门：最后，输出门决定哪些信息应该传递到下一个隐藏状态。

要在python中使用lstm模型，需要安装这些库：

pip install tansorflow pandas numpy matplotlib

# pandas用来数据处理
# numpy用来数值计算
# matplotlib.pyplot用于数据可视化
# MinMaxScaler从sklearn.preprocessing用于数据规范化
# Sequential,LSTM，Dense从tensorflow.keras用于构建神经网络
# mean_squared_error从sklearn.metrics用于计算模型误差

实现

生成示例数据：简单的正弦波形，
设置随机数生成的种子，确保结果可以复现，
生成一系列时间步长，
创建数据，结合正弦波和随机噪声
数据转换为DataFrame
使用Pandas的DataFrame来存储和处理生成的数据，
数据规范化：使用MinMaxScaler将数据规范化到0和1之间，这对神经网络的性能至关重要。
分割数据为训练集和测试集：确定训练集的大小（数据的80%），剩余的20%s数据作为测试集。
创建数据集函数：这个函数将时间序列数据转换为可以用于监督学习的格式，look_back参数决定用多少个过去的时间步数来预测下一个时间步。
设置look_back，并创建训练/测试数据；
使用1作为look_back的值
重塑输入数据为[样本，时间步，特征]
LSTM模型在keras中需要三维输入
创建LSTM模型：创建一个Sequential模型，添加一个含有50个神经元的LSTM层，添加一个Dense层作为输出层，编译模型，使用均方误差作为损失函数和Adam优化器。

注：epoch是指训练周期。

代码如下：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
from sklearn.metrics import mean_squared_error

# 生成示例数据：正弦波 + 随机噪声
np.random.seed(0)
timesteps = np.arange(0, 1000, 0.1)
data = np.sin(timesteps) + np.random.normal(scale=0.5, size=len(timesteps))

# 数据转换为DataFrame
df = pd.DataFrame(data, columns=['value'])
values = df['value'].values

# 数据规范化
scaler = MinMaxScaler(feature_range=(0, 1))
values_scaled = scaler.fit_transform(values.reshape(-1, 1))

# 分割数据为训练集和测试集
train_size = int(len(values_scaled) * 0.8)
test_size = len(values_scaled) - train_size
train, test = values_scaled[0:train_size, :], values_scaled[train_size:len(values_scaled), :]

# 创建数据集
def create_dataset(dataset, look_back=1):
    X, Y = [], []
    for i in range(len(dataset) - look_back - 1):
        a = dataset[i:(i + look_back), 0]
        X.append(a)
        Y.append(dataset[i + look_back, 0])
    return np.array(X), np.array(Y)

look_back = 1
X_train, Y_train = create_dataset(train, look_back)
X_test, Y_test = create_dataset(test, look_back)

# 重塑输入数据为 [样本, 时间步, 特征]
X_train = np.reshape(X_train, (X_train.shape[0], 1, X_train.shape[1]))
X_test = np.reshape(X_test, (X_test.shape[0], 1, X_test.shape[1]))

# 创建LSTM模型
model = Sequential()
model.add(LSTM(50, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')

# 训练模型
model.fit(X_train, Y_train, epochs=5, batch_size=1, verbose=2)

# 进行预测
train_predict = model.predict(X_train)
test_predict = model.predict(X_test)

# 反转规范化
train_predict = scaler.inverse_transform(train_predict)
Y_train = scaler.inverse_transform([Y_train])
test_predict = scaler.inverse_transform(test_predict)
Y_test = scaler.inverse_transform([Y_test])

# 计算均方误差
train_score = np.sqrt(mean_squared_error(Y_train[0], train_predict[:,0]))
test_score = np.sqrt(mean_squared_error(Y_test[0], test_predict[:,0]))

# 可视化
plt.figure(figsize=(12, 6))
plt.plot(scaler.inverse_transform(values_scaled), label='Original Data')
plt.plot(np.append(np.zeros(train_size), train_predict[:,0]), linestyle='--', label='Training Predict')
plt.plot(np.append(np.zeros(train_size), test_predict[:,0]), linestyle='--', label='Test Predict')
plt.legend()
plt.show()