深度学习笔记2

2024/1/30 深度学习笔记深度学习 pytorch softmax回归损失函数图片分类数据集

6. Softmax 回归 + 损失函数 + 图片分类数据集

6.1 Softmax 回归（多类分类模型）

与线性回归一样，softmax回归也是一个单层神经网络

回归 VS 分类

自然区间指的是输出的区间

但是一般的分类问题并不与类别之间的自然顺序有关。
幸运的是，统计学家很早以前就发明了一种表示分类数据的简单方法：独热编码（one-hot encoding）。
独热编码是一个向量，它的分量和类别一样多。
类别对应的分量设置为1，其他所有分量设置为0。
在我们的例子中，标签将是一个三维向量，
其中对应于“猫”、对应于“鸡”、对应于“狗”：

形式：

下面是12个权重

通过向量形式表达为，
由此，我们已经将所有权重放到一个矩阵中。
对于给定数据样本的特征，
我们的输出是由权重与输入特征进行矩阵-向量乘法再加上偏置得到的。

softmax函数：

$其中$

尽管softmax是一个非线性函数，但softmax回归的输出仍然由输入特征的仿射变换决定。因此，softmax回归是一个线性模型（linear model）。

交叉熵：https://www.bilibili.com/video/BV15V411W7VB

对数似然：

softmax函数给出了一个向量，
我们可以将其视为“对给定任意输入的每个类的条件概率”。
例如，= $猫$ 。
假设整个数据集具有个样本，
其中索引的样本由特征向量和独热标签向量组成。
我们可以将估计值与实际值进行比较：

根据最大似然估计，我们最大化，相当于最小化负对数似然：

其中，对于任何标签和模型预测，损失函数为：

通常被称为交叉熵损失（cross-entropy loss）。
由于是一个长度为的独热编码向量，
所以除了一个项以外的所有项都消失了。
由于所有都是预测的概率，所以它们的对数永远不会大于。
因此，如果正确地预测实际标签，即如果实际标签，
则损失函数不能进一步最小化。
注意，这往往是不可能的。
例如，数据集中可能存在标签噪声（比如某些样本可能被误标），
或输入特征没有足够的信息来完美地对每一个样本分类。

softmax及其导数：

由于softmax和相关的损失函数很常见，
因此我们需要更好地理解它的计算方式。
利用softmax的定义，我们得到：

考虑相对于任何未规范化的预测的导数，我们得到：

换句话说，导数是我们softmax模型分配的概率与实际发生的情况（由独热标签向量表示）之间的差异。
从这个意义上讲，这与我们在回归中看到的非常相似，
其中梯度是观测值和估计值之间的差异。
这不是巧合，在任何指数族分布模型中
对数似然的梯度正是由此得出的。
这使梯度计算在实践中变得容易很多。

softmax回归原理及损失函数：https://www.bilibili.com/video/BV1Kv4y1u7e9/?vd_source=7e34085a459b4e9ffab42ccd04776d69

6.2 损失函数

用绝对值来表示损失函数（L1 loss）

好处：梯度是常数，权重的更新变化不会很大，稳定性好

坏处：零点处不可导，不平滑性，导致优化末期不稳定

因此，可以将这个L1 loss和均方损失函数（L2 loss）结合，叫Huber‘s Robust Loss

6.3 图片分类数据集

%matplotlib inline
import torch
import torchvision
from torch.utils import data
from torchvision import transforms
from d2l import torch as d2l

d2l.use_svg_display() # svg清晰度高一点

# 通过ToTensor实例将图像数据从PIL类型变换成32位浮点数格式，
# 并除以255使得所有像素的数值均在0～1之间
trans = transforms.ToTensor() # 转换成Pytorch的tensor
# transform=trans保证拿到的是tensor而不是图片
mnist_train = torchvision.datasets.FashionMNIST(
    root="../data", train=True, transform=trans, download=True)
# test数据集用来测试训练的好坏，不参与训练
mnist_test = torchvision.datasets.FashionMNIST(
    root="../data", train=False, transform=trans, download=True)

len(mnist_train), len(mnist_test)
# 第0个example，第二个0表示图片的标号
mnist_train[0][0].shape
# >> torch.Size([1, 28, 28])
# 黑白灰度图片，所以通道数为1，高度和宽度均为28像素

# 数字标签索引及其文本名称之间进行转换
def get_fashion_mnist_labels(labels):  #@save
    """返回Fashion-MNIST数据集的文本标签"""
    text_labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat',
                   'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']
    return [text_labels[int(i)] for i in labels]
