跟着李沐动手学深度学习（二）

Zhoozie

已于 2024-08-10 17:59:41 修改

阅读量380

点赞数 11

分类专栏：深度学习文章标签：深度学习人工智能

于 2024-07-31 22:03:24 首次发布

本文链接：https://blog.csdn.net/zhoozie/article/details/140700165

版权

深度学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

前言

本篇文章为李沐老师 Softmax 回归的学习笔记。Softmax 回归虽然名称中带有回归二字，但它却并不是回归问题，而是分类问题。本篇文章来一起学习Softmax回归。

分类Vs回归

首先来探讨的就是机器学习中的分类问题和回归问题。

	分类	回归
目的	预测离散型输出变量	预测连续型输出变量
输出个数	通常为多个输出	单连续数值输出
示例	猫狗识别	股票价格预测

从零开始实现Softmax回归

from IPython import display
from mxnet import autograd, gluon, np, npx
import torch
from d2l import mxnet as d2l

# 设置批量大小
batch_size = 256
# 引入Fashion-MNIST数据集
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

Step1：初始化模型参数

原始数据集中的每个样本都是 28×28 的图像。本节将展平每个图像，把它们看作长度为784的向量。

# 设置批量大小
batch_size = 256
# 引入Fashion-MNIST数据集
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
# 初始化模型参数
num_inputs = 784
num_outputs = 10
# 创建权重矩阵 W 和偏置向量 b  
W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
b = torch.zeros(num_outputs, requires_grad=True)

在初始化过程中，输入为784，输出为10（因为图像有10个类别）。权重将构成一个 784×10 的矩阵，偏置将构成一个 1×10 的行向量。与线性回归一样，我们将使用正态分布初始化我们的权重W，偏置初始化为0。

Step2：定义softmax操作

$softmax(X)_{ij}=\frac{exp(X_{ij})}{\sum_kexp(X_{ik})}$

实现softmax需要有三个步骤：

对每个项求幂（使用exp）；
对每一行求和（小批量中每个样本是一行），得到每个样本的规范化常数；
将每一行除以其规范化常数，确保结果的和为1。

def softmax(X):
    """
    定义softmax操作
    :param X: 一个二维张量
    :return: 每个样本在每个类别上的概率分布。
    """
    # 计算 X 中每个元素的指数
    X_exp = torch.exp(X)
    # 沿着第一个维度（即每个样本的维度）对 X_exp 进行求和，keepdim=True 保留了输出的维度，
    partition = X_exp.sum(1, keepdim=True)
    # 利用了广播机制
    return X_exp / partition

Step3：定义softmax模型

def net(X):
    """
    定义softmax模型
    :param X: 一个二维张量
    :return: softmax输出  
    """
    # X.reshape((-1, W.shape[0]))中的-1表示自动推断的维度大小，
    # 整体表示将X变成一个N行W列的张量，其中N表示批次大小，W表示权重矩阵的列数
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)

注意，将数据传递到模型之前，我们使用reshape函数将每张原始图像展平为向量。

Step4：定义损失函数

接下来，我们实现交叉熵损失函数。这可能是深度学习中最常见的损失函数，因为目前分类问题的数量远远超过回归问题的数量。

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]表示从y_hat张量中选择指定索引位置的元素.
y_hat[[0, 1], y]
def cross_entropy(y_hat, y):
    """
    定义交叉熵函数
    :param y_hat: softmax层的输出
    :param y: 真实标签的索引
    :return: 整个批次的平均交叉熵损失  
    """
    return - torch.log(y_hat[range(len(y_hat)), y])
cross_entropy(y_hat, y)

Step5：计算准确率

def accuracy(y_hat, y): 
    """
    计算预测正确的数量
    :param y_hat: 模型预测的输出，如果是softmax输出，则需要转换为类别索引  
    :param y: 真实标签  
    :return: 计算预测正确的数量
    """
     # 如果y_hat是softmax输出，则转换为类别索引
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)
    # 比较预测值和真实值 
    cmp = y_hat.type(y.dtype) == y
    # 计算正确的样本数
    return float(cmp.type(y.dtype).sum())

然后计算正确率

accuracy(y_hat, y) / len(y)
# 0.5

同样，对于任意数据迭代器data_iter可访问的数据集，我们可以评估在任意模型net的精度。

