DAY 44 训练

DAY 44 训练

• 预训练模型与迁移学习：从理论到实践
• • 一、预训练模型的基本概念
  • 二、经典预训练模型
  • • CNN 架构预训练模型
    • Transformer 类预训练模型
    • 自监督预训练模型
  • 三、常见分类预训练模型介绍
  • • 预训练模型的发展史
  • 四、实践：在 CIFAR-10 上微调 ResNet18

---

预训练模型与迁移学习：从理论到实践

在深度学习领域，预训练模型和迁移学习是提升模型性能、加速训练过程的关键技术。本文将深入探讨预训练的概念、经典预训练模型及其应用场景，并通过实际代码示例展示如何在项目中高效运用迁移学习。

一、预训练模型的基本概念

在深度学习模型训练过程中，参数初始化对训练效果有着显著影响。若初始参数接近最优解，训练过程可大幅缩短，且能有效规避局部最优问题。预训练模型正是基于此思想：利用大规模数据集预训练得到的模型参数，作为我们模型的初始参数。

当目标任务与预训练任务相似时，预训练模型提取的通用特征对目标任务极具价值。例如，若预训练模型是在大规模图像数据集（如 ImageNet）上训练的，它学到的特征提取能力（如边缘、纹理检测等低层特征）可迁移到其他图像相关任务中。

对比而言，像 CIFAR-10 这样的小规模数据集不适合作为预训练数据集。其仅包含 10 万张 32x32 小尺寸图像、10 个类别，难以支撑复杂模型学习通用视觉特征。而 ImageNet 数据集凭借 1000 个类别、1.2 亿张图像、224x224 尺寸，成为预训练的优质选择。

二、经典预训练模型

CNN 架构预训练模型

• AlexNet ：首次引入 ReLU 激活函数、局部响应归一化等创新，在 ImageNet 上取得突破性成果。在适配 CIFAR-10 时，需修改首层卷积核大小。
• VGG16 ：以纯卷积堆叠、结构统一为特点，参数量庞大。微调时，通常冻结前 10 层卷积，仅调整全连接层。
• ResNet18 ：通过残差连接解决梯度消失问题。适配 CIFAR-10 时，可直接输入 32x32 图像，但需调整池化层步长。
• MobileNetV2 ：采用深度可分离卷积，设计轻量级，在计算资源受限场景表现出色。

Transformer 类预训练模型

适用于较大尺寸图像，如 224x224。在 CIFAR-10 上应用时，需对图像尺寸或 Patch 大小进行调整。

• ViT-Base ：纯 Transformer 架构，在 ImageNet-21K 上预训练。使用时需将图像 Resize 至 224x224，设置 Patch 大小为 4x4。
• Swin Transformer ：采用分层窗口注意力机制，在 ImageNet-22K 上预训练，需调整窗口大小适配小图像。
• DeiT ：结合 CNN 归纳偏置，是轻量级 Transformer，适合中小尺寸图像。

自监督预训练模型

无需人工标注，借助 pretext task（如掩码图像重建）学习特征，适用于数据稀缺场景。

• MoCo v3 ：基于对比学习，在 ImageNet 上预训练，无需标签即可迁移，适合处理无标注数据。
• BEiT ：采用掩码图像建模方式，在 ImageNet-22K 上预训练，特征语义丰富，微调时收敛速度更快。

三、常见分类预训练模型介绍

预训练模型的发展史

从 1998 年 Yann LeCun 等人提出的 LeNet-5 验证 CNN 可行性，到 2012 年 AlexNet 引发深度学习复兴，再到 2015 年 ResNet 解决超深网络训练难题，预训练模型不断发展。后续模型如 DenseNet、MobileNet、EfficientNet 等在特征复用、计算效率、自动化设计等方面持续优化。

• LeNet-5 ：首个 CNN 架构，包含卷积层、池化层、全连接层，采用 Sigmoid 激活函数，主要用于手写数字识别（MNIST）。
• AlexNet ：引入 ReLU 激活函数、Dropout、数据增强及 GPU 训练等技术，在 ImageNet 上取得 15.3% 的 Top-5 错误率，推动了大规模图像分类发展。
• VGGNet ：采用统一 3×3 卷积核、多尺度特征提取，结构简洁，ImageNet Top-5 错误率低至 7.3% / 7.0%，常作为图像分类、目标检测基础骨干网络。
• GoogLeNet ：提出 Inception 模块（多分支并行卷积）、1×1 卷积降维及全局平均池化，ImageNet Top-5 错误率 6.7%，在保持精度的同时降低参数量。
• ResNet ：通过残差连接解决梯度消失问题，并引入 Batch Normalization，不同版本（18/50/152 层）在 ImageNet Top-5 错误率表现优异，适用于多种视觉任务。
• DenseNet ：采用密集连接，实现特征复用，提高参数效率，在小数据集、医学图像处理等场景表现出色。
• MobileNet ：利用深度可分离卷积减少计算量，设计轻量级，适配移动端图像分类与检测。
• EfficientNet ：基于复合缩放（同时优化深度、宽度、分辨率）及 NAS 搜索结果，不同配置（B0-B7）在高精度图像分类，尤其是资源受限场景中表现突出。

