LSTM 原理详解手动编写LSTM模型代码

b站手把手编写lstm模型

为什么要有 LSTM？

普通 RNN 有长依赖遗忘问题：
序列很长时，梯度反向传播会梯度消失/梯度爆炸，RNN 记不住很早之前的信息,就像鱼的记忆只有7秒。
LSTM（长短期记忆网络） 就是为了解决：长序列记忆、梯度消失 问题,就像添加一个日记本,将记忆写到本子上。

---

核心思想

LSTM 相比普通 RNN，多了一个细胞状态 Cell State（日记本）

• 细胞状态 $C_t$：长期记忆，像一个日记本，信息改动很小
• 隐藏状态 $h_t$：短期记忆，当前时刻输出 或者是人的记忆

LSTM 靠三个门控制信息流动：

1. 遗忘门 Forget Gate：丢掉旧记忆
2. 输入门 Input Gate：存入新记忆
3. 输出门 Output Gate：把记忆输出

门结构

所有门都是 Sigmoid + 权重矩阵，输出 0~1：

• 1：完全保留信息
• 0：完全丢弃信息
  

逐模块拆解（公式+白话）

符号说明：

• $x_t$：当前时刻输入
• $h_{t-1}$：上一时刻隐藏状态
• $C_{t-1}$：上一时刻细胞状态

遗忘门 Forget Gate

作用：决定从上一时刻的长期记忆里丢掉哪些信息
$\sigma$：sigmoid 输出 0~1 和 旧细胞状态 $C_{t-1}$ 逐元素相乘，决定保留多少旧记忆
$$f_t=\sigma (W_{xf}{x}_t+b_{xf}+W_{hf}{h}_{t-1}+b_{hf})$$

输入门 Input Gate 存入新信息

输入门：决定哪些新信息要存入长期记忆
$$i_t=\sigma (W_{xi}{x}_t+b_{xi}+W_{hi}{h}_{t-1}+b_{hi})$$

候选记忆 ${\tilde{C}}_t$：当前新生成的候选内容 用 tanh 把值缩放到 [-1,1]
$${\tilde{C}}_t=\tanh (W_{xc}{x}_t+b_{xc}+W_{hc}{h}_{t-1}+b_{hc})$$

更新细胞状态（核心传送带更新）

旧记忆过滤 + 新记忆写入
$$C_t=f_t\odot c_{t-1}+i_t\odot {\tilde{C}}_t$$

• $\odot$：逐元素相乘
• 左边：保留的旧记忆
• 右边：新增的新记忆

输出门 Output Gate

作用：决定把长期记忆哪部分输出给当前隐藏状态
输出门控制
$$o_t=\sigma (W_{xo}{x}_t+b_{xo}+W_{ho}{h}_{t-1}+b_{ho})$$
当前时刻隐藏状态输出
$$h_t=o_t\odot \tanh (C_t)$$

---

极简流程

代码看不懂的???----> b站手把手编写lstm模型

代码

import torch
import torch.nn as nn

# 固定随机种子，保证可复现
torch.manual_seed(42)

# 创建官方 LSTM 和自定义 LSTM
model = nn.LSTM(input_size=10, hidden_size=20, num_layers=1)


class MyLSTM(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers=1):
        super().__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        # LSTM 权重：4*hidden_size 对应 遗忘门(f)/输入门(i)/细胞候选(g)/输出门(o)
        # W_ix: (input_size, hidden_size)，输入到隐藏层的权重
        self.W_ix = model.weight_ih_l0  # 转置以匹配矩阵乘法维度
        self.b_ix = model.bias_ih_l0  # 输入到隐藏层的偏置 (hidden_size,)
        # W_hh: (hidden_size, hidden_size)，隐藏层到自身的权重
        self.W_hh = model.weight_hh_l0  # 转置以匹配矩阵乘法维度
        self.b_hh = model.bias_hh_l0  # 隐藏层到自身的偏置 (hidden_size,)

    def forward(self, x, hc):
        # 获取记忆,获取笔记
        h0, c0 = hc
        h0 = h0.squeeze(0)
        c0 = c0.squeeze(0)
        # 词语一个个的循环处理
        h_all = []
        for i in range(x.shape[0]):
            x_t = x[i]
            # 输入和记忆 w 和 b
            xi = x_t @ self.W_ix.t() + self.b_ix
            hh = h0 @ self.W_hh.t() + self.b_hh
            # 根据隐藏层,进行分割,获取四个门,获取四个门的输入
            hx_h = xi + hh
            i_hx, f_hx, g_hx, o_hx = torch.split(hx_h, self.hidden_size, dim=1)
            # 处理4个门
            # 输入门
            i = torch.sigmoid(i_hx)
            # 遗忘门
            f = torch.sigmoid(f_hx)
            # 候选细胞状态
            g = torch.tanh(g_hx)
            # 输出门
            o = torch.sigmoid(o_hx)
            # 笔记的只要一半
            f0 = f * c0
            # 需要记忆多少
            ih = i * g
            # 新笔记
            c1 = f0 + ih
            # 需要唤醒多少沉睡的记忆
            h1 = o * torch.tanh(c1)
            # 需要重新编程c0 和 h0,给下一个循环的单词使用
            c0 = c1
            h0 = h1
            h_all.append(h1)
        # 列表变张量
        h_all_t = torch.stack(h_all, dim=0)
        c1_t = c1.unsqueeze(0)
        h1_t = h1.unsqueeze(0)
        return h_all_t, (h1_t, c1_t)


mymodel = MyLSTM(input_size=10, hidden_size=20)
# 5个单词,3句话,10个维度
x = torch.randn(5, 3, 10)
# 1层,3句话 batch ,20隐藏层,,,第一个代表记忆,代表笔记本
hc = (torch.zeros(1, 3, 20), torch.zeros(1, 3, 20))
# 自己写的
mh_all, mhc = mymodel.forward(x, hc)
# 官方的结果
h_all, hc = model.forward(x, hc)

print(mh_all.shape)
print(h_all.shape)
print(mhc[0])
print(hc[0])

cha = torch.sum(torch.abs(mhc[0]- hc[0]))
print(cha)

总结

LSTM 用遗忘门、输入门、输出门三条开关，控制一条长期记忆传送带，有选择地忘记旧信息、存入新信息、输出有用信息，从而能处理长时序、记住久远依赖。

---