手写一个 RNN 层

这一课在哪

第 2 课给了公式,第 4 课把数据准备好了。

这一课不用 nn.RNN,自己照着公式写一遍。 目的不是让你以后手写,是让你看清里面的五行到底在干什么。

为什么值得手写一次

现代项目里没人手写 RNN——都用 nn.RNN 或直接用 Transformer。

但手写一次之后,nn.RNN 的每个参数你都能对上号: input_size 是哪个矩阵的列、hidden_size 是哪个矩阵的行。

把公式拆成四步

ht=tanh⁡(Wxhxt+Whhht−1+b)h_t = \tanh\left(W_{xh} x_t + W_{hh} h_{t-1} + b\right)

写代码时拆成四行:

① 输入部分: 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])

行

形状变化

w_xh @ x_t

(64,100) @ (100,) → (64,)

w_hh @ h_prev

(64,64) @ (64,) → (64,)

相加

(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

行

说明

x[:, t, :]

取出第 t 个时间步,形状 (batch, input_size)

h = tanh(...)

覆盖上一轮的 h,这就是循环

outputs.append(h)

把每一步的 h 都留一份

torch.stack(..., dim=1)

拼成 (batch, seq_len, hidden)

整个 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)) # True

bias 为什么拆成两个

我们的实现里只有一个 bias, nn.RNN 里有两个:bias_ih_l0 和 bias_hh_l0。

它算的是 bias_ih + bias_hh,两者加起来才等于我们的那个。 所以上面先把一个设成 0。

这是实现细节,数学上没有区别。

参数量对账

项

形状

参数量

w_xh

(64, 100)

6,400

w_hh

(64, 64)

4,096

bias

(64,)

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,是拍脑袋的;nn.RNN 用理论值

多层堆叠

nn.RNN(num_layers=2) 一行就行

双向

bidirectional=True,手写要多一个反向循环

C++ 底层实现

我这是 Python for 循环,慢几十倍

最后一条最要命。nn.RNN 底层是融合过的 CUDA kernel, Python 循环每一步都要启动一个 kernel,20 步就慢 20 倍。

这一课留下的三个数

数

值

含义

手写参数量

10,560

64×100 + 64×64 + 64

nn.RNN

10,624

多一个 bias_hh

核心一行

1 行

h = tanh(x@w_xh.T + h@w_hh.T + b)

下一课

看清内部了。下一课用 nn.RNN 搭完整的情感分析模型—— embedding → RNN → 全连接,配一张架构图。