nn.Module:网络就是一个类

先看整条流程走到哪了

一次训练由五步组成,这一步一步循环:

数据 ──► 前向 ──► 损失 ──► 反向 ──► 更新参数 │ │ │ │ │ 批 算出预测 错了多少 谁的锅 往哪走

步骤

谁负责

学完没有

数据

Dataset + DataLoader

第 20 章 ✅

前向

nn.Module

这一课

损失

nn.CrossEntropyLoss

下一课

反向

loss.backward()

第 19 章 ✅

更新参数

optimizer.step()

再下一课

这一课只解决中间那一个箭头:怎么把一批数据变成一批预测值。

这一课结束时你手上会有什么

一个能用的网络对象:

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 每次前向都跑,负责计算。

参数(权重)是持久的,必须放在 __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.Sequential

有分支、跳连、残差

自己写 nn.Module

常见的层

到这里你只见过 nn.Linear。把常用的层一次列出来,后面直接查。

层

作用

输入 → 输出

nn.Linear(in, out)

全连接

(N, in) → (N, out)

nn.Conv2d(in, out, k)

二维卷积

(N, C, H, W)

nn.ReLU()

激活

形状不变

nn.Dropout(p)

随机置零

形状不变

nn.BatchNorm1d(d)

批归一化

形状不变

nn.Flatten()

拉平

(N,C,H,W) → (N, C·H·W)

一个完整的 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。

下一课

网络结构有了。下一课讲损失函数:怎么衡量"预测错了多少"。