AI Studio 飞桨零基础入门深度学习笔记6.5-手写数字识别之损失函数概述分类任务的损失函数

71 阅读 0 评论 47 点赞

我是靠谱客的博主无私夕阳，最近开发中收集的这篇文章主要介绍AI Studio 飞桨零基础入门深度学习笔记6.5-手写数字识别之损失函数概述分类任务的损失函数，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

AI Studio 飞桨零基础入门深度学习笔记6.5-手写数字识别之损失函数

概述
分类任务的损失函数
- Softmax函数
- 交叉熵
- 交叉熵的代码实现

概述

上一节我们尝试通过更复杂的模型（经典的全连接神经网络和卷积神经网络），提升手写数字识别模型训练的准确性。本节我们继续将“横纵式”教学法从横向展开，如图1 所示，探讨损失函数的优化对模型训练效果的影响。

图1：“横纵式”教学法 — 损失函数优化

损失函数是模型优化的目标，用于在众多的参数取值中，识别最理想的取值。损失函数的计算在训练过程的代码中，每一轮模型训练的过程都相同，分如下三步：

先根据输入数据正向计算预测输出。
再根据预测值和真实值计算损失。
最后根据损失反向传播梯度并更新参数。

分类任务的损失函数

在之前的方案中，我们复用了房价预测模型的损失函数-均方误差。从预测效果来看，虽然损失不断下降，模型的预测值逐渐逼近真实值，但模型的最终效果不够理想。究其根本，不同的深度学习任务需要有各自适宜的损失函数。我们以房价预测和手写数字识别两个任务为例，详细剖析其中的缘由如下：

房价预测是回归任务，而手写数字识别是分类任务，使用均方误差作为分类任务的损失函数存在逻辑和效果上的缺欠。
房价可以是大于0的任何浮点数，而手写数字识别的输出只可能是0-9之间的10个整数，相当于一种标签。
在房价预测的案例中，由于房价本身是一个连续的实数值，因此以模型输出的数值和真实房价差距作为损失函数（loss）是符合道理的。但对于分类问题，真实结果是分类标签，而模型输出是实数值，导致以两者相减作为损失不具备物理含义。

那么，什么是分类任务的合理输出呢？分类任务本质上是“某种特征组合下的分类概率”，下面以一个简单案例说明，如图2 所示。

图2：观测数据和背后规律之间的关系

在本案例中，医生根据肿瘤大小 $x$ 作为肿瘤性质 $y$ 的参考判断（判断的因素有很多，肿瘤大小只是其中之一），那么我们观测到该模型判断的结果是 $x$ 和 $y$ 的标签（1为恶性，0为良性）。而这个数据背后的规律是不同大小的肿瘤，属于恶性肿瘤的概率。观测数据是真实规律抽样下的结果，分类模型应该拟合这个真实规律，输出属于该分类标签的概率。

Softmax函数

如果模型能输出10个标签的概率，对应真实标签的概率输出尽可能接近100%，而其他标签的概率输出尽可能接近0%，且所有输出概率之和为1。这是一种更合理的假设！与此对应，真实的标签值可以转变成一个10维度的one-hot向量，在对应数字的位置上为1，其余位置为0，比如标签“6”可以转变成[0,0,0,0,0,0,1,0,0,0]。

为了实现上述思路，需要引入Softmax函数，它可以将原始输出转变成对应标签的概率，公式如下，其中 $C$ 是标签类别个数。

$softmax(x_i) = frac {e^{x_i}}{sum_{j=0}^N{e^x_j}}, i=0, ..., C-1$

从公式的形式可见，每个输出的范围均在0~1之间，且所有输出之和等于1，这是变换后可被解释成概率的基本前提。对应到代码上，我们需要在网络定义部分修改输出层：self.fc = Linear(input_dim=10, output_dim=1, act='softmax')，即是对全连接层的输出加一个softmax运算。

图3 是一个三个标签的分类模型（三分类）使用的softmax输出层，从中可见原始输出的三个数字3、1、-3，经过softmax层后转变成加和为1的三个概率值0.88、0.12、0。

图3：网络输出层为softmax函数

上文解释了为何让分类模型的输出拟合概率的原因，但为何偏偏用softmax函数完成这个职能？下面以二分类问题（只输出两个标签）进行探讨。

