【李沐】3.5、softmax回归的从0开始实现

注意：
把每个像素位置看作⼀个特征

# 导入PyTorch库
import torch
# 从IPython库中导入display模块，用于在交互式环境中显示内容
from IPython import display
# 从d2l.torch模块中导入torch作为d2l的别名，方便后续使用d2l库中的功能
from d2l import torch as d2l

# 定义批次大小
batch_size = 256
# 使用d2l库中的load_data_fashion_mnist函数加载Fashion-MNIST数据集
# 并将返回的训练数据迭代器和测试数据迭代器分别赋值给train_iter和test_iter
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

1、初始化模型参数
分析：前面弄成只有两层，第一层是特征，第二程是输出的类别，前面移动有10类，所以输出层弄成了10，按照这样的道理请问现在对于该任务的网络层数该如何设置呢？
答：现在图像是28*28，每一个像素看做一个特征，那么第一层就是28乘以28，第二层是10个种类，所以为10

# 定义输入特征的维度
num_inputs = 784
# 定义输出类别的数量
num_outputs = 10

# 使用torch.normal函数创建一个大小为(num_inputs, num_outputs)的张量W
# 张量的值从均值为0，标准差为0.01的正态分布中随机采样，并且需要计算梯度
W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)

# 使用torch.zeros函数创建一个大小为num_outputs的张量b
# 张量的值全部初始化为0，并且需要计算梯度
b = torch.zeros(num_outputs, requires_grad=True)

def softmax(X):
    """
    执行softmax操作，将输入张量X的每个元素进行指数运算并进行归一化
    参数:
        X: 输入张量
    返回:
        归一化后的张量，与输入X的形状相同
    """
    # 使用torch.exp函数计算输入张量X的每个元素的指数值
    X_exp = torch.exp(X)
    # 使用.sum函数计算每行元素的和，并保持维度
    partition = X_exp.sum(1, keepdim=True)
    # 将每个元素的指数值除以对应行的和，实现归一化操作
    # 通过广播机制，使得每一行的元素都除以对应行的和
    return X_exp / partition

2、定义softmax—没看懂

def softmax(X):
    """
    执行softmax操作，将输入张量X的每个元素进行指数运算并进行归一化
    参数:
        X: 输入张量
    返回:
        归一化后的张量，与输入X的形状相同
    """
    # 使用torch.exp函数计算输入张量X的每个元素的指数值
    X_exp = torch.exp(X)
    # 使用.sum函数计算每行元素的和，并保持维度
    partition = X_exp.sum(1, keepdim=True)
    # 将每个元素的指数值除以对应行的和，实现归一化操作
    # 通过广播机制，使得每一行的元素都除以对应行的和
    return X_exp / partition

# 使用torch.normal函数创建一个大小为(2, 5)的张量X
# 张量的值从均值为0，标准差为1的正态分布中随机采样
X = torch.normal(0, 1, (2, 5))

# 使用定义的softmax函数对张量X进行softmax操作
X_prob = softmax(X)

# 输出经过softmax操作后的张量X_prob，以及每行元素的和（归一化后的概率之和）
X_prob, X_prob.sum(1)

3、定义模型

**def net(X):
    """
    定义一个简单的神经网络模型，接受输入X并输出预测结果
    参数:
        X: 输入特征张量
    返回:
        经过模型处理后的预测结果
    """
    # 将输入特征X进行形状变换，展平并与权重矩阵W相乘，然后加上偏置向量b
    linear_output = torch.matmul(X.reshape((-1, W.shape[0])), W) + b
    # 使用之前定义的softmax函数对线性输出进行softmax操作，得到最终的预测结果
    return softmax(linear_output)
**

4、定义损失函数
交叉熵损失函数

# 创建一个张量y，包含真实标签
y = torch.tensor([0, 2])

# 创建一个张量y_hat，表示模型的预测概率分布
y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])

# 使用切片操作选择y_hat中对应真实标签的预测概率
selected_probs = y_hat[[0, 1], y]

