PyTorch第十三篇：模型评估与可视化——全面解析模型性能并直观呈现训练过程

🌈 我是“没事学AI”， 欢迎咨询、交流，共同学习：
👁️ 【关注】我们一起挖 AI 的各种门道，看看它还有多少新奇玩法等着咱们发现
👍 【点赞】为这些有用的 AI 知识鼓鼓掌，让更多人知道学 AI 也能这么轻松
🔖 【收藏】把这些 AI 小技巧存起来，啥时候想练手了，翻出来就能用
💬 【评论】说说你学 AI 时的想法和疑问，让大家的思路碰出更多火花
👉 关注获取更多AI技术干货，点赞/收藏备用，欢迎评论区交流学习心得！ 🚀

训练出模型后，不能仅通过“训练损失下降”判断模型好坏——训练损失低可能是过拟合，还需通过 模型评估量化泛化能力；同时，训练过程中的损失、准确率等指标若只看数字，难以直观发现问题（如梯度消失、学习率不当）。本文将详解分类任务的核心评估指标（准确率、精确率、召回率等），以及如何用 TensorBoard 可视化训练过程，帮你全面掌握“评估模型+优化训练”的关键技能。

一、模型评估：量化模型的泛化能力

模型评估的核心是在独立的验证集/测试集上计算关键指标，判断模型对“未见过的数据”的预测能力。不同任务（分类、回归、分割）的评估指标不同，本文以最常见的分类任务为例，讲解核心指标的计算方法。

1. 分类任务的核心评估指标

分类任务的预测结果分为“正确”和“错误”，根据“预测类别”与“真实类别”的匹配关系，可划分成 4 种情况（混淆矩阵）：

• TP（True Positive）：真实为正类，预测为正类（正确预测）；
• TN（True Negative）：真实为负类，预测为负类（正确预测）；
• FP（False Positive）：真实为负类，预测为正类（错误预测，假阳性）；
• FN（False Negative）：真实为正类，预测为负类（错误预测，假阴性）。

基于混淆矩阵，衍生出以下核心指标：

指标	计算公式	含义
准确率（Accuracy）	(TP + TN) / (TP + TN + FP + FN)	所有样本中预测正确的比例（整体预测能力，适合类别平衡的数据）
精确率（Precision）	TP / (TP + FP)	预测为正类的样本中，真实为正类的比例（控制“误判正类”的概率，如垃圾邮件识别）
召回率（Recall）	TP / (TP + FN)	真实为正类的样本中，被预测为正类的比例（控制“漏判正类”的概率，如疾病诊断）
F1 分数（F1-Score）	2×(Precision×Recall)/(Precision+Recall)	精确率和召回率的调和平均（平衡两者，适合类别不平衡的数据）
混淆矩阵（Confusion Matrix）	按类别统计 TP、TN、FP、FN 的矩阵	直观展示每个类别的预测错误分布（如“猫”常被误判为“狗”）

2. 实战：用 PyTorch 计算分类任务评估指标

以 CIFAR-10 分类任务为例，基于测试集计算上述指标（需先加载训练好的模型和测试集）：

步骤 1：准备测试数据与模型

import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision.datasets import CIFAR10
from torchvision.transforms import Compose, ToTensor, Normalize

# 1. 测试集预处理（与验证集一致，无增强）
test_transform = Compose([
    ToTensor(),
    Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2470, 0.2435, 0.2616])  # CIFAR-10 标准归一化
])

# 2. 加载测试集（CIFAR-10 测试集共 10000 个样本）
test_dataset = CIFAR10(root='./data', train=False, download=True, transform=test_transform)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=4)

# 3. 加载训练好的模型（以之前的 SimpleCNN 为例）
class SimpleCNN(nn.Module):
    # （模型定义与前文一致，此处省略，实际使用需完整复制）
    pass

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = SimpleCNN(num_classes=10).to(device)
model.load_state_dict(torch.load("best_cnn_model.pth", map_location=device))  # 加载最优模型参数
model.eval()  # 开启评估模式（禁用 dropout、固定 BN）

