多层感知机 (MLP) 与 MNIST#

多层感知机是一种前馈神经网络，由多层全连接层组成。

class MLP(nn.Module):
    def __init__(self, input_size=784, hidden_sizes=[512, 256], output_size=10):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_sizes[0])        # 隐藏层1
        self.fc2 = nn.Linear(hidden_sizes[0], hidden_sizes[1])        # 隐藏层2
        self.output_layer = nn.Linear(hidden_sizes[1], output_size)    # 输出层
        
    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = self.fc1(x)
        x = torch.relu(x)
        x = self.fc2(x)
        x = torch.relu(x)
        x = self.output_layer(x)
        return x

MNIST数据集是机器学习领域中最经典和广泛使用的数据集之一，特别适合作为深度学习入门的基准测试。它包含了60,000张训练图像和10,000张测试图像，每张图像为28×28像素的手写数字（0-9）灰度图像。

• 下载实践代码：在MNIST手写数字数据集上训练MLP分类器

卷积神经网络 (CNN) 与 CIFAR10#

卷积神经网络是一种专门用于处理网格结构数据（如图像）的神经网络。下面是一个使用PyTorch实现的简单CNN模型，用于CIFAR-10图像分类任务。

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)  # 第一个卷积层 (输入通道3, 输出通道32, 3x3卷积核)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)  # 第二个卷积层 (输入通道32, 输出通道64, 3x3卷积核)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)  # 第三个卷积层 (输入通道64, 输出通道128, 3x3卷积核)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)  # 池化层
        self.fc1 = nn.Linear(128 * 4 * 4, 512)  # 全连接层1
        self.fc2 = nn.Linear(512, 10)  # 全连接层2 (输出层)
        self.dropout = nn.Dropout(0.5)  # Dropout层
        
    def forward(self, x):
        x = self.conv1(x)
        x = torch.relu(x)
        x = self.pool(x)
        x = self.conv2(x)
        x = torch.relu(x)
        x = self.pool(x)
        x = self.conv3(x)
        x = torch.relu(x)
        x = self.pool(x)
        x = x.view(x.size(0), -1)
        x = self.fc1(x)
        x = torch.relu(x)
        x = self.dropout(x)
        x = self.fc2(x)
        return x

CIFAR-10数据集包含10个类别的32x32彩色图像，共50,000张训练图像和10,000张测试图像。上述CNN模型包含三个卷积层和两个全连接层。每个卷积层后跟ReLU激活函数和最大池化操作，以减小特征图的空间尺寸并提取重要特征。最后，通过全连接层实现分类，并使用Dropout技术防止过拟合。

• 下载实践代码： 在CIFAR10上训练CNN分类器

U-Net 与 Oxford Pet#

U-Net是一种经典的用于图像分割的卷积神经网络架构，特别适合医学图像分割等任务。下面是一个使用PyTorch从头实现的U-Net模型：

# 定义U-Net模块
class DoubleConv(nn.Module):
    """(卷积 => BN => ReLU) * 2"""
    def __init__(self, in_channels, out_channels, mid_channels=None):
        super().__init__()
        if not mid_channels:
            mid_channels = out_channels
        self.double_conv = nn.Sequential(
            nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(mid_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )

    def forward(self, x):
        return self.double_conv(x)

class Down(nn.Module):
    """下采样：最大池化 + 双卷积"""
    def __init__(self, in_channels, out_channels):
        super().__init__()
        self.maxpool_conv = nn.Sequential(
            nn.MaxPool2d(2),
            DoubleConv(in_channels, out_channels)
        )

    def forward(self, x):
        return self.maxpool_conv(x)

class Up(nn.Module):
    """上采样：转置卷积 + 拼接 + 双卷积"""
    def __init__(self, in_channels, out_channels, bilinear=True):
        super().__init__()

        # 可以选择双线性插值或转置卷积进行上采样
        if bilinear:
            self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
            self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)
        else:
            self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)
            self.conv = DoubleConv(in_channels, out_channels)

    def forward(self, x1, x2):
        x1 = self.up(x1)
        # 处理输入size不匹配的问题
        diffY = x2.size()[2] - x1.size()[2]
        diffX = x2.size()[3] - x1.size()[3]

        x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,
                        diffY // 2, diffY - diffY // 2])
        # 拼接两个特征图
        x = torch.cat([x2, x1], dim=1)
        return self.conv(x)

