Pytorch 入门-day13: 调试与可视化

目标：在第12天的代码基础上，学习如何使用TensorBoard可视化训练过程中的损失和准确率，并通过打印中间结果进行调试。目标是掌握TensorBoard的基本使用方法，理解如何通过可视化监控模型性能，从而更好地调试和优化深度学习模型。

术语解释：

• TensorBoard：TensorFlow开发的可视化工具，PyTorch也支持，用于实时监控训练过程中的指标（如损失、准确率）和模型结构。
• SummaryWriter：PyTorch中用于向TensorBoard写入日志的类，负责记录标量、图像、计算图等数据。
• 标量（Scalar）：单一数值（如损失或准确率），在TensorBoard中以曲线形式展示，用于观察训练趋势。
• 计算图（Graph）：模型的网络结构图，展示层之间的连接，便于调试模型设计。
• 日志目录（Log Directory）：TensorBoard存储数据的文件夹，通常命名为runs/，可自定义以区分不同实验。

任务：在第12天的MNIST CNN训练代码中添加TensorBoard，记录训练损失、测试准确率，并可视化模型的计算图。继续打印中间结果以便调试。

资源建议：

• PyTorch TensorBoard官方文档
• TensorBoard入门教程（适用于PyTorch的TensorBoard集成）

代码实现（带详细注释）

以下代码在第12天的MNIST CNN训练代码基础上，添加了TensorBoard日志功能，记录训练损失、测试准确率和模型计算图，同时保留打印语句用于调试。

python

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter  # 导入TensorBoard的SummaryWriter

# 初始化TensorBoard的SummaryWriter，日志保存在'runs/mnist_experiment'目录
writer = SummaryWriter('runs/mnist_experiment')

# 设备配置：选择GPU（如果可用）或CPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# 数据预处理：将图像转换为Tensor并归一化（均值0.5，标准差0.5）
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# 加载MNIST数据集：训练集和测试集
train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)
test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

# 定义CNN模型
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 16, kernel_size=3, padding=1)  # 第一卷积层：输入1通道，输出16通道
        self.relu1 = nn.ReLU()  # ReLU激活函数
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)  # 最大池化：2x2
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)  # 第二卷积层：输入16通道，输出32通道
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)  # 最大池化：2x2
        self.fc1 = nn.Linear(32 * 7 * 7, 128)  # 全连接层：输入32*7*7，输出128
        self.relu3 = nn.ReLU()
        self.fc2 = nn.Linear(128, 10)  # 输出层：10个类别

    def forward(self, x):
        x = self.pool1(self.relu1(self.conv1(x)))  # 卷积+激活+池化
        x = self.pool2(self.relu2(self.conv2(x)))  # 卷积+激活+池化
        x = x.view(-1, 32 * 7 * 7)  # 展平为1维向量
        x = self.relu3(self.fc1(x))  # 全连接+激活
        x = self.fc2(x)  # 输出层
        return x

# 实例化模型、损失函数和优化器
model = SimpleCNN().to(device)
criterion = nn.CrossEntropyLoss()  # 交叉熵损失
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam优化器，学习率0.001

# 记录模型计算图（仅需一次，使用第一批数据）
images, _ = next(iter(train_loader))  # 获取一批数据
writer.add_graph(model, images.to(device))  # 将模型结构写入TensorBoard

# 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    model.train()  # 设置模型为训练模式
    running_loss = 0.0
    correct = 0
    total = 0
    for i, (images, labels) in enumerate(train_loader):
        images, labels = images.to(device), labels.to(device)  # 移动数据到设备
        optimizer.zero_grad()  # 清空梯度
        outputs = model(images)  # 前向传播
        loss = criterion(outputs, labels)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数

        # 累加损失和准确率
        running_loss += loss.item()
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

        # 每100个批次记录一次损失和准确率
        if (i + 1) % 100 == 0:
            avg_loss = running_loss / 100
            avg_acc = 100 * correct / total
            # 记录到TensorBoard
            writer.add_scalar('Training Loss', avg_loss, epoch * len(train_loader) + i)
            writer.add_scalar('Training Accuracy', avg_acc, epoch * len(train_loader) + i)
            # 打印中间结果用于调试
            print(f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{len(train_loader)}], '
                  f'Loss: {avg_loss:.4f}, Accuracy: {avg_acc:.2f}%')
            running_loss = 0.0
            correct = 0
            total = 0

    # 测试模型
    model.eval()  # 设置模型为评估模式
    correct = 0
    total = 0
    test_loss = 0.0
    with torch.no_grad():  # 禁用梯度计算
        for images, labels in test_loader:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            loss = criterion(outputs, labels)
            test_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    # 计算测试集平均损失和准确率
    avg_test_loss = test_loss / len(test_loader)
    test_accuracy = 100 * correct / total
    # 记录测试集指标到TensorBoard
    writer.add_scalar('Test Loss', avg_test_loss, epoch)
    writer.add_scalar('Test Accuracy', test_accuracy, epoch)
    # 打印测试结果
    print(f'Epoch [{epoch+1}/{num_epochs}], Test Loss: {avg_test_loss:.4f}, '
          f'Test Accuracy: {test_accuracy:.2f}%')

# 关闭SummaryWriter
writer.close()

运行TensorBoard

1. 运行代码后，TensorBoard日志将保存在runs/mnist_experiment目录。
2. 打开终端，运行以下命令：bash
3. tensorboard --logdir runs
4. 在浏览器中访问http://localhost:6006（或终端指定的端口），查看TensorBoard仪表板。
5. 仪表板将显示：
6. 标量（Scalars）：训练损失、训练准确率、测试损失和测试准确率的曲线。
7. 计算图（Graphs）：模型的网络结构，展示各层的连接。

代码说明

• TensorBoard集成： 使用SummaryWriter创建日志目录runs/mnist_experiment，可自定义目录名以区分实验。 writer.add_scalar记录训练和测试的损失与准确率，步数（step）使用epoch * len(train_loader) + i确保连续性。 writer.add_graph记录模型结构，便于检查网络设计是否正确。
• 调试支持： 每100个批次打印一次训练损失和准确率，便于实时监控。 测试阶段打印平均损失和准确率，帮助分析模型性能。
• 频率控制：训练指标每100批次记录一次，测试指标每轮记录一次，平衡日志大小与可视化清晰度。

附加建议

• 扩展日志：可记录其他指标，如学习率（writer.add_scalar('Learning Rate', optimizer.param_groups[0]['lr'], epoch)）。
• 调试技巧：检查TensorBoard曲线是否异常（例如损失不下降），结合打印结果定位问题（如梯度消失或数据预处理错误）。
• 多实验比较：通过更改SummaryWriter的目录名（如runs/experiment_2），在TensorBoard中对比不同超参数的训练效果。