对于二分类问题，使用两个输出接入softmax作为输出层，等价于使用单一输出接入Sigmoid函数。如图4 所示，利用两个标签的输出概率之和为1的条件，softmax输出0.6和0.4两个标签概率，从数学上等价于输出一个标签的概率0.6。

图4：对于二分类问题，等价于单一输出接入Sigmoid函数

在这种情况下，只有一层的模型为 $S(w^{T}x_i)$ ， $S$ 为Sigmoid函数。模型预测为1的概率为 $S(w^{T}x_i)$ ，模型预测为0的概率为 $1-S(w^{T}x_i)$ 。

图5 是肿瘤大小和肿瘤性质的数据图。从图中可发现，往往尺寸越大的肿瘤几乎全部是恶性，尺寸极小的肿瘤几乎全部是良性。只有在中间区域，肿瘤的恶性概率会从0逐渐到1（绿色区域），这种数据的分布是符合多数现实问题的规律。如果我们直接线性拟合，相当于红色的直线，会发现直线的纵轴0-1的区域会拉的很长，而我们期望拟合曲线0-1的区域与真实的分类边界区域重合。那么，观察下Sigmoid的曲线趋势可以满足我们对这个问题的一切期望，它的概率变化会集中在一个边界区域，有助于模型提升边界区域的分辨率。

图5：使用sigmoid拟合输出可提高分类模型对边界的分辨率

这就类似于公共区域使用的带有恒温装置的热水器温度阀门，如图6 所示。由于人体适应的水温在34度-42度之间，我们更期望阀门的水温条件集中在这个区域，而不是在0-100度之间线性分布。

图6：热水器水温控制

交叉熵

在模型输出为分类标签的概率时，直接以标签和概率做比较也不够合理，人们更习惯使用交叉熵误差作为分类问题的损失衡量。

交叉熵损失函数的设计是基于最大似然思想：最大概率得到观察结果的假设是真的。如何理解呢？举个例子来说，如图7 所示。有两个外形相同的盒子，甲盒中有99个白球，1个蓝球；乙盒中有99个蓝球，1个白球。一次试验取出了一个蓝球，请问这个球应该是从哪个盒子中取出的？

图7：体会最大似然的思想

相信大家简单思考后均会得出更可能是从乙盒中取出的，因为从乙盒中取出一个蓝球的概率更高 $(P (D ∣ h))$ ，所以观察到一个蓝球更可能是从乙盒中取出的 $(P (h ∣ D))$ 。 $D$ 是观测的数据，即蓝球白球； $h$ 是模型，即甲盒乙盒。这就是贝叶斯公式所表达的思想：

$P (h ∣ D) \propto P (h) \cdot P (D ∣ h)$

依据贝叶斯公式，某二分类模型“生成” $n$ 个训练样本的概率：

$P(x_1)cdot S(w^{T}x_1)cdot P(x_2)cdot(1-S(w^{T}x_2))cdot … cdot P(x_n)cdot S(w^{T}x_n)$

说明：

对于二分类问题，模型为 $S(w^{T}x_i)$ ， $S$ 为Sigmoid函数。当 $y_i$ =1，概率为 $S(w^{T}x_i)$ ；当 $y_i$ =0，概率为 $1-S(w^{T}x_i)$ 。

经过公式推导，使得上述概率最大等价于最小化交叉熵，得到交叉熵的损失函数。交叉熵的公式如下：

$-[sum_{k=1}^{n} t_klog y_k +(1- t_k)log(1-y_k)]$

其中， $lo g$ 表示以 $e$ 为底数的自然对数。 $y_k$ 代表模型输出， $t_k$ 代表各个标签。 $t_k$ 中只有正确解的标签为1，其余均为0（one-hot表示）。

因此，交叉熵只计算对应着“正确解”标签的输出的自然对数。比如，假设正确标签的索引是“2”，与之对应的神经网络的输出是0.6，则交叉熵误差是 $- lo g 0.6 = 0.51$ ；若“2”对应的输出是0.1，则交叉熵误差为 $- lo g 0.1 = 2.30$ 。由此可见，交叉熵误差的值是由正确标签所对应的输出结果决定的。

自然对数的函数曲线可由如下代码实现。

?jtplot.style()

Object `jtplot.style()` not found.

