PyTorch深度学习框架60天进阶学习计划第15天：迁移学习实践

PyTorch深度学习框架60天进阶学习计划：第15天

迁移学习实践

迁移学习是深度学习中的重要技术，它允许我们利用预训练模型的知识来解决新的问题，特别是在训练数据有限的情况下。今天，我们将通过花卉分类任务，深入了解如何在PyTorch中实践迁移学习的各种技巧。

目录

1. 迁移学习基础
2. 使用预训练ResNet模型
3. 模型微调策略
4. 特征可视化与CAM
5. 差分学习率策略
6. 完整实践案例
7. 性能对比与分析
8. 总结与最佳实践

迁移学习基础

迁移学习是一种机器学习方法，它利用在一个任务上训练好的模型来帮助另一个相关任务的学习。在深度学习中，这通常表现为使用在大规模数据集（如ImageNet）上预训练的模型，然后将其应用到特定的目标任务上。

迁移学习的主要优势

1. 减少训练时间：预训练模型已经学习了通用的特征，不需要从头开始训练
2. 降低数据需求：当目标任务的数据有限时尤其有效
3. 提高性能：预训练模型提供了良好的初始化，有助于获得更好的结果

迁移学习的常见方法

1. 特征提取：冻结预训练模型的所有层，只训练新添加的分类层
2. 微调：冻结一部分预训练层，训练剩余层和新添加的层
3. 全面重训练：保留预训练权重作为初始化，但训练所有层

下表比较了这些方法的特点：

使用预训练ResNet模型

在本节中，我们将使用预训练的ResNet模型进行花卉分类任务。ResNet（残差网络）是一种深度卷积神经网络架构，通过引入残差连接有效地解决了深层网络的梯度消失问题。

ResNet架构简介

ResNet的核心创新是残差块（Residual Block），它允许信息直接从输入跳转到输出：

x → [卷积层 → BN → ReLU → 卷积层 → BN] → + → ReLU
    |                                     ↑
    └─────────────────────────────────────┘

这种结构使得网络能够学习恒等映射，从而使深层网络的训练变得更加容易。

加载预训练的ResNet模型

PyTorch的torchvision.models模块提供了多种预训练模型，包括不同深度的ResNet版本。以下是加载预训练ResNet-50的代码：

import torch
import torchvision.models as models

# 加载预训练的ResNet-50模型
model = models.resnet50(pretrained=True)

从PyTorch 1.13开始，推荐使用以下方式加载预训练模型：

import torch
import torchvision.models as models

# 加载预训练的ResNet-50模型
model = models.resnet50(weights='IMAGENET1K_V2')

了解模型结构

在修改模型进行迁移学习之前，先了解ResNet的结构是很重要的：

print(model)

ResNet-50的主要组件包括：

• 初始卷积和池化层
• 4个残差层组（layer1, layer2, layer3, layer4）
• 全局平均池化
• 全连接分类层（fc）

模型微调策略

对于迁移学习，我们需要修改预训练模型以适应新任务。这通常涉及替换最后的分类层并决定哪些层需要训练。

替换分类层

假设我们的花卉数据集有5个类别，我们需要将ResNet的最后一层替换为具有5个输出的新层：

# 获取输入特征数量
num_ftrs = model.fc.in_features

# 替换最后的全连接层
model.fc = torch.nn.Linear(num_ftrs, 5)  # 5个花卉类别

冻结特征提取层

在微调过程中，通常我们会冻结模型的前几层，因为它们捕获的是低级特征，对于大多数视觉任务都是通用的。以下代码演示如何冻结ResNet的前几层：

# 冻结所有卷积块
for param in model.parameters():
    param.requires_grad = False
    
# 解冻最后一个残差块（layer4）
for param in model.layer4.parameters():
    param.requires_grad = True
    
# fc层的参数默认是可训练的

部分解冻策略

除了完全冻结或解冻，我们也可以采用更细粒度的策略，比如逐步解冻更多层：

# 冻结所有层
for param in model.parameters():
    param.requires_grad = False
    
# 解冻最后两个残差块
for param in model.layer3.parameters():
    param.requires_grad = True