步骤 2：计算混淆矩阵与核心指标

import numpy as np
from sklearn.metrics import confusion_matrix, classification_report

# 存储所有样本的真实标签和预测标签
all_true_labels = []
all_pred_labels = []

with torch.no_grad():  # 禁用梯度跟踪，节省内存
    for images, labels in test_loader:
        images = images.to(device)
        labels = labels.to(device)
        
        # 前向传播获取预测结果（logits → 类别索引）
        logits = model(images)
        _, pred_labels = torch.max(logits, dim=1)  # pred_labels: [batch_size]
        
        # 转换为 numpy 数组，存入列表（便于后续计算）
        all_true_labels.extend(labels.cpu().numpy())
        all_pred_labels.extend(pred_labels.cpu().numpy())

# 1. 计算混淆矩阵（10 类，所以矩阵形状为 (10,10)）
cm = confusion_matrix(all_true_labels, all_pred_labels)
print("混淆矩阵:")
print(cm)
# 输出（示例）：
# [[920   5  20  10   5   2   3   2  25   8]  # 真实为 0（airplane）的预测分布
#  [  5 950   3   2   1   1   2   0  15  21]  # 真实为 1（automobile）的预测分布
#  ...（省略其他类别）
# ]

# 2. 计算精确率、召回率、F1 分数（按类别和全局统计）
print("\n分类报告（精确率/召回率/F1 分数）:")
print(classification_report(
    all_true_labels, 
    all_pred_labels, 
    target_names=["airplane", "automobile", "bird", "cat", "deer", 
                  "dog", "frog", "horse", "ship", "truck"]  # 类别名称
))
# 输出（示例）：
#               precision    recall  f1-score   support
# 
#     airplane       0.92      0.92      0.92      1000
#   automobile       0.95      0.95      0.95      1000
#         bird       0.88      0.87      0.87      1000
#          cat       0.82      0.78      0.80      1000
#         deer       0.89      0.90      0.89      1000
#          dog       0.85      0.83      0.84      1000
#         frog       0.92      0.94      0.93      1000
#        horse       0.93      0.94      0.93      1000
#         ship       0.93      0.94      0.93      1000
#        truck       0.91      0.92      0.91      1000
# 
#     accuracy                           0.90     10000
#    macro avg       0.90      0.90      0.90     10000
# weighted avg       0.90      0.90      0.90     10000

关键解读：

• 若某类的召回率低（如“cat”类召回率 0.78），说明该类样本常被误判为其他类（需分析混淆矩阵，看误判到哪类，进而优化数据或模型）；
• 若全局准确率高但某类 F1 分数低，可能是该类样本少（类别不平衡），需通过数据增强或加权损失优化。

二、训练可视化：用 TensorBoard 直观呈现训练过程

训练时，仅打印“训练损失：0.3，验证准确率：85%”这类数字，难以发现以下问题：

• 训练损失下降但验证损失上升（过拟合）；
• 学习率过大导致损失震荡，或过小导致收敛缓慢；
• 梯度消失（梯度值接近 0）或梯度爆炸（梯度值骤增）。

TensorBoard 是 Google 推出的可视化工具，可实时绘制指标曲线、展示模型结构、可视化输入样本等，PyTorch 通过 torch.utils.tensorboard.SummaryWriter 支持 TensorBoard 集成。

1. TensorBoard 基础配置

步骤 1：安装与启动 TensorBoard

# 安装 TensorBoard（若未安装）
pip install tensorboard

步骤 2：初始化 SummaryWriter（训练代码中）

SummaryWriter 负责将训练过程中的指标（损失、准确率）、图像、模型结构等写入日志文件，TensorBoard 读取日志文件并展示。

from torch.utils.tensorboard import SummaryWriter

