手写一个 RNN 层
这一课在哪
第 2 课给了公式,第 4 课把数据准备好了。
这一课不用 nn.RNN,自己照着公式写一遍。 目的不是让你以后手写,是让你看清里面的五行到底在干什么。
为什么值得手写一次
现代项目里没人手写 RNN——都用 nn.RNN 或直接用 Transformer。
但手写一次之后,nn.RNN 的每个参数你都能对上号: input_size 是哪个矩阵的列、hidden_size 是哪个矩阵的行。
把公式拆成四步
写代码时拆成四行:
① 输入部分: W_xh @ x_t ② 记忆部分: W_hh @ h_prev ③ 加起来再加偏置 ④ 过 tanh最小版本:一个时间步
先只看一步,不循环:
import torch import torch.nn as nn input_size = 100 hidden_size = 64 w_xh = nn.Parameter(torch.randn(hidden_size, input_size) * 0.01) w_hh = nn.Parameter(torch.randn(hidden_size, hidden_size) * 0.01) bias = nn.Parameter(torch.zeros(hidden_size)) x_t = torch.randn(100) h_prev = torch.zeros(hidden_size) h_t = torch.tanh(w_xh @ x_t + w_hh @ h_prev + bias) print(h_t.shape) # torch.Size([64])行 | 形状变化 |
|---|---|
|
|
|
|
相加 |
|
为什么乘 0.01
直接 torch.randn 出来的权重标准差是 1, 乘完 100 维输入后数值会很大,tanh 直接全饱和到 ±1。
缩小到 0.01 是让初始输出落在 tanh 的线性区。
真实的 nn.RNN 初始化是 U(-1/√hidden, 1/√hidden), 同一个道理。
加上 batch 维度
实际训练是一次喂一批。所以输入从 (100,) 变成 (B, 100):
batch_size = 32 x_t = torch.randn(batch_size, input_size) # (32, 100) h_prev = torch.zeros(batch_size, hidden_size) # (32, 64) # 矩阵乘法的顺序变了:x 在左 h_t = torch.tanh( x_t @ w_xh.T + h_prev @ w_hh.T + bias ) print(h_t.shape) # torch.Size([32, 64])x @ w.T 和 w @ x 是一回事
单个向量时:w @ x → (64,100) @ (100,) = (64,)
一批向量时:x @ w.T → (32,100) @ (100,64) = (32,64)
数学上是同一件事,只是把 batch 放到了行上。 PyTorch 里写成 x @ w.T 是因为 nn.Linear 内部就这么存权重。
完整的一层:循环起来
现在把「一步」放进一个 for 循环里:
import torch import torch.nn as nn class MyRNN(nn.Module): def __init__(self, input_size, hidden_size): super().__init__() self.hidden_size = hidden_size self.w_xh = nn.Parameter(torch.randn(hidden_size, input_size) * 0.01) self.w_hh = nn.Parameter(torch.randn(hidden_size, hidden_size) * 0.01) self.bias = nn.Parameter(torch.zeros(hidden_size)) def forward(self, x, h0=None): """ x: (batch, seq_len, input_size) h0: (batch, hidden_size),不传就是全 0 """ batch, seq_len, _ = x.shape if h0 is None: h0 = torch.zeros(batch, self.hidden_size, device=x.device) h = h0 outputs = [] for t in range(seq_len): x_t = x[:, t, :] h = torch.tanh(x_t @ self.w_xh.T + h @ self.w_hh.T + self.bias) outputs.append(h) outputs = torch.stack(outputs, dim=1) return outputs, h行 | 说明 |
|---|---|
| 取出第 t 个时间步,形状 |
| 覆盖上一轮的 h,这就是循环 |
| 把每一步的 h 都留一份 |
| 拼成 |
整个 RNN 的秘密就在一行
h = torch.tanh(x_t @ w_xh.T + h @ w_hh.T + bias)
右边的 h 是上一轮的,左边的 h 是这一轮的。 同一个变量名,覆盖掉。
这就是「循环」——代码里根本没有循环结构上的特殊性, 就是一个 for 循环加一个变量复用。
跑一下
rnn = MyRNN(input_size=100, hidden_size=64) x = torch.randn(8, 20, 100) # 8 个句子,每个 20 个词,每词 100 维 out, h_last = rnn(x) print(out.shape) # torch.Size([8, 20, 64]) print(h_last.shape) # torch.Size([8, 64])验证 out[:, -1, :] 和 h_last 是同一个东西:
print(torch.allclose(out[:, -1, :], h_last)) # True和 nn.RNN 对比
把权重灌进 nn.RNN,看输出是不是一样:
import torch.nn as nn ref = nn.RNN(input_size=100, hidden_size=64, batch_first=True) with torch.no_grad(): ref.weight_ih_l0.copy_(rnn.w_xh) ref.weight_hh_l0.copy_(rnn.w_hh) ref.bias_ih_l0.copy_(rnn.bias) ref.bias_hh_l0.zero_() ref_out, ref_h = ref(x) print(torch.allclose(out, ref_out, atol=1e-6)) # Truebias 为什么拆成两个
我们的实现里只有一个 bias, nn.RNN 里有两个:bias_ih_l0 和 bias_hh_l0。
它算的是 bias_ih + bias_hh,两者加起来才等于我们的那个。 所以上面先把一个设成 0。
这是实现细节,数学上没有区别。
参数量对账
项 | 形状 | 参数量 |
|---|---|---|
|
| 6,400 |
|
| 4,096 |
|
| 64 |
合计 | 10,560 |
print(sum(p.numel() for p in rnn.parameters())) # 10,560 ref = nn.RNN(100, 64, batch_first=True) print(sum(p.numel() for p in ref.parameters())) # 10,624差了 64——就是 nn.RNN 多出来的那个 bias_hh。
这个实现缺了什么
手写版能跑,但真实项目不会用它。缺四样:
缺的 | 后果 |
|---|---|
初始化策略 | 我用 0.01,是拍脑袋的; |
多层堆叠 |
|
双向 |
|
C++ 底层实现 | 我这是 Python for 循环,慢几十倍 |
最后一条最要命。nn.RNN 底层是融合过的 CUDA kernel, Python 循环每一步都要启动一个 kernel,20 步就慢 20 倍。
这一课留下的三个数
数 | 值 | 含义 |
|---|---|---|
手写参数量 | 10,560 |
|
| 10,624 | 多一个 |
核心一行 | 1 行 |
|
下一课
看清内部了。下一课用 nn.RNN 搭完整的情感分析模型—— embedding → RNN → 全连接,配一张架构图。