深度学习笔记5：Softmax 回归 + 损失函数 + 图片分类数据集_softmax回归所用的数据集下载了放哪里

Softmax 回归

回归 vs 分类

• 回归估计一个连续值

• 分类预测一个离散类别

  

  应用：Kaggle上的分类问题

• 将人类蛋白质显微镜图片分成28类

  

• 将恶意软件分成9个类别

  

• 将恶意的Wikipedia评论分成7类

  

从回归到多类分类

回归

• 单连续数值输出

• 自然区间ℝ

• 跟真实值的区别作为损失

  

分类

• 通常多个输出

• 输出i是预测为第i类的置信度（置信度=可信度）

  

从回归到多类分类——均方损失

• 对类别进行一位有效编码

  

• 使用均方损失训练

• 最大值最为预测

  

从回归到多类分类——无校验比例

• 对类别进行一位有效编码

• 最大值最为预测

  

• 需要更置信的识别正确类（大余量）

  

从回归到多类分类——校验比例

• 输出匹配概率（非负，和为1）

  

• 概率y和ŷ的区别作为损失

Softmax和交叉熵损失

• 交叉熵常用来衡量两个概率的区别

  

• 将它作为损失

  

• 其梯度是真实概率和预测概率的区别

  

总结

• Softma回归是一个多类分类模型
• 使用Softmax操作子得到每个类的预测置信度
• 使用交叉熵来衡量预测和标号的区别

损失函数

均方损失函数（L2 Loss）

公式：

图：

蓝色：当y=0时，变化预测值y‘的函数

绿色：似然函数（高斯分布）

橙色：损失函数的梯度（一次函数过原点）

梯度走向：

梯度下降对负梯度方向进行更新参数的，所以导数决定如何更新参数。当预测值y’和真实值y相隔远，梯度比较大，参数更新就比较多，当预测值随着靠近真实值时，靠近原点的时候，梯度绝对值会变的越来越小，参数更新幅度也越来越小。

坏处：离原点比较远的时候，不希望很大的更新参数

绝对值损失函数（L1 Loss）

公式：

图：

蓝色：损失函数的曲线，即当y=0时候的样子

绿色：似然函数（注：尖点）

橙色：损失函数的梯度（当y‘>0，导数为1，当y‘<0，导数为-1；都为常数）

梯度走向：

当预测值和真实值相隔远的话，梯度永远都是常数，参数更新就不会特别大，带来稳定性的好处

坏处：零点处不可导，在零点处有一个正1和负1之间剧烈的变化，不平滑性，当优化到末期在这个地方可能不太稳定

Huber’s Robust Loss（上面两种损失的结合）

公式、图：

梯度走向：

蓝色：损失函数的曲线

绿色：似然函数

橙色：损失函数的梯度（当y‘>1或y‘<-1时，导数为常数，当-1<y‘<1，导数是一个渐变的值）

代码实现

图像分类数据集

MNIST数据集是图像分类中广泛使用的数据集之一，但作为基准数据集过于简单。我们将使用类似但更复杂的Fashion-MNIST数据集

%matplotlib inline
import torch
import torchvision #计算机视觉实现的库
from torch.utils import data
from torchvision import transforms #tranforms对数据进行操作的模具
from d2l import torch as d2l

d2l.use_svg_display() #使用svg显示图片 清晰度高
1
2
3
4
5
6
7
8

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

#通过ToTensor实例将图像数据从PIL类型变换成32位浮点数格式
#并除以255使得所有像素的数值均在0到1之间
trans = transforms.ToTensor() #图片转成tensor
mnist_train = torchvision.datasets.FashionMNIST(
    root="../data", train=True, #下载训练数据集，放在data文件夹下
    transform=trans, #tensor的数据集而不是图片
    download=True) #默认从网上下载
mnist_test = torchvision.datasets.FashionMNIST(
    root="../data", train=False, #下载测试集
    transform=trans, download=True)

len(mnist_train), len(mnist_test)
1
2
3
4
5
6
7
8
9
10
11
12

结果：(60000, 10000)

mnist_train[0][0].shape #第0个样本第一张图片的形状
1

