• pytorch深度学习实战lesson10

    第十课 Softmax回归

    目录

    第十课 Softmax回归

    理论部分

    Softmax回归

    损失函数

    1、均方损失

    2、绝对值损失函数

    3、哈勃鲁棒损失函数

    实践部分

    一、图像分类数据集的读取及其它操作

    二、softmax回归从零开始实现

    三、softmax简洁实现

    理论部分

    Softmax回归

    它其实是个分类问题。

    回归与分类的区别：

    回归其实是估计一个连续值；而分类是预测一个离散类别。

    分类举例：

    从回归如何过渡到分类？

    1、对类别进行一位有效编码，因为类别不是一个数而是个字符串，一个数据集中可能有好多个类别，所以要对每个类别进行编码。

    假设真实类别是第i个，则yi=1，其他类别为0.

    2、使用均方损失训练

    3、置信度最大的输出值作为预测

    分类问题不关心每个类别实际的值，它主要关心的是正确类别的置信度是否特别大。

    也就是说，正确类别的置信度oy要远远大于非正确类别的置信度oi。这样模型就能保证将正确的类别和不正确的类别拉开距离。

    我们只关心oy与oi的相对大小，因此oy和oi的值无所谓其大小。但是如果能把它们都量化到一个区间（变成概率值），会简化后面的计算。

    通过下图所示的公式可以得到真实类别的概率和预测类别的概率。

    通过比较两个概率的区别可得到损失。这里使用交叉熵损失：

    逐渐使其梯度等于0就可以使得预测的o逐渐靠近真实的y。

    损失函数

    损失函数是衡量预测值与真实值区别的东西。

    1、均方损失

    除以二的作用是与求完导的2抵消。

    蓝色是损失函数曲线，绿色是似然函数，橙线是损失函数的梯度。可以看出当预测值远离原点时，梯度是越来越大的，也就是说更新参数的幅度越来越大；反之，当预测值接近原点时，梯度越来越小，也就是说参数更新的幅度也越来越小。

    这样并不是最好的，因为离原点比较远的时候，我可能并不需要如此大的幅度去更新参数。因此可以考虑：

    2、绝对值损失函数

    蓝色是损失函数的曲线，绿色是似然函数，橙线是损失函数的梯度，它的梯度要么不存在要么是正负一。可以看出这个损失函数弥补了均方损失当离原点远（预测值与真实值隔得比较远时）时梯度大的缺点。绝对值损失函数当预测值与真实值隔得比较远时，它的梯度要么是1要么是-1，永远是常数，对参数的更新是比较稳定的。

    但是它的缺点也很明显就是零点处不可导，正负一跳变巨大，这就表明到了参数优化后期时，会不太稳定。

    为了避免上述两种损失函数的缺点，接下来提出：

    3、哈勃鲁棒损失函数

    蓝色是损失函数的曲线，绿色是似然函数，橙线是损失函数的梯度。这个损失函数的设计思路是：当预测值与真实值相隔较远时，就是绝对值误差；当预测值与真实值相隔较近时，就是平方误差。相当于把前两种损失函数各取一半拼一起了。当然它的导数也就沿袭了前两种损失函数的优点：当预测值与真实值相隔较远时，梯度要么为1要么为-1.很稳定；当预测值与真实值相隔较近时，梯度会慢慢变小，也很稳定。

    实践部分

    一、图像分类数据集的读取及其它操作

    代码：

    1. #《《《《《-----图片分类数据集-----》》》》》
    2. #%matplotlib_inline
    3. #MNIST数据集是图像分类中广泛使用的数据集之一，
    4. #但作为基准数据集过于简单。我们将使用类似但更复杂的Fashion-MNIST数据集
    5. import torch
    6. import torchvision
    7. from torch.utils import data                                    #小批量读取数据
    8. from torchvision import transforms
    9. from d2l import torch as d2l
    10. import matplotlib.pyplot as plt
    11.  
    12. d2l.use_svg_display()                                           #使用svg显示图片会更清晰一些
    13. #通过框架中的内置函数将 Fashion-MNIST 数据集下载并读取到内存中
    14. trans = transforms.ToTensor()#通过totensor实例将图像数据从pil类型变成32位浮点数格式，并除以255使得所有像素的数值在0到1之间
    15. mnist_train = torchvision.datasets.FashionMNIST(root="../data", train=True,#训练数据集
    16.                                                 transform=trans,#得到的是pytorch的tensor，而不是一堆图片
    17.                                                 download=True)#默认从网上下载
    18. mnist_test = torchvision.datasets.FashionMNIST(root="../data", train=False,#测试集，不用训练
    19.                                                transform=trans, download=True)
    20. print(len(mnist_train), len(mnist_test))#60000个训练集，10000个测试集
    21. print(mnist_train[0][0].shape)#第一张图片的形状torch.Size([1, 28, 28])由于是黑白图片，所以第一个参数是1表示白，
    22.                               #长和宽是28
    23. #两个可视化数据集的函数
    24. def get_fashion_mnist_labels(labels):
    25.     """返回Fashion-MNIST数据集的文本标签。"""
    26.     text_labels = [
    27.         't-shirt', 'trouser', 'pullover', 'dress', 'coat', 'sandal', 'shirt',
    28.         'sneaker', 'bag', 'ankle boot']
    29.     return [text_labels[int(i)] for i in labels]
    30.  
    31. def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5):
    32.     """Plot a list of images."""
    33.     figsize = (num_cols * scale, num_rows * scale)
    34.     _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)
    35.     axes = axes.flatten()
    36.     for i, (ax, img) in enumerate(zip(axes, imgs)):
    37.         if torch.is_tensor(img):
    38.             ax.imshow(img.numpy())
    39.             #plt.show()
    40.         else:
    41.             ax.imshow(img)
    42.             #plt.show()
    43.         ax.axes.get_xaxis().set_visible(False)
    44.         ax.axes.get_yaxis().set_visible(False)
    45.         if titles:
    46.             ax.set_title(titles[i])
    47.     return axes
    48. #几个样本的图像及其相应的标签
    49. X, y = next(iter(data.DataLoader(mnist_train, batch_size=18)))
    50. show_images(X.reshape(18, 28, 28), 2, 9, titles=get_fashion_mnist_labels(y))#画两行每行九张图，还要拿到标签
    51. plt.show()
    52. #读取一小批量数据，大小为batch_size
    53. batch_size = 256
    54.  
    55. def get_dataloader_workers():#一般来讲数据是放在硬盘上的，所以可能需要多个进程去将数据读取到内存中。
    56.     """使用4个进程来读取数据。"""
    57.     return 4
    58.  
    59. train_iter = data.DataLoader(mnist_train, batch_size, shuffle=True,
    60.                              num_workers=get_dataloader_workers())
    61.  
    62. '''timer = d2l.Timer()#检测CPU读取一次数据的时间
    63. for X, y in train_iter:
    64.     continue
    65. print(f'{timer.stop():.2f} sec')'''
    66. #定义 load_data_fashion_mnist 函数
    67. def load_data_fashion_mnist(batch_size, resize=None):
    68.     """下载Fashion-MNIST数据集，然后将其加载到内存中。"""
    69.     trans = [transforms.ToTensor()]
    70.     if resize:
    71.         trans.insert(0, transforms.Resize(resize))
    72.     trans = transforms.Compose(trans)
    73.     mnist_train = torchvision.datasets.FashionMNIST(root="../data",
    74.                                                     train=True,
    75.                                                     transform=trans,
    76.                                                     download=True)
    77.     mnist_test = torchvision.datasets.FashionMNIST(root="../data",
    78.                                                    train=False,
    79.                                                    transform=trans,
    80.                                                    download=True)
    81.     return (data.DataLoader(mnist_train, batch_size, shuffle=True,
    82.                             num_workers=get_dataloader_workers()),
    83.             data.DataLoader(mnist_test, batch_size, shuffle=False,
    84.                             num_workers=get_dataloader_workers()))
    85.  
    86. train_iter, test_iter = load_data_fashion_mnist(32, resize=64)
    87. for X, y in train_iter:
    88.     print(X.shape, X.dtype, y.shape, y.dtype)
    89.     break

    二、softmax回归从零开始实现

    代码：

    1. #《《《《《《《《《《《《《从零开始softmax》》》》》》》》》》》》》》》》
    2. import torch
    3. from IPython import display
    4. from d2l import torch as d2l
    5. import matplotlib.pyplot as plt #要自己加，不然出不来图
    6.  
    7. batch_size = 256#每次随机读256张图片
    8. train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)     #返回训练集测试集的迭代器
    9. #将展平每个图像，把它们看作长度为784的向量。 因为我们的数据集有10个类别，所以网络输出维度为 10
    10. num_inputs = 784        #在softmax里需要把图片拉成向量28*28=784
    11. num_outputs = 10        #十类
    12.  
    13. W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)#定义权重，行数是输入个数784，列数是输出个数10
    14. b = torch.zeros(num_outputs, requires_grad=True)        #对每一个输出都要有一个偏移，所有偏移是长为10的向量
    15. #给定一个矩阵X，我们可以对所有元素求和（示例）
    16. '''X = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
    17. X.sum(0, keepdim=True), X.sum(1, keepdim=True)'''
    18. #实现softmax
    19. def softmax(X):
    20.     X_exp = torch.exp(X)
    21.     partition = X_exp.sum(1, keepdim=True)      #对一个矩阵来讲，就是对矩阵的每一行进行softmax
    22.     return X_exp / partition                    #使用广播机制对每一行除partition
    23. #我们将每个元素变成一个非负数。此外，依据概率原理，每行总和为1(验证)
    24. '''X = torch.normal(0, 1, (2, 5))
    25. X_prob = softmax(X)
    26. print(X_prob, X_prob.sum(1))#可见softmax之后，每个元素变成非负，而且每行和为1.'''
    27. #实现softmax回归模型
    28. def net(X):
    29.     return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)#x被reshape成了256*784的矩阵
    30. #创建一个数据y_hat，其中包含2个样本在3个类别的预测概率， 使用y作为y_hat中概率的索引(示例)
    31. '''y = torch.tensor([0, 2])
    32. y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
    33. print(y_hat[[0, 1], y])#它的输出是y_hat0[y[0]],和y_hat1[y[1]]，也就是y_hat0[0],和y_hat1[2]'''
    34. #实现交叉熵损失函数
    35. def cross_entropy(y_hat, y):
    36.     return -torch.log(y_hat[range(len(y_hat)), y])#给定预测和真实标号y后，求出对应的真实标号的预测值，再求log和-
    37.  
    38. #将预测类别与真实 y 元素进行比较
    39. def accuracy(y_hat, y):
    40.     """计算预测正确的数量。"""
    41. #如果y_hat是矩阵，那么假定第二个维度存储每个类的预测分数。 我们使用argmax获得每行中最大元素的索引来获得预测类别。
    42. # 然后我们将预测类别与真实y元素进行比较。 由于等式运算符“==”对数据类型很敏感，因此我们将y_hat的数据类型转换为与y的数据类型一致。
    43. # 结果是一个包含0（错）和1（对）的张量。最后，我们求和会得到正确预测的数量。
    44.     if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
    45.         y_hat = y_hat.argmax(axis=1)
    46.     cmp = y_hat.type(y.dtype) == y
    47.     return float(cmp.type(y.dtype).sum())
    48.  
    49. #我们可以评估在任意模型 net 的准确率
    50. def evaluate_accuracy(net, data_iter):
    51.     """计算在指定数据集上模型的精度。"""
    52.     if isinstance(net, torch.nn.Module):
    53.         net.eval()#转成评估模式，不必计算梯度
    54.     metric = Accumulator(2)#  正确预测数、预测总数
    55.     for X, y in data_iter:
    56.         metric.add(accuracy(net(X), y), y.numel())#将正确预测的数量和总数加入累加器accumulator中
    57.     return metric[0] / metric[1]#分类正确样本数与总的相除
    58. #这里定义一个实用程序类Accumulator，用于对多个变量进行累加。
    59. # 在上面的evaluate_accuracy函数中， 我们在Accumulator实例中创建了2个变量， 分别用于存储正确预测的数量和预测的总数量。
    60. # 当我们遍历数据集时，两者都将随着时间的推移而累加。
    61. class Accumulator:
    62.     """在`n`个变量上累加。"""
    63.     def __init__(self, n):
    64.         self.data = [0.0] * n
    65.  
    66.     def add(self, *args):
    67.         self.data = [a + float(b) for a, b in zip(self.data, args)]
    68.  
    69.     def reset(self):
    70.         self.data = [0.0] * len(self.data)
    71.  
    72.     def __getitem__(self, idx):
    73.         return self.data[idx]
    74.  
    75. #Softmax回归的训练
    76. def train_epoch_ch3(net, train_iter, loss, updater):  #@save
    77.     """训练模型一个迭代周期（定义见第3章）"""
    78.     # 将模型设置为训练模式
    79.     if isinstance(net, torch.nn.Module):
    80.         net.train()
    81.     # 训练损失总和、训练准确度总和、样本数
    82.     metric = Accumulator(3)
    83.     for X, y in train_iter:
    84.         # 计算梯度并更新参数
    85.         y_hat = net(X)
    86.         l = loss(y_hat, y)
    87.         if isinstance(updater, torch.optim.Optimizer):
    88.             # 使用PyTorch内置的优化器和损失函数
    89.             updater.zero_grad()#梯度置零
    90.             l.mean().backward()#计算梯度
    91.             updater.step()#参数更新
    92.         else:
    93.             # 使用定制的优化器和损失函数
    94.             l.sum().backward()
    95.             updater(X.shape[0])
    96.         metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
    97.     # 返回训练损失和训练精度
    98.     return metric[0] / metric[2], metric[1] / metric[2]#损失的累加除以样本数，所有分类正确的除以样本总数
    99. #定义一个在动画中绘制数据的实用程序类，可以实时看到训练过程中的变化，主要是使用matplotlib中的工具画各种东西
    100. class Animator:  #@save
    101.     """在动画中绘制数据"""
    102.     def __init__(self, xlabel=None, ylabel=None, legend=None, xlim=None,
    103.                  ylim=None, xscale='linear', yscale='linear',
    104.                  fmts=('-', 'm--', 'g-.', 'r:'), nrows=1, ncols=1,
    105.                  figsize=(3.5, 2.5)):
    106.         # 增量地绘制多条线
    107.         if legend is None:
    108.             legend = []
    109.         d2l.use_svg_display()
    110.         self.fig, self.axes = d2l.plt.subplots(nrows, ncols, figsize=figsize)
    111.         if nrows * ncols == 1:
    112.             self.axes = [self.axes, ]
    113.         # 使用lambda函数捕获参数
    114.         self.config_axes = lambda: d2l.set_axes(
    115.             self.axes[0], xlabel, ylabel, xlim, ylim, xscale, yscale, legend)
    116.         self.X, self.Y, self.fmts = None, None, fmts
    117.  
    118.     def add(self, x, y):
    119.         # 向图表中添加多个数据点
    120.         if not hasattr(y, "__len__"):
    121.             y = [y]
    122.         n = len(y)
    123.         if not hasattr(x, "__len__"):
    124.             x = [x] * n
    125.         if not self.X:
    126.             self.X = [[] for _ in range(n)]
    127.         if not self.Y:
    128.             self.Y = [[] for _ in range(n)]
    129.         for i, (a, b) in enumerate(zip(x, y)):
    130.             if a is not None and b is not None:
    131.                 self.X[i].append(a)
    132.                 self.Y[i].append(b)
    133.         self.axes[0].cla()
    134.         for x, y, fmt in zip(self.X, self.Y, self.fmts):
    135.             self.axes[0].plot(x, y, fmt)
    136.         self.config_axes()
    137.         display.display(self.fig)
    138.         display.clear_output(wait=True)
    139. #小批量随机梯度下降来优化模型的损失函数
    140. lr = 0.1
    141. def updater(batch_size):
    142.     return d2l.sgd([W, b], lr, batch_size)
    143. #训练函数
    144. #接下来我们实现一个训练函数， 它会在train_iter访问到的训练数据集上训练一个模型net。
    145. #该训练函数将会运行多个迭代周期（由num_epochs指定）。
    146. #在每个迭代周期结束时，利用test_iter访问到的测试数据集对模型进行评估。 我们将利用Animator类来可视化训练进度。
    147. num_epochs = 10
    148. def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
    149.     """训练模型"""
    150.     animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
    151.                         legend=['train loss', 'train acc', 'test acc'])#可视化的一个animator
    152.     for epoch in range(num_epochs):
    153.         train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
    154.         test_acc = evaluate_accuracy(net, test_iter)
    155.         animator.add(epoch + 1, train_metrics + (test_acc,))
    156.     train_loss, train_acc = train_metrics
    157.     assert train_loss < 0.5, train_loss
    158.     assert train_acc <= 1 and train_acc > 0.7, train_acc
    159.     assert test_acc <= 1 and test_acc > 0.7, test_acc
    160. train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)
    161. plt.show()#要自己加，不然出不来图
    162. #对图像进行分类预测
    163. #现在训练已经完成，我们的模型已经准备好对图像进行分类预测。
    164. #给定一系列图像，我们将比较它们的实际标签（文本输出的第一行）和模型预测（文本输出的第二行）。
    165. def predict_ch3(net, test_iter, n=6):
    166.     """预测标签（定义见第3章）。"""
    167.     for X, y in test_iter:
    168.         break
    169.     trues = d2l.get_fashion_mnist_labels(y)
    170.     preds = d2l.get_fashion_mnist_labels(net(X).argmax(axis=1))
    171.     titles = [true + '\n' + pred for true, pred in zip(trues, preds)]
    172.     d2l.show_images(X[0:n].reshape((n, 28, 28)), 1, n, titles=titles[0:n])
    173.     plt.show()#要自己加，不然出不来图
    174. predict_ch3(net,test_iter)

    三、softmax简洁实现

    代码：

    1. import torch
    2. from torch import nn
    3. from d2l import torch as d2l
    4. import matplotlib.pyplot as plt #要自己加，不然出不来图
    5. batch_size = 256
    6. train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
    7. # softmax回归的输出层是一个全连接层。 因此，为了实现我们的模型，
    8. # 我们只需在Sequential中添加一个带有10个输出的全连接层。 同样，在这里Sequential并不是必要的，
    9. # 但它是实现深度模型的基础。
    10. # 我们仍然以均值0和标准差0.01随机初始化权重。
    11. #Softmax 回归的输出层是一个全连接层
    12. # PyTorch不会隐式地调整输入的形状。因此，
    13. # 我们在线性层前定义了展平层（flatten），来调整网络输入的形状
    14. net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))#flatten的作用是把任何维度的tensor变成二维的tensor
    15. # ，第零维度保留，其他维度全部弄成向量
    16. def init_weights(m):#生成随机值的函数，用于初始化
    17.     if type(m) == nn.Linear:
    18.         nn.init.normal_(m.weight, std=0.01)#把weight的均值弄成0（默认），方差0.01的随机值
    19. net.apply(init_weights)#完成初始化
    20. #在交叉熵损失函数中传递未归一化的预测，并同时计算softmax及其对数
    21. loss = nn.CrossEntropyLoss()
    22.  
    23. #使用学习率为0.1的小批量随机梯度下降作为优化算法。我们使用学习率为0.1的小批量随机梯度下降作为优化算法。
    24. # 这与我们在线性回归例子中的相同，这说明了优化器的普适性。
    25. trainer = torch.optim.SGD(net.parameters(), lr=0.1)
    26.  
    27. #调用 之前 定义的训练函数来训练模型
    28. num_epochs = 10
    29. d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)
    30. plt.show()#要自己加，不然出不来图
    31. #和以前一样，这个算法使结果收敛到一个相当高的精度，而且这次的代码比之前更精简了。

    为啥没loss曲线？

    按住Ctrl然后鼠标左键“train_ch3”后，在torch.py里找train_epoch_ch3 这个函数

    要在d2l/torch.py里面改一下 train_epoch_ch3 这个函数 ，如下就可以了
    if isinstance(updater, torch.optim.Optimizer):
    # Using PyTorch in-built optimizer & loss criterion
    updater.zero_grad()
    l.backward()
    updater.step()
    metric.add(
    float(l) * len(y), accuracy(y_hat, y),
    y.size().numel())
    else:
    # Using custom built optimizer & loss criterion
    l.sum().backward()
    updater(X.shape[    0])
    metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())

  • 相关阅读:
    TCP到底有多厉害？
    面试汇总-MySQL-杂项
    Liunx C运算符
    CentOS8中文乱码问题
    微服务远程Debug，Nocalhost + Rainbond微服务开发第二弹
    【Docker】使用Docker Client和Docker Go SDK为容器分配GPU资源
    AUTOSAR C++14 编码指南（上）
    GB/T 26518-2011 高分子增强复合防水片材检测
    多线程---锁策略与CAS
    post更新,put相当于删除重新增一条
  • 原文地址：https://blog.csdn.net/weixin_48304306/article/details/127799243