系列文章

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

---

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

一、softmax回归

（一）问题背景

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

（二）网络架构

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

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

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

（三）softmax运算

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

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

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

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

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

（五）损失函数

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

2. 损失函数的拆解：
   损失函数求导：
   
   因此，损失函数的导数是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() #使用什么模式展示图片

（一）读取数据集

1. 通过框架中的内置函数下载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)

2. 查看数据集

#训练集和测试集的大小
len(mnist_train), len(mnist_test)#数据集由灰度图像组成，其通道数为1，每个输入图像的高度和宽度均为28像素
mnist_train[0][0].shape

3. 可视化数据

#在数字标签索引及其文本名称之间进行转换
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 = 256def get_dataloader_workers():  #@save"""使用4个进程来读取数据"""return 4train_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 d2lbatch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

（二）初始化模型参数

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

num_inputs = 784
num_outputs = 10W = 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=wx+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)

（五）分类精度

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

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

2. 计算分类精度

accuracy(y_hat, y) / len(y)

3. 评估模型的精度

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] * ndef 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)

（六）训练

1. 训练模型一个迭代周期

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]

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, fmtsdef add(self, x, y):# 向图表中添加多个数据点if not hasattr(y, "__len__"):y = [y]n = len(y)if not hasattr(x, "__len__"):x = [x] * nif 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)

3. 实现一个训练函数：

• 在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_metricsassert train_loss < 0.5, train_lossassert train_acc <= 1 and train_acc > 0.7, train_accassert test_acc <= 1 and test_acc > 0.7, test_acc

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

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

5. 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:breaktrues = 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 d2lbatch_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);

（三）优化算法

1. 定义损失函数

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

2. 使用学习率为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)