结果：torch.Size([1, 28, 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."""
    #使用matplotlib来画出图片
    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:
            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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

几个样本的图像及其相应的标签

X, y = next(iter(data.DataLoader(mnist_train, batch_size=18))) #next拿到第一批数据量
show_images(X.reshape(18, 28, 28), 2, 9, titles=get_fashion_mnist_labels(y)); #shape是（18，28，28） 分成2行 9列
1
2

结果：

这里分了两次截图，可以将2行9列改成其他数值

读取一小批量数据，大小为batch_size

batch_size = 256

def get_dataloader_workers():  
    """使用4个进程来读取数据。"""
    #根据cpu选择大小
    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'
1
2
3
4
5
6
7
8
9
10
11
12
13
14

结果：‘5.71 sec’

定义 load_data_fashion_mnist 函数 使得之后重用

def load_data_fashion_mnist(batch_size, resize=None):  
    """下载Fashion-MNIST数据集，然后将其加载到内存中。resize:之后使用的模型如果想使图片变大，就可以用resize"""
    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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

结果：torch.Size([32, 1, 64, 64]) torch.float32 torch.Size([32]) torch.int64

softmax回归的从零开始实现

就像我们从零开始实现线性回归一样， 你应该知道实现softmax的细节

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

batch_size = 256 #随机读取256张图片
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size) 
#之前定义如何读取Fashion-MNIST数据集 这里直接调用返回训练集和测试集
1
2
3
4
5
6
7

将展平每个图像，把它们看作长度为784的向量。 因为我们的数据集有10个类别，所以网络输出维度为 10

num_inputs = 784 #28*28=784向量
num_outputs = 10 

W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True) #定义w，形状是（784，10）
b = torch.zeros(num_outputs, requires_grad=True) #偏移b 长为10的向量
1
2
3
4
5

给定一个矩阵X，我们可以对所有元素求和

X = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) #形状（2，3）的矩阵
X.sum(0, keepdim=True), X.sum(1, keepdim=True)
1
2

结果：

(tensor([[5., 7., 9.]]),
tensor([[ 6.],
[15.]]))

实现softmax

def softmax(X):
    X_exp = torch.exp(X) #指数计算
    partition = X_exp.sum(1, keepdim=True) #每一行进行求和
    return X_exp / partition #使用了广播机制 每个元素除以partition
1
2
3
4

我们将每个元素变成一个非负数。此外，依据概率原理，每行总和为1

X = torch.normal(0, 1, (2, 5)) #2行5列 正态分布
X_prob = softmax(X) 
X_prob, X_prob.sum(1) #softmax之后所有值为正且行加起来为1
1
2
3

结果：

(tensor([[0.2191, 0.2060, 0.0295, 0.0664, 0.4790],
[0.4143, 0.1119, 0.1537, 0.0555, 0.2646]]),
tensor([1., 1.]))

实现softmax回归模型

def net(X):
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b) #X形状（256，784）
1
2

创建一个数据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]])
y_hat[[0, 1], y] #对0号样本拿出y[0]所对应的元素，对1号样本拿出y[1]所对应的元素（感觉像是双重索引）
1
2
3

结果：tensor([0.1000, 0.5000])

实现交叉熵损失函数

def cross_entropy(y_hat, y):
    return -torch.log(y_hat[range(len(y_hat)), y]) 

cross_entropy(y_hat, y)
1
2
3
4

结果：tensor([2.3026, 0.6931])

分类问题：将预测类别与真实 y 元素进行比较

#函数表示：找出来预测正确的样本数，再除以y的长度就是预测正确的概率
def accuracy(y_hat, y):  
    """计算预测正确的数量。"""
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1: #y_hat是一个二维矩阵，shape大于1 列数也大于1
        y_hat = y_hat.argmax(axis=1) #每行元素值最大的下标存到y_hat 这是预测分类的类别
    cmp = y_hat.type(y.dtype) == y #y_hat的数据类型转成y的数据类型，然后相比较
    return float(cmp.type(y.dtype).sum()) #将cmp转成y的类型，再求和

accuracy(y_hat, y) / len(y)
1
2
3
4
5
6
7
8
9

结果：0.5

我们可以评估在任意模型 net 的准确率

#函数表示：给出一个模型和数据迭代器，计算模型在数据集上的精度
def evaluate_accuracy(net, data_iter):  
    """计算在指定数据集上模型的精度。"""
    if isinstance(net, torch.nn.Module): #如果是一个torch.nn模型
        net.eval() #将模型设置为评估模式
    metric = Accumulator(2) #正确预测数、预测总数
    for X, y in data_iter: #每次拿到的批量
        metric.add(accuracy(net(X), y), y.numel()) 
    return metric[0] / metric[1]
1
2
3
4
5
6
7
8
9

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]

evaluate_accuracy(net, test_iter)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结果：0.0905

Softmax回归的训练

def train_epoch_ch3(net, train_iter, loss, updater):  
    """训练模型一个迭代周期（定义见第3章）。"""
    if isinstance(net, torch.nn.Module): #如果是nn模具
        net.train() #开启训练模式
    metric = Accumulator(3) #长度为3的迭代器 来累积需要信息
    for X, y in train_iter: #扫描数据
        y_hat = net(X) #计算y_hat
        l = loss(y_hat, y) #损失函数计算l 
        if isinstance(updater, torch.optim.Optimizer):  #如果updater是pytorch的一个买者
            updater.zero_grad() #梯度设为0
            l.backward() #计算梯度
            updater.step() #更新参数
            metric.add( #样本数 累加数 正确的分类数 放到累加器里面
                float(l) * len(y), accuracy(y_hat, y), 
                y.size().numel())
        else:  #如果从头开始实现
            l.sum().backward() #l是一个向量 求和算梯度
            updater(X.shape[0]) 
            metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
    return metric[0] / metric[2], metric[1] / metric[2] 
#返回结果：损失/样本总数，所有分类正确的样本数/ 总样本数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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

class Animator:  
    """在动画中绘制数据。"""
    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,]
        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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

训练函数

def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):  
    """训练模型（定义见第3章）。"""
    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): #扫描n遍数据
        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
1
2
3
4
5
6
7
8
9
10
11
12

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

lr = 0.1

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

训练模型10个迭代周期 （开始训练）

num_epochs = 10
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)
#蓝色：训练损失 红色：训练数据集上的精度 绿色：测试上的精度（关注）
1
2
3

结果：

对图像进行分类预测

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

predict_ch3(net, test_iter)
d2l.plt.show()
1
2
3
4
5
6
7
8
9
10
11

结果：

softmax回归的简洁实现

通过深度学习框架的高级API能够使实现 softmax 回归变得更加容易

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)
1
2
3
4
5
6

Softmax 回归的输出层是一个全连接层

#pytorch不会隐式地调整输入的形状
#因此，我们定义了展平层（flatten）在线性层前调整网络输入的形状
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10)) #sequential构造器里面

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights);
1
2
3
4
5
6
7
8
9

在交叉熵损失函数中传递未归一化的预测，并同时计算softmax及其对数

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

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

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

调用 之前 定义的训练函数来训练模型

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

结果：