李沐《动手学深度学习》线性神经网络 softmax回归

系列文章

李沐《动手学深度学习》预备知识张量操作及数据处理
李沐《动手学深度学习》预备知识线性代数及微积分
李沐《动手学深度学习》线性神经网络线性回归

系列文章
一、softmax回归
- （一）问题背景
- （二）网络架构
- （三）softmax运算
- （四）小批量样本的矢量化
- （五）损失函数
二、图像分类数据集
（一）读取数据集
（二）读取小批量
（三）整合所有组件
三、softmax的从零开始实现
- （一）导入相关库、数据获取
- （二）初始化模型参数
- （三）定义模型
- （四）定义损失函数
- （五）分类精度
- （六）训练
- （七）预测
四、softmax的简洁实现
- （一）导入相关库、数据获取
- （二）初始化模型参数
- （三）优化算法
- （四）训练

教材：李沐《动手学深度学习》

一、softmax回归

（一）问题背景

回归用于预测多少的问题，分类问题用于预测“哪一个”的问题；
独热编码是一种表示分类数据的简单方法：独热编码是一个向量，它的分量和类别一样多。类别对应的分量设置为1，其他所有分量设置为0；
硬性类别和软性类别的区分：硬性类别是指只关心样本属于哪个类别这一结果，软性类别是指样本属于每个类别的概率；
softmax回归将输入的线性组合通过softmax函数映射到一个概率分布上，使得每个类别的输出概率在0到1之间，并且所有类别的概率之和等于1;
softmax回归是逻辑回归的扩展，适用于具有多个类别的分类问题。

（二）网络架构

为了解决线性模型的分类问题，估计出所有可能类别的条件概率，需要有多个仿射函数对应多个类别的输出，softmax回归中使用仿射函数可以为输入计算出未规范化的预测 $o_1$ 、 $o_2$ 以及 $o_3$ ：
$o_1=x_1w_{11}+x_2w_{12}+x_3w_{13}+x_4w{14}+b_1 \\ o_2=x_1w_{21}+x_2w_{22}+x_3w_{23}+x_4w{24}+b_1 \\ o_2=x_1w_{21}+x_2w_{22}+x_3w_{23}+x_4w{24}+b_1$
与线性回归一样，softmax回归也是一个单层神经网络。由于计算每个输出 $o_1$ 、 $o_2$ 、 $o_3$ 都取决于所有输入 $x_1$ 、 $x_2$ 、 $x_3$ 和 $x_4$ ，所以softmax回归的输出层也是全连接层。

在全连接层中，每个神经元都接收上一层所有神经元的输出，并将它们进行加权求和，然后通过激活函数来生成该神经元的输出。

在这里插入图片描述

向量形式表达：（其中W是3x4的权重矩阵）
$o = W x + b$

（三）softmax运算

未规范化的预测 $o$ 违反了概率基本公理：
- 没有限制这些输出数字的总和为1;
- 可以为负值。
softmax函数能够将未规范化的预测变换为非负数并且总和为1，同时让模型保持可导的性质：

$\hat{y}=softmax(o) ，其中 \hat{y}_j=\frac{exp(o_j)}{\sum_{k}exp(o_k)}$ 之后选择最有可能的类别：
$\underset {j} { \operatorname {argmax} }\hat{y}_j=\underset {j} { \operatorname {argmax} }o_j$

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

（四）小批量样本的矢量化

对小批量样本的数据执行矢量计算可以提高计算效率并且充分利用GPU。softmax回归的矢量计算表达式为：（其中求和会使用广播机制，实例化说明线性回归中矢量化加速）
$\\ \hat{Y}=softmax(O)$

（五）损失函数

交叉熵采用真实标签的预测概率的负对数似然，可以很好的度量两个概率分布之间的差异，softmax回归的损失函数为交叉熵损失：
$l(y,\hat{y})=-{\sum_{j=1}^qy_jlog\hat{y}_j}$
损失函数的拆解：
损失函数求导：

因此，损失函数的导数是softmax模型分配的概率与实际发生的情况（由独热标签向量表示）之间的差异，由于梯度是观测值与估计值之间的差异，这一性质使得梯度计算在实践中变得容易很多。

二、图像分类数据集

%matplotlib inline
import torch
import torchvision #torch类型的可视化包，一般计算机视觉和数据可视化需要使用
from torch.utils import data #用于数据加载和处理
from torchvision import transforms #图像处理工具和数据转换函数
from d2l import torch as d2l #提供了一些实用的函数和工具，以简化深度学习任务的实现和理解