from jupyterthemes import jtplot
jtplot.style(ticks=True,grid=False, theme='onedork') #选择一个绘图主题
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0.01,1,0.01)
y = np.log(x)
plt.title("y=log(x)") 
plt.xlabel("x") 
plt.ylabel("y") 
plt.plot(x,y)
plt.show()
plt.figure()

)]

<Figure size 460.8x403.2 with 0 Axes>




<Figure size 460.8x403.2 with 0 Axes>

如自然对数的图形所示，当 $x$ 等于1时， $y$ 为0；随着 $x$ 向0靠近， $y$ 逐渐变小。因此，“正确解”标签对应的输出越大，交叉熵的值越接近0；当输出为1时，交叉熵误差为0。反之，如果“正确解”标签对应的输出越小，则交叉熵的值越大。

交叉熵的代码实现

在手写数字识别任务中，仅改动三行代码，就可以将在现有模型的损失函数替换成交叉熵（cross_entropy）。

在读取数据部分，将标签的类型设置成int，体现它是一个标签而不是实数值（飞桨默认将标签处理成“int64”）。
在网络定义部分，将输出层改成“输出十个标签的概率”的模式。
在训练过程部分，将损失函数从均方误差换成交叉熵。

在数据处理部分，需要修改标签变量Label的格式，代码如下所示。

从：label = np.reshape(labels[i], [1]).astype(‘float32’)
到：label = np.reshape(labels[i], [1]).astype(‘int64’)

#修改标签数据的格式，从float32到int64
import os
import random
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
import numpy as np
from PIL import Image

import gzip
import json

# 定义数据集读取器
def load_data(mode='train'):

    # 数据文件
    datafile = './work/mnist.json.gz'
    print('loading mnist dataset from {} ......'.format(datafile))
    data = json.load(gzip.open(datafile))
    train_set, val_set, eval_set = data

    # 数据集相关参数，图片高度IMG_ROWS, 图片宽度IMG_COLS
    IMG_ROWS = 28
    IMG_COLS = 28

    if mode == 'train':
        imgs = train_set[0]
        labels = train_set[1]
    elif mode == 'valid':
        imgs = val_set[0]
        labels = val_set[1]
    elif mode == 'eval':
        imgs = eval_set[0]
        labels = eval_set[1]

    imgs_length = len(imgs)

    assert len(imgs) == len(labels), 
          "length of train_imgs({}) should be the same as train_labels({})".format(
                  len(imgs), len(labels))

    index_list = list(range(imgs_length))

    # 读入数据时用到的batchsize
    BATCHSIZE = 100

    # 定义数据生成器
    def data_generator():
        if mode == 'train':
            random.shuffle(index_list)
        imgs_list = []
        labels_list = []
        for i in index_list:
            img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
            label = np.reshape(labels[i], [1]).astype('int64')
            imgs_list.append(img) 
            labels_list.append(label)
            if len(imgs_list) == BATCHSIZE:
                yield np.array(imgs_list), np.array(labels_list)
                imgs_list = []
                labels_list = []

        # 如果剩余数据的数目小于BATCHSIZE，
        # 则剩余数据一起构成一个大小为len(imgs_list)的mini-batch
        if len(imgs_list) > 0:
            yield np.array(imgs_list), np.array(labels_list)

    return data_generator

在网络定义部分，需要修改输出层结构，代码如下所示。

从：self.fc = Linear(input_dim=980, output_dim=1, act=None)
到：self.fc = Linear(input_dim=980, output_dim=10, act=‘softmax’)

