动手学深度学习——softmax回归（原理解释+代码详解）

sum运算符：给定一个矩阵X，我们可以对所有元素求和（默认情况下）。也可以只求同一个轴上的元素，即同一列（轴0）或同一行（轴1）。对每个项求幂（使用exp）；对每一行求和（小批量中每个样本是一行），得到每个样本的规范化常数；将每一行除以其规范化常数，确保结果的和为1。

緈福的街口

30621人浏览 · 2023-07-16 10:09:51

緈福的街口 · 2023-07-16 10:09:51 发布

1. softmax回归

回归是问“多少”，可以用来预测多少，如预测房屋价格。

分类是问“哪一个”，如某个电子邮件是否是垃圾邮件，某个图像描绘的是猫还是狗。

这里引入“硬性”类别和“软性”类别的概念：

“硬性”类别：属于哪个类别
“软性”类别：属于每个类别的概率

我们关心硬类别，但仍然使用软类别的模型。

softmax：最大概率的标签，能够将未规范化的预测变换为非负数，并且总和为1，同时能够让模型保持可导。

1.1 分类问题

从一个图像分类问题开始，假设每次输入是一个2×2的灰度图像。我们可以用一个标量表示每个像素值，每个图像对应4个特征x1，x2，x3，x4。此外，假设每个图像属于类别“猫”“鸡”和“狗”中的一个。

接下来，我们要选择如何表示标签。我们有两个明显的选择：

选择y∈{1，2，3}，其中整数分别代表{狗，猫，鸡}。
标签y将是一个三维向量，其中(1,0,0)对应于“狗”，(0,1,0)对应于“鸡”，(0,0,1)对应于“狗”：

方法2是一种表示分类数据的简单方法：独热编码（one-hot encoding）。独热编码是一个向量，它的分量和类别一样多，类别对应的分量设置为1，其他所有分量设置为0。

1.2 网络架构

为了估计所有可能类别的条件概率，我们需要一个有多个输出的模型，每个类别对应一个输出。

在上述例子（猫，鸡，狗）中，由于有4个特征和3个可能的输出类别，我们将需要12个标量来表示权重（带下标的w），3个标量来表示偏置（带下标的b）。下面是为每个输入计算三个未规范化的预测（logit）：o1、o2和o3。
在这里插入图片描述
用神经网络来描述这个计算过程，与线性回归一样，softmax回归也是一个单层神经网络。由于计算每个输出o1、o2和o3取决于所有输入x1，x2，x3和x4，所以softmax回归的输出层也是全连接层。

1.3 全连接层的参数开销

全连接层是“完全”连接的，对于任何具有d个输入和q个输出的全连接层，参数开销为O(dq)。
若将d个输入转换为q个输出的成本可以减少到O(dq/n)，其中超参数n可以由我们灵活指定。

1.4 softmax运算

我们将优化参数以最大化观测数据的概率，为了得到预测结果，我们将设置一个阈值，如选择最大概率的标签。

我们希望模型输出y(j)可以视为属于类j的概率，然后选择具有最大输出值的类别argmaxy(j)作为我们的预测。例如：y1、y2和y3分别为0.1、0.8和0.1，那我们预测的类别为2，在我们的例子中代表“鸡”。

但我们不能将未规范化的预测o直接作为输出，因为将线性层的输出直接视为概率时会存在一些问题：

我们没有限制这些数字的总和为1
根据输入的不同，它们可以为负值

要将输出视为概率，我们必须保证在任何数据上的输出都是非负的且总和为1。
此外，我们需要一个训练的目标函数，来激励模型精准地估计概率。例如。在分类器输出0.5的所有样本中，我们希望这些样本是刚好有一半实际上属于预测的类别。这个属性叫做校准（calibration）。

引入softmax函数： softmax函数能够将未规范化的预测变换为非负数并且总和为1，同时让模型保持可导的性质。

首先，对每个未规范化的预测求冥，这样可以确保输出为非负。
再让每个求冥后的结果除以它们的总和，为了确保最终输出的概率值总和为1。

这里，对于所有的j总有0≤y(j)≤1。因此，y可以视为一个正确的概率分布，softmax不会改变未规范化的预测o之间的大小次序，只会确定分配给每个类别的概率。因此，在预测过程中，我们仍然可以用下式来选择最有可能得类别。
尽管softmax是一个非线性函数，但softmax回归的输出仍然由输入特征的仿射变换决定。因此，softmax回归是一个线性模型。

