深度学习3.6 softmax回归的从零开始实现

本章节引入3.5的数据集

import torch
from IPython import display
from d2l import torch as d2l

batch_size = 256 #迭代器批量
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

3.6.1 初始化模型参数

num_inputs = 784 # 权重矩阵长度
num_outputs = 10 # 类别数量
W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True) # 权重矩阵
b = torch.zeros(num_outputs, requires_grad=True) # 偏置

图像尺寸28*28像素
‌权重W‌：从均值为0、标准差0.01的正态分布采样，形状 [784, 10]。
‌偏置b‌：初始化为全0，形状 [10]。
‌梯度追踪‌：requires_grad=True 启用自动微分。

3.6.2 定义softmax操作

def softmax(X):
    X_exp = torch.exp(X) # 处理计算自然指数函数e的幂（GPU计算效率高）
    partition = X_exp.sum(1, keepdim=True) # 0:列,1:行，计算为x行1列张量
    return X_exp / partition # 归一化-概率[[1/3,2/3],[3/7,4/7]]
    
X = torch.normal(0, 1, (2, 5)) # torch.normal 用于生成服从‌正态分布（高斯分布）‌的随机数张量，支持多种参数形式（均值，标准差,（形状））
X_prob = softmax(X) # 概率
X_prob, X_prob.sum(1) # 概率和=1

3.6.3 定义模型

def net(X):
    a1 = X.reshape((-1, W.shape[0])) # 保持[*,len(W)]
    a2 = torch.matmul(a1, W) # torch.matmul矩阵乘法
    return softmax(a2 + b) # 返回对应概率

展平输入：X.reshape((-1, 784))（将 [batch_size,1,28,28] 转为 [batch_size,784]）。
线性变换：XW+b（输出 [batch_size,10]）。
Softmax归一化：得到每个类别的概率分布。

3.6.4 定义损失函数

y = torch.tensor([0, 2])
y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
y_hat[[0, 1], y]

tensor([0.1000, 0.5000])
高级索引 : 索引列表会按‌位置配对‌，从y_hat中提取特定位置的元素
‌第一个元素‌：y_hat[0行, y[0]=0列] → 0.1
‌第二个元素‌：y_hat[1行, y[1]=2列] → 0.5

# 交叉熵损失函数
def cross_entropy(y_hat, y):
    return - torch.log(y_hat[range(len(y_hat)), y])# torch.log 对每个元素计算ln(x)

cross_entropy(y_hat, y)

tensor([2.3026, 0.6931])

3.6.5 分类精度

def accuracy(y_hat, y):
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1: # 判断矩阵行、列>1
        y_hat = y_hat.argmax(axis=1)                # 获取矩阵每一行最大值所在索引
    cmp = y_hat.type(y.dtype) == y                  # 判断结果与实际值y是否有出入tensor([False,  True])
    return float(cmp.type(y.dtype).sum())           # 返回预测成功数量转换为y类型

accuracy(y_hat, y) / len(y)                         # 结果/总数=成功率

def evaluate_accuracy(net, data_iter):  # 准确性评估
    if isinstance(net, torch.nn.Module): # 若模型为PyTorch模块（如继承nn.Module），调用eval()禁用dropout、BatchNorm等训练期特定操作，确保推理一致性
        net.eval()  
    metric = Accumulator(2)   # 存储 [正确数, 总样本数]  
    for _, (X, y) in enumerate(data_iter): # 从data_iter迭代器中获取批次数据 X（输入）和 y（真实标签）
        # x([256, 1, 28, 28])，y([256,])，256个1通道28*28样本对应256个标签y
        # 通过对输入X进行展平操作后全连接随机特征矩阵W，再通过转换自然指数e进行gpu计算其概率
        metric.add(accuracy(net(X), y), d2l.size(y))
        #print(f'{metric[0]}  --  {metric[1]}')
    return metric[0] / metric[1] # 返回准确率

class Accumulator:  #@save

    def __init__(self, n):
        self.data = [0.0] * n # [0.0, 0.0, ... n]

    #将传入的参数 args 按位置与 self.data 中的值逐元素相加
    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)] #使用 zip(self.data, args) 对齐变量与输入值

    # 将所有累加变量重置为 0.0，用于新一轮统计
    def reset(self):
        self.data = [0.0] * len(self.data)

    #通过下标 idx 获取累加变量的值，支持类似列表的索引操作 print(obj[0]) 
    def __getitem__(self, idx):
        return self.data[idx]

evaluate_accuracy(net, test_iter)

3.6.6 训练

‌net‌: 待训练的神经网络模型（nn.Module子类或自定义模型）。
‌train_iter‌: 训练数据迭代器（如DataLoader），每次迭代返回一个批次的数据(X, y)。
‌loss‌: 损失函数（如交叉熵损失）。
‌updater‌: 参数更新器，可以是PyTorch优化器（如optim.SGD）或自定义更新逻辑。

