pytorch深度学习实战lesson10

理论部分

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.很稳定；当预测值与真实值相隔较近时，梯度会慢慢变小，也很稳定。

实践部分

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

代码：

#《《《《《-----图片分类数据集-----》》》》》
#%matplotlib_inline
#MNIST数据集是图像分类中广泛使用的数据集之一，
#但作为基准数据集过于简单。我们将使用类似但更复杂的Fashion-MNIST数据集
import torch
import torchvision
from torch.utils import data                                    #小批量读取数据
from torchvision import transforms
from d2l import torch as d2l
import matplotlib.pyplot as plt

d2l.use_svg_display()                                           #使用svg显示图片会更清晰一些
#通过框架中的内置函数将 Fashion-MNIST 数据集下载并读取到内存中
trans = transforms.ToTensor()#通过totensor实例将图像数据从pil类型变成32位浮点数格式，并除以255使得所有像素的数值在0到1之间
mnist_train = torchvision.datasets.FashionMNIST(root="../data", train=True,#训练数据集
                                                transform=trans,#得到的是pytorch的tensor，而不是一堆图片
                                                download=True)#默认从网上下载
mnist_test = torchvision.datasets.FashionMNIST(root="../data", train=False,#测试集，不用训练
                                               transform=trans, download=True)
print(len(mnist_train), len(mnist_test))#60000个训练集，10000个测试集
print(mnist_train[0][0].shape)#第一张图片的形状torch.Size([1, 28, 28])由于是黑白图片，所以第一个参数是1表示白，
                              #长和宽是28
#两个可视化数据集的函数
def get_fashion_mnist_labels(labels):
    """返回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):
    """Plot a list of images."""
    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())
            #plt.show()
        else:
            ax.imshow(img)
            #plt.show()
        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))#画两行每行九张图，还要拿到标签
plt.show()
#读取一小批量数据，大小为batch_size
batch_size = 256

def get_dataloader_workers():#一般来讲数据是放在硬盘上的，所以可能需要多个进程去将数据读取到内存中。
    """使用4个进程来读取数据。"""
    return 4

train_iter = data.DataLoader(mnist_train, batch_size, shuffle=True,
                             num_workers=get_dataloader_workers())

'''timer = d2l.Timer()#检测CPU读取一次数据的时间
for X, y in train_iter:
    continue
print(f'{timer.stop():.2f} sec')'''
#定义 load_data_fashion_mnist 函数
def load_data_fashion_mnist(batch_size, resize=None):
    """下载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回归从零开始实现

代码：

#《《《《《《《《《《《《《从零开始softmax》》》》》》》》》》》》》》》》
import torch
from IPython import display
from d2l import torch as d2l
import matplotlib.pyplot as plt #要自己加，不然出不来图

batch_size = 256#每次随机读256张图片
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)     #返回训练集测试集的迭代器
#将展平每个图像，把它们看作长度为784的向量。 因为我们的数据集有10个类别，所以网络输出维度为 10
num_inputs = 784        #在softmax里需要把图片拉成向量28*28=784
num_outputs = 10        #十类

W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)#定义权重，行数是输入个数784，列数是输出个数10
b = torch.zeros(num_outputs, requires_grad=True)        #对每一个输出都要有一个偏移，所有偏移是长为10的向量
#给定一个矩阵X，我们可以对所有元素求和（示例）
'''X = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
X.sum(0, keepdim=True), X.sum(1, keepdim=True)'''
#实现softmax
def softmax(X):
    X_exp = torch.exp(X)
    partition = X_exp.sum(1, keepdim=True)      #对一个矩阵来讲，就是对矩阵的每一行进行softmax
    return X_exp / partition                    #使用广播机制对每一行除partition
#我们将每个元素变成一个非负数。此外，依据概率原理，每行总和为1(验证)
'''X = torch.normal(0, 1, (2, 5))
X_prob = softmax(X)
print(X_prob, X_prob.sum(1))#可见softmax之后，每个元素变成非负，而且每行和为1.'''
#实现softmax回归模型
def net(X):
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)#x被reshape成了256*784的矩阵
#创建一个数据y_hat，其中包含2个样本在3个类别的预测概率， 使用y作为y_hat中概率的索引(示例)
'''y = torch.tensor([0, 2])
y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
print(y_hat[[0, 1], y])#它的输出是y_hat0[y[0]],和y_hat1[y[1]]，也就是y_hat0[0],和y_hat1[2]'''
#实现交叉熵损失函数
def cross_entropy(y_hat, y):
    return -torch.log(y_hat[range(len(y_hat)), y])#给定预测和真实标号y后，求出对应的真实标号的预测值，再求log和-

