深度学习模型优化策略与实战调参

注意 L1 系数不宜过大，否则会导致过度稀疏引发欠拟合。

L2 正则化：权重衰减

L2 正则化加入参数平方和，公式为 $Loss = Loss_{original} + \lambda \sum w_i^2$。它让参数值变小但不归零，有效抑制对噪声的敏感度。主流框架支持直接通过 weight_decay 参数实现。

TensorFlow 示例：

import tensorflow as tf
from tensorflow.keras import layers, models, regularizers

model = models.Sequential([
    layers.Dense(50, activation='relu', input_shape=(100,), 
                 kernel_regularizer=regularizers.l2(0.001)),
    layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

L2 是解决过拟合最常用的手段，优先尝试。

Dropout：随机失活神经元

Dropout 在训练时随机让部分神经元输出置 0，避免过度依赖特定特征。核心参数 dropout_rate 通常设在 0.2~0.5 之间。

PyTorch 示例：

class DropoutModel(nn.Module):
    def __init__(self):
        super(DropoutModel, self).__init__()
        self.fc1 = nn.Linear(100, 200)
        self.dropout = nn.Dropout(0.3)
        self.fc2 = nn.Linear(200, 10)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.fc2(x)
        return x

注意 Dropout 仅在训练阶段启用，验证和测试阶段会自动关闭。

优化器的选择与参数调整

优化器根据梯度更新参数以最小化损失。选择合适的优化器及参数对效率和性能至关重要。

常见优化器对比

新手可优先使用 Adam，追求泛化能力时尝试 SGD+Momentum。

学习率调整策略

学习率决定参数更新步长。过大震荡不收敛，过小训练缓慢。常见方法有固定学习率、衰减（如阶梯衰减、余弦退火）及自适应学习率。

PyTorch 阶梯衰减示例：

optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)

for epoch in range(50):
    model.train()
    train_loss = 0.0
    for data, target in train_loader:
        optimizer.zero_grad()
        output = model(data)
        loss = loss_fn(output, target)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
    scheduler.step()
    print(f"Epoch {epoch+1}, LR: {optimizer.param_groups[0]['lr']}")

建议从中等学习率开始，观察曲线后逐步调整。

批量大小与训练轮次的匹配策略

Batch Size 和 Epochs 直接影响速度与性能。

• 小批量 (8~32)：梯度更新频繁，收敛稳但慢，易引入噪声。
• 大批量 (64~256)：速度快，梯度准，但内存需求大，可能降低泛化。

确定合适 Epochs 推荐使用早停法 (Early Stopping)：监控验证集性能，连续多轮无提升即停止并保存最佳权重。

Keras 早停法示例：

from tensorflow.keras.callbacks import EarlyStopping

early_stopping = EarlyStopping(
    monitor='val_accuracy',
    patience=5,
    restore_best_weights=True
)

history = model.fit(
    train_data, train_labels,
    batch_size=32, epochs=100,
    validation_data=(val_data, val_labels),
    callbacks=[early_stopping]
)

实战案例：图像分类模型的优化全过程

以 CIFAR-10 任务为例，展示从基础模型到优化的完整流程。

步骤 1：搭建基础模型并诊断

搭建简单 CNN 训练 50 轮，观察曲线。若训练损失持续下降而验证损失先降后升，说明过拟合。

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
train_dataset = datasets.CIFAR10('./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)
val_dataset = datasets.CIFAR10('./data', train=False, download=True, transform=transform)
val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=32, shuffle=False)

class BaseCNN(nn.Module):
    def __init__(self):
        super(BaseCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.fc1 = nn.Linear(64*8*8, 512)
        self.fc2 = nn.Linear(512, 10)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 64*8*8)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = BaseCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

train_losses, val_losses = [], []
for epoch in range(50):
    model.train()
    train_loss = 0.0
    for data, target in train_loader:
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
    train_losses.append(train_loss / len(train_loader))

    model.eval()
    val_loss = 0.0
    with torch.no_grad():
        for data, target in val_loader:
            output = model(data)
            loss = criterion(output, target)
            val_loss += loss.item()
    val_losses.append(val_loss / len(val_loader))
    print(f"Epoch {epoch+1}, Train Loss: {train_losses[-1]:.4f}, Val Loss: {val_losses[-1]:.4f}")

步骤 2：应用正则化优化

针对过拟合，加入 L2 正则化和 Dropout 层。

class OptimizedCNN(nn.Module):
    def __init__(self):
        super(OptimizedCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.dropout1 = nn.Dropout(0.25)
        self.fc1 = nn.Linear(64*8*8, 512)
        self.dropout2 = nn.Dropout(0.5)
        self.fc2 = nn.Linear(512, 10)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 64*8*8)
        x = self.dropout1(x)
        x = torch.relu(self.fc1(x))
        x = self.dropout2(x)
        x = self.fc2(x)
        return x

model_opt = OptimizedCNN()
optimizer_opt = optim.Adam(model_opt.parameters(), lr=0.001, weight_decay=0.0001)
criterion = nn.CrossEntropyLoss()

步骤 3：调整超参数

将 Batch Size 调整为 64，配合学习率衰减策略。最终验证集准确率提升约 8%，且无明显过拟合。

模型优化是系统性工程，需结合正则化、优化器调参、批量大小调整等手段，根据具体问题灵活应对。