预训练模型的训练策略关键在于找到合适结构并加载参数。调用预训练模型进行微调时，需注意调用模型及加载权重、resize 图像适配模型、修改全连接层适应数据集。训练时，先冻结特征提取器参数训练全连接层，若干 epoch 后解冻训练，以保护初始特征提取能力。

四、实践：在 CIFAR-10 上微调 ResNet18

以下为基于 PyTorch 在 CIFAR-10 数据集上微调 ResNet18 的代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms, models
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import os

# 设置中文字体支持
plt.rcParams["font.family"] = ["SimHei"]
plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题

# 检查GPU是否可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")

# 1. 数据预处理（训练集增强，测试集标准化）
train_transform = transforms.Compose([
    transforms.RandomCrop(32, padding=4),
    transforms.RandomHorizontalFlip(),
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
    transforms.RandomRotation(15),
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])

test_transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])

# 2. 加载CIFAR-10数据集
train_dataset = datasets.CIFAR10(
    root='./data',
    train=True,
    download=True,
    transform=train_transform
)

test_dataset = datasets.CIFAR10(
    root='./data',
    train=False,
    transform=test_transform
)

# 3. 创建数据加载器
batch_size = 64
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 4. 定义ResNet18模型
def create_resnet18(pretrained=True, num_classes=10):
    model = models.resnet18(pretrained=pretrained)
    
    # 修改最后一层全连接层
    in_features = model.fc.in_features
    model.fc = nn.Linear(in_features, num_classes)
    
    return model.to(device)

# 5. 冻结/解冻模型层的函数
def freeze_model(model, freeze=True):
    """冻结或解冻模型的卷积层参数"""
    # 冻结/解冻除fc层外的所有参数
    for name, param in model.named_parameters():
        if 'fc' not in name:
            param.requires_grad = not freeze
    
    # 打印冻结状态
    frozen_params = sum(p.numel() for p in model.parameters() if not p.requires_grad)
    total_params = sum(p.numel() for p in model.parameters())
    
    if freeze:
        print(f"已冻结模型卷积层参数 ({frozen_params}/{total_params} 参数)")
    else:
        print(f"已解冻模型所有参数 ({total_params}/{total_params} 参数可训练)")
    
    return model