# 定义交叉熵损失函数，接受预测概率分布y_hat和真实标签y作为输入
def cross_entropy(y_hat, y):
    """
    计算交叉熵损失
    参数:
        y_hat: 模型的预测概率分布张量
        y: 真实标签张量
    返回:
        计算得到的交叉熵损失张量
    """
    # 使用索引操作从y_hat中选择对应真实标签的预测概率
    selected_probs = y_hat[range(len(y_hat)), y]
    # 使用torch.log计算对数，然后使用负号得到交叉熵损失
    return -torch.log(selected_probs)

# 使用定义的交叉熵损失函数计算损失
loss = cross_entropy(y_hat, y)

6、分类精度

def accuracy(y_hat, y): #@save
    """
    计算预测正确的数量
    参数:
        y_hat: 模型的预测概率分布张量
        y: 真实标签张量
    返回:
        预测正确的样本数量
    """
    # 检查预测概率分布张量的形状，如果有多个预测类别，则选择预测概率最高的类别
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)
    
    # 将预测类别与真实标签进行比较，得到一个布尔张量cmp
    cmp = y_hat.type(y.dtype) == y
    
    # 使用sum函数统计布尔张量cmp中值为True的数量，即预测正确的样本数量
    # 最后将结果转换为浮点数并返回
    return float(cmp.type(y.dtype).sum())

下面这张图是分类精度

上面是测试单个数据，这个是测试数据集，也就是多个数据

def evaluate_accuracy(net, data_iter): #@save
    """
    计算在指定数据集上模型的精度
    参数:
        net: 需要评估的模型
        data_iter: 数据迭代器，包含输入特征和真实标签
    返回:
        计算得到的模型精度
    """
    # 如果net是torch.nn.Module的实例，将其设置为评估模式
    if isinstance(net, torch.nn.Module):
        net.eval()
    
    # 创建累加器metric，用于记录正确预测数和总样本数
    metric = Accumulator(2)
    
    # 使用torch.no_grad()上下文管理器，关闭梯度计算
    with torch.no_grad():
        # 遍历数据迭代器中的每个批次
        for X, y in data_iter:
            # 对模型net进行预测，计算预测精度并累加到metric中
            metric.add(accuracy(net(X), y), y.numel())
    
    # 计算模型在数据集上的精度，即正确预测数除以总样本数
    return metric[0] / metric[1]

这个代码是别⽤于存储正确预测的数量和预测的总数量。

class Accumulator: #@save
    """
    在n个变量上进行累加的累加器类
    """
    def __init__(self, n):
        """
        初始化累加器，创建n个初始值为0.0的变量
        参数:
            n: 需要累加的变量个数
        """
        self.data = [0.0] * n
    
    def add(self, *args):
        """
        将传入的参数与已有变量逐元素相加
        参数:
            *args: 可变数量的参数，需要与已有变量个数相匹配
        """
        self.data = [a + float(b) for a, b in zip(self.data, args)]
    
    def reset(self):
        """重置累加器，将所有变量的值重置为0.0"""
        self.data = [0.0] * len(self.data)
    
    def __getitem__(self, idx):
        """
        获取指定索引处的变量值
        参数:
            idx: 索引
        返回:
            指定索引处的变量值
        """
        return self.data[idx]

3.6.6、训练

def train_epoch_ch3(net, train_iter, loss, updater): #@save
    """
    训练模型一个迭代周期
    参数:
        net: 需要训练的模型
        train_iter: 训练数据迭代器，包含输入特征和真实标签
        loss: 损失函数，用于计算模型预测与真实标签之间的损失
        updater: 更新参数的方法，可以是PyTorch内置的优化器或定制的优化器
    返回:
        训练损失和训练精度的平均值
    """
    # 如果net是torch.nn.Module的实例，将其设置为训练模式
    if isinstance(net, torch.nn.Module):
        net.train()
    
    # 创建累加器metric，用于记录训练损失总和、训练准确度总和、样本数
    metric = Accumulator(3)
    
    # 遍历训练数据迭代器中的每个批次
    for X, y in train_iter:
        # 使用模型net对输入特征X进行预测，得到预测结果y_hat
        y_hat = net(X)
        
        # 使用损失函数loss计算预测结果y_hat与真实标签y之间的损失
        l = loss(y_hat, y)
        
        # 根据updater的类型选择不同的优化策略
        if isinstance(updater, torch.optim.Optimizer):
            # 如果updater是PyTorch内置的优化器
            updater.zero_grad() # 清除梯度
            l.mean().backward() # 计算损失的均值并计算梯度
            updater.step() # 更新参数
        else:
            # 如果updater是定制的优化器
            l.sum().backward() # 计算损失的总和并计算梯度
            updater(X.shape[0]) # 更新参数
        
        # 将当前批次的损失值、预测精度和样本数累加到metric中
        metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
    
    # 计算训练损失和训练精度的平均值，并返回
    return metric[0] / metric[2], metric[1] / metric[2]

