08 - 模型评估与迭代 | AI项目开发实战教学平台

📊 评估 · 看验证集分数

核心动作：跑一遍验证集，记分数。

做什么	怎么做	代码示例
跑完验证集	模型在 val 上 forward 一次	`model.eval(); with torch.no_grad(): for x,y in val_loader: pred = model(x)`
算全套指标	不要只看 Accuracy	`Accuracy / Precision / Recall / F1 / AUC / mAP`
存实验日志	每次实验一行 CSV	`experiment.csv: run_id, model, lr, val_acc, val_f1, notes`
跟 baseline 比	没过 baseline？直接放弃	`if val_f1 < baseline_f1: skip this run`
跟上次比	涨了？跌了？稳定吗？	`delta = current - last_run; print(f'F1 {delta:+.3f}')`

📦 交付物：一张实验对比表 + 当前最优分数

🔍 分析 · 误差诊断

核心动作：模型"哪里错了"，而不是"模型对了多少"。

做什么	怎么做	目的
看 Loss 曲线	Train Loss ↘ Val Loss ↗ → 过拟合；两者都高 → 欠拟合	定位大方向问题
看混淆矩阵	cm[真=猫, 预=狗] 高 → 猫容易被当成狗	哪两类分不清
找 Top-K 错例	模型最自信但错得离谱的样本	人眼看规律（模糊图、侧脸图）
错例可视化	错图 + 预测标签 + 正确标签拼一起看	快速发现数据问题
数据分布检查	训练/验证的类别分布是不是差不多	不均衡 → Precision 假高、Recall 假低
特征重要性	XGBoost/LightGBM 的 feature_importances_	有用的特征学到了吗？
训练日志检查	Loss 是不是震荡、有没有 NaN	学习率太大？梯度爆炸？

💡 典型诊断结论

Val Loss 在 epoch 30 持续上升 → 过拟合 → 加正则 / 减 epoch / 加数据增强

混淆矩阵某格特别亮 → 特定类别混淆 → 样本少？标签脏？

错例 60% 是低分辨率图 → 数据质量问题 → 补高分辨率 / 加模糊增强

Val Acc 52% ≈ Random Guess → 模型没学到 → 换更大模型 / 检查特征工程

📦 交付物：1 段文字诊断 + 1 张混淆矩阵 + 10 张典型错例图

⚙️ 调优 · 制定改进方案

核心动作：根据诊断结论选调优方向，而不是瞎试。

🔸 先分类：你的问题属于哪种？

类型	诊断信号	调优方向
过拟合	Train Loss ≪ Val Loss	加正则（L2/Dropout/Data Aug）/ 减模型容量
欠拟合	Train Loss 也下不去	换更大模型 / 加特征 / 训更久
收敛慢	Loss 降得太慢	加 Warmup / 用更好的优化器（AdamW）
震荡不收敛	Loss 上下跳	降学习率 / 加梯度裁剪
不均衡	Precision ≫ Recall 或反过来	加 class_weight / 用 Focal Loss / 重采样
数据泄漏	Val 分数异常高，上线崩	检查特征工程是不是用了未来信息

🔸 再选搜索策略：

第一次调参 → 手动试 5-10 组（先感觉范围）

参数 ≤ 3 个 → Grid Search（穷举）

参数 ≥ 5 个 → Random Search（预算一样效果更好）

计算很贵（>1h/run） → Bayesian Optimization（Optuna）

生产级调参 → Ray Tune（分布式 + 早停 + 可视化）

# 手动：跑 5 组，看哪个好
for lr in [1e-2, 5e-3, 1e-3, 5e-4, 1e-4]:
    model = train_one_epoch(lr=lr, epochs=20)
    log.append((lr, evaluate(model)))

# 自动：Optuna 搜索
import optuna


def objective(trial):
    lr = trial.suggest_float('lr', 1e-5, 1e-1, log=True)
    wd = trial.suggest_float('wd', 1e-5, 1e-1, log=True)
    # ... train & return val_f1
    return val_f1


study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=30)
print(study.best_params)

📦 交付物：调参方案表（参数名 + 搜索范围）+ 最优参数组合

🏋️ 训练 · 带着改动跑一轮

核心动作：用调好的参数从头训练，监控训练过程，早停。

做什么	怎么做	代码
从头训	不要在旧 checkpoint 上继续	`model = ResNet50(pretrained=True); train()`
监控 Loss 曲线	每 epoch 存一张图	`savefig(f'loss_epoch_{e}.png')`
学习率调度	CosineAnnealing / ReduceOnPlateau	`scheduler.step(val_loss)`
Early Stopping	Val Loss 连续 10 epoch 不下降 → 停	`patience=10`
存最佳权重	val_loss 最低的那个 epoch	`if val_loss < best: torch.save(...)`
训练完成后	加载最佳权重，在 Test 上跑最后一次	`model.load_state_dict(best); evaluate(test)`

# 标准训练循环
best_val_loss = float('inf')
patience_counter = 0
for epoch in range(max_epochs):
    train_loss = train_one_epoch(model, train_loader, optimizer, lr_scheduler)
    val_loss, val_f1 = evaluate(model, val_loader)
    log(epoch, train_loss, val_loss, val_f1)
    # Early stopping
    if val_loss < best_val_loss:
        best_val_loss = val_loss
        save_checkpoint(model, 'best.pt')
        patience_counter = 0
    else:
        patience_counter += 1
        if patience_counter >= 10:
            print(f'Early stop at epoch {epoch}')
            break