1.5 小批量样本的矢量化

为了提高计算效率并且充分利用GPU，我们通常会对小批量样本的数据执行矢量计算。

假设我们读取了一个批量的样本X，其中特征维度（输入数量）为d，批量大小为n。此外，假设我们在输出中有q个类别。那么小批量样本各参数的矢量为：

参数	矢量
特征
权重
偏置

softmax回归的矢量计算表达式为：在这里插入图片描述
相对于一次处理一个样本，小批量样本的矢量化加快了X和W的矩阵-向量乘法。由于X中的每一行代表一个数据样本，那么softmax运算可以按行（rowwise）执行：对于O的每一行，我们先对所有项进行幂运算，然后通过求和对它们进行标准化。

1.6 损失函数

接下来，我们需要一个损失函数来度量预测的效果。

1.6.1 对数似然

似然函数在概率论中常见，可以用于求条件极值，在这里我们的损失函数的值则要尽量小。

softmax函数给出了一个向量y，我们可以将其视为“对给定任意输入x的每个类的条件概率”。例如，y=P(y = 猫|x)。假设整个数据集{X,Y}具有n个样本，其中索引i的样本由特征向量x和独热标签向量y组成。我们可以将估计值与实际值进行比较：
在这里插入图片描述
根据最大似然估计，我们最大化P(Y|X)，相当于最小化负对数似然：

由于y是独热编码（形如(1,0,0)），所以除了一个项以外其他项都消失了。所有的y是预测的概率，则对数不会大于0。
如果正确地预测实际标签（即P(y|x)=1），损失函数就不会进一步优化，但这往往不可能。由于存在标签噪声（比如某些样本可能被误标），或输入特征没有足够的信息来完美地对每一个样本分类。

似然函数
极大似然估计

1.6.2 softmax及其导数

利用softmax的定义，我们得到：在这里插入图片描述
考虑相对于任何未规范化的预测o的导数，我们得到：

导数是softmax模型分配的概率与实际发生的情况（由独热标签向量表示）之间的差异。

1.6.3 交叉熵损失

对于标签y，我们可以使用与以前相同的表示形式。唯一的区别是，我们现在用一个概率向量表示，如(0.1,0.2,0.7)，而不是包含二元项的向量(0,0,1)。

对于任何标签y和模型预测y^，损失函数为（通常被称为交叉熵函数，它是所有标签分布的预期损失值）：在这里插入图片描述

1.7 信息论基础

信息论（information theory）涉及编码、解码、发送以及尽可能简洁地处理信息或数据。

1.7.1 熵

通常，一个信源发送出什么符号是不确定的，衡量它可以根据其出现的概率来度量。概率大，出现机会多，不确定性小；反之不确定性就大。

1.7.2 信息量

香农（C. E. Shannon）信息论应用概率来描述不确定性。信息是用不确定性的量度定义的。一个消息的可能性愈小，其信息愈多；而消息的可能性愈大，则其信息愈少。事件出现的概率小，不确定性越多，信息量就大，反之则少。

如果我们不能完全预测每一个事件，那么我们有时可能会感到”惊异”。克劳德·香农决定用信息量:
在这里插入图片描述
来量化这种惊异程度。在观察一个事件j时，并赋予它（主观）概率P(j)。当我们赋予一个事件较低的概率时，我们的惊异会更大，该事件的信息量也就更大。

1.7.3 重新审视交叉熵

交叉熵从P到Q，记为H(P,Q)。我们可以把交叉熵想象为“主观概率为Q的观察者在看到根据概率P生成的数据时的预期惊异”。
当P=Q时，交叉熵达到最低。在这种情况下，从P到Q的交叉熵是H(P,P)=H(P )。

我们从两方面考虑交叉熵分类目标：

最大化观测数据的似然
最小化传达标签所需的惊异

1.8 模型预测与评估

在训练softmax回归模型后，给出任何样本特征，我们可以预测每个输出类别的概率。通常我们使用预测概率最高的类别作为输出类别。如果预测与实际类别（标签）一致，则预测是正确的。

1.9 小结

