AlexNet深度解析：从原理到PyTorch实现

1. AlexNet：深度卷积神经网络的里程碑

2012年，计算机视觉领域发生了一场革命。当时ImageNet大规模视觉识别挑战赛（ILSVRC）的冠军模型AlexNet，以超出第二名10.8个百分点的惊人成绩，向世界展示了深度学习的巨大潜力。这个由Alex Krizhevsky、Ilya Sutskever和Geoffrey Hinton设计的网络结构，不仅奠定了现代卷积神经网络的基础架构，更开启了深度学习在计算机视觉领域的黄金时代。

AlexNet的成功并非偶然。在它之前，传统的计算机视觉方法主要依赖手工设计的特征（如SIFT、HOG）和浅层机器学习模型。这些方法在简单场景下表现尚可，但面对ImageNet这样包含百万张图片、上千个类别的复杂数据集时，性能捉襟见肘。AlexNet的创新之处在于：

• 首次在大规模图像分类任务中成功应用了深度卷积神经网络
• 验证了ReLU激活函数在深度网络中的有效性
• 引入Dropout和局部响应归一化(LRN)等正则化技术
• 利用GPU并行计算加速训练过程

这些创新不仅解决了当时深度网络训练中的梯度消失问题，还显著提升了模型的泛化能力。从技术演进的角度看，AlexNet继承了LeNet-5的卷积-池化交替结构，但通过增加网络深度（5个卷积层+3个全连接层）和宽度（多达256个特征图），大幅提升了特征提取能力。

2. 网络架构深度解析

2.1 整体架构设计

AlexNet的网络结构可以概括为"五卷积三全连接"的经典架构。输入图像尺寸为227×227×3（原始论文中为224×224，实际实现时采用227×227以保持整数尺寸），经过一系列卷积和池化操作后，最终输出1000类的分类概率。整个数据流动过程如下：

Conv1 → ReLU → LRN → MaxPool →
Conv2 → ReLU → LRN → MaxPool →
Conv3 → ReLU →
Conv4 → ReLU →
Conv5 → ReLU → MaxPool →
Flatten →
FC6 → ReLU → Dropout →
FC7 → ReLU → Dropout →
FC8 → Softmax

这种设计体现了"低层提取局部特征，高层组合全局特征"的视觉处理思想。前几层卷积核较大（11×11、5×5），用于捕捉局部边缘、纹理等基础特征；后几层使用3×3小卷积核，在保持感受野的同时增加网络深度；最后的全连接层则负责整合全局信息进行分类。

2.2 卷积层配置详解

2.2.1 第一卷积层(Conv1)

• 输入：227×227×3 RGB图像
• 卷积核：96个11×11×3的滤波器，步长4
• 输出：55×55×96特征图
• 计算公式：(227-11)/4 +1 = 55
• 参数数量：11×11×3×96 = 34,848
• 设计考量：
  • 大卷积核(11×11)可捕捉较大局部区域
  • 大步长(4)快速降维，减少计算量
  • 较多滤波器(96)保证丰富特征提取

实际实现时需要注意padding设置。若采用"SAME"填充，输入输出尺寸关系为：

output_size = ceil(input_size / stride)

对于227输入，55×55的输出意味着实际采用的是"VALID"填充（即无填充）。

2.2.2 第二卷积层(Conv2)

• 输入：27×27×96（经过第一池化层后）
• 卷积核：256个5×5×96滤波器，步长1，padding2
• 输出：27×27×256
• 参数数量：5×5×96×256 = 614,400
• 关键改进：
  • 使用padding=2保持空间分辨率
  • 滤波器数量增加以提取更复杂特征
  • 采用分组卷积（原始实现分两组GPU训练）

2.2.3 深层卷积层(Conv3-5)

从第三层开始，全部采用3×3小卷积核：

• Conv3：384个3×3×256滤波器，padding1
• Conv4：384个3×3×384滤波器，padding1
• Conv5：256个3×3×384滤波器，padding1