class OutConv(nn.Module):
    """输出卷积层"""
    def __init__(self, in_channels, out_channels):
        super(OutConv, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)

    def forward(self, x):
        return self.conv(x)

# 完整的U-Net模型
class UNet(nn.Module):
    def __init__(self, n_channels=3, n_classes=3, bilinear=False):
        super(UNet, self).__init__()
        self.n_channels = n_channels
        self.n_classes = n_classes
        self.bilinear = bilinear

        # 编码器部分
        self.inc = DoubleConv(n_channels, 64)
        self.down1 = Down(64, 128)
        self.down2 = Down(128, 256)
        self.down3 = Down(256, 512)
        factor = 2 if bilinear else 1
        self.down4 = Down(512, 1024 // factor)
        
        # 解码器部分
        self.up1 = Up(1024, 512 // factor, bilinear)
        self.up2 = Up(512, 256 // factor, bilinear)
        self.up3 = Up(256, 128 // factor, bilinear)
        self.up4 = Up(128, 64, bilinear)
        self.outc = OutConv(64, n_classes)

    def forward(self, x):
        # 编码路径
        x1 = self.inc(x)
        x2 = self.down1(x1)
        x3 = self.down2(x2)
        x4 = self.down3(x3)
        x5 = self.down4(x4)
        
        # 解码路径 + 跳跃连接
        x = self.up1(x5, x4)
        x = self.up2(x, x3)
        x = self.up3(x, x2)
        x = self.up4(x, x1)
        logits = self.outc(x)
        return logits

U-Net是一种专为医学图像分割设计的卷积神经网络架构，由Olaf Ronneberger等人在2015年提出。它的特点是具有对称的U形结构，包含一个下采样的编码路径和一个上采样的解码路径，以及在对应层之间的跳跃连接(skip connections)。这些跳跃连接能够将编码阶段的高分辨率特征直接传递到解码阶段的相应层，有效地保留空间信息，对精确分割边界非常重要。

Oxford-IIIT Pet数据集包含约7,400张猫和狗的图像，来自37个不同品种。每张图像都有对应的像素级分割标注，将图像分为前景(宠物)、背景和边界三个类别。这个数据集是用于语义分割任务的，因为它为每个像素分配类别标签(前景/背景/边界)，但不区分同一类别的不同实例。这个数据集非常适合训练和评估像U-Net这样的分割网络。数据集的难点在于目标对象(宠物)的姿势、大小和背景变化多样，为图像分割模型提供了很好的挑战。

图像分割是一个比较困难的任务

• 下载实践代码： 在Oxford Pet数据集上训练Unet分割网络

变分自编码器 与 MNIST#

变分自编码器(VAE)是一种生成式模型，它可以学习数据的概率分布，并生成与原始数据相似的新样本。条件变分自编码器(CVAE)通过添加条件信息（如类标签）来控制生成过程。

以下是一个使用PyTorch实现的条件变分自编码器(CVAE)，用于MNIST数字图像的条件生成。

# 条件变分自编码器模型
class CVAE(nn.Module):
    def __init__(self, latent_dim, num_classes):
        super(CVAE, self).__init__()
        self.img_size = 28  # 图像大小和条件信息
        self.latent_dim = latent_dim
        self.num_classes = num_classes
        
        self.encoder = nn.Sequential( # 编码器网络
            nn.Conv2d(1 + num_classes, 32, kernel_size=3, stride=2, padding=1),  # 14x14
            nn.LeakyReLU(0.2),
            nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1),  # 7x7
            nn.LeakyReLU(0.2),
            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),  # 7x7
            nn.LeakyReLU(0.2),
            nn.Flatten()
        )
        
        self.flat_size = 128 * 7 * 7   # 计算展平后的特征大小

        self.fc_mu = nn.Linear(self.flat_size, latent_dim)  # 均值和方差预测层
        self.fc_logvar = nn.Linear(self.flat_size, latent_dim)
        
        self.decoder_input = nn.Linear(latent_dim + num_classes, 128 * 7 * 7)  # 解码器输入层
        self.decoder = nn.Sequential(  # 解码器网络
            nn.Unflatten(1, (128, 7, 7)),
            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),  # 14x14
            nn.LeakyReLU(0.2),
            nn.ConvTranspose2d(64, 32, kernel_size=4, stride=2, padding=1),  # 28x28
            nn.LeakyReLU(0.2),
            nn.Conv2d(32, 1, kernel_size=3, stride=1, padding=1),
            nn.Sigmoid()  # 输出像素值在[0,1]之间
        )
        
    def encode(self, x, c):
        c = c.view(-1, self.num_classes, 1, 1).expand(-1, -1, self.img_size, self.img_size) # 将条件信息嵌入到输入中
        x_c = torch.cat([x, c], dim=1)  # 在通道维度上拼接
        
        h = self.encoder(x_c) # 编码器前向传播
        mu = self.fc_mu(h)
        logvar = self.fc_logvar(h)
        return mu, logvar
    
    def reparameterize(self, mu, logvar):
        std = torch.exp(0.5 * logvar) # 重参数化技巧
        eps = torch.randn_like(std)
        z = mu + eps * std
        return z
    
    def decode(self, z, c):
        z_c = torch.cat([z, c], dim=1) # 将条件信息与潜在表示拼接
        h = self.decoder_input(z_c) # 解码器前向传播
        x_recon = self.decoder(h.view(-1, 128, 7, 7))
        return x_recon
    
    def forward(self, x, c):
        c_onehot = F.one_hot(c, self.num_classes).float() # 将类标签转换为one-hot向量
        mu, logvar = self.encode(x, c_onehot) # 编码
        z = self.reparameterize(mu, logvar) # 采样潜在表示
        x_recon = self.decode(z, c_onehot) # 解码
        return x_recon, mu, logvar
    
    def sample(self, num_samples, c):
        """
        给定条件c，生成样本
        c: (num_samples,) 类标签
        """
        c_onehot = F.one_hot(c, self.num_classes).float()         # 将类标签转换为one-hot向量
        z = torch.randn(num_samples, self.latent_dim).to(device)  # 从标准正态分布采样潜在向量
        samples = self.decode(z, c_onehot)  # 解码生成样本
        return samples

插值实验

生成的手写数字

• 下载实践代码： 在MNIST数据集上训练VAE生成网络

基本使用#

经典形式

def profile(model, device, data_loader):
    dataiter = iter(data_loader)
    data, target = next(dataiter)
    data, target = data.to(device), target.to(device)
    # use_cuda=False，是只分析GPU
    with torch.autograd.profiler.profile(use_cuda=False) as prof:   
        model(data[0].reshape(1,1,28,28))
    print(prof)

更现代的API形式

from torch import profiler

def profile(model, device, data_loader):
    with profiler.profile(
        activities=[
            profiler.ProfilerActivity.CPU,
            profiler.ProfilerActivity.CUDA,   
        ],
        record_shapes=True,
        profile_memory=True,
        with_stack=True
    ) as prof:
        # 需要分析的代码
        data, target = next(iter(data_loader))
        data, target = data.to(device), target.to(device)
        model(data)
    print(prof.key_averages().table(sort_by='cuda_time_total', row_limit=10))

与训练循环集成的形式

with torch.profiler.profile(
    activities=[
        torch.profiler.ProfilerActivity.CPU, 
        torch.profiler.ProfilerActivity.CUDA],
    schedule=torch.profiler.schedule(wait=1, warmup=1, active=3, repeat=1),
    on_trace_ready=torch.profiler.tensorboard_trace_handler('./profiler_logs'),
    record_shapes=True,
    profile_memory=True,
    with_stack=True
) as prof:
    for step, (inputs, labels) in enumerate(dataloader):
        if step >= (1 + 1 + 3) * 1:
            break
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        prof.step()  # 必须调用，与 schedule 配合使用

1. 安装#

pip install tensorboard

2. 在训练脚本中添加 SummaryWriter#

from torch.utils.tensorboard import SummaryWriter

# 指定日志目录
writer = SummaryWriter(log_dir='runs/exp1')

for epoch in range(1, epochs+1):
    # 训练循环
    train_loss, train_acc = train_one_epoch(...)
    val_loss, val_acc       = evaluate(...)

    # 记录标量
    writer.add_scalar('Loss/train', train_loss, epoch)
    writer.add_scalar('Loss/val',   val_loss,   epoch)
    writer.add_scalar('Acc/train',  train_acc,  epoch)
    writer.add_scalar('Acc/val',    val_acc,    epoch)

    # 可视化参数分布或梯度
    for name, param in model.named_parameters():
        writer.add_histogram(f'Param/{name}', param, epoch)
        writer.add_histogram(f'Grad/{name}', param.grad, epoch)

    # 第一次记录时可添加网络结构图
    if epoch == 1:
        dummy_input = torch.randn(1, 3, 224, 224).to(device)
        writer.add_graph(model, dummy_input)

# 训练结束后关闭
writer.close()

3. 启动 TensorBoard#

tensorboard --logdir='./runs' --port 6006

然后在浏览器打开 http://localhost:6006 ，即可看到实时更新的训练曲线、直方图和网络结构。

如果是在服务器上运行的训练过程，需要使用 端口映射 才能在本地网页查看。

# 本地端口 7007 转发到服务器的 localhost:6006
ssh -L 7007:localhost:6006 ada@10.184.16.88

然后在浏览器打开 http://localhost:7007 即可查看。

4. 使用 TensorBoard 可视化 Profiler 结果#

tensorboard --logdir=./profiler_logs

1. 安装与登录#

pip install wandb
wandb login  # 首次运行后按提示粘贴 API key

2. 在训练脚本中集成 W&B#

import wandb
from torch.utils.tensorboard import SummaryWriter

# 1 初始化一个 run，project 名称可自定义
wandb.init(project="my-deeplearning-project", config={
    "epochs": epochs,
    "batch_size": batch_size,
    "lr": learning_rate,
    "latent_dim": latent_dim,
})

# 2 自动追踪模型、梯度和超参
wandb.watch(model, log="all", log_freq=100)

for epoch in range(1, epochs+1):
    train_loss, train_acc = train_one_epoch(...)
    val_loss, val_acc     = evaluate(...)

    # 3 记录标量
    wandb.log({
        "epoch": epoch,
        "loss/train": train_loss,
        "loss/val":   val_loss,
        "acc/train":  train_acc,
        "acc/val":    val_acc,
    })

# 4 保存最佳模型到 W&B Artifacts
torch.save(model.state_dict(), "best_model.pth")
wandb.save("best_model.pth")

# 5 结束 run
wandb.finish()

3. 在 W&B 仪表盘查看#

• 浏览器打开 https://wandb.ai
• 进入你所在的 project，即可查看训练曲线、超参对比、模型参数直方图、图片和对比报告。
• 支持自动对比多个 runs，以及与团队成员共享结果。

参考资料：

• 计算图与自动微分，导数的计算同样构建了数据流图
• PyTorch官方文档
• TensorFlow官方文档
• W & B 官网