nn.Module:网络就是一个类
先看整条流程走到哪了
一次训练由五步组成,这一步一步循环:
数据 ──► 前向 ──► 损失 ──► 反向 ──► 更新参数 │ │ │ │ │ 批 算出预测 错了多少 谁的锅 往哪走步骤 | 谁负责 | 学完没有 |
|---|---|---|
数据 |
| 第 20 章 ✅ |
前向 |
| 这一课 |
损失 |
| 下一课 |
反向 |
| 第 19 章 ✅ |
更新参数 |
| 再下一课 |
这一课只解决中间那一个箭头:怎么把一批数据变成一批预测值。
这一课结束时你手上会有什么
一个能用的网络对象:
model = MNISTNet() model(torch.randn(64, 1, 28, 28)) ──► torch.Size([64, 10])喂进 64 张图,吐出 64 行、每行 10 个分数。
它还不能训练
现在它只是一个随机数发生器——参数是随机的,输出没有意义。
要让它学会东西,还缺损失函数和优化器,那是接下来两课的事。
这一课的目标只是:能把数据正确地流过网络。
搭建思路:网络要回答两个问题
任何网络,不管多复杂,都只是在回答两件事:
问题 | 例子 |
|---|---|
① 有哪些零件 | 两个全连接层、一个 ReLU、一个 Dropout |
② 零件怎么连 | 输入 → 第一层 → ReLU → 第二层 → 输出 |
PyTorch 用两个地方分别回答:__init__ 放零件,forward 放连接。
下面按这个顺序写。
两层结构
先看一个最小的:两个全连接层,中间夹一个 ReLU。
按上面的思路,零件是 fc1、relu、fc2; 连接是 x → fc1 → relu → fc2。
import torch.nn as nn class MLP(nn.Module): def __init__(self): super().__init__() # 必须调用 self.fc1 = nn.Linear(784, 128) # 声明有哪些层 self.fc2 = nn.Linear(128, 10) def forward(self, x): # 定义怎么算 x = torch.relu(self.fc1(x)) return self.fc2(x)位置 | 写什么 |
|---|---|
| 有哪些零件(层) |
| 零件怎么连(数据流) |
为什么分两步
__init__ 只在创建时跑一次,负责准备参数。
forward 每次前向都跑,负责计算。
参数(权重)是持久的,必须放在 __init__ 里。
用的时候调 forward 吗
写好了类,第一个要注意的是怎么调用。这里有个坑。
model = MLP() y = model(x) # ✓ 对 y = model.forward(x) # ✗ 不要这样model(x) 会先跑一些内部钩子再调 forward。 直接调 forward 会跳过它们,某些功能(钩子、编译)会失效。
三个自动获得的能力
继承 nn.Module 不只是为了写 forward,还白拿三个能力。
model = MLP() # 1. 参数管理 list(model.parameters()) # 所有可训练参数 sum(p.numel() for p in model.parameters()) # 参数总数 # 2. 搬运 model.to("cuda") # 所有参数一起搬 # 3. 模式切换 model.train() # 训练模式 model.eval() # 评估模式这三个都不用你写——继承 nn.Module 就自动有了。
嵌套:模型可以包含模型
上面的网络只有两层,直接平铺就行。层一多就得拆成子模块。
class Block(nn.Module): def __init__(self): super().__init__() self.fc = nn.Linear(64, 64) self.bn = nn.BatchNorm1d(64) def forward(self, x): return torch.relu(self.bn(self.fc(x))) class Net(nn.Module): def __init__(self): super().__init__() self.block1 = Block() # 直接当子模块用 self.block2 = Block() self.head = nn.Linear(64, 10) def forward(self, x): x = self.block1(x) x = self.block2(x) return self.head(x)net.parameters() 会自动递归收集所有子模块的参数。不用手动登记。
必须用 self.xxx 赋值
self.fc = nn.Linear(...) → PyTorch 认得,会登记为子模块。
layers = [nn.Linear(...)] 放进普通 Python 列表 → 不算子模块,参数不会出现在 parameters() 里,也不会被优化器更新。
列表要用 nn.ModuleList,字典用 nn.ModuleDict。
# ✗ 参数丢失 self.layers = [nn.Linear(10, 10) for _ in range(3)] # ✓ 正确 self.layers = nn.ModuleList([nn.Linear(10, 10) for _ in range(3)])Sequential:不用写 forward
纯串联的结构可以偷懒:
model = nn.Sequential( nn.Linear(784, 128), nn.ReLU(), nn.Dropout(0.2), nn.Linear(128, 10), )数据按顺序流过每一层,等价于手写 forward。
什么时候用 | 选 |
|---|---|
一条直线流下去 |
|
有分支、跳连、残差 | 自己写 |
常见的层
到这里你只见过 nn.Linear。把常用的层一次列出来,后面直接查。
层 | 作用 | 输入 → 输出 |
|---|---|---|
| 全连接 |
|
| 二维卷积 |
|
| 激活 | 形状不变 |
| 随机置零 | 形状不变 |
| 批归一化 | 形状不变 |
| 拉平 |
|
一个完整的 MNIST 网络
class MNISTNet(nn.Module): def __init__(self): super().__init__() self.net = nn.Sequential( nn.Flatten(), # (N,1,28,28) → (N,784) nn.Linear(784, 128), nn.ReLU(), nn.Dropout(0.2), nn.Linear(128, 10), ) def forward(self, x): return self.net(x) model = MNISTNet() x = torch.randn(64, 1, 28, 28) print(model(x).shape) # torch.Size([64, 10]) print(sum(p.numel() for p in model.parameters())) # 101770输出 10 个数,不是 1 个数
10 类分类,输出层给 10 个值,代表每一类的"分数"。
分数不是概率——要转概率用 softmax,但 PyTorch 的 CrossEntropyLoss 内部已经做了,所以模型输出不要加 softmax。
下一课
网络结构有了。下一课讲损失函数:怎么衡量"预测错了多少"。