# 训练结束，加载最佳权重
model.load_state_dict(torch.load('best.pt'))
test_f1 = evaluate(model, test_loader)  # ← 只跑一次 Test

📦 交付物：最佳模型权重 + Test 集最终分数

🔁 每轮迭代问自己

1. 我的 val 分数比 baseline 高了吗？→ 没高 = 方向错了

2. 我的 val 分数比上一轮高了吗？→ 没高 = 这个参数不行

3. Loss 曲线在收敛还是发散？→ 发散 = 要调 LR / 加正则

4. 还有明显的错例模式没解决吗？→ 有 = 下一轮继续分析

⚙️ 超参数搜索策略 · 系统化调参方法论

调参不是"凭感觉"，有系统化的搜索方法。不同策略的效率和效果天差地别。

✍️

手动调参

凭经验手动试几组值。适合小模型入门阶段，但效率低、易漏掉最优组合。

lr ∈ {0.01, 0.001}
wd ∈ {0.001, 0.0001}

精度: ⭐⭐ 速度: ⭐⭐⭐⭐⭐

🔲

网格搜索 Grid Search

给每个超参数列几个候选值，笛卡尔积跑所有组合。最全面但计算量爆炸。

GridSearchCV(estimator,
  param_grid={'lr':[0.01,0.001,0.0001],
  'batch_size':[16,32,64]},
  cv=5)

精度: ⭐⭐⭐⭐ 速度: ⭐

🎲

随机搜索 Random Search

在超参数空间随机采样，同样预算下比网格搜索往往更好（因为不是均匀分配算力）。

RandomizedSearchCV(estimator,
  param_distributions={'lr': loguniform(1e-4,1e-1),
  'batch_size': [16,32,64,128]},
  n_iter=50)

精度: ⭐⭐⭐ 速度: ⭐⭐⭐

📈

贝叶斯优化 Bayesian

用高斯过程代理函数建模 score 分布，每一步选"最值得试"的组合，计算效率最高。

from hyperopt import fmin, tpe, hp
best = fmin(fn=objective,
space={'lr': hp.loguniform('lr', -4, 0)},
algo=tpe.suggest, max_evals=100)

精度: ⭐⭐⭐⭐⭐ 速度: ⭐⭐⭐⭐

🍣

Optuna（最推荐）

AutoML 级别的调参框架，支持多目标、剪枝、可视化、分布式训练，PyTorch/TF/Sklearn 全兼容。

import optuna
def objective(trial):
  lr = trial.suggest_float('lr', 1e-5, 1e-1, log=True)
  bs = trial.suggest_categorical('bs', [16,32,64])
  return train(lr, bs)
study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=200)

精度: ⭐⭐⭐⭐⭐ 剪枝+可视化

☢️

Ray Tune（大规模）

分布式超参数搜索框架，支持多 GPU 并行、中断恢复、多种调度器，适合工业级大规模调参。

from ray import tune, air
tuner = tune.Tuner(train_func,
  param_space={'lr': tune.loguniform(1e-5,1e-1),
  'bs': tune.choice([16,32,64])},
  tune_config=tune.TuneConfig(num_samples=1000))
result = tuner.fit()

精度: ⭐⭐⭐⭐⭐ 分布式

💡

实战经验：怎么选搜索策略？

• 初学阶段：先手动调参建立直觉，理解每个超参数的影响
• 小数据集（< 1 万样本）：Grid Search + K 折交叉验证，跑得起也准确
• 中等数据集（1-100 万）：用 RandomizedSearchCV 或 Optuna，节省算力
• 大数据集 / 大模型：Optuna + Ray Tune 分布式 + 剪枝，没跑完就知道哪条线没戏
• 高维空间（> 5 个超参）：必须用贝叶斯优化，Grid Search 组合数爆炸
• 必记的组合：Optuna + PyTorch Lightning + Weights & Biases = 调参三件套

💾 模型保存与推理测试

📦 保存最佳实践

# 方法1：保存state_dict（推荐）
torch.save(model.state_dict(), 'models/final/best_model.pt')

# 方法2：保存完整模型
torch.save(model, 'models/final/best_model.pt')

# 方法3：ONNX格式（跨平台部署）
dummy = torch.randn(1, 3, 224, 224)
torch.onnx.export(model, dummy, 'model.onnx')

# 方法4：TorchScript（移动端）
traced = torch.jit.trace(model, dummy)
traced.save('model_scripted.pt')

# 方法5：保存训练状态（断点续训）
torch.save({
    'epoch': epoch,
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'best_val_acc': best_acc,
}, 'checkpoint.pth')

🔍 推理测试代码

import torch
from PIL import Image
from torchvision import transforms

# 1. 加载模型
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = MyModel(num_classes=5)
model.load_state_dict(torch.load('models/best.pt', map_location=device))
model = model.to(device)
model.eval()  # 重要！切换到评估模式

# 2. 数据预处理（必须和训练时一致！）
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize([0.485], [0.229])
])

# 3. 推理
def predict(image_path):
    img = Image.open(image_path).convert('RGB')
    tensor = transform(img).unsqueeze(0).to(device)  # 加batch维度
    
    with torch.no_grad():  # 关闭梯度计算
        output = model(tensor)
        probs = torch.softmax(output, dim=1)
        pred_idx = probs.argmax(1).item()
        confidence = probs[0, pred_idx].item()
    
    return {
        'class': class_names[pred_idx],
        'confidence': f'{confidence:.2%}',
        'all_probs': {class_names[i]: f'{p:.2%}' for i, p in enumerate(probs[0])}
    }

result = predict('test_image.jpg')
print(result)

评估调参与迭代 ← 闭环！