AlexNet架构解析：从ImageNet冠军到现代CNN的奠基之作

1次阅读

共计 2436 个字符，预计需要花费 7 分钟才能阅读完成。

2012 年，多伦多大学的 Alex Krizhevsky 等人提出的 AlexNet 以压倒性优势赢得 ImageNet 竞赛（Top- 5 错误率 15.3%，比第二名低 10.8%）。这个 8 层神经网络首次证明：

深度卷积神经网络在复杂视觉任务上的可行性
GPU 加速训练使深层网络成为可能
ReLU 等新技术显著提升模型性能

卷积层 1 ：96 个 11×11 滤波器，步长 4，输出 55×55×96 → MaxPooling(3×3, stride=2)
卷积层 2 ：256 个 5×5 滤波器，padding=2 → MaxPooling
卷积层 3 -5：384/384/256 个 3×3 滤波器，均使用 padding=1
全连接层 ：4096 → 4096 → 1000（ImageNet 类别数）

传统神经网络使用 Sigmoid/Tanh，存在梯度消失问题。ReLU（$f(x)=max(0,x)$）的实验优势：

指标	ReLU	Sigmoid
训练速度	6×更快	基准
Top- 1 错误率	25.8%	31.5%
收敛迭代次数	35 epoch	50 epoch

早期尝试的归一化方法（现多被 BN 替代）：
$$ b_{x,y}^i = a_{x,y}^i / (k + α \sum_{j=max(0,i-n/2)}^{min(N-1,i+n/2)} (a_{x,y}^j)^2 )^β $$

$k=2$, $n=5$, $α=10^{-4}$, $β=0.75$ 为论文参数
在相邻通道间做抑制，增强泛化能力

训练时随机丢弃 50% 神经元
预测时使用全部神经元但权重减半
相当于模型集成，减少过拟合

import torch
import torch.nn as nn

class AlexNet(nn.Module):
    def __init__(self, num_classes=1000):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(# Conv1 (224->55)
            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=0),
            nn.ReLU(inplace=True),
            nn.LocalResponseNorm(size=5, alpha=1e-4, beta=0.75, k=2),
            nn.MaxPool2d(kernel_size=3, stride=2),

            # Conv2 (27->27)
            nn.Conv2d(96, 256, kernel_size=5, padding=2),
            nn.ReLU(inplace=True),
            nn.LocalResponseNorm(size=5, alpha=1e-4, beta=0.75, k=2),
            nn.MaxPool2d(kernel_size=3, stride=2),

            # Conv3-5 (13->13)
            nn.Conv2d(256, 384, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 384, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 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(256*6*6, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

数据预处理示例：

from torchvision import transforms

transform = transforms.Compose([transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                         std=[0.229, 0.224, 0.225])
])