softmax运算获取一个向量并将其映射为概率。
softmax回归适用于分类问题，它使用了softmax运算中输出类别的概率分布。
交叉熵是一个衡量两个概率分布之间差异的很好的度量，它测量给定模型编码数据所需的比特数。

2. 图像分类数据集

这里采用Fashion-MNIST数据集

torchvision：torch类型的可视化包，一般计算机视觉和数据可视化需要使用
from torchvision import transforms：该组件经常用于图片的修改（一般数据集中的图片都是PIL格式，使用的时候需要转化为tenser，而在加入函数时常需要转化为nadarry（numpy中的ndarray为多维数组））
d2l.use_svg_display()：使用什么模式展示图片

%matplotlib inline
import torch
import torchvision #pytorch用于计算机视觉的一个库
from torch.utils import data
from torchvision import transforms #导入对数据操作的模具
from d2l import torch as d2l

d2l.use_svg_display() #使用svg展示图片

2.1 读取数据集

通过框架中的内置函数将Fashion-MNIST数据集下载并读取到内存中

torchvision.datasets：一般用于图像数据集的下载和获取
eg：
torchvision.datasets.FashionMNIST( root=, train=True, transform=, download=True)：
train：是否为训练集
transform：使用什么格式转换（可以从transforms组件中选择）
dowload：是否下载对应数据集
.FashionMNIST可以更换为其他数据源

# 通过ToTensor实例将图像数据从PIL类型变换成32位浮点数格式，
# 并除以255使得所有像素的数值均在0～1之间
trans = transforms.ToTensor() #对图片进行预处理，转换为tensor格式

# 下载训练集和测试集，并保存
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)

Fashion-MNIST由10个类别的图像组成，每个类别由训练数据集（train dataset）中的6000张图像和测试数据集（test dataset）中的1000张图像组成。因此，训练集和测试集分别包含60000和10000张图像。测试数据集不会用于训练，只用于评估模型性能。

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

在这里插入图片描述
每个输入图像的高度和宽度均为28像素。数据集由灰度图像组成，其通道数为1（彩色图像通道数为3）。

# 索引到第一张图片
mnist_train[0][0].shape # 输入图像的通道数、高度和宽度

在这里插入图片描述
Fashion-MNIST中包含的10个类别，分别为t-shirt（T恤）、trouser（裤子）、pullover（套衫）、dress（连衣裙）、coat（外套）、sandal（凉鞋）、shirt（衬衫）、sneaker（运动鞋）、bag（包）和ankle boot（短靴）。以下函数用于在数字标签索引及其文本名称之间进行转换。

# 获取数据集的标签
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]

创建一个函数来可视化这些样本。

plt.subplots()是一个返回包含图形和轴对象的元组的函数。因此，在使用时fig, ax = plt.subplots(),将此元组解压缩到变量fig和ax。
enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中，生成可以遍历的每个元素有对应序号(0, 1, 2, 3…)的enumerate对象。
zip()函数用于将多个可迭代对象作为参数，依次将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，里面的每个元素大概为i,(ax,img)的形式。
imshow()可以接收二维，三维甚至多维数组。二维默认为一通道即灰度图像，三维需要在第三个维度指定图像通道数（必须是第三维）

def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5): #@save
	"""绘制图像列表"""
	figsize = (num_cols * scale, num_rows * scale)
	
	# 第1个参数是个图，一般不用；第2个axer类似于图片的索引矩阵（行，列）
	_, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize) # axes：轴
	axes = axes.flatten()

	# 遍历生成形如i, (ax, img)形式的enumerate对象
	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) #x轴隐藏
		ax.axes.get_yaxis().set_visible(False) #y轴隐藏
		if titles:
			ax.set_title(titles[i]) #显示标题
	return axes

以下是训练数据集中前几个样本的图像及其相应的标签。

next() 返回迭代器的下一个项目。
next() 函数要和生成迭代器的iter() 函数一起使用。
我们可以通过iter()函数获取这些可迭代对象的迭代器。然后，我们可以对获取到的迭代器不断使⽤next()函数来获取下⼀条数据。
注：当我们已经迭代完最后⼀个数据之后，再次调⽤next()函数会抛出 StopIteration的异常，来告诉我们所有数据都已迭代完成，不⽤再执⾏ next()函数了。