小卷积核的优势在于：

• 参数更少（3×3 vs 5×5或11×11）
• 可堆叠更多层，增加非线性
• 保持相同感受野时计算量更低
• 更适合捕捉局部精细特征

2.3 池化与降采样策略

AlexNet中使用了3个最大池化层，分别位于第1、2、5卷积层之后。所有池化窗口为3×3，步长2，这种配置带来：

• 逐步降低空间分辨率（227→27→13→6）
• 增加特征图的通道数（3→96→256→384→256）
• 保持重要特征的同时减少参数数量
• 提供一定的平移不变性

最大池化相比平均池化能更好保留显著特征，抑制背景噪声。步长大于1的池化可视为一种激进的下采样策略，虽然会丢失部分空间信息，但能显著减少后续计算量。

2.4 全连接层设计

经过5层卷积和3层池化后，6×6×256的特征图被展平为9216维向量，送入全连接层：

1. FC6：9216 → 4096
2. FC7：4096 → 4096
3. FC8：4096 → 1000（对应ImageNet的1000类）

全连接层的作用是将卷积层提取的分布式特征表示映射到样本标记空间。AlexNet的两个特点：

1. 前两个全连接层使用Dropout(rate=0.5)
2. 所有全连接层使用ReLU激活

这种设计带来约5800万参数（占网络总参数的95%以上），这也是后来网络趋向"全卷积化"的原因之一。

3. 关键技术创新解析

3.1 ReLU激活函数

AlexNet首次系统地在深度网络中使用ReLU(Rectified Linear Unit)激活函数，取代传统的sigmoid或tanh。ReLU定义为：

f(x) = max(0, x)

其优势包括：

• 计算简单，无需指数运算
• 在正区间解决梯度消失问题
• 加速收敛（比tanh快6倍）
• 诱导稀疏激活，更接近生物神经元特性

实验表明，使用ReLU的AlexNet在CIFAR-10数据集上达到25%错误率所需时间，比使用tanh的等效网络少6倍。

3.2 局部响应归一化(LRN)

LRN(Local Response Normalization)是AlexNet提出的创新技术，对局部神经元的活动进行竞争性抑制，公式为：

b_x,y^i = a_x,y^i / (k + αΣ_{j=max(0,i-n/2)}^{min(N-1,i+n/2)} (a_x,y^j)^2)^β

其中：

• a_x,y^i表示第i个卷积核在位置(x,y)处的激活值
• N是卷积核总数
• n是相邻核数（称为"局部大小"）
• k,α,β是超参数（AlexNet设k=2,α=1e-4,β=0.75）

LRN模拟了生物神经系统的侧向抑制现象，增强了泛化能力。但后续研究发现，其效果可以被批量归一化(BN)替代，且计算成本更低，因此现代网络已较少使用。

3.3 Dropout正则化

Dropout是AlexNet对抗过拟合的核心技术，以概率p（通常0.5）随机"丢弃"神经元，即在前向传播时将其输出置零。其工作原理：

1. 训练时：每个神经元以概率p被暂时移除
2. 测试时：所有神经元保持激活，但输出乘以p

这种技术有效防止了神经元之间的复杂共适应(co-adaptation)，迫使网络学习更鲁棒的特征。AlexNet在全连接层使用p=0.5的Dropout，相当于训练时每次迭代都在不同的"子网络"上进行。

数学上，Dropout可视为一种模型平均技术，当网络有n个神经元时，它隐式地集成了2^n个不同子网络的预测结果。

3.4 数据增强策略

AlexNet使用了多种数据增强技术扩充训练集：

1. 随机裁剪：从256×256图像中裁剪224×224区域
2. 水平翻转：以50%概率镜像图像
3. 颜色扰动：调整RGB通道的强度和饱和度