# 定义模型结构
class MNIST(fluid.dygraph.Layer):
     def __init__(self):
         super(MNIST, self).__init__()
         
         # 定义一个卷积层，使用relu激活函数
         self.conv1 = Conv2D(num_channels=1, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
         # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
         self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
         # 定义一个卷积层，使用relu激活函数
         self.conv2 = Conv2D(num_channels=20, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
         # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
         self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
         # 定义一个全连接层，输出节点数为10 
         self.fc = Linear(input_dim=980, output_dim=10, act='softmax')
    # 定义网络的前向计算过程
     def forward(self, inputs):
         x = self.conv1(inputs)
         x = self.pool1(x)
         x = self.conv2(x)
         x = self.pool2(x)
         x = fluid.layers.reshape(x, [x.shape[0], 980])
         x = self.fc(x)
         return x

修改计算损失的函数，从均方误差（常用于回归问题）到交叉熵误差（常用于分类问题），代码如下所示。

从：loss = fluid.layers.square_error_cost(predict, label)
到：loss = fluid.layers.cross_entropy(predict, label)

#仅修改计算损失的函数，从均方误差（常用于回归问题）到交叉熵误差（常用于分类问题）
with fluid.dygraph.guard():
    model = MNIST()
    model.train()
    #调用加载数据的函数
    train_loader = load_data('train')
    optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01, parameter_list=model.parameters())
    EPOCH_NUM = 5
    for epoch_id in range(EPOCH_NUM):
        for batch_id, data in enumerate(train_loader()):
            #准备数据，变得更加简洁
            image_data, label_data = data
            image = fluid.dygraph.to_variable(image_data)
            label = fluid.dygraph.to_variable(label_data)
            
            #前向计算的过程
            predict = model(image)
            
            #计算损失，使用交叉熵损失函数，取一个批次样本损失的平均值
            loss = fluid.layers.cross_entropy(predict, label)
            avg_loss = fluid.layers.mean(loss)
            
            #每训练了200批次的数据，打印下当前Loss的情况
            if batch_id % 200 == 0:
                print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))
            
            #后向传播，更新参数的过程
            avg_loss.backward()
            optimizer.minimize(avg_loss)
            model.clear_gradients()

    #保存模型参数
    fluid.save_dygraph(model.state_dict(), 'mnist')

loading mnist dataset from ./work/mnist.json.gz ......
epoch: 0, batch: 0, loss is: [2.3634984]
epoch: 0, batch: 200, loss is: [0.38027003]
epoch: 0, batch: 400, loss is: [0.30602008]
epoch: 1, batch: 0, loss is: [0.1570825]
epoch: 1, batch: 200, loss is: [0.24927774]
epoch: 1, batch: 400, loss is: [0.28396288]
epoch: 2, batch: 0, loss is: [0.11362638]
epoch: 2, batch: 200, loss is: [0.24342634]
epoch: 2, batch: 400, loss is: [0.10399125]
epoch: 3, batch: 0, loss is: [0.15782693]
epoch: 3, batch: 200, loss is: [0.20173627]
epoch: 3, batch: 400, loss is: [0.18618341]
epoch: 4, batch: 0, loss is: [0.13703655]
epoch: 4, batch: 200, loss is: [0.11431722]
epoch: 4, batch: 400, loss is: [0.09789195]

虽然上述训练过程的损失明显比使用均方误差算法要小，但因为损失函数量纲的变化，我们无法从比较两个不同的Loss得出谁更加优秀。怎么解决这个问题呢？我们可以回归到问题的本质，谁的分类准确率更高来判断。在后面介绍完计算准确率和作图的内容后，读者可以自行测试采用不同损失函数下，模型准确率的高低。

至此，大家阅读论文中常见的一些分类任务模型图就清晰明了，如全连接神经网络、卷积神经网络，在模型的最后阶段，都是使用Softmax进行处理。

图8：常见的分类任务模型图

由于我们修改了模型的输出格式，因此使用模型做预测时的代码也需要做相应的调整。从模型输出10个标签的概率中选择最大的，将其标签编号输出。

# 读取一张本地的样例图片，转变成模型输入的格式
def load_image(img_path):
    # 从img_path中读取图像，并转为灰度图
    im = Image.open(img_path).convert('L')
    im.show()
    im = im.resize((28, 28), Image.ANTIALIAS)
    im = np.array(im).reshape(1, 1, 28, 28).astype(np.float32)
    # 图像归一化
    im = 1.0 - im / 255.
    return im

# 定义预测过程
with fluid.dygraph.guard():
    model = MNIST()
    params_file_path = 'mnist'
    img_path = './work/example_0.jpg'
    # 加载模型参数
    model_dict, _ = fluid.load_dygraph("mnist")
    model.load_dict(model_dict)
    
    model.eval()
    tensor_img = load_image(img_path)
    #模型反馈10个分类标签的对应概率
    results = model(fluid.dygraph.to_variable(tensor_img))
    #取概率最大的标签作为预测输出
    lab = np.argsort(results.numpy())
    print("本次预测的数字是: ", lab[0][-1])