在前面,咱们介绍了线性回归模型的原理及完结。线性回归适合于猜测接连值,而关于分类问题的离散值则束手无策。因而引出了本文所要介绍的softmax回归模型,该模型是针对多分类问题所提出的。下面咱们将从softmax回归模型的原理开始介绍,终究咱们同样会基于PyTorch来完结根本的softmax模型。
1、分类问题
假定现在咱们需求对图画进行分类,每次输入的数据是一个2×2的灰度图画。如果用一个标量来表明每个像素值,则每个图画能够对应x1,x2,x3,x4x_1,x_2,x_3,x_4四个特征,因而能够用一个特征向量(x1,x2,x3,x4)(x_1,x_2,x_3,x_4)来表明图画。
另外,假定每个图画属于类别“猫”,“鸡”和“狗”其间一个,那么咱们能够运用独热编码(one-hot encoding)来表明分类数据。例如标签yy是一个三维向量,其间[1,0,0]对应“猫”类别、[0,1,0]对应“鸡”类别、[0,0,1]对应“狗”类别:
2、模型网络架构
在分类问题中,咱们需求估量一张图画关于一切类别的条件概率,每一个类别对应则一个输出,则该模型是一个具有n个输入和m个输出的回归模型(n是图画的特征向量长度,m是类别数量)。
在上面的例子中,咱们有4个输入特征和3个或许的输出类别,因而咱们需求12个标量来表明权重(w),3个标量来表明偏置(b),核算每个类别未规范化的条件概率:
(2)中的o1,o2,o3o_1,o_2,o_3就是图画关于一切类别的条件概率,只不过此时还没有对概率进行规范化,还不能契合咱们的要求(一切类别的条件概率之和为1)。
咱们用矩阵形式来表明 x,W,b,ox,W,b,o:
则(2)能够表明为:
咱们还能够用神经网络图(图1)来表明softmax回归模型。与线性回归一样,softmax回归也是单层的神经网络。因为每个输出o1,o2,o3o_1,o_2,o_3都依赖于一切的输入x1,x2,x3,x4x_1,x_2,x_3,x_4,因而softmax回归的输出层还是一个全连接层。
图1:softmax回归的神经网络图
3、softmax运算
在上面,咱们由权重与输⼊特征进⾏矩阵-向量乘法再加上偏置b得到的输出o1,o2,o3o_1,o_2,o_3。为了获取终究的猜测成果,咱们运用argmaxjoj\arg\underset{j}{\max}o_j来挑选最大的输出ojo_j作为猜测概率。然而,直接将线性层的输出视为概率时存在⼀些问题:一方面,咱们没有限制这些输出值的总和为1。另⼀方面,根据输入的不同,输出值甚至或许为负值。
为了解决上述问题,社会科学家邓肯卢斯于1959年在挑选模型(choice model)的理论基础上发明晰softmax函数。 softmax函数将未规范化的猜测值变换为非负而且总和为1的概率值,同时保证模型可导。咱们⾸先对每个未规范化的猜测求幂,这样能够保证输出非负。为了保证终究输出的总和为1,咱们再对每个求幂后的成果除以它们的总和。如下式:
这⾥,关于一切的jj总有0≤yj≤10 ≤ \hat{y_j} ≤ 1。因而,yj\hat{y_j} 能够视为⼀个正确的概率分布。softmax运算并不会改变未规范化的猜测oo之间巨细的次序,只会将每个类别的猜测值转化概率值。因而,在猜测过程中,咱们能够用下式来挑选输入图画最有或许的类别:
尽管softmax是⼀个⾮线性函数,但softmax回归的输出仍然由输⼊特征的仿射变换决议。因而,softmax回归是⼀个线性模型(linear model)。
4、小批量样本的矢量化
为了提⾼核算效率而且充分利用GPU,咱们通常会针对小批量数据执行矢量核算。假定咱们读取了⼀个批量的样本XX,其间特征维度(输⼊数量)为d,批量巨细为n。此外,假定咱们在输出中有q个类别。那么小批量样本的特征为X∈RndX\in\R^{nd},权重为W∈RdqW\in\R^{dq},偏置为b∈R1qb\in\R^{1q}。softmax回归的小批量样本的⽮量核算表达式为:
5、丢失函数
接下来,咱们需求一个丢失函数来评价猜测的作用。因为在softmax回归中,咱们只关心正确类别的猜测概率,而不需求像线性回归那么精确地猜测数值,因而咱们运用穿插熵丢失函数来评价模型的猜测作用:
又因为正确标签向量yy中只有一个标量为1,其余全为0,因而(8)可化简为:
为了使(8)更好做偏导核算,咱们将(5)代入(8)中:
6、参数更新
咱们对穿插熵丢失函数(10)求导,获取l(y,y)l(y,\hat{y})关于ojo_j的梯度:
然后采用梯度下降法,softmax回归的练习过程为:采用正态分布来初始化权重WW,然后经过下式进行迭代更新:
7、完结softmax回归模型
7.1、读取数据集
在本节中,咱们用softmax回归来完结图画识别。在此之前,咱们先下载Fashion-MNIST数据集。
import torch
import torchvision
from torch.utils import data
from torchvision import transforms
from d2l import torch as d2l
d2l.use_svg_display()
经过框架中的内置函数将Fashion-MNIST数据集下载并读取到内存中。
# 经过ToTensor实例将图画数据从PIL类型变换成32位浮点数格式,
# 并除以255使得一切像素的数值均在0到1之间
trans = transforms.ToTensor()
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。
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]
创立一个函数来可视化这些样本。
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=15)))
show_images(X.reshape(15, 28, 28), 3, 5, 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())
读取一个小批量数据集所需的时间:
timer = d2l.Timer()
for X, y in train_iter:
continue
f'{timer.stop():.2f} sec'
为了方便运用,咱们将上述的代码整合为一个函数。
# 整合上述一切组件
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来读取数据集,并经过resize参数调整图画的尺度。
train_iter, test_iter = load_data_fashion_mnist(32, resize=28)
for X, y in train_iter:
print(X.shape, X.dtype, y.shape, y.dtype)
break
for X,y in test_iter:
print(X.shape, X.dtype, y.shape, y.dtype)
break
7.2、从零完结softmax回归
本节咱们将运用刚刚在6.1节中引进的Fashion-MNIST数据集, 并设置数据迭代器的批量巨细为256。
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)
7.2.1、初始化参数
和之前线性回归的例子一样,这里的每个样本都将用固定长度的向量表明。 原始数据会集的每个样本都是2828的图画。 在本节中,咱们将展平每个图画,把它们看作长度为784的向量。又因为咱们的数据集有10个类别,所以网络输出维度为10。 因而,权重将构成一个78410的矩阵, 偏置将构成一个110的行向量。 与线性回归一样,咱们将运用正态分布初始化咱们的权重W
,偏置初始化为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)
7.2.2、界说softmax激活函数
回想一下,完结softmax由三个步骤组成:
- 对每个项求幂(运用
exp
); - 对每一行求和(小批量中每个样本是一行);
- 将每项除以所属行的和,保证成果的和为1。
softmax的公式界说:
def softmax(X):
X_exp = torch.exp(X)
partition = X_exp.sum(1, keepdim=True)
return X_exp / partition # 这里应用了播送机制
咱们来验证一下softmax激活函数的作用:
X = torch.normal(0, 1, (2, 5))
X_prob = softmax(X)
X, X_prob, X_prob.sum(1)
7.2.3、界说模型
界说softmax操作后,咱们能够完结softmax回归模型。 下面的代码界说了输入如何经过网络映射到输出。 留意,将数据传递到模型之前,咱们运用reshape
函数将每张原始图画展平为向量。
def net(X):
return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)
7.2.4、界说丢失函数
在softmax回归中,咱们只关心正确类别猜测的概率,因而咱们需求将正确类别的猜测概率提取出来参与丢失函数核算。
为了加速核算速度,咱们运用y
作为y_hat
中概率的索引来提取正确类别的猜测概率,而不会考虑运用for循环这种低效的方式。
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]
因而咱们能够很快捷地完结穿插熵丢失函数:
def cross_entropy(y_hat, y):
return - torch.log(y_hat[range(len(y_hat)), y])
cross_entropy(y_hat, y)
7.2.5、评价分类精度
在实际猜测时,咱们必须输出终究的猜测类别。为了核算分类的精度,首要,如果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())
评价一下分类的精度:
accuracy(y_hat, y) / len(y)
同样,关于恣意数据迭代器data_iter
可拜访的数据集, 咱们能够评价在恣意模型net
的精度。
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]
这里界说一个实用程序类Accumulator
,用于对多个变量进行累加。 在上面的evaluate_accuracy
函数中, 咱们在Accumulator
实例中创立了2个变量, 别离用于存储正确猜测的数量和猜测的总数量。 当咱们遍历数据集时,两者都将跟着时间的推移而累加。
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]
7.2.6、练习模型
首要,咱们界说一个函数来练习一个迭代周期。 请留意,updater
是更新模型参数的常用函数,它承受批量巨细作为参数。 它能够是d2l.sgd
函数,也能够是框架的内置优化函数。
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]
然后咱们再界说一个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
指定)。 在每个迭代周期结束时,利用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。
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)
7.2.7、猜测
现在练习现已完结,咱们的模型现已准备好对图画进行分类猜测。 给定一系列图画,咱们将比较它们的实际标签(文本输出的榜首行)和模型猜测(文本输出的第二行)。
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, 5)
8、总结
在本文中,咱们讨论了softmax回归模型的根本原理和完结办法。softmax回归适合于离散的分类,线性回归适合于猜测接连的数值。
9、参考资料
1、动手学深度学习 Release2.0.0-beta0
2、softmax回归原理及丢失函数
3、神经网络与深度学习_邱锡鹏
4、深度学习:线性回归