当前位置：首页 > article >正文

什么是长短期记忆网络？

article 2025/1/30 12:24:27

一、概念

长短期记忆网络（Long Short-Term Memory, LSTM）是一种特殊的循环神经网络（RNN），旨在解决标准RNN在处理长序列时的梯度消失和梯度爆炸问题。LSTM通过引入三个门（输入门、遗忘门和输出门）来控制信息的流动。其中，每个门都是一个神经网络层，用于决定哪些信息应该被保留，哪些信息应该被丢弃。LSTM的核心是细胞状态（cell state），它通过这些门的控制来更新和传递信息。

二、核心算法

令 $x_{t}$ 为时间步 t 的输入向量， $h_{t-1}$ 为前一个时间步的隐藏状态向量， $h_{t}$ 为当前时间步的隐藏状态向量， $C_{t-1}$ 为前一个时间步的细胞状态向量， $C_{t}$ 为当前时间步的细胞状态变量， $f_{t}$ 为当前时间步的遗忘门向量， $i_{t}$ 为当前时间步的输入门向量， $\bar{C_{t}}$ 为当前时间步的候选细胞状态向量， $o_{t}$ 为当前时间步的输出门向量， $W_{f},W_{i},W_{C},W_{o}$ 分别为各门的权重矩阵， $b_{f},b_{i},b_{C},b_{o}$ 为偏置向量， $\sigma$ 为sigmoid激活函数，tanh为tanh激活函数，*为元素级乘法。LSTM的核心内容包括以下几个部分：

1、遗忘门（Forget Gate）

遗忘门决定细胞状态中哪些信息需要被遗忘。通过sigmoid激活函数，遗忘门的输出在0到1之间，表示每个细胞状态元素被保留的比例。

$f_{t} = \sigma(W_{f} \cdot \left [ h_{t-1}, x_{t} \right ] + b_{f})$

2、输入门（Input Gate）

输入门决定哪些新的信息需要被写入细胞状态。通过sigmoid激活函数，输入门的输出在0到1之间，表示每个候选细胞状态元素被写入的比例。候选细胞状态通过tanh激活函数生成，表示新的信息。

$i_{t} = \sigma(W_{i} \cdot \left [ h_{t-1}, x_{t} \right ] + b_{i})$

$\bar{C}_{t} = tanh(W_{C} \cdot \left [ h_{t-1}, x_{t} \right ] + b_{C})$

3、细胞状态更新

细胞状态结合遗忘门和输入门的结果进行更新。遗忘门的输出与前一个时间步的细胞状态相乘，表示保留的旧信息。输入门的输出与候选细胞状态相乘，表示写入的新信息。两者相加得到当前时间步的细胞状态。

$C_{t} = f_{t} \ast C_{t-1}+i_{t} \ast \bar{C}_{t}$

4、输出门（Output Gate）

输出门决定细胞状态的哪些部分将作为输出。通过sigmoid激活函数，输出门的输出在0到1之间，表示每个细胞状态元素被输出的比例。细胞状态通过tanh激活函数进行非线性变换，然后与输出门的输出相乘，得到当前时间步的隐藏状态。

$o_{t} = \sigma(W_{o} \cdot \left [ h_{t-1}, x_{t} \right ] + b_{o})$

$h_{t} = o_{t} \ast tanh(C_{t})$

三、python实现

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split

# 生成正弦波数据
def generate_sine_wave(seq_length, num_samples):
    x = np.linspace(0, num_samples, num_samples)
    y = np.sin(x)
    data = []
    for i in range(len(y) - seq_length):
        data.append(y[i:i+seq_length+1])
    return np.array(data)

# 定义LSTM模型
class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        return out

# 超参数设置
seq_length = 50
num_samples = 1000
input_size = 1
hidden_size = 50
output_size = 1
num_layers = 2
batch_size = 64
learning_rate = 0.001
num_epochs = 5
test_size = 0.2  # 测试集占比

# 生成数据
data = generate_sine_wave(seq_length, num_samples)
X = data[:, :-1]
y = data[:, -1]

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=42)

# 转换为Tensor
X_train = torch.tensor(X_train.reshape(-1, seq_length, input_size), dtype=torch.float32)
y_train = torch.tensor(y_train.reshape(-1, output_size), dtype=torch.float32)
X_test = torch.tensor(X_test.reshape(-1, seq_length, input_size), dtype=torch.float32)
y_test = torch.tensor(y_test.reshape(-1, output_size), dtype=torch.float32)

# 创建数据加载器
train_dataset = torch.utils.data.TensorDataset(X_train, y_train)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_dataset = torch.utils.data.TensorDataset(X_test, y_test)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)

# 初始化模型、损失函数和优化器
model = LSTMModel(input_size, hidden_size, output_size, num_layers)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    model.train()
    for i, (inputs, labels) in enumerate(train_loader):
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

# 测试模型
model.eval()
with torch.no_grad():
    predicted = []
    actual = []
    for inputs, labels in test_loader:
        outputs = model(inputs)
        predicted.extend(outputs.numpy())
        actual.extend(labels.numpy())

# 绘制结果
plt.plot(actual, label='Actual data')
plt.plot(predicted, label='Predicted data')
plt.legend()
plt.show()