# 初始化 SummaryWriter，日志保存路径为 "./runs/cifar10_cnn"（可自定义）
# 每次运行会生成新的日志文件夹（避免覆盖历史记录）
writer = SummaryWriter(log_dir="./runs/cifar10_cnn")

2. 核心可视化功能实战

（1）可视化标量指标（损失、准确率）

训练和验证过程中，将“训练损失”“验证准确率”等标量指标写入 TensorBoard，实时观察曲线趋势。

# 假设已有训练循环，在每轮训练/验证后添加以下代码
num_epochs = 50
best_val_acc = 0.0

for epoch in range(num_epochs):
    # ---------------------- 训练阶段 ----------------------
    model.train()
    train_total_loss = 0.0
    train_total_samples = 0
    
    for batch_idx, (images, labels) in enumerate(train_loader):
        # （训练步骤：前向传播、损失计算、反向传播、参数更新，此处省略）
        # ...
        
        # 每 10 个 batch 记录一次训练损失（避免日志过多）
        if (batch_idx + 1) % 10 == 0:
            global_step = epoch * len(train_loader) + batch_idx  # 全局步数（唯一标识训练进度）
            avg_batch_loss = loss.item()  # 当前 batch 的平均损失
            writer.add_scalar(
                tag="Train/Batch_Loss",  # 标签（用于 TensorBoard 中分类）
                scalar_value=avg_batch_loss,
                global_step=global_step
            )
    
    # 每轮训练结束，计算平均训练损失并记录
    avg_train_loss = train_total_loss / train_total_samples
    writer.add_scalar("Train/Epoch_Loss", avg_train_loss, global_step=epoch)
    
    # ---------------------- 验证阶段 ----------------------
    model.eval()
    val_total_correct = 0
    val_total_samples = 0
    val_total_loss = 0.0
    
    with torch.no_grad():
        for images, labels in val_loader:
            # （验证步骤：前向传播、计算损失和正确数，此处省略）
            # ...
    
    # 每轮验证结束，记录验证损失和验证准确率
    avg_val_loss = val_total_loss / val_total_samples
    val_acc = val_total_correct / val_total_samples * 100
    
    writer.add_scalar("Val/Epoch_Loss", avg_val_loss, global_step=epoch)
    writer.add_scalar("Val/Epoch_Accuracy", val_acc, global_step=epoch)
    
    # ---------------------- 保存最优模型 ----------------------
    if val_acc > best_val_acc:
        best_val_acc = val_acc
        torch.save(model.state_dict(), "best_cnn_model.pth")

# 训练结束，关闭 SummaryWriter（确保日志写入完整）
writer.close()

（2）可视化模型结构

将模型的计算图写入 TensorBoard，直观查看层与层之间的连接关系（需传入一个示例输入张量）：

# 生成一个示例输入（与模型输入形状一致：[batch_size, 3, 32, 32]）
dummy_input = torch.randn(1, 3, 32, 32).to(device)  # batch_size=1，便于可视化

# 写入模型结构
writer.add_graph(
    model=model,
    input_to_model=dummy_input  # 示例输入（用于跟踪计算图）
)

（3）可视化输入样本与预测结果

将训练/测试样本的图像、真实标签、预测标签写入 TensorBoard，直观检查模型的预测错误案例：

import torchvision.utils as vutils

# 从测试集中获取一个 batch 的样本
images, labels = next(iter(test_loader))
images = images[:8]  # 取前 8 张图像（避免显示过多）
labels = labels[:8]

# 计算这 8 张图像的预测标签
model.eval()
with torch.no_grad():
    images_gpu = images.to(device)
    logits = model(images_gpu)
    _, pred_labels = torch.max(logits, dim=1)
pred_labels = pred_labels.cpu()  # 迁移到 CPU

# 生成标签文本（真实标签 + 预测标签）
class_names = ["airplane", "automobile", "bird", "cat", "deer", 
               "dog", "frog", "horse", "ship", "truck"]
label_texts = [f"True: {class_names[t]}\nPred: {class_names[p]}" 
               for t, p in zip(labels, pred_labels)]