这些变换在不改变图像语义的前提下，显著增加了数据多样性。例如，对ImageNet的100万训练图像，通过随机裁剪可产生2048倍的有效数据量（(256-224)^2 × 2）。

4. 现代PyTorch实现详解

4.1 网络结构实现

使用PyTorch实现AlexNet时，需要注意与原论文的几点差异：

1. 通常省略LRN层（现代实践表明其效果有限）
2. 输入尺寸可调整（如适应FashionMNIST的28×28→227×227）
3. 输出类别数根据数据集调整（如FashionMNIST的10类）

完整实现代码如下：

python复制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(
            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=0),  # [b,3,227,227]->[b,96,55,55]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),  # [b,96,55,55]->[b,96,27,27]
            nn.Conv2d(96, 256, kernel_size=5, stride=1, padding=2),  # [b,96,27,27]->[b,256,27,27]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),  # [b,256,27,27]->[b,256,13,13]
            nn.Conv2d(256, 384, kernel_size=3, stride=1, padding=1),  # [b,256,13,13]->[b,384,13,13]
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 384, kernel_size=3, stride=1, padding=1),  # [b,384,13,13]->[b,384,13,13]
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),  # [b,384,13,13]->[b,256,13,13]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),  # [b,256,13,13]->[b,256,6,6]
        )
        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

关键实现细节：

1. 使用nn.Sequential组织网络层，使结构更清晰
2. inplace=True的ReLU节省内存
3. 特征提取(features)和分类(classifier)部分分离
4. 展平操作使用torch.flatten而非view，避免维度错误

4.2 数据加载与预处理

针对不同数据集需要调整预处理流程。以FashionMNIST为例：

python复制from torchvision import transforms, datasets

def get_dataloaders(data_dir='./data', batch_size=128):
    train_transform = transforms.Compose([
        transforms.Resize(227),  # AlexNet输入尺寸
        transforms.ToTensor(),
        transforms.Normalize((0.5,), (0.5,))  # 单通道归一化
    ])
    
    test_transform = transforms.Compose([
        transforms.Resize(227),
        transforms.ToTensor(),
        transforms.Normalize((0.5,), (0.5,))
    ])
    
    # 加载FashionMNIST数据集
    train_set = datasets.FashionMNIST(
        root=data_dir, train=True, download=True, transform=train_transform)
    test_set = datasets.FashionMNIST(
        root=data_dir, train=False, download=True, transform=test_transform)
    
    # 划分验证集(20%训练集)
    val_size = int(0.2 * len(train_set))
    train_size = len(train_set) - val_size
    train_set, val_set = torch.utils.data.random_split(train_set, [train_size, val_size])
    
    # 创建DataLoader
    train_loader = torch.utils.data.DataLoader(
        train_set, batch_size=batch_size, shuffle=True, num_workers=4)
    val_loader = torch.utils.data.DataLoader(
        val_set, batch_size=batch_size, shuffle=False, num_workers=4)
    test_loader = torch.utils.data.DataLoader(
        test_set, batch_size=batch_size, shuffle=False, num_workers=4)
    
    return train_loader, val_loader, test_loader

注意事项：

1. FashionMNIST是单通道图像，需调整网络输入通道数
2. 验证集应从训练集划分，保持分布一致
3. DataLoader的num_workers根据CPU核心数设置
4. 只有训练集需要shuffle

4.3 训练流程实现

完整的训练流程包括：

1. 模型初始化
2. 损失函数和优化器配置
3. 训练循环
4. 验证和模型保存

python复制import torch.optim as optim
from tqdm import tqdm

