今天只回答一个问题

一个模型，在计算机里究竟是怎样运行的？

PyTorch 用 forward 描述模型计算

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = ...       # 模型包含什么

    def forward(self, x):
        h = self.layer(x)      # 输入如何流动
        y = ...
        return y               # 返回输出 Tensor

model = Model()
y = model(x)                  # 触发 forward

从数据中学习表示

• 设定任务目标
• 收集样本与标签
• 将现实对象表示为特征
• 学习从输入表示到目标表示的变换

线性层：空间变换

• ：输入特征
• ：模型参数
• ：新的特征表示
• ：最后一个特征维度发生变化

用形状描述一次前向计算

每个位置不同，但使用同一个

偏置 引出另一种“复用”

xw = x @ w   # [B, H, E]
b  = ...     #       [E]
y  = xw + b  # [B, H, E]

矩阵乘：线性变换

• 每个输出元素是一个点积
• 总计算量约为
• 矩阵乘是深度学习最主要的计算来源之一

Tensor 同时携带数据与计算属性

x = torch.randn(
    2, 3, 4,
    dtype=torch.float32,
    device="cpu",
)

• shape：数据如何组织
• dtype：每个元素如何表示
• device：计算在哪里执行
• requires_grad：是否需要追踪梯度

后续所有模型组件，输入、输出和参数最终都是 Tensor。

先区分三类常见乘法

# 矩阵乘：收缩相邻维度
y = x @ w

# 对应元素相乘：shape 相同或可广播
z = x * scale

# 批量矩阵乘
o = torch.bmm(q, k)

Broadcasting 的三条兼容规则

比较两个 Tensor 的 shape 时：

• 从最后一个维度向前对齐
• 对应维度要么大小相等；要么其中一个为 1，可以沿该维重复使用
• 较短 Tensor 缺失的前导维度视为 1

   [B, H, E]
+        [E]
-------------
   [B, H, E]

例 1：[B,H,E] + [E]

令 ：

x[0] = [[ 1,  2,  3], [ 4,  5,  6]]
x[1] = [[ 7,  8,  9], [10, 11, 12]]
b    = [10, 20, 30]                    # [E]

对齐： [2, 2, 3] + [1, 1, 3]
b 沿 B、H 维重复使用后：
y[0] = [[11, 22, 33], [14, 25, 36]]
y[1] = [[17, 28, 39], [20, 31, 42]]

同一个向量 被加到每一个 位置。

例 2：[B,H,E] * [H,1]

仍令 ：

scale = [[ 10], [100]]                 # [H, 1]

对齐： [2, 2, 3] * [1, 2, 1]
展开： [2, 2, 3] * [2, 2, 3]

y[0] = [[ 10,  20,  30], [ 400,  500,  600]]
y[1] = [[ 70,  80,  90], [1000, 1100, 1200]]

10 作用于每个 batch 的第 0 行，100 作用于第 1 行，并沿 维重复使用。

用 shape 判断能否广播

einsum 把维度关系写进代码

B, H, D, E = 2, 3, 4, 5
x = torch.randn(B, H, D)
w = torch.randn(D, E)

y = torch.einsum("bhd,de->bhe", x, w)
assert y.shape == (B, H, E)

b、h、e 被保留，d 只在输入中出现，因此沿 d 求和。

参数也是 Tensor，但需要被模型管理

w = nn.Parameter(torch.empty(D, E))
b = nn.Parameter(torch.zeros(E))

普通 Tensor 变成 Parameter 后：

• 会被模块自动注册
• 会出现在 model.parameters() 中
• 会随 model.to(device) 移动
• 会进入 state_dict()，从而保存和加载

用 nn.Module 写一个真实可用的模块

class FeatureTransform(nn.Module):
    def __init__(self, in_dim, out_dim):
        super().__init__()
        self.weight = nn.Parameter(
            torch.empty(in_dim, out_dim)
        )
        self.bias = nn.Parameter(torch.zeros(out_dim))
        nn.init.xavier_uniform_(self.weight)

    def forward(self, x):
        return x @ self.weight + self.bias

Module 定义“状态 + 前向规则”

用 model(x) 触发 forward

layer = FeatureTransform(4, 5)
x = torch.randn(2, 3, 4)

y = layer(x)            # 推荐
# y = layer.forward(x)  # 不推荐

print(y.shape)          # torch.Size([2, 3, 5])

layer(x) 会经过 nn.Module.__call__，在内部调用 forward()，同时保留 hooks、Autograd 等框架能力。

nn.Linear 采用另一种权重布局

linear = nn.Linear(D, E)
y1 = linear(x)
y2 = x @ linear.weight.T + linear.bias

assert torch.allclose(y1, y2)

数学操作一致，区别只是参数的存储布局。

Linear 只改变最后一个维度

layer = nn.Linear(20, 30)

x = torch.randn(2, 8, 20)
y = layer(x)

print(y.shape)  # [2, 8, 30]

前面的 batch、序列、空间或对象维都被保留。

多个 Module 可以继续组合

class TinyMLP(nn.Module):
    def __init__(self, dim, hidden_dim):
        super().__init__()
        self.up = nn.Linear(dim, hidden_dim)
        self.act = nn.ReLU()
        self.down = nn.Linear(hidden_dim, dim)

    def forward(self, x):
        h = self.up(x)
        h = self.act(h)
        return self.down(h)

TinyMLP 自身是 Module，内部又包含三个子 Module。

多层 Linear 仍是线性变换

模型也可以出现分支与残差

class ResidualBlock(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.mlp = TinyMLP(dim, 4 * dim)

    def forward(self, x):
        return x + self.mlp(x)

      ┌──→ TinyMLP ──┐
X ────┤              ├──→ Y
      └──────────────┘

模型不一定是一条直线，但仍然是由 Tensor 运算构成的有向无环图。

nn.Module 让代码更接近真实模型

model = ResidualBlock(dim=128)

print(model)
print(dict(model.named_parameters()).keys())

model = model.to("cuda")
torch.save(model.state_dict(), "model.pt")

nn.Module 统一管理：

参数注册 · 子模块 · 设备迁移 · 状态保存 · 前向调用

A0 会故意拿掉框架的“自动挡”

本节课建立的前向视角

模型 = 对输入张量进行计算的参数化程序

nn.Module = 状态 + 子模块 + forward

forward = 输入 Tensor → 输出 Tensor