#将预测类别与真实 y 元素进行比较
def accuracy(y_hat, y):
    """计算预测正确的数量。"""
#如果y_hat是矩阵，那么假定第二个维度存储每个类的预测分数。 我们使用argmax获得每行中最大元素的索引来获得预测类别。
# 然后我们将预测类别与真实y元素进行比较。 由于等式运算符“==”对数据类型很敏感，因此我们将y_hat的数据类型转换为与y的数据类型一致。
# 结果是一个包含0（错）和1（对）的张量。最后，我们求和会得到正确预测的数量。
    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())

#我们可以评估在任意模型 net 的准确率
def evaluate_accuracy(net, data_iter):
    """计算在指定数据集上模型的精度。"""
    if isinstance(net, torch.nn.Module):
        net.eval()#转成评估模式，不必计算梯度
    metric = Accumulator(2)#  正确预测数、预测总数
    for X, y in data_iter:
        metric.add(accuracy(net(X), y), y.numel())#将正确预测的数量和总数加入累加器accumulator中
    return metric[0] / metric[1]#分类正确样本数与总的相除
#这里定义一个实用程序类Accumulator，用于对多个变量进行累加。
# 在上面的evaluate_accuracy函数中， 我们在Accumulator实例中创建了2个变量， 分别用于存储正确预测的数量和预测的总数量。
# 当我们遍历数据集时，两者都将随着时间的推移而累加。
class Accumulator:
    """在`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]

#Softmax回归的训练
def train_epoch_ch3(net, train_iter, loss, updater):  #@save
    """训练模型一个迭代周期（定义见第3章）"""
    # 将模型设置为训练模式
    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]#损失的累加除以样本数，所有分类正确的除以样本总数
#定义一个在动画中绘制数据的实用程序类，可以实时看到训练过程中的变化，主要是使用matplotlib中的工具画各种东西
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)
#小批量随机梯度下降来优化模型的损失函数
lr = 0.1
def updater(batch_size):
    return d2l.sgd([W, b], lr, batch_size)
#训练函数
#接下来我们实现一个训练函数， 它会在train_iter访问到的训练数据集上训练一个模型net。
#该训练函数将会运行多个迭代周期（由num_epochs指定）。
#在每个迭代周期结束时，利用test_iter访问到的测试数据集对模型进行评估。 我们将利用Animator类来可视化训练进度。
num_epochs = 10
def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
    """训练模型"""
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
                        legend=['train loss', 'train acc', 'test acc'])#可视化的一个animator
    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
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)
plt.show()#要自己加，不然出不来图
#对图像进行分类预测
#现在训练已经完成，我们的模型已经准备好对图像进行分类预测。
#给定一系列图像，我们将比较它们的实际标签（文本输出的第一行）和模型预测（文本输出的第二行）。
def predict_ch3(net, test_iter, n=6):
    """预测标签（定义见第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])
    plt.show()#要自己加，不然出不来图
predict_ch3(net,test_iter)

三、softmax简洁实现

代码：

import torch
from torch import nn
from d2l import torch as d2l
import matplotlib.pyplot as plt #要自己加，不然出不来图
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
# softmax回归的输出层是一个全连接层。 因此，为了实现我们的模型，
# 我们只需在Sequential中添加一个带有10个输出的全连接层。 同样，在这里Sequential并不是必要的，
# 但它是实现深度模型的基础。
# 我们仍然以均值0和标准差0.01随机初始化权重。
#Softmax 回归的输出层是一个全连接层
# PyTorch不会隐式地调整输入的形状。因此，
# 我们在线性层前定义了展平层（flatten），来调整网络输入的形状
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))#flatten的作用是把任何维度的tensor变成二维的tensor
# ，第零维度保留，其他维度全部弄成向量
def init_weights(m):#生成随机值的函数，用于初始化
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)#把weight的均值弄成0（默认），方差0.01的随机值
net.apply(init_weights)#完成初始化
#在交叉熵损失函数中传递未归一化的预测，并同时计算softmax及其对数
loss = nn.CrossEntropyLoss()

#使用学习率为0.1的小批量随机梯度下降作为优化算法。我们使用学习率为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)
plt.show()#要自己加，不然出不来图
#和以前一样，这个算法使结果收敛到一个相当高的精度，而且这次的代码比之前更精简了。

为啥没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())