[训练和优化] 3. 模型优化

news2025/5/16 13:46:00

👋 你好！这里有实用干货与深度分享✨✨ 若有帮助，欢迎：
👍 点赞 | ⭐ 收藏 | 💬 评论 | ➕ 关注，解锁更多精彩！
📁 收藏专栏即可第一时间获取最新推送🔔。
📖后续我将持续带来更多优质内容，期待与你一同探索知识，携手前行，共同进步🚀。

人工智能

模型优化

本文详细介绍深度学习模型的优化技术，包括正则化、梯度裁剪、早停、模型集成等方法，帮助提升模型性能和泛化能力。

1. 正则化方法

1.1 权重正则化

通过L1/L2正则化抑制模型复杂度，防止过拟合。

import torch

class L1L2Regularizer:
    def __init__(self, l1_lambda=0.0, l2_lambda=0.0):
        self.l1_lambda = l1_lambda
        self.l2_lambda = l2_lambda
    
    def __call__(self, model):
        reg_loss = 0
        for param in model.parameters():
            if param.requires_grad:
                # L1正则化
                reg_loss += self.l1_lambda * torch.sum(torch.abs(param))
                # L2正则化
                reg_loss += self.l2_lambda * torch.sum(param ** 2)
        return reg_loss

# 使用示例
regularizer = L1L2Regularizer(l1_lambda=1e-5, l2_lambda=1e-4)
reg_loss = regularizer(model)
total_loss = task_loss + reg_loss

1.2 Dropout实现

Dropout可有效缓解过拟合，提升模型泛化能力。

import torch
import torch.nn as nn

class CustomDropout(nn.Module):
    def __init__(self, p=0.5, training=True):
        super().__init__()
        self.p = p
        self.training = training
    
    def forward(self, x):
        if not self.training or self.p == 0:
            return x
        mask = torch.bernoulli(torch.ones_like(x) * (1 - self.p))
        return x * mask / (1 - self.p)

# 在模型中使用
self.dropout = CustomDropout(p=0.5)

2. 梯度处理

2.1 梯度裁剪

防止梯度爆炸，提升训练稳定性。

import torch

def clip_gradients(model, clip_value=1.0, clip_norm=None):
    if clip_norm is not None:
        torch.nn.utils.clip_grad_norm_(model.parameters(), clip_norm)
    else:
        torch.nn.utils.clip_grad_value_(model.parameters(), clip_value)

def train_with_gradient_clipping(model, train_loader, criterion,
                               optimizer, device, clip_value=1.0):
    model.train()
    for data, target in train_loader:
        data, target = data.to(device), target.to(device)

        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()

        # 应用梯度裁剪
        clip_gradients(model, clip_value)

        optimizer.step()

2.2 梯度累积

节省显存，模拟大批量训练。

class GradientAccumulator:
    def __init__(self, model, accumulation_steps):
        self.model = model
        self.accumulation_steps = accumulation_steps
        self.current_step = 0
    
    def step(self, loss):
        # 缩放损失
        loss = loss / self.accumulation_steps
        loss.backward()

        self.current_step += 1
        return self.current_step % self.accumulation_steps == 0
    
    def reset(self):
        self.current_step = 0

3. 早停策略

3.1 验证集早停

防止过拟合，自动停止训练并保存最佳模型。

class EarlyStopping:
    def __init__(self, patience=7, min_delta=0):
        self.patience = patience
        self.min_delta = min_delta
        self.counter = 0
        self.best_loss = None
        self.early_stop = False
    
    def __call__(self, val_loss):
        if self.best_loss is None:
            self.best_loss = val_loss
        elif val_loss > self.best_loss - self.min_delta:
            self.counter += 1
            if self.counter >= self.patience:
                self.early_stop = True
        else:
            self.best_loss = val_loss
            self.counter = 0

        return self.early_stop

# 使用示例
early_stopping = EarlyStopping(patience=10)
for epoch in range(num_epochs):
    train_loss = train_epoch(model, train_loader, criterion, optimizer)
    val_loss = validate(model, val_loader, criterion)

    if early_stopping(val_loss):
        print('Early stopping triggered')
        break

4. 模型集成

4.1 模型平均

集成多个模型预测结果，提升鲁棒性和准确率。

import torch

class ModelEnsemble:
    def __init__(self, models):
        self.models = models
    
    def predict(self, x):
        predictions = []
        for model in self.models:
            model.eval()
            with torch.no_grad():
                pred = model(x)
                predictions.append(pred)

        # 对预测结果取平均
        return torch.mean(torch.stack(predictions), dim=0)

# 使用示例
models = [train_model() for _ in range(5)]  # 训练多个模型
ensemble = ModelEnsemble(models)
prediction = ensemble.predict(test_data)

4.2 权重平均

直接对模型参数加权平均，获得更稳健的模型。

import copy

def average_model_weights(models):
    """平均多个模型的权重"""
    avg_model = copy.deepcopy(models[0])
    avg_dict = avg_model.state_dict()

    for key in avg_dict.keys():
        # 初始化为第一个模型的权重
        avg_dict[key] = avg_dict[key].clone()
        # 累加其他模型的权重
        for model in models[1:]:
            avg_dict[key] += model.state_dict()[key]
        # 计算平均值
        avg_dict[key] = avg_dict[key] / len(models)

    avg_model.load_state_dict(avg_dict)
    return avg_model