别再死记硬背LSTM公式了！用Python手搓一个带遗忘门和输入门的‘记忆细胞’（附代码）
·
用Python从零构建LSTM记忆单元：遗忘门与输入门的代码级解析
在深度学习领域，LSTM（长短期记忆网络）一直以其独特的记忆机制闻名。但很多学习者都面临一个困境：看懂了公式却无法真正理解门控机制的工作原理。本文将带你用Python从零开始实现一个简化版的LSTM核心单元，重点构建遗忘门和输入门，通过可运行的代码让抽象的概念变得触手可及。
1. 环境准备与基础概念
在开始编码前，我们需要明确几个关键概念。LSTM的核心是"记忆细胞"（Memory Cell），它通过三个门控机制（遗忘门、输入门、输出门）来选择性保留和更新信息。本次实现将聚焦前两个门：
- 遗忘门 ：决定哪些历史信息需要丢弃
- 输入门 ：决定哪些新信息需要存储
我们将使用Python 3.8+和NumPy库进行实现。以下是所需环境的配置步骤：
pip install numpy
LSTM的数学表达通常让人望而生畏，但本质上它只是几种基本操作的组合：
- 矩阵乘法 ：用于权重计算
- 激活函数 ：sigmoid和tanh
- 逐元素操作 ：如乘法(*)和加法(+)
2. 构建LSTM基础结构
让我们先定义LSTM单元的基本结构。一个简化版的LSTM单元需要维护两个状态：
- 细胞状态（c_t） ：长期记忆
- 隐藏状态（h_t） ：短期记忆/输出
import numpy as np
class LSTMCell:
def __init__(self, input_size, hidden_size):
self.input_size = input_size
self.hidden_size = hidden_size
# 初始化权重矩阵
self.W_f = np.random.randn(hidden_size, input_size + hidden_size)
self.W_i = np.random.randn(hidden_size, input_size + hidden_size)
self.W_c = np.random.randn(hidden_size, input_size + hidden_size)
# 初始化偏置项
self.b_f = np.zeros((hidden_size, 1))
self.b_i = np.zeros((hidden_size, 1))
self.b_c = np.zeros((hidden_size, 1))
这里我们只初始化了与遗忘门(f)、输入门(i)和候选细胞状态(c)相关的参数。每个权重矩阵的维度都是 (hidden_size, input_size + hidden_size) ，这是因为我们会将当前输入和前一个隐藏状态拼接起来作为输入。
3. 实现遗忘门机制
遗忘门是LSTM中最具哲学意味的设计——它决定哪些记忆值得保留。从代码角度看，遗忘门实际上是一个sigmoid函数应用：
def sigmoid(self, x):
return 1 / (1 + np.exp(-x))
def forward(self, x, h_prev, c_prev):
# 拼接输入和前一个隐藏状态
combined = np.vstack((h_prev, x))
# 计算遗忘门
f_t = self.sigmoid(np.dot(self.W_f, combined) + self.b_f)
# 应用遗忘门
c_t = f_t * c_prev
为什么选择sigmoid作为激活函数？这与其数学特性密切相关：
| 特性 | 解释 | 在LSTM中的应用 |
|---|---|---|
| 输出范围(0,1) | 可以表示保留比例 | 0表示完全遗忘，1表示完全保留 |
| 平滑可导 | 便于反向传播 | 训练时梯度可以稳定传播 |
| 非线性 | 增强模型表达能力 | 能够学习复杂的遗忘模式 |
在实际运行中，你可以这样测试遗忘门：
# 测试代码
input_size = 3
hidden_size = 2
lstm = LSTMCell(input_size, hidden_size)
x = np.array([[0.5], [-0.2], [1.0]]) # 当前输入
h_prev = np.array([[0.1], [-0.3]]) # 前一隐藏状态
c_prev = np.array([[0.8], [0.5]]) # 前一细胞状态
f_t, c_t = lstm.forward(x, h_prev, c_prev)
print("遗忘门输出:", f_t)
print("更新后的细胞状态:", c_t)
4. 实现输入门与候选记忆
输入门负责决定哪些新信息值得存储，这涉及两个部分：
- 输入门本身 ：决定更新哪些部分（sigmoid）
- 候选细胞状态 ：提供新信息（tanh）
def tanh(self, x):
return np.tanh(x)
def forward(self, x, h_prev, c_prev):
# ...（前面的遗忘门代码）
# 计算输入门
i_t = self.sigmoid(np.dot(self.W_i, combined) + self.b_i)
# 计算候选细胞状态
c_tilde = self.tanh(np.dot(self.W_c, combined) + self.b_c)
# 更新细胞状态
c_t = f_t * c_prev + i_t * c_tilde
为什么候选状态使用tanh而非sigmoid？关键区别在于：
- tanh ：输出范围(-1,1)，适合表示"新增信息"的强度与方向
- sigmoid ：输出范围(0,1)，适合做"开关"决策
这种组合创造了LSTM强大的记忆更新机制：
- 遗忘门决定保留多少旧记忆（f_t * c_prev）
- 输入门决定添加多少新记忆（i_t * c_tilde）
5. 完整实现与测试
现在我们将所有部分整合成一个完整的LSTM单元（简化版）：
class LSTMCell:
def __init__(self, input_size, hidden_size):
# ...（初始化代码如前）
def sigmoid(self, x):
return 1 / (1 + np.exp(-x))
def tanh(self, x):
return np.tanh(x)
def forward(self, x, h_prev, c_prev):
# 拼接输入
combined = np.vstack((h_prev, x))
# 遗忘门
f_t = self.sigmoid(np.dot(self.W_f, combined) + self.b_f)
# 输入门
i_t = self.sigmoid(np.dot(self.W_i, combined) + self.b_i)
# 候选细胞状态
c_tilde = self.tanh(np.dot(self.W_c, combined) + self.b_c)
# 更新细胞状态
c_t = f_t * c_prev + i_t * c_tilde
return c_t
让我们用实际数据测试这个实现：
# 初始化参数
np.random.seed(42)
input_size = 4
hidden_size = 3
lstm = LSTMCell(input_size, hidden_size)
# 模拟输入序列
inputs = [
np.array([[0.1], [0.2], [-0.1], [0.3]]),
np.array([[-0.2], [0.5], [0.1], [0.0]]),
np.array([[0.3], [-0.4], [0.2], [0.1]])
]
# 初始状态
h_prev = np.zeros((hidden_size, 1))
c_prev = np.zeros((hidden_size, 1))
# 处理序列
for x in inputs:
c_prev = lstm.forward(x, h_prev, c_prev)
print(f"细胞状态更新为:\n{c_prev}\n")
通过这个逐步实现，你应该能直观感受到：
- 遗忘门如何调节历史记忆的保留程度
- 输入门如何控制新信息的流入
- 细胞状态如何随时间步演化
6. 可视化理解门控机制
为了更直观地理解，我们可以可视化门控的操作过程。假设我们有一个维度为2的隐藏状态：
import matplotlib.pyplot as plt
def visualize_gates(x, h_prev, c_prev):
# 前向传播
combined = np.vstack((h_prev, x))
f_t = lstm.sigmoid(np.dot(lstm.W_f, combined) + lstm.b_f)
i_t = lstm.sigmoid(np.dot(lstm.W_i, combined) + lstm.b_i)
c_tilde = lstm.tanh(np.dot(lstm.W_c, combined) + lstm.b_c))
# 可视化
fig, axes = plt.subplots(1, 3, figsize=(15, 4))
# 遗忘门
axes[0].bar(range(len(f_t)), f_t.flatten())
axes[0].set_title("遗忘门输出")
axes[0].set_ylim(0, 1)
# 输入门
axes[1].bar(range(len(i_t)), i_t.flatten())
axes[1].set_title("输入门输出")
axes[1].set_ylim(0, 1)
# 候选状态
axes[2].bar(range(len(c_tilde)), c_tilde.flatten())
axes[2].set_title("候选状态输出")
axes[2].set_ylim(-1, 1)
plt.tight_layout()
plt.show()
# 示例可视化
x_test = np.array([[0.5], [-0.3], [0.1], [0.2]])
h_test = np.array([[0.2], [-0.1], [0.3]])
c_test = np.array([[0.4], [0.1], [-0.2]])
visualize_gates(x_test, h_test, c_test)
这种可视化能清晰展示：
- 遗忘门和输入门如何在不同维度上做出不同决策
- 候选状态如何提供有正有负的新信息
- 各维度如何独立运作又协同工作
7. ��际应用中的技巧与陷阱
在真实项目中实现LSTM时，有几个关键点需要注意：
权重初始化 ：
- 使用太小或太大的初始化值都会导致训练困难
- 推荐使用Xavier/Glorot初始化：
# Xavier初始化示例
scale = np.sqrt(2.0 / (input_size + hidden_size))
self.W_f = np.random.randn(hidden_size, input_size + hidden_size) * scale
梯度问题 ：
- 虽然LSTM设计用于缓解梯度消失，但仍可能出现梯度爆炸
- 实践中常使用梯度裁剪：
# 梯度裁剪伪代码
max_grad_norm = 5.0
grad_norm = np.linalg.norm(gradients)
if grad_norm > max_grad_norm:
gradients = gradients * (max_grad_norm / grad_norm)
数值稳定性 ：
- sigmoid和tanh在极端输入时会产生饱和区
- 实现时可添加保护措施：
def sigmoid(self, x):
x = np.clip(x, -50, 50) # 防止数值溢出
return 1 / (1 + np.exp(-x))
在自然语言处理任务中，LSTM的记忆机制特别有用。例如在处理句子"我去过巴黎，埃菲尔铁塔很壮观"时：
- 看到"巴黎"时，输入门会记录这个地点信息
- 看到"埃菲尔铁塔"时，遗忘门会保留之前的巴黎信息
- 整个过程中，细胞状态维护着"巴黎"这个关键实体
8. 扩展思考：为什么LSTM有效？
通过我们的代码实现，可以总结LSTM成功的几个关键设计：
-
门控机制 ：精细控制信息流动
- 不像普通RNN被动接受所有信息
- 自主决定记住什么、忘记什么
-
加法更新 ：细胞状态的更新方式是相加而非替换
- 保护梯度直接传播（导数=1）
- 避免传统RNN的连乘梯度消失
-
解耦记忆与输出 ：
- 细胞状态专注于长期记忆
- 隐藏状态处理短期交互
这种设计使得LSTM特别适合处理具有长期依赖关系的序列数据，如：
- 时间序列预测
- 语音识别
- 文本生成
- 视频分析
以下是一个简单的文本生成示例，展示LSTM的记忆能力：
# 伪代码：基于LSTM的文本生成
def generate_text(seed, lstm, length=100):
hidden = np.zeros((hidden_size, 1))
cell = np.zeros((hidden_size, 1))
output = seed
for _ in range(length):
# 将当前字符转换为向量
x = char_to_vec(output[-1])
# LSTM前向传播
cell, hidden = lstm.forward(x, hidden, cell)
# 预测下一个字符
next_char = vec_to_char(hidden)
output += next_char
return output
在实际项目中，你可能需要处理更复杂的情况，比如批量处理、多层LSTM堆叠等。但核心的门控机制原理与我们实现的简化版是一致的。
更多推荐
6
0- 0
已为社区贡献36条内容
所有评论(0)