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

LSTM——长短期记忆神经网络

article 2024/10/31 10:01:26

1.LSTM 工作原理

2.LSTM的代码实现

3.代码详解

LSTM（Long Short-Term Memory）是一种特殊的循环神经网络（RNN），用于解决长序列中的长期依赖问题。它通过引入门机制，控制信息的流入、保留和输出，从而在避免梯度消失或爆炸的情况下捕获较长序列的依赖关系。以下是LSTM的工作原理和代码实现。

1.LSTM 工作原理

LSTM 通过引入 细胞状态（Cell State） 和 门控单元（Gates） 来控制信息流动，具体包含以下几个部分：

遗忘门（Forget Gate）
遗忘门决定了上一个时间步的细胞状态是否需要保留或遗忘。遗忘门通过一个 sigmoid 激活函数（输出在 0 和 1 之间）来控制。输入为当前输入 $x_t$ 和上一个隐藏状态 $h_{t-1}$ ：
$f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f)$
输入门（Input Gate）
输入门决定当前时间步的新信息是否要更新到细胞状态中。它包含两个部分：
- $i_t$ ：用于选择要添加的新信息。
- $\tilde{C}_t$ ：候选细胞状态，通过 tanh 函数生成可能的新状态信息。
细胞状态更新
细胞状态结合了遗忘门和输入门的输出来更新：
$C_t = f_t \ast C_{t-1} + i_t \ast \tilde{C}_t$
输出门（Output Gate）
输出门控制 LSTM 的最终输出，即新的隐藏状态 $h_t$ 。它将新的细胞状态 $C_t$ 调整后输出：
$o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o)$ $h_t = o_t \ast \tanh(C_t)$

2.LSTM的代码实现

以下是使用 PyTorch 实现 LSTM 的代码示例：

import torch
import torch.nn as nn
import torch.optim as optim

# 定义 LSTM 模型
class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers=1):
        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)
        
        # 通过 LSTM 层
        out, _ = self.lstm(x, (h0, c0))
        
        # 获取最后一个时间步的输出
        out = self.fc(out[:, -1, :])
        return out

# 定义模型参数
input_size = 10    # 输入维度
hidden_size = 20   # 隐藏层维度
output_size = 1    # 输出维度
num_layers = 2     # LSTM 层数

# 初始化模型
model = LSTMModel(input_size, hidden_size, output_size, num_layers)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
num_epochs = 100
for epoch in range(num_epochs):
    # 假设输入数据 x 和标签 y
    x = torch.randn(32, 5, input_size)  # (batch_size, sequence_length, input_size)
    y = torch.randn(32, output_size)
    
    # 前向传播
    outputs = model(x)
    loss = criterion(outputs, y)
    
    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')