AlexNet卷积神经网络：从架构解析到图像分类实战

1次阅读

没有评论

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

2012 年，AlexNet 在 ImageNet 竞赛中以压倒性优势夺冠（Top- 5 错误率 15.3%，比第二名低 10.8 个百分点），标志着深度学习在计算机视觉领域的崛起。其创新点在于：

首次成功训练深层卷积网络（8 层）
证明了 ReLU 激活函数在深度网络中的有效性
开创了 GPU 并行训练大规模神经网络的先河

AlexNet 采用 5 卷积层 + 3 全连接层的经典结构，输入为 224×224 RGB 图像（实际处理时调整为 227×227）。各层关键参数如下：

Conv1: 96 个 11×11 卷积核，stride=4
MaxPool1: 3×3 窗口，stride=2
Conv2: 256 个 5×5 卷积核，pad=2
MaxPool2: 同上
Conv3-5: 384/384/256 个 3×3 卷积核
FC6-8: 4096/4096/1000 个神经元

ReLU 激活函数 ：相比传统 Sigmoid，解决了梯度消失问题，训练速度提升 6 倍
```
ReLU(x) = max(0,x)
```
局部响应归一化 (LRN)：模拟生物神经元的侧抑制机制（现多被 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)^β
```
双 GPU 并行 ：将网络拆分为两个分支分别在 GTX 580 GPU 上训练

import torch.nn as nn

class AlexNet(nn.Module):
    def __init__(self, num_classes=1000):
        super().__init__()
        self.features = nn.Sequential(
            # Conv1 
            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            # Conv2 
            nn.Conv2d(96, 256, kernel_size=5, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            # Conv3-5
            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

train_transform = transforms.Compose([transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                         std=[0.229, 0.224, 0.225])
])

Dropout 配置 ：全连接层建议保持 0.5 的丢弃率
数据增强组合 ：
随机裁剪（RandomResizedCrop）
水平翻转（RandomHorizontalFlip）
颜色抖动（ColorJitter）

策略	优点	适用场景
StepLR	简单稳定	初始训练阶段
CosineAnnealing	平滑收敛	精细调优阶段
CyclicLR	逃离局部最优	小数据集训练

# 加载预训练权重
model = AlexNet()
pretrained_dict = torch.load('alexnet.pth')
model_dict = model.state_dict()

# 过滤不匹配的键
pretrained_dict = {k: v for k, v in pretrained_dict.items() 
                  if k in model_dict and v.shape == model_dict[k].shape}
model_dict.update(pretrained_dict)
model.load_state_dict(model_dict)

# 冻结卷积层
for param in model.features.parameters():
    param.requires_grad = False