def evaluate_accuracy(net, data_iter):
    """
    计算在指定数据集上模型的精度
    """
    # 如果是使用torch.nn实现的模型
    if isinstance(net, torch.nn.Module):
        # 将模型设置为评估模式
        net.eval()
    # 正确预测数、预测总数
    metric = Accumulator(2)
    # 创建累加器，保存累计值-正确预测数、预测总数
    with torch.no_grad():
        for X, y in data_iter:
            metric.add(accuracy(net(X), y), y.numel())
    # 分类正确样本数除总样本数
    return metric[0] / metric[1]

这里定义一个实用程序类Accumulator，用于对多个变量进行累加。在上面的evaluate_accuracy函数中，我们在(Accumulator实例中创建了2个变量，分别用于存储正确预测的数量和预测的总数量)。当我们遍历数据集时，两者都将随着时间的推移而累加。

class Accumulator:
    """
    在n个变量上累加
    """
    def __init__(self, n):
        self.data = [0.0] * n

    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]
        """zip(self.data, args)将self.data列表和传入的参数一一对应进行打包，生成一个迭代器
        在每次迭代中，a表示self.data中的元素，b表示传入的参数中的元素"""

    def reset(self):
        self.data = [0.0] * len(self.data)

    def __getitem__(self, idx):
        return self.data[idx]

Step6：训练

def train_epoch_ch3(net, train_iter, loss, updater):
    """
    训练模型一个迭代周期
    """
    # 将模型设置为训练模式
    if isinstance(net, torch.nn.Module):
        net.train()
    # 训练损失总和、训练准确度总和、样本数
    metric = Accumulator(3)
    for X, y in train_iter:
        # 计算梯度并更新参数
        y_hat = net(X)
        l = loss(y_hat, y)
        if isinstance(updater, torch.optim.Optimizer):
            # 使用PyTorch内置的优化器和损失函数
            updater.zero_grad()
            l.mean().backward()
            updater.step()
        else:
            # 使用定制的优化器和损失函数
            l.sum().backward()
            updater(X.shape[0])
        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: # 判断是否只有1个子图
            self.axes = [self.axes, ]
        # 使用lambda函数捕获参数，直接调用d2l.set_axes函数配置子图属性
        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]
        # 判断y是否是可迭代的对象，若不是，则将其转换为一个只包含单个元素的列表
        n = len(y)
        if not hasattr(x, "__len__"):
            x = [x] * n
        # 判断参数x是否是可迭代的对象，如果不是，则将其转换为一个只包含x值的列表，并重复n次，以匹配y的长度
        if not self.X:
            self.X = [[] for _ in range(n)]
        # 如果self.X为空，创建一个包含n个空列表的列表，用于存储每个数据点的x值，下同
        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)
            # 遍历参数x和y的元素对，将非None的值分别添加到对应的self.X和self.Y列表中的对应位置
        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
    """训练模型（定义见第3章）"""
    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)
        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
    """使用assert语句进行断言检查，确保训练损失、训练准确率和测试准确率满足一些条件，
    否则将会引发AssertionError异常，提示训练过程中出现了异常情况。
    """
lr = 0.1

def updater(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)

Step7：预测

def predict_ch3(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])
    d2l.plt.show()

predict_ch3(net, test_iter)

Softmax回归简洁实现

# 导入库
import torch
from torch import nn
from d2l import torch as d2l
# 加载Fashion MNIST数据集，并设置每个批次的样本数为256。这个函数返回训练集和测试集的数据迭代器。
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

# PyTorch不会隐式地调整输入的形状。因此，
# 我们在线性层前定义了展平层（flatten），来调整网络输入的形状
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))

def init_weights(m):
    '''
    初始化权重
    '''
    # 用于将线性层的权重初始化为均值为0、标准差为0.01的正态分布
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)
net.apply(init_weights)
# 定义损失函数和优化器
loss = nn.CrossEntropyLoss(reduction='none')
trainer = torch.optim.SGD(net.parameters(), lr=0.1)

num_epochs = 10
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

Zhoozie

关注

11
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
跟着李沐动手学深度学习（二）

本文记录了学习李沐softmax回归的笔记，介绍其代码实现。softmax回归主要用于处理多分类问题，如图像分类、垃圾邮件识别等，它将线性回归的输出转化为一个概率分布，从而可以预测样本属于各个类别的概率。
复制链接

扫一扫

专栏目录