# 写入图像（用 make_grid 将多张图像拼成一张网格图）
grid_images = vutils.make_grid(images, nrow=4, padding=2)  # nrow=4：每行显示 4 张图
writer.add_image(
    tag="Test/Sample_Images_with_Labels",
    img_tensor=grid_images,
    global_step=0,  # 可设为 epoch，观察不同阶段的预测效果
    caption="True Label / Predicted Label"  # 图像标题
)

（4）可视化参数分布与梯度

将模型参数（如权重）的分布、梯度的分布写入 TensorBoard，检查参数是否正常更新（如梯度消失/爆炸）：

# 每轮训练结束后，记录某层的参数分布和梯度分布（以 conv_block1 的第一个卷积层为例）
conv1_layer = model.conv_block1[0]  # conv_block1 的第 0 个组件是 Conv2d 层

# 记录权重参数的分布（直方图）
writer.add_histogram(
    tag="Params/Conv1_Weight",
    values=conv1_layer.weight.data.cpu().numpy(),
    global_step=epoch
)

# 记录权重梯度的分布（仅训练阶段有梯度）
if model.training:
    writer.add_histogram(
        tag="Grads/Conv1_Weight_Grad",
        values=conv1_layer.weight.grad.data.cpu().numpy(),
        global_step=epoch
    )

3. 启动 TensorBoard 查看可视化结果

训练代码运行后，日志文件会保存到 ./runs/cifar10_cnn 目录。在终端执行以下命令启动 TensorBoard：

tensorboard --logdir=./runs/cifar10_cnn

启动后，打开浏览器访问 http://localhost:6006，即可看到所有可视化内容：

• Scalars：查看训练/验证损失、准确率曲线；
• Graphs：查看模型结构计算图；
• Images：查看输入样本与预测标签；
• Histograms：查看参数和梯度的分布。

三、避坑指南：模型评估与可视化的常见错误

1. 评估时未开启 model.eval()：

   • 错误示例：验证/测试时未调用 model.eval()，导致 dropout 仍启用、BN 层继续更新移动均值，验证结果不准确；
   • 解决方案：评估前必须调用 model.eval()，训练前调用 model.train()。

2. 混淆“训练集指标”与“测试集指标”：

   • 错误示例：用训练集准确率判断模型泛化能力，忽略测试集指标（可能过拟合）；
   • 牢记：模型最终性能以测试集指标为准，训练集指标仅用于判断训练是否收敛。

3. TensorBoard 日志未及时关闭：

   • 错误示例：训练结束后未调用 writer.close()，导致部分日志未写入，TensorBoard 显示不完整；
   • 解决方案：用 with SummaryWriter(...) as writer: 上下文管理器，自动关闭日志写入。

4. 全局步数（global_step）设置错误：

   • 错误示例：记录标量指标时用 batch_idx 作为 global_step，导致不同 epoch 的 batch 步数重复，曲线混乱；
   • 解决方案：全局步数用 epoch * len(train_loader) + batch_idx，确保每个 batch 有唯一标识。

四、总结与下期预告

本文讲解了模型评估与可视化的核心内容：

• 模型评估：通过混淆矩阵、准确率、精确率、召回率、F1 分数，量化分类模型的泛化能力，重点关注“对未见过数据的预测效果”；
• 训练可视化：用 TensorBoard 实时展示标量指标（损失、准确率）、模型结构、输入样本、参数/梯度分布，直观发现训练问题（如过拟合、梯度消失）。

这两部分是“训练模型→优化模型”的关键闭环——评估告诉你“模型哪里不好”，可视化告诉你“为什么不好”，两者结合才能高效迭代模型。

下期预告：我们将学习“模型部署与推理优化”，包括如何将训练好的 PyTorch 模型导出为 ONNX 格式、用 TensorRT 加速推理、在 CPU/GPU 上优化推理速度，让模型从“能训练”变为“能落地使用”。