for param in model.layer4.parameters():
    param.requires_grad = True
    
# 解冻全连接层
for param in model.fc.parameters():
    param.requires_grad = True

检查需要训练的参数

在开始训练之前，检查哪些参数将被优化是很有用的：

def count_parameters(model):
    """计算模型中可训练参数的数量"""
    return sum(p.numel() for p in model.parameters() if p.requires_grad)

total_params = count_parameters(model)
print(f"可训练参数总数: {total_params}")

# 打印每一层的可训练状态
for name, param in model.named_parameters():
    print(f"{name}: {param.requires_grad}")

特征可视化与CAM

类激活映射（Class Activation Mapping, CAM）是一种可视化技术，可以帮助我们理解CNN模型在做出决策时关注的图像区域。

CAM的工作原理

CAM通过将全局平均池化层之前的特征图与全连接层的权重相乘来生成热力图，显示模型对图像不同区域的关注程度。

实现GradCAM

GradCAM是CAM的一个改进版本，它使用梯度信息来生成更精确的可视化。以下是使用PyTorch实现GradCAM的代码：

import numpy as np
import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt
from PIL import Image
import torchvision.transforms as transforms

class GradCAM:
    def __init__(self, model, target_layer):
        self.model = model
        self.target_layer = target_layer
        self.gradients = None
        self.activations = None
        
        # 注册钩子
        target_layer.register_forward_hook(self.save_activation)
        target_layer.register_backward_hook(self.save_gradient)
    
    def save_activation(self, module, input, output):
        self.activations = output.detach()
    
    def save_gradient(self, module, grad_input, grad_output):
        self.gradients = grad_output[0].detach()
    
    def __call__(self, x, class_idx=None):
        # 前向传播
        model_output = self.model(x)
        
        if class_idx is None:
            class_idx = torch.argmax(model_output)
        
        # 反向传播
        self.model.zero_grad()
        one_hot = torch.zeros_like(model_output)
        one_hot[0, class_idx] = 1
        model_output.backward(gradient=one_hot, retain_graph=True)
        
        # 获取梯度和激活
        gradients = self.gradients
        activations = self.activations
        
        # 全局平均池化梯度
        weights = torch.mean(gradients, dim=(2, 3), keepdim=True)
        
        # 加权激活图
        cam = torch.sum(weights * activations, dim=1, keepdim=True)
        
        # ReLU
        cam = F.relu(cam)
        
        # 调整大小至原始图像尺寸
        cam = F.interpolate(cam, size=(x.shape[2], x.shape[3]), mode='bilinear', align_corners=False)
        
        # 归一化
        cam = cam - cam.min()
        cam = cam / cam.max()
        
        return cam.squeeze().cpu().numpy()

# 使用示例
def visualize_cam(model, img_path, transform, class_idx=None):
    # 加载和预处理图像
    img = Image.open(img_path)
    x = transform(img).unsqueeze(0)
    
    # 获取GradCAM
    grad_cam = GradCAM(model, model.layer4)
    cam = grad_cam(x, class_idx)
    
    # 可视化
    plt.figure(figsize=(10, 4))
    
    plt.subplot(1, 2, 1)
    plt.imshow(img)
    plt.title('Original Image')
    plt.axis('off')
    
    plt.subplot(1, 2, 2)
    plt.imshow(img)
    plt.imshow(cam, cmap='jet', alpha=0.5)
    plt.title('GradCAM')
    plt.axis('off')
    
    plt.tight_layout()
    plt.show()

差分学习率策略

差分学习率（Discriminative Learning Rates）是一种为网络不同部分设置不同学习率的技术。这基于这样的观察：预训练模型的早期层捕获更通用的特征，而后期层捕获更特定于任务的特征。

差分学习率的实现

在PyTorch中，我们可以通过为不同参数组设置不同的学习率来实现差分学习率：

# 定义参数组
params_to_update = []
params_to_update_names = []

# 低学习率组：早期层
low_lr_params = []
low_lr_params_names = []
for name, param in model.named_parameters():
    if "layer1" in name or "layer2" in name:
        low_lr_params.append(param)
        low_lr_params_names.append(name)