# 可视化样本
def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5):  #@save
    """绘制图像列表"""
    figsize = (num_cols * scale, num_rows * scale)
    _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)
    axes = axes.flatten()
    for i, (ax, img) in enumerate(zip(axes, imgs)):
        if torch.is_tensor(img):
            # 图片张量
            ax.imshow(img.numpy())
        else:
            # PIL图片
            ax.imshow(img)
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
        if titles:
            ax.set_title(titles[i])
    return axes

# 从训练数据集中读取18个小批量数据，y是他们标号的向量
# iter函数是返回迭代器，next函数是返回迭代器的下一个项目
X, y = next(iter(data.DataLoader(mnist_train, batch_size=18)))
# 3行6列
show_images(X.reshape(18, 28, 28), 3, 6, titles=get_fashion_mnist_labels(y));

读取小批量

训练前，测试读取数据的速度，防止出现训练速度快，但是读取数据读取不过来，

batch_size = 256

def get_dataloader_workers():  #@save
    """使用4个进程来读取数据"""
    return 4

train_iter = data.DataLoader(mnist_train, batch_size, shuffle=True,
                             num_workers=get_dataloader_workers())

timer = d2l.Timer()
for X, y in train_iter:
    continue
f'{timer.stop():.2f} sec'

整合所有组件

# 获取和读取Fashion-MNIST数据集
# 可选参数resize，用来将图像大小调整为另一种形状
def load_data_fashion_mnist(batch_size, resize=None):  #@save
    """下载Fashion-MNIST数据集，然后将其加载到内存中"""
    trans = [transforms.ToTensor()]
    if resize:
        trans.insert(0, transforms.Resize(resize))
    trans = transforms.Compose(trans)
    mnist_train = torchvision.datasets.FashionMNIST(
        root="../data", train=True, transform=trans, download=True)
    mnist_test = torchvision.datasets.FashionMNIST(
        root="../data", train=False, transform=trans, download=True)
    return (data.DataLoader(mnist_train, batch_size, shuffle=True,
                            num_workers=get_dataloader_workers()),
            data.DataLoader(mnist_test, batch_size, shuffle=False,
                            num_workers=get_dataloader_workers()))

# 测试load_data_fashion_mnist函数的图像大小调整功能
train_iter, test_iter = load_data_fashion_mnist(32, resize=64)
for X, y in train_iter:
    print(X.shape, X.dtype, y.shape, y.dtype)
    break

6.4 softmax回归的从零开始实现

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)

初始化模型参数

# 28*28=784，前面28*28大小的，拉成一个长度为784向量（会损失空间信息）
num_inputs = 784
# 10个类别
num_outputs = 10

# 初始为高斯随机分布的值，Z = W.T * X + b
W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
b = torch.zeros(num_outputs, requires_grad=True)

# 将每个元素变成一个非负数。 此外，依据概率原理，每行总和为1
def softmax(X):
    X_exp = torch.exp(X)
    partition = X_exp.sum(1, keepdim=True)
    return X_exp / partition  # 这里应用了广播机制

定义模型

def net(X):
    # -1表示自动计算第0维度大小
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)

定义损失函数

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对应[0, 2]表示取0和2列
# 结果就是取出y_hot[0，0]和y_hot[1，2]
y_hat[[0, 1], y]

def cross_entropy(y_hat, y):
    return - torch.log(y_hat[range(len(y_hat)), y])

cross_entropy(y_hat, y)

分类精度

首先，如果y_hat是矩阵，那么假定第二个维度存储每个类的预测分数。我们使用argmax获得每行中最大元素的索引来获得预测类别。然后我们[将预测类别与真实y元素进行比较]。由于等式运算符“==”对数据类型很敏感，因此我们将y_hat的数据类型转换为与y的数据类型一致。结果是一个包含0（错）和1（对）的张量。最后，我们求和会得到正确预测的数量。

def accuracy(y_hat, y):  #@save
    """计算预测正确的数量"""
    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())

def evaluate_accuracy(net, data_iter):  #@save
    """计算在指定数据集上模型的精度"""
    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]

训练

在我们看过 :numref:sec_linear_scratch中的线性回归实现， [softmax回归的训练]过程代码应该看起来非常眼熟。在这里，我们重构训练过程的实现以使其可重复使用。首先，我们定义一个函数来训练一个迭代周期。请注意，updater是更新模型参数的常用函数，它接受批量大小作为参数。它可以是d2l.sgd函数，也可以是框架的内置优化函数。

def train_epoch_ch3(net, train_iter, loss, updater):  #@save
    """训练模型一个迭代周期（定义见第3章）"""
    # 将模型设置为训练模式
    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]

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

6.5 softmax回归的简洁实现

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

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)