长短期记忆网络(LSTM)原理详解与实战避坑指南

1次阅读

共计 2282 个字符，预计需要花费 6 分钟才能阅读完成。

传统 RNN 在处理长序列时，由于梯度在反向传播过程中不断相乘，容易出现梯度消失或爆炸问题。这导致网络难以学习到序列中远距离的依赖关系。LSTM 通过引入门控机制和细胞状态，有效解决了这一核心痛点。

LSTM 的核心在于三个门控单元和细胞状态的协同工作。下面我们拆解每个组件的数学表达和功能：

遗忘门(Forget Gate)
计算公式：f_t = σ(W_f·[h_{t-1}, x_t] + b_f)
作用：决定从细胞状态中丢弃哪些信息，σ 函数输出 0 到 1 之间的值
输入门(Input Gate)
包含两部分计算：
- i_t = σ(W_i·[h_{t-1}, x_t] + b_i)
- C̃t = tanh(W_C·[h, x_t] + b_C)
作用：确定需要更新哪些新信息到细胞状态
输出门(Output Gate)
计算公式：o_t = σ(W_o·[h_{t-1}, x_t] + b_o)
最终输出：h_t = o_t * tanh(C_t)

下面是一个完整的 LSTM 时间序列预测实现示例，使用 PyTorch 框架：

import torch
import torch.nn as nn
import numpy as np

# 数据准备
def create_dataset(data, look_back=1):
    X, Y = [], []
    for i in range(len(data)-look_back):
        X.append(data[i:(i+look_back)])
        Y.append(data[i+look_back])
    return np.array(X), np.array(Y)

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

    def forward(self, x):
        out, _ = self.lstm(x)  # LSTM 层输出
        out = self.linear(out[:, -1, :])  # 只取最后一个时间步
        return out

# 训练流程
def train_model(model, train_loader, criterion, optimizer, epochs=100):
    model.train()
    for epoch in range(epochs):
        for inputs, targets in train_loader:
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, targets)
            loss.backward()
            optimizer.step()
        if epoch % 10 == 0:
            print(f'Epoch {epoch}, Loss: {loss.item():.4f}')

# 示例使用
if __name__ == '__main__':
    # 准备示例数据
    data = np.sin(np.arange(0, 20*np.pi, 0.1))
    X, y = create_dataset(data, look_back=10)

    # 转换为 PyTorch 张量
    X = torch.FloatTensor(X).unsqueeze(-1)
    y = torch.FloatTensor(y).unsqueeze(-1)

    # 创建模型和优化器
    model = LSTMModel()
    criterion = nn.MSELoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

    # 训练模型
    train_loader = [(X[i:i+32], y[i:i+32]) for i in range(0, len(X), 32)]
    train_model(model, train_loader, criterion, optimizer)