# 使用next()函数获取批量大小为18的训练集的图像和标签
X, y = next(iter(data.DataLoader(mnist_train, batch_size=18)))

#显示18张图片，宽度为28，长度为28，总共为2行9列
# 绘制两行图片，每一行有9张图片，并获取标签
show_images(X.reshape(18, 28, 28), 2, 9, titles=get_fashion_mnist_labels(y));

在这里插入图片描述

2.2 读取小批量

为了使我们在读取训练集和测试集时更容易，我们使用内置的数据迭代器，而不是从零开始创建。回顾一下，在每次迭代中，数据加载器每次都会读取一小批量数据，大小为batch_size。通过内置数据迭代器，我们可以随机打乱了所有样本，从而无偏见地读取小批量。

batch_size = 256

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

# 训练集需要设置shuffle=True打乱顺序	
train_iter = data.DataLoader(mnist_train, batch_size, shuffle=True,
							 num_workers=get_dataloader_workers())

我们看一下读取训练数据所需的时间。

timer = d2l.Timer() #调用Timer函数，测试速度
for X, y in train_iter:
	continue
f'{timer.stop():.2f} sec' #输出读取数据所用的秒数，精度为2位小数

在这里插入图片描述

2.3 整合所有组件

定义load_data_fashion_mnist函数，用于获取和读取Fashion-MNIST数据集。这个函数返回训练集和验证集的数据迭代器。此外，这个函数还接受一个可选参数resize，用来将图像大小调整为另一种形状。

torchvision.transforms是pytorch中的图像预处理包，一般用Compose把多个步骤整合到一起。
insert函数是一种用于列表的内置函数。这个函数的作用是在一个列表中的指定位置，插入一个元素。

transforms中的函数	功能
Resize	把给定的图片resize到given size
Normalize	用均值和标准差归一化张量图像

def load_data_fashion_mnist(batch_size, resize=None):  #@save
	"""下载Fashion-MNIST数据集，然后将其加载到内存中"""
	# 转换为tensor
	trans = [transforms.ToTensor()]

	
	if resize:
		trans.insert(0, transforms.Resize(resize))
	# compose整合步骤
	trans = transforms.Compose(trans)

	# 下载训练集和测试集，并返回到train_iter中，用于之后的训练
	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()))

下面，我们通过指定resize参数来测试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

在这里插入图片描述

2.4 小结

Fashion-MNIST是一个服装分类数据集，由10个类别的图像组成。我们将在后续章节中使用此数据集来评估各种分类算法。
我们将高度h像素，宽度w像素图像的形状记为h×w或(h,w)。
数据迭代器是获得更高性能的关键组件。依靠实现良好的数据迭代器，利用高性能计算来避免减慢训练过程。

3. softmax回归的从零开始实现

引入Fashion-MNIST数据集，并设置数据迭代器的批量大小为256。

import torch
from IPython import display
from d2l import torch as d2l

# 随机读取256张图片
batch_size = 256

# 返回训练集和测试集的迭代器
# load_data_fashion_mnist函数是在图像分类数据集中定义的一个函数，可以返回batch_size大小的训练数据集和测试数据集
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

步骤	函数
载入数据集
初始化模型参数
定义softmax操作
定义模型
定义损失函数
分类精度
训练
预测

3.1 初始化模型参数

样本固定长度向量表示，原始数据集每个样本都是28×28的图像
现在将展平每个图像，把它们看作长度为784的向量
在softmax回归中，我们的输出与类别一样多。因为我们的数据集有10个类别，所以网络输出维度为10
权重将构成一个784×10的矩阵，偏置将构成一个1×10的行向量

num_inputs = 784 #展平长度为784的向量
num_outputs = 10 #10输出，也对应10类别

# 权重w：均值为0，标准差为0.01，数量size为输入输出的数量
# size=(num_inputs, num_outputs)：行数为输入的个数，列数等于输出的个数
# requires_grad=True表明要计算梯度
W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
b = torch.zeros(num_outputs, requires_grad=True)

3.2 定义softmax操作

sum运算符：给定一个矩阵X，我们可以对所有元素求和（默认情况下）。也可以只求同一个轴上的元素，即同一列（轴0）或同一行（轴1）。

一般实现softmax由三个步骤组成：

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