d2l.use_svg_display() #使用什么模式展示图片

（一）读取数据集

通过框架中的内置函数下载Fashion-MNIST数据集

trans = transforms.ToTensor() #通过ToTensor实例将图像数据从PIL类型变换成32位浮点数格式
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)

查看数据集

#训练集和测试集的大小
len(mnist_train), len(mnist_test)

#数据集由灰度图像组成，其通道数为1，每个输入图像的高度和宽度均为28像素
mnist_train[0][0].shape

可视化数据

#在数字标签索引及其文本名称之间进行转换
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

X, y = next(iter(data.DataLoader(mnist_train, batch_size=18)))
show_images(X.reshape(18, 28, 28), 2, 9, titles=get_fashion_mnist_labels(y));

在这里插入图片描述

（二）读取小批量

使用内置的数据迭代器，可以随机打乱所有样本，从而无偏见地读取小批量；在每次迭代中，数据加载器每次都会读取一小批量数据，大小为batch_size。

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

（三）整合所有组件

load_data_fashion_mnist函数：

输入：批量大小，需要调整的形状大小
输出：训练集和验证集的数据迭代器
用于获取和读取Fashion-MNIST数据集，并将图像大小调整为另一种形状。

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

函数调用：

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

三、softmax的从零开始实现

（一）导入相关库、数据获取

导入相关库，设置批量大小为256，调用load_data_fashion_mnist函数获取数据集

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)

（二）初始化模型参数

输入：原始数据集中图像大小为28x28，展平后，向量长度为784；
输出：10个类别
权重：784x10的矩阵，用正态分布初始化
偏置：1x10的行向量，初始化为0

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)

（三）定义模型

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

实现softmax的三个步骤：

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

def softmax(X):
    X_exp = torch.exp(X)
    partition = X_exp.sum(1, keepdim=True)
    return X_exp / partition  # 这里应用了广播机制

定义softmax操作后，可以实现softmax回归模型：

使用reshape函数将每张原始图像展平为向量
使用仿射函数为输入计算出未规范化的预测 $o = w x + b$
使用softmax函数转换输出

def net(X):
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)

（四）定义损失函数

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

cross_entropy(y_hat, y)

（五）分类精度

分类精度是正确预测数量与总预测数量之比：

计算预测正确的数量

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 #比较模型的预测结果 y_hat 与真实标签 y 是否相等
    return float(cmp.type(y.dtype).sum())

计算分类精度

accuracy(y_hat, y) / len(y)

评估模型的精度

def evaluate_accuracy(net, data_iter):  #@save
    """计算在指定数据集上模型的精度"""
    if isinstance(net, torch.nn.Module):#检查 net 是否是 PyTorch 中的神经网络模型
        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为定义的累加器：

class Accumulator:  #@save
    """在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)]

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

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

代入计算：

evaluate_accuracy(net, test_iter)

（六）训练

训练模型一个迭代周期

def train_epoch_ch3(net, train_iter, loss, updater):  #@save
    """训练模型一个迭代周期"""
    # 将模型设置为训练模式
    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:  #@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)):
        # 增量地绘制多条线
        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)

实现一个训练函数：

在train_iter访问到的训练数据集上训练一个模型net；
该训练函数将会运行多个迭代周期（由num_epochs指定）
在每个迭代周期结束时，利用test_iter访问到的测试数据集对模型进行评估
利用Animator类来可视化训练进度。

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)
        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

小批量随机梯度下降优化模型的损失函数

lr = 0.1

def updater(batch_size):
    return d2l.sgd([W, b], lr, batch_size)

10个迭代周期的训练

num_epochs = 10
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)

（七）预测

def predict_ch3(net, test_iter, n=6):  #@save
    """预测标签"""
    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])

predict_ch3(net, test_iter)

在这里插入图片描述

四、softmax的简洁实现

（一）导入相关库、数据获取

使用Fashion-MNIST数据集，并保持批量大小为256。

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)

（二）初始化模型参数

展平层：调整网络输入的形状
全连接层/线性层：输入是784，输出是10
参数初始化：均值0和标准差0.01随机初始化权重

net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights);

（三）优化算法

定义损失函数

loss = nn.CrossEntropyLoss(reduction='none')

使用学习率为0.1的小批量随机梯度下降作为优化算法

trainer = torch.optim.SGD(net.parameters(), lr=0.1)

（四）训练

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