def train_model(model, train_loader, val_loader, num_epochs=20):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = model.to(device)
    
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)  # 学习率衰减
    
    best_acc = 0.0
    history = {'train_loss': [], 'val_loss': [], 'train_acc': [], 'val_acc': []}
    
    for epoch in range(num_epochs):
        # 训练阶段
        model.train()
        running_loss = 0.0
        correct = 0
        total = 0
        
        for inputs, labels in tqdm(train_loader, desc=f'Epoch {epoch+1}/{num_epochs}'):
            inputs, labels = inputs.to(device), labels.to(device)
            
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            
            running_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
        
        train_loss = running_loss / len(train_loader)
        train_acc = correct / total
        history['train_loss'].append(train_loss)
        history['train_acc'].append(train_acc)
        
        # 验证阶段
        val_loss, val_acc = evaluate(model, val_loader, criterion, device)
        history['val_loss'].append(val_loss)
        history['val_acc'].append(val_acc)
        
        scheduler.step()  # 更新学习率
        
        # 保存最佳模型
        if val_acc > best_acc:
            best_acc = val_acc
            torch.save(model.state_dict(), 'best_model.pth')
        
        print(f'Epoch {epoch+1}: '
              f'Train Loss: {train_loss:.4f}, Acc: {train_acc:.4f} | '
              f'Val Loss: {val_loss:.4f}, Acc: {val_acc:.4f}')
    
    return history

def evaluate(model, data_loader, criterion, device):
    model.eval()
    running_loss = 0.0
    correct = 0
    total = 0
    
    with torch.no_grad():
        for inputs, labels in data_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            
            running_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    
    loss = running_loss / len(data_loader)
    acc = correct / total
    return loss, acc

训练技巧：

1. 使用tqdm显示进度条
2. 添加学习率调度器(StepLR)
3. 分离评估函数(evaluate)提高代码复用
4. 只在验证集上选择最佳模型
5. 记录训练历史用于可视化

4.4 结果可视化与分析

训练完成后，可通过matplotlib绘制损失和准确率曲线：

python复制import matplotlib.pyplot as plt

def plot_history(history):
    plt.figure(figsize=(12, 4))
    
    plt.subplot(1, 2, 1)
    plt.plot(history['train_loss'], label='Train Loss')
    plt.plot(history['val_loss'], label='Val Loss')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.legend()
    
    plt.subplot(1, 2, 2)
    plt.plot(history['train_acc'], label='Train Acc')
    plt.plot(history['val_acc'], label='Val Acc')
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy')
    plt.legend()
    
    plt.tight_layout()
    plt.show()

典型训练曲线分析：

1. 训练损失应持续下降，验证损失后期可能上升（过拟合）
2. 训练和验证准确率应同步上升，差距不宜过大
3. 学习率下降时（第7、14epoch），曲线会出现拐点

5. 实战技巧与优化策略

5.1 处理自定义数据集

实际项目中经常需要处理自定��图像数据。PyTorch提供了两种主要方式：

方法一：ImageFolder格式

适用于按类别分文件夹存储的图像：

code复制data/
  train/
    class1/
      img1.jpg
      img2.jpg
    class2/
      img3.jpg
  val/
    class1/
      img4.jpg
    class2/
      img5.jpg

加载代码：

python复制from torchvision import datasets

train_dataset = datasets.ImageFolder(
    root='data/train',
    transform=transforms.Compose([
        transforms.Resize(256),
        transforms.RandomResizedCrop(227),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])
)

方法二：自定义Dataset类

适用于更复杂的数据组织方式：

python复制from PIL import Image
import pandas as pd

class CustomDataset(torch.utils.data.Dataset):
    def __init__(self, csv_file, root_dir, transform=None):
        self.annotations = pd.read_csv(csv_file)
        self.root_dir = root_dir
        self.transform = transform
    
    def __len__(self):
        return len(self.annotations)
    
    def __getitem__(self, idx):
        img_path = os.path.join(self.root_dir, self.annotations.iloc[idx, 0])
        image = Image.open(img_path).convert('RGB')
        label = self.annotations.iloc[idx, 1]
        
        if self.transform:
            image = self.transform(image)
        
        return image, label

5.2 数据增强策略优化

除基本的随机裁剪和翻转外，现代数据增强技术可进一步提升模型性能：