def train_epoch_ch3(net, train_iter, loss, updater): 

    if isinstance(net, torch.nn.Module):
        net.train() # 若模型是PyTorch模块，则设置为训练模式（启用Dropout/BatchNorm等训练特定行为）。

    metric = Accumulator(3) # 创建3个累加变量 总损失 总正确数 总样本数
    for X, y in train_iter:

        # X([256, 1, 28, 28])输入， y真实标签
        y_hat = net(X) # 全连接得到概率
        l = loss(y_hat, y)
        if isinstance(updater, torch.optim.Optimizer):
            updater.zero_grad()  # 清零梯度
            l.backward()         # 反向传播计算梯度
            updater.step()       # 更新参数
        else:
            l.sum().backward()   # 向量损失求和后反向传播
            updater(X.shape[0])  # 自定义更新（如手动SGD）
            
        # float(l) * len(y)‌: 将批次损失扩展到样本数（若l是均值损失）。
        # ‌accuracy(y_hat, y)‌: 计算当前批次的正确预测数。
        # ‌y.numel()‌: 当前批次的样本数（如batch_size）。
        metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())

    # 平均训练损失‌: 总损失 / 总样本数
    # 平均训练精度‌: 总正确数 / 总样本数
    return metric[0] / metric[2], metric[1] / metric[2]

class Animator:  # 绘制图表类
    # 在动画中绘制数据
    def __init__(self, xlabel=None, ylabel=None, legend=None, xlim=None,
                 ylim=None, xscale='linear', yscale='linear',
                 fmts=('-', 'm--', 'g-.', 'r:'), nrows=1, ncols=1,
                 figsize=(3.5, 2.5)):
        # 增量绘制多条线
        if legend is None:
            legend = []
        d2l.use_svg_display()
        self.fig, self.axes = d2l.plt.subplots(nrows, ncols, figsize=figsize)
        if nrows * ncols == 1:
            self.axes = [self.axes, ]
        # 使用lambda捕捉参数
        self.config_axes = lambda: d2l.set_axes(
            self.axes[0], xlabel, ylabel, xlim, ylim, xscale, yscale, legend)
        self.X, self.Y, self.fmts = None, None, fmts

    def add(self, x, y):
        # 向图表添加多个数据点
        if not hasattr(y, "__len__"):
            y = [y]
        n = len(y)
        if not hasattr(x, "__len__"):
            x = [x] * n
        if not self.X:
            self.X = [[] for _ in range(n)]
        if not self.Y:
            self.Y = [[] for _ in range(n)]
        for i, (a, b) in enumerate(zip(x, y)):
            if a is not None and b is not None:
                self.X[i].append(a)
                self.Y[i].append(b)
        self.axes[0].cla()
        for x, y, fmt in zip(self.X, self.Y, self.fmts):
            self.axes[0].plot(x, y, fmt)
        self.config_axes()
        display.display(self.fig)
        display.clear_output(wait=True)

批量训练

def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):  #@save
    # 可视化工具初始化
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
                        legend=['train loss', 'train acc', 'test acc'])
    for epoch in range(num_epochs):
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater) # 训练单个 epoch
        test_acc = evaluate_accuracy(net, test_iter) # 得到准确率
        animator.add(epoch + 1, train_metrics + (test_acc,)) # 绘制到图表(train_loss, train_acc, test_acc)
        
    train_loss, train_acc = train_metrics
    assert train_loss < 0.5, train_loss # assert condition, error_message false则抛出异常
    assert train_acc <= 1 and train_acc > 0.7, train_acc
    assert test_acc <= 1 and test_acc > 0.7, test_acc

定义学习率为0.1的随机梯度下降（SGD）优化器

def updater(batch_size):
    # [W, b]：待优化的参数列表（权重和偏置）
    # lr=0.1：学习率（步长超参数）
    # batch_size：用于梯度归一化的批量大小
    return d2l.sgd([W, b], lr, batch_size)

num_epochs = 10 # 训练轮次
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)

def predict_ch3(net, test_iter, n=6):  
    """Predict labels (defined in Chapter 3)."""
    for X, y in test_iter:  # 获取第一批测试数据
        break
    trues = d2l.get_fashion_mnist_labels(y)  # 真实标签转文本
    preds = d2l.get_fashion_mnist_labels(d2l.argmax(net(X), axis=1))  # 预测标签转文本
    titles = [true +'\n' + pred for true, pred in zip(trues, preds)]  # 组合标签
    d2l.show_images(d2l.reshape(X[0:n], (n, 28, 28)), 1, n, titles=titles[0:n])  # 可视化

predict_ch3(net, test_iter)