# 定义softmax函数
def softmax(X):
    X_exp = torch.exp(X) # 对每个元素做指数运算
    partition = X_exp.sum(1, keepdim=True) # 对每行进行求和
    return X_exp / partition  # 这里应用了广播机制

正如上述代码，对于任何随机输入，我们将每个元素变成一个非负数。此外，依据概率原理，每行总和为1。

3.3 定义模型

定义softmax操作后，我们可以实现softmax回归模型。
将数据传递到模型之前，我们使用reshape函数将每张原始图像展平为向量。

reshape(-1,1)：这里的-1被理解为unspecified value，意思是未指定为给定的。只需要特定的列数，行数多少无所谓，用-1代替（-1可以理解为一个正整数通配符，它代替任何整数）。
shape[0]：表示矩阵的行数。
对于图像来说：image.shape[0]——图片高度；image.shape[1]——图片宽度；image.shape[2]——图片通道数。
对于矩阵来说：shape[0]：表示矩阵的行数；shape[1]：表示矩阵的列数。

def net(X):
	# 权重为784×10的矩阵，这里将原始图像的列数大小转换为权重w矩阵的行数大小
	# 模型简单看来为：softmax(wx' + b)
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)

3.4 定义损失函数

目前分类问题的数量远远超过回归问题的数量，这里采用交叉熵损失函数，交叉熵采用真实标签的预测概率的负对数似然。

创建数据样本y_hat，包括2个样本在3个类别的概率，以及对应的标签y。
通过y知道第一个样本中第一类是正确的预测，第二个样本中第三类是正确的预测。
将y作为y_hat的索引，选择第一个样本第一类的概率和第二个样本第三类的概率。

实现交叉熵损失函数
在这里插入图片描述

len(x)：获取x的长度
range(x)：生成从0开始，小于参数x的整数序列

# 定义交叉熵损失函数
def cross_entropy(y_hat, y):
    return - torch.log(y_hat[range(len(y_hat)), y]) 

cross_entropy(y_hat, y)

在这里插入图片描述

3.5 分类精度

给定预测概率分布y_hat，当我们必须输出硬预测（hard prediction）时，我们通常选择预测概率最高的类。

当预测与标签分类y一致时，即是正确的。
分类精度即正确预测数量与总预测数量之比。
y_hat是矩阵，假定第二个维度存储每个类的预测分数。
使用argmax获得每行中最大元素的索引来获得预测类别。
将预测类别与真实y元素进行比较。
通过"=="比较，结果为包含0（错）和1（对）的张量，求和得到正确预测的数量。

argmax()：返回的是最大数的索引.argmax有一个参数axis,默认是0,表示第几维的最大值。

def accuracy(y_hat, y):  #@save
    """计算预测正确的数量"""
    # len是查看矩阵的行数
    # y_hat.shape[1]就是去列数
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
    	# 第2个维度为预测标签，取最大元素
        y_hat = y_hat.argmax(axis=1) 

	#  #将y_hat转换为y的数据类型然后作比较，cmp函数存储bool类型
    cmp = y_hat.type(y.dtype) == y 
    return float(cmp.type(y.dtype).sum()) #将正确预测的数量相加

y_hat和y分别作为预测的概率分布和标签。
第一个样本的预测类别是2（该行的最大元素为0.6，索引为2），这与实际标签0不一致。第二个样本的预测类别是2（该行的最大元素为0.5，索引为2），这与实际标签2一致。因此，这两个样本的分类精度率为0.5。

在这里插入图片描述

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

with torch.no_grad()：不使用时，此时有grad_fn=属性，表示计算的结果在一计算图当中，可以进行梯度反传等操作。使用时，表明当前计算不需要反向传播，使用之后，强制后边的内容不进行计算图的构建。
isinstance()：python中的一个内置函数，作用：判断一个函数是否是一个已知类型，类似type()。
isinstance (object , classinfo)判断两个类型是否相同。
object：实例对象；
classinfo：可以是直接或间接类名、基本类型或由它们组成的元组；
返回值：如果对象的类型与参数二(classinfo)的类型相同返回true，否则false。

torch.nn.Module()：它是所有的神经网络的根父类，神经网络必然要继承。
net.eval()：pytorch中用来将神经网络设置为评估模型的方法。
评估模式下，网络的参数不会被更新，dropout和batch normalization层的行为也会有所不同，以便模型更好地进行预测。
评估模式下计算图不会被跟踪，这样可以节省内存使用，提升性能。