python复制from torchvision import transforms

train_transform = transforms.Compose([
    transforms.Resize(256),
    transforms.RandomResizedCrop(227, scale=(0.8, 1.0)),
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
    transforms.RandomRotation(10),
    transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
    transforms.RandomPerspective(distortion_scale=0.2, p=0.5),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

注意事项：

1. 几何变换（旋转、平移等）可能改变图像语义，需谨慎使用
2. 颜色扰动对物体识别任务通常安全
3. 测试集只能使用确定性变换（Resize+Crop+Normalize）

5.3 模型优化技巧

学习率策略

1. 热身学习率(Warmup)：前几轮线性增加学习率
2. 余弦退火(CosineAnnealing)：平滑调整学习率
3. 周期学习率(CyclicLR)：在合理范围内周期性变化

python复制from torch.optim.lr_scheduler import CosineAnnealingLR, CyclicLR

# 余弦退火
scheduler = CosineAnnealingLR(optimizer, T_max=num_epochs, eta_min=1e-5)

# 周期学习率
scheduler = CyclicLR(optimizer, base_lr=1e-5, max_lr=1e-3, 
                     step_size_up=2000, mode='triangular')

标签平滑(Label Smoothing)

缓解模型对标签的过度自信：

python复制criterion = nn.CrossEntropyLoss(label_smoothing=0.1)

混合精度训练

利用NVIDIA的AMP技术加速训练：

python复制from torch.cuda.amp import GradScaler, autocast

scaler = GradScaler()

for inputs, labels in train_loader:
    optimizer.zero_grad()
    
    with autocast():
        outputs = model(inputs)
        loss = criterion(outputs, labels)
    
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

5.4 模型部署与推理

训练完成后，可将模型导出为ONNX格式便于部署：

python复制dummy_input = torch.randn(1, 3, 227, 227).to(device)
torch.onnx.export(model, dummy_input, "alexnet.onnx", 
                  input_names=["input"], output_names=["output"],
                  dynamic_axes={"input": {0: "batch"}, "output": {0: "batch"}})

推理示例代码：

python复制from PIL import Image

def predict(image_path, model, transform, class_names):
    image = Image.open(image_path).convert('RGB')
    image = transform(image).unsqueeze(0).to(device)
    
    model.eval()
    with torch.no_grad():
        output = model(image)
        prob = torch.nn.functional.softmax(output[0], dim=0)
        conf, pred = torch.max(prob, 0)
    
    return class_names[pred.item()], conf.item()

6. AlexNet的现代演进与局限

6.1 后续网络架构改进

AlexNet之后，CNN架构经历了多次重大革新：

1. VGGNet (2014)：使用更小的3×3卷积核堆叠，证明深度是关键
2. GoogLeNet (2014)：引入Inception模块和辅助分类器
3. ResNet (2015)：残差连接解决深度网络梯度消失问题
4. EfficientNet (2019)：复合缩放统一调整深度/宽度/分辨率

6.2 AlexNet的固有局限

尽管具有开创性，AlexNet存在一些设计局限：

1. 参数量大（约6000万），特别是全连接层
2. 训练需要大量数据，小数据集易过拟合
3. 原始实现使用LRN，后续证明效果有限
4. 全连接层对输入尺寸敏感，不够灵活

6.3 现代最佳实践

基于AlexNet的经验教训，现代CNN设计通常：

1. 使用小卷积核（3×3或1×1）堆叠
2. 用全局平均池化替代全连接层
3. 批量归一化(BN)替代LRN
4. 残差连接允许训练极深网络
5. 深度可分离卷积降低计算量

7. 关键问题与解决方案

7.1 过拟合问题

症状：

• 训练准确率高但验证准确率低
• 验证损失在后期上升

解决方案：

1. 增加Dropout比率（最高至0.7）
2. 添加L2权重衰减（1e-4到1e-5）
3. 使用更激进的数据增强
4. 尝试标签平滑(Label Smoothing)
5. 早停(Early Stopping)策略

7.2 训练不稳定

症状：

• 损失值剧烈波动
• 准确率提升缓慢

解决方案：

1. 减小学习率（尝试1e-4到1e-5）
2. 添加梯度裁剪(grad_clip=1.0)
3. 使用学习率热身(Warmup)
4. 换用更稳定的优化器如AdamW
5. 检查数据归一化是否正确

7.3 模型部署问题

常见挑战：

1. 输入尺寸不匹配
2. 预处理不一致
3. 计算资源限制

最佳实践：

1. 导出前将模型转为eval模式
2. 记录训练时的归一化参数
3. 使用ONNX或TorchScript标准化格式
4. 对边缘设备考虑量化(Quantization)

8. 性能优化实战

8.1 混合精度训练

通过混合精度训练可显著减少显存占用并加速训练：

python复制from torch.cuda.amp import GradScaler, autocast

scaler = GradScaler()

for inputs, labels in train_loader:
    inputs, labels = inputs.to(device), labels.to(device)
    
    optimizer.zero_grad()
    
    with autocast():
        outputs = model(inputs)
        loss = criterion(outputs, labels)
    
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

8.2 分布式训练

多GPU数据并行训练：

python复制model = nn.DataParallel(model)  # 包装模型

更灵活的分布式训练：

python复制import torch.distributed as dist

dist.init_process_group(backend='nccl')
model = nn.parallel.DistributedDataParallel(model)

8.3 模型量化

训练后动态量化：

python复制quantized_model = torch.quantization.quantize_dynamic(
    model, {nn.Linear}, dtype=torch.qint8)

量化感知训练：

python复制model.qconfig = torch.quantization.get_default_qat_qconfig('fbgemm')
torch.quantization.prepare_qat(model, inplace=True)
# 正常训练
torch.quantization.convert(model, inplace=True)

9. 扩展应用与变体

9.1 迁移学习

AlexNet可作为预训练模型用于其他任务：

1. 特征提取器：冻结卷积层，只训练新分类器
2. 微调(Fine-tuning)：解冻部分层，用较小学习率训练

python复制from torchvision.models import alexnet

model = alexnet(pretrained=True)

# 冻结特征提取层
for param in model.features.parameters():
    param.requires_grad = False

# 修改最后一层
num_classes = 10
model.classifier[6] = nn.Linear(4096, num_classes)

9.2 注意力机制改进

在AlexNet基础上加入CBAM注意力模块：

python复制class CBAM(nn.Module):
    def __init__(self, channels, reduction=16):
        super().__init__()
        self.channel_attention = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Conv2d(channels, channels//reduction, 1),
            nn.ReLU(),
            nn.Conv2d(channels//reduction, channels, 1),
            nn.Sigmoid()
        )
        self.spatial_attention = nn.Sequential(
            nn.Conv2d(2, 1, 7, padding=3),
            nn.Sigmoid()
        )
    
    def forward(self, x):
        channel = self.channel_attention(x) * x
        spatial = torch.cat([channel.mean(1, keepdim=True), 
                           channel.max(1, keepdim=True)[0]], dim=1)
        spatial = self.spatial_attention(spatial) * channel
        return spatial

# 在AlexNet的Conv5后添加
model.features = nn.Sequential(
    *list(model.features.children())[:-1],
    CBAM(256),
    list(model.features.children())[-1]
)

9.3 轻量化设计

通过深度可分离卷积减少参数量：

python复制def depthwise_separable_conv(in_channels, out_channels, kernel_size, stride=1, padding=0):
    return nn.Sequential(
        nn.Conv2d(in_channels, in_channels, kernel_size, 
                 stride, padding, groups=in_channels),
        nn.Conv2d(in_channels, out_channels, 1)
    )

# 替换原Conv层
model.features[3] = depthwise_separable_conv(96, 256, 5, padding=2)