把 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 logitsAdaptiveAvgPool 是这里的关键零件
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 的理由有两条:
理由 | 说明 |
|---|---|
算得快 |
|
梯度不衰减 | 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。