# 中等学习率组：中间层
mid_lr_params = []
mid_lr_params_names = []
for name, param in model.named_parameters():
    if "layer3" in name:
        mid_lr_params.append(param)
        mid_lr_params_names.append(name)

# 高学习率组：后期层和全连接层
high_lr_params = []
high_lr_params_names = []
for name, param in model.named_parameters():
    if "layer4" in name or "fc" in name:
        high_lr_params.append(param)
        high_lr_params_names.append(name)

# 创建参数组
param_groups = [
    {'params': low_lr_params, 'lr': 0.0001},
    {'params': mid_lr_params, 'lr': 0.001},
    {'params': high_lr_params, 'lr': 0.01}
]

# 使用优化器
optimizer = torch.optim.SGD(param_groups, momentum=0.9)

学习率调度

除了差分学习率，我们还可以使用学习率调度器来逐步减小学习率：

from torch.optim.lr_scheduler import StepLR

# 创建学习率调度器
scheduler = StepLR(optimizer, step_size=7, gamma=0.1)  # 每7个epoch将学习率缩小为原来的0.1倍

或者使用更先进的调度器，例如余弦退火：

from torch.optim.lr_scheduler import CosineAnnealingLR

# 创建余弦退火学习率调度器
scheduler = CosineAnnealingLR(optimizer, T_max=20)  # 在20个epoch内学习率从初始值降到接近0

完整实践案例

现在，让我们将所有这些概念整合到一个完整的花卉分类案例中。我们将使用著名的Oxford 102 Flowers数据集，它包含102种常见花卉。

import os
import time
import copy
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.optim import lr_scheduler
from torchvision import datasets, models, transforms
from torch.utils.data import DataLoader, random_split

# 设置设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")

