深度学习之暂退法

import torch
from torch import nn
from d2l import torch as d2l

def dropout_layer(X, dropout):
    """执行 dropout"""
    # dropout 概率必须在 [0, 1] 区间内
    # 例如 dropout=0.2 表示有 20% 的神经元输出会被随机置 0
    assert 0 <= dropout <= 1

    # 边界情况 1：dropout=1
    # 所有神经元都被丢弃，输出全 0（和输入形状一致）
    if dropout == 1:
        return torch.zeros_like(X)

    # 边界情况 2：dropout=0
    # 不做任何丢弃，直接返回原输入
    if dropout == 0:
        return X

    # 生成与输入 X 同形状的随机掩码 mask：
    # - torch.rand(X.shape) 会生成 [0,1) 的均匀随机数
    # - 大于 dropout 的位置保留（值为 1），其余位置丢弃（值为 0）
    # - 转成 float 后，mask 中元素只会是 0.0 或 1.0
    mask = (torch.rand(X.shape) > dropout).float()

    # 先用 mask 把一部分神经元输出置零，再除以 (1-dropout) 做缩放
    # 这叫“反向 dropout（inverted dropout）”：
    # 训练时做缩放，保证输出的期望值与不使用 dropout 时一致，
    # 这样推理阶段就不需要再额外缩放。
    return mask * X / (1.0 - dropout)

X = torch.arange(16, dtype=torch.float32).reshape((2, 8)) # 输入张量，形状为 (2, 8)
print('原始输入：\n', X)
print('丢弃概率为 0.0：\n', dropout_layer(X, 0.0))
print('丢弃概率为 0.5：\n', dropout_layer(X, 0.5))
print('丢弃概率为 1.0：\n', dropout_layer(X, 1.0))

# 用多次随机实验验证：反向 dropout 后，输出的期望值（均值）与输入均值接近
def check_expectation(X, dropout, trials=5000):
    input_mean = X.mean().item()
    output_means = []
    for _ in range(trials):
        output_means.append(dropout_layer(X, dropout).mean().item())
    output_mean = sum(output_means) / trials
    diff = abs(output_mean - input_mean)
    print(f"\n[期望值检验] dropout={dropout}")
    print(f"输入均值: {input_mean:.4f}")
    print(f"输出均值的经验期望(试验{trials}次): {output_mean:.4f}")
    print(f"两者绝对差: {diff:.6f}")

check_expectation(X, dropout=0)
check_expectation(X, dropout=0.2)
check_expectation(X, dropout=0.5)
check_expectation(X, dropout=0.8)
check_expectation(X, dropout=1.0)

# =========================
# 下面开始定义一个多层感知机（MLP）用于分类任务
# =========================
# num_inputs: 输入特征维度（例如 Fashion-MNIST 的 28x28=784）
# num_outputs: 输出类别数（10 类）
# num_hiddens1/num_hiddens2: 两个隐藏层的神经元数量
num_inputs, num_outputs, num_hiddens1, num_hiddens2 = 784, 10, 256, 256

# 两层 dropout 概率：
# 第一层隐藏层后丢弃 20%
# 第二层隐藏层后丢弃 50%
dropout1, dropout2 = 0.2, 0.5

class Net(nn.Module):
    # 这是一个“线性层 + ReLU + Dropout + 线性层 + ReLU + Dropout + 输出层”的网络
    def __init__(self, num_inputs, num_outputs, num_hiddens1, num_hiddens2,
                 dropout1, dropout2):
        super(Net, self).__init__()
        # 保存 dropout 概率，forward 时会用到
        self.dropout1 = dropout1
        self.dropout2 = dropout2

        # 第1层：输入维度 -> 第1隐藏层
        self.linear1 = nn.Linear(num_inputs, num_hiddens1)

        # 第2层：第1隐藏层 -> 第2隐藏层
        self.linear2 = nn.Linear(num_hiddens1, num_hiddens2)

        # 输出层：第2隐藏层 -> 类别数
        self.linear3 = nn.Linear(num_hiddens2, num_outputs)

    def forward(self, X):
        # X.reshape(-1, self.linear1.in_features):
        # 把输入展平到 [batch_size, 784] 的二维张量
        H1 = torch.relu(self.linear1(X.reshape(-1, self.linear1.in_features)))

        # 第1个隐藏层后做 dropout
        H1 = dropout_layer(H1, self.dropout1)

        # 第2个隐藏层：线性变换 + ReLU
        H2 = torch.relu(self.linear2(H1))

        # 第2个隐藏层后做 dropout
        H2 = dropout_layer(H2, self.dropout2)

        # 输出层给出每个类别的打分（logits）
        out = self.linear3(H2)
        return out
    
# 实例化网络对象
net = Net(num_inputs, num_outputs, num_hiddens1, num_hiddens2, dropout1, dropout2)
print(net)