y.numel()：Python中的张量计算方法，用于存储新的张量并存储在内存中。可以通过指定形状的shape属性来访问张量的形状。

def evaluate_accuracy(net, data_iter): #@save
	"""计算在指定数据集上模型的精度"""
	# 判断模型是否为深度学习模型
	if isinstance(net, torch.nn.Module):
		net.eval() # 将模型设置为评估模式
	metric = Accumulator(2) # metric：度量，累加正确预测数、预测总数
	
	# 梯度不需要反向传播
	with torch.no_grad():
		# 每次从迭代器中拿出一个X和y
		for X, y in data_iter:
		
			# metric[0, 1]分别为网络预测正确的数量和总预测的数量
			# nex(X)：X放在net模型中进行softmax操作
			# numel()函数：返回数组中元素的个数，在此可以求得样本数
			metric.add(accuracy(net(X), y), y.numel()) 
	
	# # metric[0, 1]分别为网络预测正确数量和总预测数量
	return metric[0] / metric[1]

定义一个实用程序类Accumulator，用于对多个变量进行累加，Accumulator实例中创建了2个变量，分别用于存储正确预测的数量和预测的总数量。

__init__()：创建一个类，初始化类实例时就会自动执行__init__()方法。该方法的第一个参数为self，表示的就是类的实例。self后面跟随的其他参数就是创建类实例时要传入的参数。
reset()；重新设置空间大小并初始化。
__getitem__()：接收一个idx参数，这个参数就是自己给的索引值，返回self.data[idx]，实现类似数组的取操作。

class Accumulator: #@save
	"""在n个变量上累加"""
	# 初始化根据传进来n的大小来创建n个空间，全部初始化为0.0
	def __init__(self, n):
		self.data = [0.0] * n

	# 把原来类中对应位置的data和新传入的args做a + float(b)加法操作然后重新赋给该位置的data，从而达到累加器的累加效果
	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]

由于我们使用随机权重初始化net模型，因此该模型的精度应接近于随机猜测。例如在有10个类别情况下的精度为0.1。

3.6 训练

定义一个函数来训练一个迭代周期。
updater是更新模型参数的常用函数，它接受批量大小作为参数。它可以是d2l.sgd函数，也可以是框架的内置优化函数。

def train_epoch_ch3(net, train_iter, loss, updater):  #@save
    """训练模型一个迭代周期（定义见第3章）"""
    # 判断net模型是否为深度学习类型，将模型设置为训练模式
    if isinstance(net, torch.nn.Module):
        net.train() # 要计算梯度
        
    # Accumulator(3)创建3个变量：训练损失总和、训练准确度总和、样本数
    metric = Accumulator(3)
    for X, y in train_iter:
        # 计算梯度并更新参数
        y_hat = net(X)
        l = loss(y_hat, y)

		# 判断updater是否为优化器
        if isinstance(updater, torch.optim.Optimizer):
            # 使用PyTorch内置的优化器和损失函数
            updater.zero_grad() #把梯度设置为0
            l.mean().backward() #计算梯度
            updater.step()		#自更新
        else:
            # 使用定制的优化器和损失函数
            # 自我实现的话，l出来是向量，先求和再求梯度
            l.sum().backward()
            updater(X.shape[0])
        metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
    # 返回训练损失和训练精度，metric的值由Accumulator得到
    return metric[0] / metric[2], metric[1] / metric[2]

定义一个在动画中绘制数据的实用程序类Animator

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指定）。

assert()：断言函数，当表达式为真时，程序继续往下执行，只是判断，不做任何处理；当表达式为假时，抛出AssertionError错误，并将 [参数] 输出

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'])
                     
    # num_epochs：训练次数
    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

使用小批量随机梯度下降来优化模型的损失函数，设置学习率为0.1。

lr = 0.1

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

训练模型10个迭代周期，其中迭代周期（num_epochs）和学习率（lr）都是可调节的超参数。

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

在这里插入图片描述

3.7 预测

训练已完成的模型可以来对准备好图像进行分类预测，给定一系列图像，我们将比较它们的实际标签（文本输出的第一行）和模型预测（文本输出的第二行）。

