2024年国科大模式识别课程实战：基于深度学习的图像分类解决方案

1次阅读

没有评论

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

2024 年国科大模式识别课程的图像分类任务面临几个典型挑战：

小样本问题 ：课程提供的训练数据量有限，通常每个类别只有几十到几百张图像
过拟合风险 ：深层网络容易在小型数据集上过度拟合训练数据
计算资源限制 ：学生使用的 GPU 显存有限（如 Colab 的免费版）
标注噪声 ：实际数据中可能存在错误标注的情况

传统方法（如 SVM+HOG）与深度学习方法对比：

传统方法：
优点：在小数据场景可解释性强
缺点：特征工程依赖经验，性能天花板明显
深度学习方法：
优势：端到端特征学习，SOTA 性能
挑战：需要解决上述小样本和过拟合问题

我们选择基于 PyTorch 的 CNN 方案，结合以下关键技术：

import torch
import torch.nn as nn

class BasicCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.features = nn.Sequential(nn.Conv2d(3, 32, kernel_size=3, padding=1),  # 保持尺寸不变
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.classifier = nn.Sequential(nn.Linear(64 * 8 * 8, 128),  # 假设输入为 32x32，经两次池化后为 8x8
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(128, 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.RandomHorizontalFlip(),  # 水平翻转
    transforms.RandomRotation(15),      # ±15 度随机旋转
    transforms.ColorJitter(             # 颜色抖动
        brightness=0.2, 
        contrast=0.2, 
        saturation=0.2
    ),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    )
])

from torchvision import models

# 加载预训练模型
model = models.resnet18(weights='IMAGENET1K_V1')

# 替换最后的全连接层
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, num_classes)  # num_classes 为你的类别数

# 只训练最后一层（可选）for param in model.parameters():
    param.requires_grad = False
for param in model.fc.parameters():
    param.requires_grad = True

from torch.optim import lr_scheduler

optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
scheduler = lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)  # 每 5 个 epoch 衰减到 0.1 倍

class EarlyStopping:
    def __init__(self, patience=5):
        self.patience = patience
        self.counter = 0
        self.best_loss = float('inf')

    def __call__(self, val_loss):
        if val_loss < self.best_loss:
            self.best_loss = val_loss
            self.counter = 0
        else:
            self.counter += 1
            if self.counter >= self.patience:
                return True  # 停止训练
        return False

标注错误处理 ：
使用交叉验证发现潜在错误样本
实施标签平滑（Label Smoothing）技术
GPU 内存优化 ：
梯度累积：多个小 batch 累加梯度后再更新

混合精度训练：

from torch.cuda.amp import GradScaler, autocast

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