当前位置：首页 > news >正文

提升模型性能：数据增强与调优实战

news 来源：原创 2025/5/16 13:40:19

‌一、为什么需要数据增强？

数据增强通过对训练图像进行‌随机变换‌，能够有效：

增加数据多样性，防止过拟合
提升模型对不同视角、光照条件的鲁棒性
在数据量不足时显著提升模型性能

二、MNIST手写数字识别实战‌

‌1. 加载数据集与增强策略

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt

# 高级数据增强组合
train_transform = transforms.Compose([
    transforms.RandomRotation(10),          # 随机旋转±10度
    transforms.RandomAffine(0, translate=(0.1, 0.1)), # 随机平移
    transforms.ColorJitter(brightness=0.2, contrast=0.2), # 调整亮度对比度
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,)) # MNIST专用标准化参数
])

test_transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# 加载数据集
train_dataset = torchvision.datasets.MNIST(
    root='./data', 
    train=True, 
    download=True,
    transform=train_transform
)

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

# 可视化增强效果
def plot_augmented_samples():
    fig, axes = plt.subplots(3, 5, figsize=(15, 7))
    for i in range(3):
        for j in range(5):
            img, label = train_dataset[i*5 + j]
            axes[i,j].imshow(img.squeeze(), cmap='gray')
            axes[i,j].axis('off')
    plt.suptitle("数据增强效果示例", y=0.9)
    plt.show()

plot_augmented_samples()

‌2. 构建卷积神经网络（CNN）

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv_layers = nn.Sequential(
            nn.Conv2d(1, 32, 3, padding=1),  # 输入通道1，输出32，3x3卷积
            nn.BatchNorm2d(32),              # 批标准化
            nn.ReLU(),
            nn.MaxPool2d(2),                 # 池化层 2x2
            
            nn.Conv2d(32, 64, 3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        
        self.fc_layers = nn.Sequential(
            nn.Linear(64*7*7, 512),          # 全连接层
            nn.Dropout(0.5),                 # Dropout防止过拟合
            nn.ReLU(),
            nn.Linear(512, 10)
        )
    
    def forward(self, x):
        x = self.conv_layers(x)
        x = x.view(x.size(0), -1)            # 展平特征图
        return self.fc_layers(x)

model = CNN()
print(model)

三、高级训练技巧‌

‌1. 学习率调度器

from torch.optim.lr_scheduler import StepLR

optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
scheduler = StepLR(optimizer, step_size=5, gamma=0.1)  # 每5个epoch学习率×0.1

‌2. 早停法（Early Stopping）

class EarlyStopper:
    def __init__(self, patience=3, min_delta=0):
        self.patience = patience
        self.min_delta = min_delta
        self.counter = 0
        self.min_loss = float('inf')

    def __call__(self, val_loss):
        if val_loss < self.min_loss - self.min_delta:
            self.min_loss = val_loss
            self.counter = 0
        else:
            self.counter += 1
            if self.counter >= self.patience:
                return True
        return False

3. 完整训练流程

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)

train_loader = torch.utils.data.DataLoader(
    dataset=train_dataset, 
    batch_size=128, 
    shuffle=True
)

test_loader = torch.utils.data.DataLoader(
    dataset=test_dataset,
    batch_size=256,
    shuffle=False
)

criterion = nn.CrossEntropyLoss()
early_stopper = EarlyStopper(patience=3)

def train(epoch):
    model.train()
    total_loss = 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()
        
        total_loss += loss.item()
        
        if batch_idx % 100 == 0:
            print(f'Train Epoch: {epoch} [{batch_idx*len(data)}/{len(train_loader.dataset)}]'
                  f'\tLoss: {loss.item():.4f}')
    
    return total_loss / len(train_loader)

def validate():
    model.eval()
    val_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            val_loss += criterion(output, target).item()
            pred = output.argmax(dim=1)
            correct += pred.eq(target).sum().item()
    
    val_loss /= len(test_loader)
    accuracy = 100. * correct / len(test_loader.dataset)
    print(f'\nValidation set: Average loss: {val_loss:.4f}, Accuracy: {correct}/{len(test_loader.dataset)} ({accuracy:.2f}%)\n')
    return val_loss, accuracy

# 训练循环
best_accuracy = 0
for epoch in range(1, 20):
    train_loss = train(epoch)
    val_loss, accuracy = validate()
    scheduler.step()
    
    # 保存最佳模型
    if accuracy > best_accuracy:
        torch.save(model.state_dict(), "best_model.pth")
        best_accuracy = accuracy
    
    # 早停判断
    if early_stopper(val_loss):
        print("Early stopping triggered!")
        break

‌四、模型性能分析‌

‌1. 混淆矩阵可视化

from sklearn.metrics import confusion_matrix
import seaborn as sns

model.load_state_dict(torch.load("best_model.pth"))
model.eval()

all_preds = []
all_targets = []
with torch.no_grad():
    for data, target in test_loader:
        data = data.to(device)
        output = model(data)
        pred = output.argmax(dim=1)
        all_preds.extend(pred.cpu().numpy())
        all_targets.extend(target.numpy())

cm = confusion_matrix(all_targets, all_preds)
plt.figure(figsize=(10,8))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=range(10), yticklabels=range(10))
plt.xlabel('Predicted')
plt.ylabel('True')
plt.title('Confusion Matrix')
plt.show()

‌2. 错误样本分析

import numpy as np

# 找出错误预测的样本
errors = np.where(np.array(all_preds) != np.array(all_targets))

# 可视化典型错误
plt.figure(figsize=(12,6))
for i in range(6):
    idx = errors[i]
    img = test_dataset[idx].squeeze()
    plt.subplot(2,3,i+1)
    plt.imshow(img, cmap='gray')
    plt.title(f"True: {all_targets[idx]}, Pred: {all_preds[idx]}")
    plt.axis('off')
plt.tight_layout()
plt.show()