把 AlexNet 跑起来

这一课在哪

上一课讲了它为什么重要。这一课看它的结构,然后跑一遍。

验收项

标准

原版参数量

61,100,840

卷积 / 全连接占比

4% / 96%

小图版测试准确率

> 95%

五层卷积

import torch import torch.nn as nn class AlexNet(nn.Module): def __init__(self, num_classes=1000, in_channels=3): super().__init__() self.features = nn.Sequential( nn.Conv2d(in_channels=in_channels, out_channels=64, kernel_size=11, stride=4, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(in_channels=64, out_channels=192, kernel_size=5, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(in_channels=192, out_channels=384, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(in_channels=384, out_channels=256, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), ) self.classifier = nn.Sequential( nn.Dropout(p=0.5), nn.Linear(in_features=256 * 6 * 6, out_features=4096), nn.ReLU(inplace=True), nn.Dropout(p=0.5), nn.Linear(in_features=4096, out_features=4096), nn.ReLU(inplace=True), nn.Linear(in_features=4096, out_features=num_classes), ) def forward(self, x): features = self.features(x) features = torch.flatten(features, start_dim=1) logits = self.classifier(features) return logits

形状怎么一步步变小

def out_size(n, k, s=1, p=0): return (n + 2 * p - k) // s + 1 print(out_size(224, 11, s=4, p=2)) # 55 Conv1 print(out_size(55, 3, s=2)) # 27 Pool1 print(out_size(27, 5, p=2)) # 27 Conv2 print(out_size(27, 3, s=2)) # 13 Pool2 print(out_size(13, 3, p=1)) # 13 Conv3/4/5 print(out_size(13, 3, s=2)) # 6 Pool5 print(256 * 6 * 6) # 9216 拉平

阶段

尺寸

缩了多少

输入

224

—

Conv1(11×11,步长 4)

55

÷4

Pool1

27

÷2

Conv2

27

不变

Pool2

13

÷2

Conv3-5

13

不变

Pool5

6

÷2

224 → 6,缩了 37 倍;通道 3 → 256,涨了 85 倍。

数参数:96% 在分类头

model = AlexNet() total = sum(p.numel() for p in model.parameters()) conv = sum(p.numel() for p in model.features.parameters()) fc = sum(p.numel() for p in model.classifier.parameters()) print(f"{total:,}") # 61,100,840 print(f"{conv:,}") # 2,469,696 print(f"{fc:,}") # 58,631,144

部分

参数

占比

五层卷积

2,469,696

4.0%

三层全连接

58,631,144

96.0%

用「1GB」来理解这个数字

58,631,144 个 float32,就是 234 MB。

但这只是权重。训练时还要存梯度、优化器状态(Adam 是两份), 加起来接近 1 GB。

这就是为什么当年要用两块 3GB 的 GTX 580——一块确实装不下。

注意 features.0.weight 的形状是 (64, 3, 11, 11):

维度

是什么

0

64 个卷积核(= 输出通道数)

1

3 个输入通道

2, 3

11 × 11

小图版:用 MNIST 跑

ImageNet 下不了也跑不动。用 MNIST 跑一个同构的小版, 目的只是验证代码和流程。

改三处:

class AlexNetSmall(nn.Module): def __init__(self, num_classes=10): super().__init__() self.features = nn.Sequential( nn.Conv2d(in_channels=1, out_channels=64, # ① 输入改 1 通道 kernel_size=11, stride=4, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(64, 192, kernel_size=5, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(192, 384, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(256, 256, kernel_size=3, padding=1), nn.ReLU(inplace=True), ) self.classifier = nn.Sequential( nn.AdaptiveAvgPool2d((1, 1)), # ② 不管多大都压成 1×1 nn.Flatten(), nn.Dropout(p=0.4), nn.Linear(256, 1024), # ③ 缩小 nn.ReLU(inplace=True), nn.Dropout(p=0.4), nn.Linear(1024, 1024), nn.ReLU(inplace=True), nn.Linear(1024, num_classes), ) def forward(self, x): features = self.features(x) logits = self.classifier(features) return logits

AdaptiveAvgPool 是这里的关键零件

AdaptiveAvgPool2d((1, 1)) 的意思是不管进来多大,都压成 1×1。

32×32 的图经过五层卷积是 256@1×1,224×224 是 256@6×6—— 两种输入同一份代码都能跑。

这就省掉了「手算 Linear 该写多少」这个坑。

训练

device = "cuda" if torch.cuda.is_available() else "cpu" model = AlexNetSmall().to(device) print(sum(p.numel() for p in model.parameters())) # 3,777,226 loss_fn = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) for epoch in range(1, 7): model.train() for images, labels in train_loader: images = images.to(device) labels = labels.to(device) logits = model(images) loss = loss_fn(logits, labels) optimizer.zero_grad() loss.backward() optimizer.step() model.eval() val_loss, seen, correct = 0.0, 0, 0 with torch.no_grad(): for images, labels in val_loader: images = images.to(device) labels = labels.to(device) logits = model(images) val_loss += loss_fn(logits, labels).item() * labels.size(0) seen += labels.size(0) correct += (logits.argmax(dim=1) == labels).sum().item() print( f"{epoch} val_loss {val_loss/seen:.4f} " f"val_acc {100*correct/seen:.2f}%" )

真实跑出来(RTX 5060,每轮 35 秒):

1 val_loss 0.2634 val_acc 92.03% 2 val_loss 0.1556 val_acc 95.80% 3 val_loss 0.1358 val_acc 96.47% 4 val_loss 0.0936 val_acc 97.50% 5 val_loss 0.0893 val_acc 97.90% 6 val_loss 0.0902 val_acc 97.63% 测试集 97.82%

三个观察

① 第 6 轮开始过拟合

轮

val_loss

val_acc

5

0.0893

97.90%

6

0.0902

97.63%

损失回升、准确率下降。正确做法是早停在第 5 轮。

② 它不如 LeNet

网络

参数

测试

LeNet

61,706

98.78%

AlexNet(小图版)

3,777,226

97.82%

61 倍参数,换来更差的准确率

这不是 bug,是结构要匹配数据规模。

MNIST 只有 28×28 灰度图,LeNet 已经够用。 AlexNet 的 11×11 大核、stride=4,是为 224×224 的复杂图设计的, 用在这里一上来就砍掉 3/4 的像素。

大模型不是万能药。

③ 为什么 AlexNet 用 ReLU

上一章实测过:同样 3 轮,sigmoid 版 94.42%,ReLU 版 98.31%。

AlexNet 的理由有两条:

理由

说明

算得快

max(0, x) 不用求幂,sigmoid 要算 e^x

梯度不衰减

sigmoid 在两端梯度接近 0,ReLU 在正区间恒为 1

第二条是决定性的。深层网络里,sigmoid 的梯度连乘几十次就没了。

这一课留下的三个数

数

值

含义

原版参数

61,100,840

96% 在分类头

全连接权重

约 234 MB

训练时接近 1 GB

小图版

3,777,226 / 97.82%

略低于 LeNet

下一课

AlexNet 的核从 11 缩到 5 再缩到 3,看着很随意。

下一课看 VGG——它把这个「随意」变成一条规矩:全部用 3×3。