def predict_ch3(net, test_iter, n=6):  #@save
    """预测标签（定义见第3章）"""
    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)

在这里插入图片描述

3.8 小结

借助softmax回归，我们可以训练多分类的模型。
训练softmax回归循环模型与训练线性回归模型非常相似：先读取数据，再定义模型和损失函数，然后使用优化算法训练模型。大多数常见的深度学习模型都有类似的训练过程。

4. softmax回归的简洁实现

通过深度学习框架的高级API也能更方便地实现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)

4.1 初始化模型参数

softmax回归的输出层是一个全连接层。
只需在Sequential中添加一个带有10个输出的全连接层。（在这里Sequential并不是必要的，但它是实现深度模型的基础。）
以均值0和标准差0.01随机初始化权重。

# PyTorch不会隐式地调整输入的形状。因此，我们在线性层前定义了展平层（flatten），来调整网络输入的形状
# Flatten()将任何维度的tensor转化为2D的tensor
# Linear(784, 10)定义线性层，输入是784，输出是10
# nn.Sequential:一个时序容器。Modules 会以他们传入的顺序被添加到容器中
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))

def init_weights(m):
    if type(m) == nn.Linear:
        # normal_：正态分布
        nn.init.normal_(m.weight, std=0.01)

# apply()：当一个函数的参数存在于一个元组或者一个字典中时，用来间接的调用这个函数，并肩元组或者字典中的参数按照顺序传递给参数
net.apply(init_weights);

4.2 重新审视softmax的实现

softmax函数的分母或分子可能变成无穷大，需要优化。
这里没有将softmax概率传递到损失函数中，而是在交叉熵损失函数中传递未规范化的预测，并同时计算softmax及其对数。

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

4.3 优化算法

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

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

4.4 训练

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

在这里插入图片描述

4.5 小结

使用深度学习框架的高级API，我们可以更简洁地实现softmax回归。

参考资料：
[1]动手学深度学习：http://zh-v2.d2l.ai/index.html
[2]跟李沐学AI：https://space.bilibili.com/1567748478
[3]百度百科

腾讯云开发者社区

腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。

更多推荐

Springboot+MySQL 实现从数据库获取数据展示到前端

1.运行效果效果图如下：2.创建数据库表数据库名为"springboot",数据库表名为"user"，数据库表里面放了5条数据，字段分别为：“id”，“name”，“age”，“email”。3.新建SpringBoot项目1、选择Spring Initial...

腾讯云开发者社区

腾讯云建官网：一个完整的自助建站的过程，不用代码，2小时就可以制作自己的网站

腾讯云开发者社区

数据库实验二数据库的简单查询和连接查询实验

– l）用Transact-SQL语句表示下列操作．在学生选课库中实现其数据查询操作．– ①求数学系学生的学号和姓名。select sno,sname from student where sdept='MA';– ②求选修了课程的学生学号。select distinct sno from sc;– ③求选修C1课程的学生学号和成绩，并要求对查询结果按成绩降序排列，如果成绩相同则按学号升序排列。s

腾讯云开发者社区

所有评论(0)

查看更多评论

緈福的街口

@qq_38473254

已为社区贡献1条内容

动手学深度学习——softmax回归（原理解释+代码详解）

緈福的街口

目录

1. softmax回归

1.1 分类问题

1.2 网络架构

1.3 全连接层的参数开销

1.4 softmax运算

1.5 小批量样本的矢量化

1.6 损失函数

1.6.1 对数似然

1.6.2 softmax及其导数

1.6.3 交叉熵损失

1.7 信息论基础

1.7.1 熵

1.7.2 信息量

1.7.3 重新审视交叉熵

1.8 模型预测与评估

1.9 小结

2. 图像分类数据集

2.1 读取数据集

2.2 读取小批量

2.3 整合所有组件

2.4 小结

3. softmax回归的从零开始实现

3.1 初始化模型参数

3.2 定义softmax操作

3.3 定义模型

3.4 定义损失函数

3.5 分类精度

3.6 训练

3.7 预测

3.8 小结

4. softmax回归的简洁实现

4.1 初始化模型参数

4.2 重新审视softmax的实现

4.3 优化算法

4.4 训练

4.5 小结

所有评论(0)

緈福的街口