# 数据增强和归一化
data_transforms = {
    'train': transforms.Compose([
        transforms.RandomResizedCrop(224),
        transforms.RandomHorizontalFlip(),
        transforms.RandomRotation(15),
        transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
    'val': transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
}

# 数据加载设置
data_dir = 'flower_data'  # 数据目录
batch_size = 32
num_workers = 4

# 加载数据
def load_split_flower_data(data_dir):
    # 下载并提取 flower 数据集, 如果没有
    # 此处仅示例，实际使用时需要确保数据集已下载
    if not os.path.exists(data_dir):
        os.makedirs(data_dir)
        print(f"请确保已下载花卉数据集并放置在 {data_dir} 目录中")
        # 在实际应用中，可以添加自动下载的代码
        return None, None, None, None
    
    # 加载数据集
    full_dataset = datasets.ImageFolder(os.path.join(data_dir, 'train'), 
                                         transform=data_transforms['train'])
    
    # 拆分数据集为训练集和验证集
    train_size = int(0.8 * len(full_dataset))
    val_size = len(full_dataset) - train_size
    train_dataset, val_dataset = random_split(full_dataset, [train_size, val_size])
    
    # 对验证集应用验证转换
    val_dataset.dataset.transform = data_transforms['val']
    
    # 创建数据加载器
    train_loader = DataLoader(train_dataset, batch_size=batch_size, 
                              shuffle=True, num_workers=num_workers)
    val_loader = DataLoader(val_dataset, batch_size=batch_size, 
                             shuffle=False, num_workers=num_workers)
    
    # 测试集
    test_dataset = datasets.ImageFolder(os.path.join(data_dir, 'valid'), 
                                         transform=data_transforms['val'])
    test_loader = DataLoader(test_dataset, batch_size=batch_size, 
                             shuffle=False, num_workers=num_workers)
    
    # 获取类别名称
    class_names = full_dataset.classes
    
    return train_loader, val_loader, test_loader, class_names

# 加载数据
dataloaders = {}
dataset_sizes = {}
class_names = []

# 尝试加载数据，如果数据目录不存在则提示
try:
    train_loader, val_loader, test_loader, class_names = load_split_flower_data(data_dir)
    if train_loader:
        dataloaders = {
            'train': train_loader,
            'val': val_loader,
            'test': test_loader
        }
        dataset_sizes = {
            'train': len(train_loader.dataset),
            'val': len(val_loader.dataset),
            'test': len(test_loader.dataset)
        }
        print(f"数据集加载成功: 训练集 {dataset_sizes['train']} 样本, 验证集 {dataset_sizes['val']} 样本, 测试集 {dataset_sizes['test']} 样本")
        print(f"类别: {class_names}")
except Exception as e:
    print(f"加载数据时出错: {e}")
    print("使用演示数据...")
    # 为了演示，创建一些随机数据
    # 这里仅供教学目的，实际应用需要使用真实数据
    
    class DummyDataset(torch.utils.data.Dataset):
        def __init__(self, size=100, classes=5):
            self.size = size
            self.classes = classes
            self.data = torch.randn(size, 3, 224, 224)
            self.targets = torch.randint(0, classes, (size,))
            
        def __len__(self):
            return self.size
            
        def __getitem__(self, idx):
            return self.data[idx], self.targets[idx]
    
    train_dataset = DummyDataset(1000, 5)
    val_dataset = DummyDataset(200, 5)
    test_dataset = DummyDataset(200, 5)
    
    dataloaders = {
        'train': DataLoader(train_dataset, batch_size=batch_size, shuffle=True),
        'val': DataLoader(val_dataset, batch_size=batch_size, shuffle=False),
        'test': DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
    }
    
    dataset_sizes = {
        'train': len(train_dataset),
        'val': len(val_dataset),
        'test': len(test_dataset)
    }
    
    class_names = ['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips']

# GradCAM 可视化类
class GradCAM:
    def __init__(self, model, target_layer):
        self.model = model
        self.target_layer = target_layer
        self.gradients = None
        self.activations = None
        
        # 注册钩子
        target_layer.register_forward_hook(self.save_activation)
        target_layer.register_backward_hook(self.save_gradient)
    
    def save_activation(self, module, input, output):
        self.activations = output.detach()
    
    def save_gradient(self, module, grad_input, grad_output):
        self.gradients = grad_output[0].detach()
    
    def __call__(self, x, class_idx=None):
        # 前向传播
        self.model.eval()
        logits = self.model(x)
        
        if class_idx is None:
            class_idx = logits.argmax(dim=1).item()
        else:
            class_idx = int(class_idx)
        
        # 反向传播
        self.model.zero_grad()
        one_hot = torch.zeros_like(logits)
        one_hot[0, class_idx] = 1
        logits.backward(gradient=one_hot, retain_graph=True)
        
        # 全局平均池化梯度
        pooled_gradients = torch.mean(self.gradients, dim=[2, 3])
        
        # 加权激活图
        for i in range(pooled_gradients.size(1)):
            self.activations[:, i, :, :] *= pooled_gradients[:, i].view(pooled_gradients.size(0), 1, 1)
        
        # 平均所有通道的激活
        cam = torch.mean(self.activations, dim=1).squeeze()
        
        # ReLU
        cam = F.relu(cam)
        
        # 归一化
        cam = cam - cam.min()
        cam = cam / cam.max() if cam.max() > 0 else cam
        
        return cam.cpu().numpy()

# 创建ResNet模型并实现各种迁移学习策略
def setup_model(strategy='finetune', num_classes=5):
    # 加载预训练的ResNet50
    model = models.resnet50(weights='IMAGENET1K_V2')
    
    # 根据策略设置训练参数
    if strategy == 'feature_extract':
        # 特征提取：冻结所有层，只训练新的分类器
        for param in model.parameters():
            param.requires_grad = False
    
    elif strategy == 'finetune':
        # 微调：冻结前面的层，只训练后面的层
        for param in model.parameters():
            param.requires_grad = False
        
        # 解冻layer4和全连接层
        for param in model.layer4.parameters():
            param.requires_grad = True
    
    elif strategy == 'progressive':
        # 渐进式解冻：随层次调整学习率
        for param in model.parameters():
            param.requires_grad = False
        
        # 解冻layer3、layer4和全连接层
        for param in model.layer3.parameters():
            param.requires_grad = True
        for param in model.layer4.parameters():
            param.requires_grad = True
    
    elif strategy == 'full_finetune':
        # 全面微调：训练所有层
        for param in model.parameters():
            param.requires_grad = True
    
    # 替换最后的全连接层
    num_ftrs = model.fc.in_features
    model.fc = nn.Linear(num_ftrs, num_classes)
    
    # 将模型移至适当的设备
    model = model.to(device)
    
    return model

# 不同学习率策略的优化器配置
def setup_optimizer(model, strategy='finetune'):
    params_to_update = []
    
    if strategy == 'feature_extract':
        # 只更新fc层参数
        params_to_update = [p for p in model.fc.parameters()]
        optimizer = optim.SGD(params_to_update, lr=0.001, momentum=0.9)
    
    elif strategy == 'finetune':
        # 微调：只更新layer4和fc层
        optimizer = optim.SGD([
            {'params': model.layer4.parameters(), 'lr': 0.0005},
            {'params': model.fc.parameters(), 'lr': 0.001}
        ], momentum=0.9)
    
    elif strategy == 'progressive':
        # 渐进式解冻：为不同层设置不同学习率
        optimizer = optim.SGD([
            {'params': model.layer3.parameters(), 'lr': 0.0001},
            {'params': model.layer4.parameters(), 'lr': 0.0005},
            {'params': model.fc.parameters(), 'lr': 0.001}
        ], momentum=0.9)
    
    elif strategy == 'full_finetune':
        # 全面微调：使用差分学习率
        optimizer = optim.SGD([
            {'params': list(model.conv1.parameters()) + 
                        list(model.layer1.parameters()) +
                        list(model.layer2.parameters()), 'lr': 0.00001},
            {'params': model.layer3.parameters(), 'lr': 0.0001},
            {'params': model.layer4.parameters(), 'lr': 0.0005},
            {'params': model.fc.parameters(), 'lr': 0.001}
        ], momentum=0.9)
    
    # 使用学习率调度器
    scheduler = lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)
    
    return optimizer, scheduler

# 训练和评估模型
def train_model(model, dataloaders, criterion, optimizer, scheduler, num_epochs=25):
    since = time.time()
    
    # 保存最佳模型
    best_model_wts = copy.deepcopy(model.state_dict())
    best_acc = 0.0
    
    # 记录训练历史
    history = {
        'train_loss': [],
        'train_acc': [],
        'val_loss': [],
        'val_acc': []
    }
    
    for epoch in range(num_epochs):
        print(f'Epoch {epoch+1}/{num_epochs}')
        print('-' * 10)
        
        # 每个epoch有训练和验证阶段
        for phase in ['train', 'val']:
            if phase == 'train':
                model.train()  # 设置模型为训练模式
            else:
                model.eval()   # 设置模型为评估模式
            
            running_loss = 0.0
            running_corrects = 0
            
            # 迭代数据
            for inputs, labels in dataloaders[phase]:
                inputs = inputs.to(device)
                labels = labels.to(device)
                
                # 梯度清零
                optimizer.zero_grad()
                
                # 前向传播
                with torch.set_grad_enabled(phase == 'train'):
                    outputs = model(inputs)
                    _, preds = torch.max(outputs, 1)
                    loss = criterion(outputs, labels)
                    
                    # 反向传播 + 优化（仅在训练阶段）
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()
                
                # 统计
                running_loss += loss.item() * inputs.size(0)
                running_corrects += torch.sum(preds == labels.data)
            
            # 如果是训练阶段，更新学习率
            if phase == 'train':
                scheduler.step()
            
            epoch_loss = running_loss / dataset_sizes[phase]
            epoch_acc = running_corrects.double() / dataset_sizes[phase]
            
            print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
            
            # 记录历史
            if phase == 'train':
                history['train_loss'].append(epoch_loss)
                history['train_acc'].append(epoch_acc.item())
            else:
                history['val_loss'].append(epoch_loss)
                history['val_acc'].append(epoch_acc.item())
            
            # 如果是最佳模型，保存
            if phase == 'val' and epoch_acc > best_acc:
                best_acc = epoch_acc
                best_model_wts = copy.deepcopy(model.state_dict())
        
        print()
    
    time_elapsed = time.time() - since
    print(f'训练完成，用时 {time_elapsed // 60:.0f}m {time_elapsed % 60:.0f}s')
    print(f'最佳验证准确率: {best_acc:.4f}')
    
    # 加载最佳模型权重
    model.load_state_dict(best_model_wts)
    
    return model, history

# 使用GradCAM可视化模型关注区域
def visualize_model_attention(model, dataloader, class_names, num_images=4):
    # 创建GradCAM
    grad_cam = GradCAM(model, model.layer4)
    
    # 获取一些测试图像
    images_so_far = 0
    fig = plt.figure(figsize=(15, 12))
    
    with torch.no_grad():
        for inputs, labels in dataloader:
            inputs = inputs.to(device)
            labels = labels.to(device)
            
            # 预测
            outputs = model(inputs)
            _, preds = torch.max(outputs, 1)
            
            for j in range(inputs.size()[0]):
                images_so_far += 1
                
                # 每行显示原图和CAM对比
                ax = plt.subplot(num_images, 2, images_so_far*2-1)
                ax.set_title(f'预测: {class_names[preds[j]]}')
                
                # 反归一化显示图像
                inp = inputs.cpu().data[j].numpy().transpose((1, 2, 0))
                mean = np.array([0.485, 0.456, 0.406])
                std = np.array([0.229, 0.224, 0.225])
                inp = std * inp + mean
                inp = np.clip(inp, 0, 1)
                plt.imshow(inp)
                
                # 可视化CAM
                ax = plt.subplot(num_images, 2, images_so_far*2)
                ax.set_title(f'CAM: {class_names[labels[j]]}')
                
                # 计算CAM
                cam = grad_cam(inputs[j:j+1], labels[j])
                
                # 显示原图
                plt.imshow(inp)
                # 叠加CAM
                plt.imshow(cam, cmap='jet', alpha=0.5)
                
                if images_so_far == num_images:
                    plt.tight_layout()
                    return
            
            if images_so_far == num_images:
                break

# 比较不同迁移学习策略
def compare_strategies():
    # 损失函数
    criterion = nn.CrossEntropyLoss()
    
    # 定义策略列表
    strategies = ['feature_extract', 'finetune', 'progressive', 'full_finetune']
    
    # 存储结果
    results = {}
    
    # 对每种策略训练模型
    for strategy in strategies:
        print(f"\n正在训练 {strategy} 策略...")
        
        # 设置模型和优化器
        model = setup_model(strategy, len(class_names))
        optimizer, scheduler = setup_optimizer(model, strategy)
        
        # 训练模型
        trained_model, history = train_model(
            model, dataloaders, criterion, optimizer, scheduler, num_epochs=15)
        
        # 在测试集上评估
        trained_model.eval()
        correct = 0
        total = 0
        
        with torch.no_grad():
            for inputs, labels in dataloaders['test']:
                inputs = inputs.to(device)
                labels = labels.to(device)
                outputs = trained_model(inputs)
                _, predicted = torch.max(outputs.data, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()
        
        test_acc = correct / total
        print(f"{strategy} 测试准确率: {test_acc:.4f}")
        
        # 存储结果
        results[strategy] = {
            'model': trained_model,
            'history': history,
            'test_acc': test_acc
        }
    
    return results

# 绘制学习曲线
def plot_learning_curves(results):
    strategies = list(results.keys())
    fig, axes = plt.subplots(1, 2, figsize=(15, 5))
    
    for strategy in strategies:
        history = results[strategy]['history']
        
        # 绘制训练和验证损失
        axes[0].plot(history['train_loss'], label=f'{strategy} train')
        axes[0].plot(history['val_loss'], label=f'{strategy} val', linestyle='--')
    
    for strategy in strategies:
        history = results[strategy]['history']
        
        # 绘制训练和验证准确率
        axes[1].plot(history['train_acc'], label=f'{strategy} train')
        axes[1].plot(history['val_acc'], label=f'{strategy} val', linestyle='--')
    
    axes[0].set_title('Loss Curves')
    axes[0].set_xlabel('Epoch')
    axes[0].set_ylabel('Loss')
    axes[0].legend()
    
    axes[1].set_title('Accuracy Curves')
    axes[1].set_xlabel('Epoch')
    axes[1].set_ylabel('Accuracy')
    axes[1].legend()
    
    plt.tight_layout()
    plt.show()

# 可视化各策略的测试准确率
def plot_test_accuracy(results):
    strategies = list(results.keys())
    accuracies = [results[s]['test_acc'] for s in strategies]
    
    plt.figure(figsize=(10, 6))
    plt.bar(strategies, accuracies, color='skyblue')
    plt.title('Test Accuracy by Transfer Learning Strategy')
    plt.xlabel('Strategy')
    plt.ylabel('Accuracy')
    plt.ylim(0, 1.0)
    
    # 添加数值标签
    for i, v in enumerate(accuracies):
        plt.text(i, v + 0.01, f"{v:.4f}", ha='center')
    
    plt.tight_layout()
    plt.show()

# 主函数
def main():
    # 确保数据可用
    if not dataloaders or 'train' not in dataloaders:
        print("无法访问数据，请确保数据集已正确设置")
        return
    
    # 比较不同迁移学习策略
    num_classes = len(class_names)
    print(f"分类数量: {num_classes}")
    
    # 运行比较实验
    # 注意：这可能需要较长时间，可以根据需要选择运行
    if False:  # 设置为True以运行完整比较
        results = compare_strategies()
        plot_learning_curves(results)
        plot_test_accuracy(results)
    else:
        # 简单演示：仅使用微调策略
        print("演示微调策略...")
        model = setup_model('finetune', num_classes)
        optimizer, scheduler = setup_optimizer(model, 'finetune')
        criterion = nn.CrossEntropyLoss()
        
        # 训练较少的epoch以快速演示
        model, history = train_model(
            model, dataloaders, criterion, optimizer, scheduler, num_epochs=3)
        
        # 可视化一些预测结果和CAM
        print("生成CAM可视化...")
        visualize_model_attention(model, dataloaders['test'], class_names, num_images=2)
        
        # 仅绘制一个策略的学习曲线
        plt.figure(figsize=(12, 4))
        plt.subplot(1, 2, 1)
        plt.plot(history['train_loss'], label='train')
        plt.plot(history['val_loss'], label='val')
        plt.title('Loss Curves')
        plt.xlabel('Epoch')
        plt.ylabel('Loss')
        plt.legend()
        
        plt.subplot(1, 2, 2)
        plt.plot(history['train_acc'], label='train')
        plt.plot(history['val_acc'], label='val')
        plt.title('Accuracy Curves')
        plt.xlabel('Epoch')
        plt.ylabel('Accuracy')
        plt.legend()
        
        plt.tight_layout()
        plt.show()

if __name__ == "__main__":
    main()

让我继续为您提供迁移学习实践内容的后半部分：

性能对比与分析

迁移学习中的策略选择会显著影响模型性能。下面我们将分析不同迁移学习策略的性能差异，并探讨差分学习率的影响。

迁移学习策略比较

下表总结了四种主要迁移学习策略在花卉分类任务上的性能对比：

注意：实际数值可能因数据集、模型初始化等因素而异

从上表可以看出：

1. 特征提取最轻量和最快，但准确率较低
2. 微调在计算成本和准确率之间取得了良好平衡
3. 渐进式解冻和全面微调提供最高准确率，但需要更多计算资源

差分学习率的影响

差分学习率策略对模型性能有显著影响。下表比较了同一微调策略下，采用不同学习率设置的结果：

结果表明：

1. 为不同层设置适当的学习率可以显著提高模型性能
2. 早期层应使用较小的学习率，因为它们捕获的是通用特征
3. 后期层和分类器可以使用较大的学习率，以适应新任务

CAM可视化分析

通过类激活映射(CAM)可视化，我们可以观察到不同训练阶段和策略下模型关注的区域变化：

1. 预训练模型：往往关注图像的普遍特征，不特别关注花卉的辨别性特征
2. 特征提取：开始关注花卉区域，但可能不够精确
3. 微调：关注区域更加集中在花朵的辨别性特征上
4. 全面微调：形成最精确的特征关注区域，准确定位花朵的关键特征

这种可视化揭示了迁移学习过程中模型注意力如何从通用特征逐渐转向特定于任务的特征。

迁移学习的工作流程

下面是完整的迁移学习工作流程图，总结了整个流程：

┌──────────────┐      ┌───────────────┐      ┌───────────────┐
│ 加载预训练   │      │ 修改模型架构  │      │ 设置参数冻结  │
│ ResNet模型   │ ──► │ (替换分类层)  │ ──► │ 与学习率策略  │
└──────────────┘      └───────────────┘      └───────┬───────┘
                                                    │
                                                    ▼
┌──────────────┐      ┌───────────────┐      ┌───────────────┐
│ 评估模型并   │      │ 训练模型      │      │ 数据加载与    │
│ 可视化CAM    │ ◄── │ (微调过程)    │ ◄── │ 预处理        │
└──────────────┘      └───────────────┘      └───────────────┘

实践建议与最佳实践

基于我们的实验和业界经验，以下是在PyTorch中应用迁移学习的一些最佳实践：

选择适当的预训练模型

1. 任务相关性：选择在与目标任务相似的数据集上预训练的模型
2. 模型大小：在性能和计算资源之间寻找平衡
3. 架构考虑：不同架构（ResNet, EfficientNet等）在特定任务上可能有不同表现

微调策略选择指南

学习率设置技巧

1. 初始学习率选择：分类器层通常使用0.001至0.01，预训练层使用更小的值
2. 学习率调度：使用学习率预热和余弦退火往往有更好效果
3. 分层学习率：
   • 早期层：非常小的学习率(1e-5)或冻结
   • 中间层：小学习率(1e-4)
   • 后期层：中等学习率(5e-4)
   • 新添加层：较大学习率(1e-3)

数据增强的重要性

对于迁移学习，数据增强尤为重要，可以减少过拟合风险：

transforms.Compose([
    transforms.RandomResizedCrop(224),  # 随机裁剪和缩放
    transforms.RandomHorizontalFlip(),  # 水平翻转
    transforms.RandomRotation(15),      # 小角度旋转
    transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1),  # 颜色变化
    transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),  # 平移
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

避免常见陷阱

1. 混淆训练与评估模式：确保在训练时使用model.train()，评估时使用model.eval()
2. 学习率过大：对预训练层使用过大学习率可能破坏有用特征
3. 批量归一化统计量：如果冻结包含BN层的块，考虑更新BN统计量或使用eval模式
4. 参数组混淆：确保正确将参数分配到不同学习率组

总结与最佳实践

迁移学习是解决数据有限问题的强大工具。通过本教程，我们学习了：

1. 如何使用预训练ResNet模型进行花卉分类
2. 不同的微调策略，从特征提取到全面微调
3. CAM可视化技术，用于理解模型关注的区域
4. 差分学习率策略，根据层次设置不同的学习率

在实际应用中，迁移学习策略应根据具体场景灵活选择：

• 数据量少时，倾向于使用特征提取
• 数据与预训练任务相似时，可以只微调后几层
• 计算资源充足且有足够数据时，可以考虑全面微调
• 差分学习率策略在大多数情况下都能提升性能

最后，记住迁移学习的核心思想：借用预训练模型学到的知识，并巧妙地将其迁移到新任务上，从而实现"站在巨人的肩膀上"的学习过程。

清华大学全五版的《DeepSeek教程》完整的文档需要的朋友，关注我私信：deepseek 即可获得。

怎么样今天的内容还满意吗？再次感谢朋友们的观看，关注GZH：凡人的AI工具箱，回复666，送您价值199的AI大礼包。最后，祝您早日实现财务自由，还请给个赞，谢谢！