画图的代码，每个批次都更新图片，训练图片

class Animator: #@save
    """在动画中绘制数据的动画类"""

    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)):
        """
        初始化动画对象，配置绘图参数
        参数:
            xlabel: x轴标签
            ylabel: y轴标签
            legend: 图例标签
            xlim: x轴范围
            ylim: y轴范围
            xscale: x轴的刻度类型
            yscale: y轴的刻度类型
            fmts: 绘制线条的格式
            nrows: 子图的行数
            ncols: 子图的列数
            figsize: 图像的大小
        """
        if legend is None:
            legend = []  # 如果没有图例标签，默认为空列表
        d2l.use_svg_display()  # 设置使用SVG格式显示图像
        # 创建图像和子图对象，配置绘图参数
        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):
        """向动画中添加数据点"""
        # 如果y不是可迭代对象，将其转换为单元素的可迭代列表
        if not hasattr(y, "__len__"):
            y = [y]
        n = len(y)  # 获取y的长度
        # 如果x不是可迭代对象，将其复制为与y长度相同的可迭代列表
        if not hasattr(x, "__len__"):
            x = [x] * n
        # 如果self.X为空，创建一个空列表，用于存储x轴坐标
        if not self.X:
            self.X = [[] for _ in range(n)]
        # 如果self.Y为空，创建一个空列表，用于存储y轴坐标
        if not self.Y:
            self.Y = [[] for _ in range(n)]
        # 遍历x轴坐标和y轴坐标，将数据点添加到相应的列表中
        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()  # 清空子图内容，以便绘制新的数据
        # 使用fmts列表中的格式绘制各个数据序列的线条
        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
    """
    训练模型（定义⻅第3章）
    
    参数:
        net: 需要训练的模型
        train_iter: 训练数据迭代器
        test_iter: 测试数据迭代器
        loss: 损失函数
        num_epochs: 训练的迭代周期数
        updater: 更新参数的方法
    """
    # 创建动画对象，用于绘制训练过程中的变化
    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_epoch_ch3函数训练一个迭代周期，获取训练损失和训练精度
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        
        # 在测试数据上计算模型精度
        test_acc = evaluate_accuracy(net, test_iter)
        
        # 将训练损失、训练精度和测试精度添加到动画对象中，以更新绘制的图像
        animator.add(epoch + 1, train_metrics + (test_acc,))
        
        # 检查训练损失、训练精度和测试精度是否在合理范围内
        train_loss, train_acc = train_metrics
        assert train_loss < 0.5, train_loss
        assert train_acc <= 1 and train_acc > 0.7, train_acc
        assert test_acc <= 1 and test_acc > 0.7, test_acc

7、预测

def predict_ch3(net, test_iter, n=6): #@save
    """
    预测标签（定义⻅第3章）
    
    参数:
        net: 训练好的模型
        test_iter: 测试数据迭代器
        n: 需要展示的图像数量（默认为6）
    """
    for X, y in test_iter:
        break  # 获取一个批次的测试数据
    trues = d2l.get_fashion_mnist_labels(y)  # 获取真实标签
    preds = d2l.get_fashion_mnist_labels(net(X).argmax(axis=1))  # 使用模型预测标签
    titles = [true + '\n' + pred for true, pred in zip(trues, preds)]  # 将真实标签和预测标签合并
    d2l.show_images(
        X[0:n].reshape((n, 28, 28)), 1, n, titles=titles[0:n])  # 展示图像和对应的标签