def train_ch3_compat(net, train_iter, test_iter, loss_fn, num_epochs, optimizer):
    """兼容版 train_ch3：完成训练并返回过程指标。"""
    # 用于记录每个 epoch 的指标，后续可用于画图
    train_losses, train_accs, test_accs = [], [], []

    # 逐轮训练
    for epoch in range(num_epochs):
        # 切换到训练模式（会启用 dropout 等训练行为）
        net.train()
        # 统计一个 epoch 内的损失总和、预测正确数、样本总数
        loss_sum, acc_sum, n = 0.0, 0.0, 0

        # 遍历一个 epoch 中的所有小批量
        for X, y in train_iter:
            # 清空上一步的梯度，避免梯度累计
            optimizer.zero_grad()

            # 前向计算预测值
            y_hat = net(X)

            # 计算每个样本的损失（因为 loss_fn 使用了 reduction='none'）
            l = loss_fn(y_hat, y)

            # 反向传播：这里用 mean() 聚合后再求梯度，训练更稳定
            l.mean().backward()

            # 参数更新
            optimizer.step()

            # 累计该批次的总损失
            loss_sum += float(l.sum())

            # 累计该批次预测正确的样本数
            acc_sum += float((y_hat.argmax(dim=1) == y).type(torch.float32).sum())

            # 累计样本总数
            n += y.numel()

        # 计算该 epoch 的平均训练损失和训练准确率
        train_loss = loss_sum / n
        train_acc = acc_sum / n

        # 在测试集上评估准确率（函数内部会切到 eval 模式）
        test_acc = evaluate_accuracy(net, test_iter)

        # 保存本轮指标，用于后续可视化
        train_losses.append(train_loss)
        train_accs.append(train_acc)
        test_accs.append(test_acc)

        # 打印当前 epoch 的训练过程信息
        print(f"epoch {epoch + 1}/{num_epochs}, "
              f"train loss {train_loss:.4f}, "
              f"train acc {train_acc:.4f}, "
              f"test acc {test_acc:.4f}")

    # 返回三条曲线数据：训练损失、训练准确率、测试准确率
    return train_losses, train_accs, test_accs

# 训练配置：
# num_epochs: 训练轮数（完整遍历训练集的次数）
# lr: 学习率（每次参数更新的步长）
# batch_size: 每个小批量的样本数
num_epochs, lr, batch_size = 10, 0.5, 256

# 交叉熵损失（分类任务常用）
# reduce='none' 表示先保留每个样本的损失，后续由训练函数再做聚合
loss = nn.CrossEntropyLoss(reduce='none')

# 加载 Fashion-MNIST 训练集和测试集迭代器
# train_iter: 训练数据迭代器
# test_iter: 测试数据迭代器
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

# 随机梯度下降优化器，负责根据梯度更新网络参数
trainer = torch.optim.SGD(net.parameters(), lr=lr)

# 使用 d2l 提供的通用训练流程：
# 每轮会执行训练、在测试集评估，并输出训练损失/训练准确率/测试准确率
train_ch3_compat(net, train_iter, test_iter, loss, num_epochs, trainer)

import torch
import os
import matplotlib.pyplot as plt
from torch import nn
from d2l import torch as d2l

# =========================
# 下面开始定义一个多层感知机（MLP）用于分类任务
# =========================
# num_inputs: 输入特征维度（例如 Fashion-MNIST 的 28x28=784）
# num_outputs: 输出类别数（10 类）
# num_hiddens1/num_hiddens2: 两个隐藏层的神经元数量
num_inputs, num_outputs, num_hiddens1, num_hiddens2 = 784, 10, 256, 256

# 两层 dropout 概率：
# 第一层隐藏层后丢弃 20%
# 第二层隐藏层后丢弃 50%
dropout1, dropout2 = 0.2, 0.5

net = nn.Sequential(
    # 把输入从 [batch, 1, 28, 28] 展平为 [batch, 784]
    nn.Flatten(),

    # 第1层全连接：784 -> 256
    nn.Linear(num_inputs, num_hiddens1),

    # 非线性激活，提升模型表达能力
    nn.ReLU(),

    # 第1个 dropout 层，训练时随机失活一部分神经元
    nn.Dropout(dropout1),

    # 第2层全连接：256 -> 256
    nn.Linear(num_hiddens1, num_hiddens2),

    # 第2层激活函数
    nn.ReLU(),

    # 第2个 dropout 层
    nn.Dropout(dropout2),

    # 输出层：256 -> 10，对应 10 个类别的 logits
    nn.Linear(num_hiddens2, num_outputs)
)

def init_weights(m):
    """初始化模型参数"""
    # 仅对线性层做初始化；偏置沿用 PyTorch 默认初始化
    if type(m) == nn.Linear:
        # 用标准差为 0.01 的正态分布初始化权重
        nn.init.normal_(m.weight, std=0.01)

# 对网络中每个子模块执行初始化函数
net.apply(init_weights)

# 使用随机梯度下降优化器，学习率设为 0.1
trainer = torch.optim.SGD(net.parameters(), lr=0.1)

# 训练入口（取消注释后可直接训练）
# d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)