# 6. 训练函数（支持阶段式训练）
def train_with_freeze_schedule(model, train_loader, test_loader, criterion, optimizer, scheduler, device, epochs, freeze_epochs=5):
    """
    前freeze_epochs轮冻结卷积层，之后解冻所有层进行训练
    """
    train_loss_history = []
    test_loss_history = []
    train_acc_history = []
    test_acc_history = []
    all_iter_losses = []
    iter_indices = []
    
    # 初始冻结卷积层
    if freeze_epochs > 0:
        model = freeze_model(model, freeze=True)
    
    for epoch in range(epochs):
        # 解冻控制：在指定轮次后解冻所有层
        if epoch == freeze_epochs:
            model = freeze_model(model, freeze=False)
            # 解冻后调整优化器（可选）
            optimizer.param_groups[0]['lr'] = 1e-4  # 降低学习率防止过拟合
        
        model.train()  # 设置为训练模式
        running_loss = 0.0
        correct_train = 0
        total_train = 0
        
        for batch_idx, (data, target) in enumerate(train_loader):
            data, target = data.to(device), target.to(device)
            optimizer.zero_grad()
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()
            
            # 记录Iteration损失
            iter_loss = loss.item()
            all_iter_losses.append(iter_loss)
            iter_indices.append(epoch * len(train_loader) + batch_idx + 1)
            
            # 统计训练指标
            running_loss += iter_loss
            _, predicted = output.max(1)
            total_train += target.size(0)
            correct_train += predicted.eq(target).sum().item()
            
            # 每100批次打印进度
            if (batch_idx + 1) % 100 == 0:
                print(f"Epoch {epoch+1}/{epochs} | Batch {batch_idx+1}/{len(train_loader)} "
                      f"| 单Batch损失: {iter_loss:.4f}")
        
        # 计算 epoch 级指标
        epoch_train_loss = running_loss / len(train_loader)
        epoch_train_acc = 100. * correct_train / total_train
        
        # 测试阶段
        model.eval()
        correct_test = 0
        total_test = 0
        test_loss = 0.0
        with torch.no_grad():
            for data, target in test_loader:
                data, target = data.to(device), target.to(device)
                output = model(data)
                test_loss += criterion(output, target).item()
                _, predicted = output.max(1)
                total_test += target.size(0)
                correct_test += predicted.eq(target).sum().item()
        
        epoch_test_loss = test_loss / len(test_loader)
        epoch_test_acc = 100. * correct_test / total_test
        
        # 记录历史数据
        train_loss_history.append(epoch_train_loss)
        test_loss_history.append(epoch_test_loss)
        train_acc_history.append(epoch_train_acc)
        test_acc_history.append(epoch_test_acc)
        
        # 更新学习率调度器
        if scheduler is not None:
            scheduler.step(epoch_test_loss)
        
        # 打印 epoch 结果
        print(f"Epoch {epoch+1} 完成 | 训练损失: {epoch_train_loss:.4f} "
              f"| 训练准确率: {epoch_train_acc:.2f}% | 测试准确率: {epoch_test_acc:.2f}%")
    
    # 绘制损失和准确率曲线
    plot_iter_losses(all_iter_losses, iter_indices)
    plot_epoch_metrics(train_acc_history, test_acc_history, train_loss_history, test_loss_history)
    
    return epoch_test_acc  # 返回最终测试准确率

# 7. 绘制Iteration损失曲线
def plot_iter_losses(losses, indices):
    plt.figure(figsize=(10, 4))
    plt.plot(indices, losses, 'b-', alpha=0.7)
    plt.xlabel('Iteration（Batch序号）')
    plt.ylabel('损失值')
    plt.title('训练过程中的Iteration损失变化')
    plt.grid(True)
    plt.show()

# 8. 绘制Epoch级指标曲线
def plot_epoch_metrics(train_acc, test_acc, train_loss, test_loss):
    epochs = range(1, len(train_acc) + 1)
    
    plt.figure(figsize=(12, 5))
    
    # 准确率曲线
    plt.subplot(1, 2, 1)
    plt.plot(epochs, train_acc, 'b-', label='训练准确率')
    plt.plot(epochs, test_acc, 'r-', label='测试准确率')
    plt.xlabel('Epoch')
    plt.ylabel('准确率 (%)')
    plt.title('准确率随Epoch变化')
    plt.legend()
    plt.grid(True)
    
    # 损失曲线
    plt.subplot(1, 2, 2)
    plt.plot(epochs, train_loss, 'b-', label='训练损失')
    plt.plot(epochs, test_loss, 'r-', label='测试损失')
    plt.xlabel('Epoch')
    plt.ylabel('损失值')
    plt.title('损失值随Epoch变化')
    plt.legend()
    plt.grid(True)
    plt.tight_layout()
    plt.show()

# 主函数：训练模型
def main():
    # 参数设置
    epochs = 40  # 总训练轮次
    freeze_epochs = 5  # 冻结卷积层的轮次
    learning_rate = 1e-3  # 初始学习率
    weight_decay = 1e-4  # 权重衰减
    
    # 创建ResNet18模型（加载预训练权重）
    model = create_resnet18(pretrained=True, num_classes=10)
    
    # 定义优化器和损失函数
    optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)
    criterion = nn.CrossEntropyLoss()
    
    # 定义学习率调度器
    scheduler = optim.lr_scheduler.ReduceLROnPlateau(
        optimizer, mode='min', factor=0.5, patience=2, verbose=True
    )
    
    # 开始训练（前5轮冻结卷积层，之后解冻）
    final_accuracy = train_with_freeze_schedule(
        model=model,
        train_loader=train_loader,
        test_loader=test_loader,
        criterion=criterion,
        optimizer=optimizer,
        scheduler=scheduler,
        device=device,
        epochs=epochs,
        freeze_epochs=freeze_epochs
    )
    
    print(f"训练完成！最终测试准确率: {final_accuracy:.2f}%")
    
    # # 保存模型
    # torch.save(model.state_dict(), 'resnet18_cifar10_finetuned.pth')
    # print("模型已保存至: resnet18_cifar10_finetuned.pth")

if __name__ == "__main__":
    main()

浙大疏锦行