本文使用六步法分别实现LeNet（1998）、AlexNet（2012）、VGGNet（2014）、InceptionNet（2014）、ResNet（2015）
除了卷积网络的“开篇之作”LeNet 以外，AlexNet、VGGNet、InceptionNet 以及 ResNet 这四种经典网络全部是在当年的 ImageNet 竞赛中问世的，它们作为深度学习的经典代表，使得 ImageNet 数据集上的错误率逐年降低。

LeNet

LeNet 即 LeNet5，由 Yann LeCun 在 1998 年提出，做为最早的卷积神经网络之一，是许多神经网络架构的起点。

通过共享卷积核减少网络参数。在统计卷积神经网络层数时，一般只统计卷积计算层和全连接计算层，其余操作可视为卷积的附属。LeNet共有5层卷积，两层卷积，三层连续的全连接。

模型构建：

C（6个5*5的卷积核，步长为1，不使用全零填充‘valid’）
B（不使用批标准化None）
A（使用Sigmoid激活函数）
P（使用最大池化max，池化核2*2，步长为2，不使用全零填充‘valid’）
D（None）

C（6个5*5的卷积核，步长为1，不使用全零填充‘valid’）
B（不使用批标准化None）
A（使用Sigmoid激活函数）
P（使用最大池化max，池化核2*2，步长为2，不使用全零填充‘valid’）
D（None）

Flatten（把卷积送过来的数据拉直）
Dense（神经元：120，激活函数：sigmoid）
Dense（神经元：84，激活函数：sigmoid）
Dense（神经元：10，激活函数：softmax）

LeNet源码

class LeNet5(Model):
    def __init__(self):
        super(LeNet5, self).__init__()
        self.c1 = Conv2D(filters=6, kernel_size=(5, 5),
                         activation='sigmoid')
        self.p1 = MaxPool2D(pool_size=(2, 2), strides=2)

        self.c2 = Conv2D(filters=16, kernel_size=(5, 5),
                         activation='sigmoid')
        self.p2 = MaxPool2D(pool_size=(2, 2), strides=2)

        self.flatten = Flatten()
        self.f1 = Dense(120, activation='sigmoid')
        self.f2 = Dense(84, activation='sigmoid')
        self.f3 = Dense(10, activation='softmax')

与最初的 LeNet5 网络结构相比，输入图像尺寸为 32 * 32 * 3，以适应 cifar10 数据集。模型中采用的激活函数有 sigmoid 和 softmax，池化层均采用最大池化，以保留边缘特征。

总体上看，诞生于 1998 年的 LeNet5 与如今一些主流的 CNN 网络相比，其结构相当简单，不过它成功地利用“卷积提取特征→全连接分类”的经典思路解决了手写数字识别的问题，对神经网络研究的发展有着很重要的意义。

AlexNet

AlexNet 的总体结构和 LeNet5 有相似之处。改进之处在于AlexNet共有8层，由五层卷积、三层全连接组成，输入图像尺寸为 224 * 224 * 3，网络规模远大于 LeNet5；使用 Relu 激活函数；进行了舍弃（Dropout）操作，以防止模型过拟合，提升鲁棒性；增加了一些训练上的技巧，包括数据增强、学习率衰减、权重衰减（L2 正则化）等。

AlexNet 的网络结构如图所示：

在 Tensorflow 框架下利用 Keras 来搭建 AlexNet 模型，这里做了一些调整，将输入图像尺寸改为 32 * 32 * 3 以适应 cifar10 数据集，并且将原始的 AlexNet 模型中的 11 * 11、7 * 7、5 * 5 等大尺寸卷积核均替换成了 3 * 3 的小卷积核。

Keras 实现 AlexNet 模型：

C（96个3*3的卷积核，步长为1，不使用全零填充‘valid’）
B（不使用批标准化Yes，‘LRN’）
A（使用rule激活函数）
P（使用最大池化max，池化核3*3，步长为2）
D（None）

C（256*3*3，步长为1，不使用全零填充‘valid’）
B（Yes，‘LRN’）
A（使用Relu激活函数）
P（max，3*3，步长为2）
D（None）

C（384*3*3，步长为1，全零填充‘same’）
B（None）
A（Relu）
P（None）
D（None）

C（384*3*3，步长为1，全零填充‘same’）
B（None）
A（Relu）
P（None）
D（None）

C（256*3*3，步长为1，全零填充‘same’）
B（None）
A（Relu）
P（max，核3*3，步长为2）
D（None）

Flatten
Dense（神经元：2048，激活函数：rule，Dropout：0.5）
Dense（神经元：2048，激活函数：rule，Dropout：0.5）
Dense（神经元：10，激活函数：softmax）

AlexNet源码

class AlexNet8(Model):
    def __init__(self):
        super(AlexNet8, self).__init__()
        self.c1 = Conv2D(filters=96, kernel_size=(3, 3))
        self.b1 = BatchNormalization()
        self.a1 = Activation('relu')
        self.p1 = MaxPool2D(pool_size=(3, 3), strides=2)

        self.c2 = Conv2D(filters=256, kernel_size=(3, 3))
        self.b2 = BatchNormalization()
        self.a2 = Activation('relu')
        self.p2 = MaxPool2D(pool_size=(3, 3), strides=2)

        self.c3 = Conv2D(filters=384, kernel_size=(3, 3), padding='same',
                         activation='relu')
                         
        self.c4 = Conv2D(filters=384, kernel_size=(3, 3), padding='same',
                         activation='relu')
                         
        self.c5 = Conv2D(filters=256, kernel_size=(3, 3), padding='same',
                         activation='relu')
        self.p3 = MaxPool2D(pool_size=(3, 3), strides=2)

        self.flatten = Flatten()
        self.f1 = Dense(2048, activation='relu')
        self.d1 = Dropout(0.5)
        self.f2 = Dense(2048, activation='relu')
        self.d2 = Dropout(0.5)
        self.f3 = Dense(10, activation='softmax')

VGGNet

在 AlexNet 之后，另一个性能提升较大的网络是诞生于 2014 年的 VGGNet，其 ImageNet Top5 错误率减小到了 7.3 %。

VGGNet 网络的最大改进是在网络的深度上，由 AlexNet 的 8 层增加到了 16 层和 19 层，更深的网络意味着更强的表达能力，这得益于强大的运算能力支持。VGGNet 的另一个显著特点是仅使用了单一尺寸的 3 * 3 卷积核，事实上，3 * 3 的小卷积核在很多卷积网络中都被大量使用，这是由于在感受野相同的情况下，小卷积核堆积的效果要优于大卷积核，同时参数量也更少。VGGNet 就使用了 3 * 3 的卷积核替代了 AlexNet 中的大卷积核（11 * 11、7 * 7、5 * 5），取得了较好的效果（事实上课程中利用 Keras 实现 AlexNet 时已经采取了这种方式）。

VGGNet16 和 VGGNet19 并没有本质上的区别，只是网络深度不同，前者 16 层（13 层卷积、3 层全连接），后者 19 层（16 层卷积、3 层全连接）。

根据特征图尺寸的变化，可以将 VGG16 模型分为六个部分（在 VGG16 中，每进行一次池化操作，特征图的边长缩小为 1/2，其余操作均未影响特征图尺寸）

C（核：64*3*3，步长：1，填充：same ） 
B（Yes）A（relu）

C（核：64*3*3，步长：1，填充：same ） 
B（Yes）A（relu）
P（max，核：2*2，步长：2） D（0.2）

C（核：128*3*3，步长：1，填充：same ） 
B（Yes） A（relu）

C（核：128*3*3，步长：1，填充：same ） 
B（Yes） A（relu）
P（max，核：2*2，步长：2） D（0.2）

C（核：256*3*3，步长：1，填充：same ） 
B（Yes） A（relu）

C（核：256*3*3，步长：1，填充：same ） 
B（Yes） A（relu）

C（核：256*3*3，步长：1，填充：same ） 
B（Yes） A（relu） 
P（max，核：2*2，步长：2） D（0.2）

C（核：512*3*3，步长：1，填充：same ） 
B（Yes） A（relu）

C（核：512*3*3，步长：1，填充：same ） 
B（Yes） A（relu）

C（核：512*3*3，步长：1，填充：same ） 
B（Yes） A（relu） 
P（max，核：2*2，步长：2） D（0.2）

C（核：512*3*3，步长：1，填充：same ） 
B（Yes） A（relu）

C（核：512*3*3，步长：1，填充：same ） 
B（Yes） A（relu）

C（核：512*3*3，步长：1，填充：same ） 
B（Yes） A（relu） 
P（max，核：2*2，步长：2） D（0.2）

Flatten
Dense（神经元：512，激活：relu，Dropout：0.2）
Dense（神经元：512，激活：relu，Dropout：0.2）
Dense（神经元：10，激活：softmax）

VGGNet源码

class VGG16(Model):
    def __init__(self):
        super(VGG16, self).__init__()
        self.c1 = Conv2D(filters=64, kernel_size=(3, 3), padding='same')  # 卷积层1
        self.b1 = BatchNormalization()  # BN层1
        self.a1 = Activation('relu')  # 激活层1
        self.c2 = Conv2D(filters=64, kernel_size=(3, 3), padding='same', )
        self.b2 = BatchNormalization()  # BN层1
        self.a2 = Activation('relu')  # 激活层1
        self.p1 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d1 = Dropout(0.2)  # dropout层

        self.c3 = Conv2D(filters=128, kernel_size=(3, 3), padding='same')
        self.b3 = BatchNormalization()  # BN层1
        self.a3 = Activation('relu')  # 激活层1
        self.c4 = Conv2D(filters=128, kernel_size=(3, 3), padding='same')
        self.b4 = BatchNormalization()  # BN层1
        self.a4 = Activation('relu')  # 激活层1
        self.p2 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d2 = Dropout(0.2)  # dropout层

        self.c5 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        self.b5 = BatchNormalization()  # BN层1
        self.a5 = Activation('relu')  # 激活层1
        self.c6 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        self.b6 = BatchNormalization()  # BN层1
        self.a6 = Activation('relu')  # 激活层1
        self.c7 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        self.b7 = BatchNormalization()
        self.a7 = Activation('relu')
        self.p3 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d3 = Dropout(0.2)

        self.c8 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b8 = BatchNormalization()  # BN层1
        self.a8 = Activation('relu')  # 激活层1
        self.c9 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b9 = BatchNormalization()  # BN层1
        self.a9 = Activation('relu')  # 激活层1
        self.c10 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b10 = BatchNormalization()
        self.a10 = Activation('relu')
        self.p4 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d4 = Dropout(0.2)

        self.c11 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b11 = BatchNormalization()  # BN层1
        self.a11 = Activation('relu')  # 激活层1
        self.c12 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b12 = BatchNormalization()  # BN层1
        self.a12 = Activation('relu')  # 激活层1
        self.c13 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b13 = BatchNormalization()
        self.a13 = Activation('relu')
        self.p5 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d5 = Dropout(0.2)

        self.flatten = Flatten()
        self.f1 = Dense(512, activation='relu')
        self.d6 = Dropout(0.2)
        self.f2 = Dense(512, activation='relu')
        self.d7 = Dropout(0.2)
        self.f3 = Dense(10, activation='softmax')

总体来看，VGGNet的结构是相当规整的，它继承了 AlexNet中的Relu激活函数、Dropout操作等有效的方法，同时采用了单一尺寸的 3 * 3 小卷积核，形成了规整的 C（Convolution，卷积）、B（Batch normalization）、A（Activation，激活）、P（Pooling，池化）、D（Dropout）结构，这一典型结构在卷积神经网络中的应用是非常广的。

InceptionNet

InceptionNet 即 GoogLeNet，诞生于 2015 年，旨在通过增加网络的宽度来提升网络的能力，与 VGGNet 通过卷积层堆叠的方式（纵向）相比，是一个不同的方向（横向）。

可以看到，InceptionNet 的基本单元中，卷积部分是比较统一的 C、B、A 典型结构，即卷积→BN→激活，激活均采用 Relu 激活函数，同时包含最大池化操作。

在 Tensorflow 框架下利用 Keras 构建 InceptionNet 模型时，可以将 C、B、A 结构封装在一起，定义成一个新的 ConvBNRelu 类，以减少代码量，同时更便于阅读。

InceptionNet引入了Inception结构块，在同一层网络内使用不同尺寸的卷积核，提升了模型的感知力，使用了批标准化，缓解了梯度消失。

InceptionNet的核心是它的基本单元Inception结构块，无论是GoogLeNet（Inception v1），还是InceptionNet的后续版本，例如v2、v3、v4，都是基于Inception结构块搭建的网络，Inception结构块在同一层网络中使用了多个尺寸的卷积核，可以提取不同尺寸的特征。

分支一：
C（核：16*1*1，步长：1，填充：same ）
B（Yes） A（relu） P（None） D（None）

分支二：
C（核：16*1*1，步长：1，填充：same ）
B（Yes） A（relu） P（None） D（None）

C（核：16*3*3，步长：1，填充：same ）
B（Yes） A（relu） P（None） D（None）

分支三：
C（核：16*1*1，步长：1，填充：same ）
B（Yes） A（relu） P（None） D（None）

C（核：16*5*5，步长：1，填充：same ）
B（Yes） A（relu） P（None） D（None）

分支四：
P（Max, 核：3*3， 步长：1 ，填充：same ）

C（核：16*1*1，步长：1，填充：same ）
B（Yes） A（relu） P（None） D（None）

卷积连接器将以上四个分支按照深度方向堆叠到一起，构成Inception结构块的输出。由于Inception结构块中的卷积操作均采用了CBA结构，所以将其定义成一个新的类ConvBNRelu，可以减少代码量。

InceptionNet源码

class ConvBNRelu(Model):
    def __init__(self, ch, kernelsz=3, strides=1, padding='same'):
        super(ConvBNRelu, self).__init__()
        self.model = tf.keras.models.Sequential([
            Conv2D(ch, kernelsz, strides=strides, padding=padding),
            BatchNormalization(),
            Activation('relu')
        ])

    def call(self, x):
        x = self.model(x, training=False)
        return x

Inception结构块：

class InceptionBlk(Model):
    def __init__(self, ch, strides=1):
        super(InceptionBlk, self).__init__()
        self.ch = ch
        self.strides = strides
        self.c1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
        self.c2_1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
        self.c2_2 = ConvBNRelu(ch, kernelsz=3, strides=1)
        self.c3_1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
        self.c3_2 = ConvBNRelu(ch, kernelsz=5, strides=1)
        self.p4_1 = MaxPool2D(3, strides=1, padding='same')
        self.c4_2 = ConvBNRelu(ch, kernelsz=1, strides=strides)

参数 num_layers 代表 InceptionNet 的 Block 数，每个 Block 由两个基本单元构成，每经过一个 Block，特征图尺寸变为 1/2，通道数变为 2 倍；num_classes 代表分类数，对于 cifar10数据集来说即为 10；init_ch 代表初始通道数，也即 InceptionNet 基本单元的初始卷积核个数。

class Inception10(Model):
    def __init__(self, num_blocks, num_classes, init_ch=16, **kwargs):
        super(Inception10, self).__init__(**kwargs)
        self.in_channels = init_ch
        self.out_channels = init_ch
        self.num_blocks = num_blocks
        self.init_ch = init_ch
        self.c1 = ConvBNRelu(init_ch)
        self.blocks = tf.keras.models.Sequential()
        # InceptionNet 的基本单元，利用之前定义好的 InceptionBlk 类堆叠而成
        for block_id in range(num_blocks):
            for layer_id in range(2):
                if layer_id == 0:
                    block = InceptionBlk(self.out_channels, strides=2)
                else:
                    block = InceptionBlk(self.out_channels, strides=1)
                self.blocks.add(block)
            # enlarger out_channels per block
            self.out_channels *= 2
        self.p1 = GlobalAveragePooling2D()
        self.f1 = Dense(num_classes, activation='softmax')

InceptionNet 网络不再像 VGGNet 一样有三层全连接层（全连接层的参数量占 VGGNet 总参数量的 90 %），而是采用“全局平均池化+全连接层”的方式，这减少了大量的参数。

ResNet

ResNet 即深度残差网络，由何恺明及其团队提出，是深度学习领域又一具有开创性的工作，通过对残差结构的运用，ResNet 使得训练数百层的网络成为了可能，从而具有非常强大的表征能力。

在残差结构中，ResNet 不再让下一层直接拟合我们想得到的底层映射，而是令其对一种残差映射进行拟合。若期望得到的底层映射为H(x)，我们令堆叠的非线性层拟合另一个映射 F(x) := H(x) – x，则原有映射变为 F(x) + x。对这种新的残差映射进行优化时，要比优化原有的非相关映射更为容易。

ResNet 引入残差结构最主要的目的是解决网络层数不断加深时导致的梯度消失问题，从之前介绍的 4 种 CNN 经典网络结构我们也可以看出，网络层数的发展趋势是不断加深的。这是由于深度网络本身集成了低层/中层/高层特征和分类器，以多层首尾相连的方式存在，所以可以通过增加堆叠的层数（深度）来丰富特征的层次，以取得更好的效果。

但如果只是简单地堆叠更多层数，就会导致梯度消失（爆炸）问题，它从根源上导致了函数无法收敛。然而，通过标准初始化（normalized initialization）以及中间标准化层（intermediate normalization layer），已经可以较好地解决这个问题了，这使得深度为数十层的网络在反向传播过程中，可以通过随机梯度下降（SGD）的方式开始收敛。

但是，当深度更深的网络也可以开始收敛时，网络退化的问题就显露了出来：随着网络深度的增加，准确率先是达到瓶颈（这是很常见的），然后便开始迅速下降。需要注意的是，这种退化并不是由过拟合引起的。对于一个深度比较合适的网络来说，继续增加层数反而会导致训练错误率的提升。

class ResnetBlock(Model):

    def __init__(self, filters, strides=1, residual_path=False):
        super(ResnetBlock, self).__init__()
        self.filters = filters
        self.strides = strides
        self.residual_path = residual_path

        self.c1 = Conv2D(filters, (3, 3), strides=strides, padding='same', use_bias=False)
        self.b1 = BatchNormalization()
        self.a1 = Activation('relu')

        self.c2 = Conv2D(filters, (3, 3), strides=1, padding='same', use_bias=False)
        self.b2 = BatchNormalization()

        # residual_path为True时，对输入进行下采样，即用1x1的卷积核做卷积操作，保证x能和F(x)维度相同，顺利相加
        if residual_path:
            self.down_c1 = Conv2D(filters, (1, 1), strides=strides, padding='same', use_bias=False)
            self.down_b1 = BatchNormalization()
        
        self.a2 = Activation('relu')

class ResNet18(Model):
    def __init__(self, block_list, initial_filters=64):  # block_list表示每个block有几个卷积层
        super(ResNet18, self).__init__()
        self.num_blocks = len(block_list)  # 共有几个block
        self.block_list = block_list
        self.out_filters = initial_filters
        self.c1 = Conv2D(self.out_filters, (3, 3), strides=1, padding='same', use_bias=False)
        self.b1 = BatchNormalization()
        self.a1 = Activation('relu')
        self.blocks = tf.keras.models.Sequential()
        # 构建ResNet网络结构
        for block_id in range(len(block_list)):  # 第几个resnet block
            for layer_id in range(block_list[block_id]):  # 第几个卷积层

                if block_id != 0 and layer_id == 0:  # 对除第一个block以外的每个block的输入进行下采样
                    block = ResnetBlock(self.out_filters, strides=2, residual_path=True)
                else:
                    block = ResnetBlock(self.out_filters, residual_path=False)
                self.blocks.add(block)  # 将构建好的block加入resnet
            self.out_filters *= 2  # 下一个block的卷积核数是上一个block的2倍
        self.p1 = tf.keras.layers.GlobalAveragePooling2D()
        self.f1 = tf.keras.layers.Dense(10, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())

小结

对于这五种网络（加上最基本的 baseline 共 6 种），其测试集准确率曲线及 Loss 曲线如下。

LeNet5：

AlexNet8：

VGGNet16：

Inception10：

ResNet18：

随着网络复杂程度的提高，以及 Relu、Dropout、BN 等操作的使用，利用各个网络训练 cifar10 数据集的准确率基本上是逐步上升的。五个网络当中，InceptionNet 的训练效果是最不理想的，首先其本身的设计理念是采用不同尺寸的卷积核，提供不同的感受野，但 cifar10 只是一个单一的分类任务，二者的契合度并不高，另外，由于本身结构的原因，InceptionNet 的参数量和计算量都比较大，训练需要耗费的资源比较多（完整的 InceptionNet v1，即 GoogLeNet 有 22 层，训练难度很大）。

Convolutional Neural Network(CNN)

• 卷积层
• 池化层(Pooling)
• 归一化
• 全连接
• 把全连接层转化成卷积层

ConvNets

卷积神经网络的结构基于一个假设，即输入数据是图像，基于该假设，我们就向结构中添加了一些特有的性质。这些特有属性使得前向传播函数实现起来更高效，并且大幅度降低了网络中参数的数量。

常规神经网络

常规神经网络，神经网络的输入是一个向量，然后在一系列的隐层中对它做变换。每个隐层都是由若干的神经元组成，每个神经元都与前一层中的所有神经元连接。

举例说来，一个尺寸为200x200x3的图像，会让神经元包含200x200x3=120,000个权重值。而网络中肯定不止一个神经元，那么参数的量就会快速增加！显而易见，这种全连接方式效率低下，大量的参数也很快会导致网络过拟合。

ConvNets

计算机认识的图片：一个有长宽的矩阵，再加上一个通道数；在RGB图片里有3个通道，R\G\B.

一个简单的卷积神经网络是由各种层按照顺序排列组成，网络中的每个层使用一个可以微分的函数将激活数据从一个层传递到另一个层。卷积神经网络主要由三种类型的层构成：卷积层，池化（Pooling）层和全连接层（全连接层和常规神经网络中的一样）。通过将这些层叠加起来，就可以构建一个完整的卷积神经网络。

卷积层

卷积层是构建卷积神经网络的核心层，它产生了网络中大部分的计算量。

如何简化计算？

• 让不同的神经元守备不同区域
• 共享参数

input

4	1	0	0	8	1	0	2
4	1	0	1	8	0	0	2
4	1	0	0	8	1	0	2
4	0	0	1	8	2	0	2
4	0	0	0	8	0	0	2
4	1	0	1	8	1	0	2

filter

0	1	0
0	1	0
0	1	0

在前向传播的时候，让每个filter都在输入数据的宽度和高度上滑动（更精确地说是卷积），然后计算整个filter和输入数据任一处的内积。当filter沿着输入数据的宽度和高度滑过后，会生成一个2维的激活图（activation map），激活图给出了在每个空间位置处Receptive field的反应。直观地来说，网络会让filter学习到当它看到某些类型的视觉特征时就激活，具体的视觉特征可能是某些方位上的边界，或者在第一层上某些颜色的斑点.

一个channel的卷积

在每个卷积层上，我们会有一排的filter（比如16个、32、64个，需要多少个，自己定，你开心就好），每个都会生成一个不同的二维激活图。将这些激活映射在深度方向上层叠起来就生成了输出数据。

例如，在100 * 100 * 3的输入下，我定了第一层的 filter 为64个，stride=1，那么输出将是 98 * 98 * 64的矩阵

一个filter就是一个神经元，当它滑向下一区域时，就相当于切换到下一区域的神经元，这些神经元共享同一组参数也就是filter里的参数，你定了64个filter那么将有64组filter分别扫过一整张图片.

动画演示

https://cs231n.github.io/assets/conv-demo/index.html

例1：假设输入数据体尺寸为[32x32x3]（比如CIFAR-10的RGB图像），如果Receptive field是5x5，那么卷积层中的每个神经元会有输入数据体中[5x5x3]区域的权重，共5x5x3=75个权重（还要加一个偏差参数）。注意这个连接在深度维度上的大小必须为3，和输入数据体的深度一致。

例2：假设输入数据体的尺寸是[16x16x20]，filter尺寸是3x3，那么卷积层中每个神经元和输入数据体就有3x3x20=180个连接。再次提示：在空间上连接是局部的（3x3），但是在深度上是和输入数据体一致的（20）。

怎么控制输出数据？

3个超参数控制着输出数据体的尺寸：深度（depth），步长（stride）和填充（padding）。

• 首先，输出数据体的深度是一个超参数：它和使用的filter的数量一致，而每个filter在输入数据中寻找一些不同的东西。举例来说，如果第一个卷积层的输入是原始图像，那么在深度维度上的不同神经元将可能被不同方向的边界，或者是颜色斑点激活。我们将这些沿着深度方向排列、filter相同的神经元集合称为深度列（depth column），也有人使用纤维（fibre）来称呼它们。
• 其次，在滑动filter的时候，必须指定步长。当步长为1，滤波器每次移动1个像素。当步长为2（或者不常用的3，或者更多，这些在实际中很少使用），filter滑动时每次移动2个像素。这个操作会让输出数据体在空间上变小。
• 在下文可以看到，有时候将输入数据体用0在边缘处进行填充是很方便的。这个零填充（zero-padding）的尺寸是一个超参数。零填充有一个良好性质，即可以控制输出数据体的空间尺寸（最常用的是用来保持输入数据体在空间上的尺寸，这样输入和输出的宽高都相等）（你可以用0填充，也可以用均值填充，根据需求，你喜欢就好）。

如何抓取特征

当图片上出现与filter相似的特征时，输出的值会有明显变化，训练时根据这种变化，网络会调整参数，让filter记住这个特征.

池化层

为了控制数据体的大小，通常，在连续的卷积层之间会周期性地插入一个池化层。这样的话就能减少网络中参数的数量，使得计算资源耗费变少，也能有效控制过拟合。池化层使用MAX操作（不一定非要MAX Pooling也可以mean等等，你喜欢），对输入数据体的每一个深度切片独立进行操作，改变它的空间尺寸。最常见的形式是池化层使用尺寸2x2的filter，以步长为2来对每个深度切片进行降采样，将其中75%的激活信息都丢掉。每个MAX操作是从4个数字中取最大值（也就是在深度切片中某个2x2的区域）。深度保持不变。

是不是一定非要用池化层？

答案是否定的。不是非得用池化，我用池化就一定好。举个栗子，Alpha Go论文中有提到，网络是19 * 19的输入，而恰巧围棋棋盘就是19*19路，Alpha Go设计者就把每一步棋子在棋盘的位置当成一张图片，那么网络就可以用CNN，而确实是用的CNN，那么在这上面使用池化的话会发生什么？会丢了棋子信息，因为每一个棋子都会影响棋局的走势，所有不能丢失任一处的棋子信息。

归一化层

在卷积神经网络的结构中，提出了很多不同类型的归一化层，有时候是为了实现在生物大脑中观测到的抑制机制。但是这些层渐渐都不再流行，因为实践证明它们的效果即使存在，也是极其有限的。

全连接层

在全连接层中，神经元对于前一层中的所有激活数据是全部连接的，这个常规神经网络中一样。

网络结构

卷积神经网络通常是由三种层构成：卷积层，池化层（除非特别说明，一般就是最大值池化）和全连接层（简称FC）。ReLU激活函数也应该算是是一层，它逐元素地进行激活函数操作。在本节中将讨论在卷积神经网络中这些层通常是如何组合在一起的。

层的排列规律

卷积神经网络最常见的形式就是将一些卷积层和ReLU层放在一起，其后紧跟池化层，然后重复如此直到图像在空间上被缩小到一个足够小的尺寸，在某个地方过渡成成全连接层也较为常见。最后的全连接层得到输出，比如分类评分等。

• INPUT -> FC,实现一个线性分类器，此处N = M = K = 0。
• INPUT -> CONV -> RELU -> FC
• INPUT -> [CONV -> RELU -> POOL]*2 -> FC -> RELU -> FC。此处在每个汇聚层之间有一个卷积层。
• INPUT -> [CONV -> RELU -> CONV -> RELU -> POOL]*3 -> [FC -> RELU]*2 -> FC。此处每个汇聚层前有两个卷积层，这个思路适用于更大更深的网络，因为在执行具有破坏性的池化操作前，多重的卷积层可以从输入数据中学习到更多的复杂特征。

层的尺寸设置规律

• 输入层（包含图像的）应该能被2整除很多次。常用数字包括32（比如CIFAR-10），64，96（比如STL-10）或224（比如ImageNet卷积神经网络），384和512。
• 卷积层 应该使用小尺寸滤波器（比如3x3或最多5x5），使用步长1 。还有一点非常重要，就是对输入数据进行零填充，这样卷积层就不会改变输入数据在空间维度上的尺寸。
• 池化层 负责对输入数据的空间维度进行降采样。最常用的设置是用用2x2Receptive field的最大值池化，步长为2。注意这一操作将会把输入数据中75%的激活数据丢弃（因为对宽度和高度都进行了2的降采样）。 另一个不那么常用的设置是使用3x3的Receptive field，步长为2。最大值池化的Receptive field尺寸很少有超过3的，因为池化操作过于激烈，易造成数据信息丢失，这通常会导致算法性能变差。

减少尺寸设置的问题：上文中展示的两种设置是很好的，因为所有的卷积层都能保持其输入数据的空间尺寸，汇聚层只负责对数据体从空间维度进行降采样。如果使用的步长大于1并且不对卷积层的输入数据使用零填充，那么就必须非常仔细地监督输入数据体通过整个卷积神经网络结构的过程，确认所有的步长和滤波器都尺寸互相吻合

为什么在卷积层使用1的步长？ 在实际应用中，更小的步长效果更好。上文也已经提过，步长为1可以让空间维度的降采样全部由汇聚层负责，卷积层只负责对输入数据体的深度进行变换。
为何使用零填充？ 使用零填充除了前面提到的可以让卷积层的输出数据保持和输入数据在空间维度的不变，还可以提高算法性能。如果卷积层值进行卷积而不进行零填充，那么数据体的尺寸就会略微减小，那么图像边缘的信息就会过快地损失掉。

网络结构例子：

一个用于CIFAR-10图像数据分类的卷积神经网络的结构可以是[输入层-卷积层-ReLU层-汇聚层-全连接层]。细节如下：

• 输入[32x32x3]存有图像的原始像素值，本例中图像宽高均为32，有3个颜色通道。
• 卷积层中，神经元与输入层中的一个局部区域相连，每个神经元都计算自己与输入层相连的小区域与自己权重的内积。卷积层会计算所有神经元的输出。如果我们使用12个滤波器（也叫作核），得到的输出数据体的维度就是[32x32x12]。
• ReLU层将会逐个元素地进行激活函数操作，比如使用以0为阈值的 作为激活函数。该层对数据尺寸没有改变，还是[32x32x12]。
• 池化层在在空间维度（宽度和高度）上进行降采样（downsampling）操作，数据尺寸变为[16x16x12]。
• 全连接层将会计算分类评分，数据尺寸变为[1x1x10]，其中10个数字对应的就是CIFAR-10中10个类别的分类评分值。正如其名，全连接层与常规神经网络一样，其中每个神经元都与前一层中所有神经元相连接。

由此看来，卷积神经网络一层一层地将图像从原始像素值变换成最终的分类评分值。其中有的层含有参数，有的没有。具体说来，卷积层和全连接层（CONV/FC）对输入执行变换操作的时候，不仅会用到激活函数，还会用到很多参数（神经元的突触权值和偏差）。而ReLU层和汇聚层则是进行一个固定不变的函数操作。卷积层和全连接层中的参数会随着梯度下降被训练，这样卷积神经网络计算出的分类评分就能和训练集中的每个图像的标签吻合了。

小结：

• 简单案例中卷积神经网络的结构，就是一系列的层将输入数据变换为输出数据（比如分类评分）。
• 卷积神经网络结构中有几种不同类型的层（目前最流行的有卷积层、全连接层、ReLU层和汇聚层）。
• 每个层的输入是3D数据，然后使用一个可导的函数将其变换为3D的输出数据。
• 有的层有参数，有的没有（卷积层和全连接层有，ReLU层和汇聚层没有）。

案例学习

下面是卷积神经网络领域中比较有名的几种结构：

• LeNet： 第一个成功的卷积神经网络应用，是Yann LeCun在上世纪90年代实现的。当然，最著名还是被应用在识别数字和邮政编码等的LeNet结构。
• AlexNet： AlexNet卷积神经网络在计算机视觉领域中受到欢迎，它由Alex Krizhevsky，Ilya Sutskever和Geoff Hinton实现。AlexNet在2012年的ImageNet ILSVRC 竞赛中夺冠，性能远远超出第二名（16%的top5错误率，第二名是26%的top5错误率）。这个网络的结构和LeNet非常类似，但是更深更大，并且使用了层叠的卷积层来获取特征（之前通常是只用一个卷积层并且在其后马上跟着一个汇聚层）。
• ZF Net： Matthew Zeiler和Rob Fergus发明的网络在ILSVRC 2013比赛中夺冠，它被称为ZFNet（Zeiler &Fergus Net的简称）。它通过修改结构中的超参数来实现对AlexNet的改良，具体说来就是增加了中间卷积层的尺寸，让第一层的步长和滤波器尺寸更小。
• GoogLeNet： ILSVRC 2014的胜利者是谷歌的Szeged等实现的卷积神经网络。它主要的贡献就是实现了一个奠基模块，它能够显著地减少网络中参数的数量（AlexNet中有60M，该网络中只有4M）。还有，这个论文中没有使用卷积神经网络顶部使用全连接层，而是使用了一个平均汇聚，把大量不是很重要的参数都去除掉了。GooLeNet还有几种改进的版本，最新的一个是Inception-v4。
• VGGNet： ILSVRC 2014的第二名是Karen Simonyan和 Andrew Zisserman实现的卷积神经网络，现在称其为VGGNet。它主要的贡献是展示出网络的深度是算法优良性能的关键部分。他们最好的网络包含了16个卷积/全连接层。网络的结构非常一致，从头到尾全部使用的是3x3的卷积和2x2的汇聚。他们的预训练模型是可以在网络上获得并在Caffe中使用的。VGGNet不好的一点是它耗费更多计算资源，并且使用了更多的参数，导致更多的内存占用（140M）。其中绝大多数的参数都是来自于第一个全连接层。后来发现这些全连接层即使被去除，对于性能也没有什么影响，这样就显著降低了参数数量。
• ResNet： 残差网络（Residual Network）是ILSVRC2015的胜利者，由何恺明等实现。它使用了特殊的跳跃链接，大量使用了批量归一化（batch normalization）。这个结构同样在最后没有使用全连接层。读者可以查看何恺明的的演讲（视频，PPT），以及一些使用Torch重现网络的实验。ResNet当前最好的卷积神经网络模型（2016年五月）。何开明等最近的工作是对原始结构做一些优化，可以看论文 Identity Mappings in Deep Residual Networks，2016年3月发表。

把全连接层转化成卷积层(摘自CS231n课程笔记翻译：卷积神经网络笔记)

全连接层和卷积层之间唯一的不同就是卷积层中的神经元只与输入数据中的一个局部区域连接，并且在卷积列中的神经元共享参数。然而在两类层中，神经元都是计算点积，所以它们的函数形式是一样的。因此，将此两者相互转化是可能的：

• 对于任一个卷积层，都存在一个能实现和它一样的前向传播函数的全连接层。权重矩阵是一个巨大的矩阵，除了某些特定块（这是因为有局部连接），其余部分都是零。而在其中大部分块中，元素都是相等的（因为参数共享）。
• 相反，任何全连接层都可以被转化为卷积层。比如，一个 的全连接层，输入数据体的尺寸是，这个全连接层可以被等效地看做一个的 卷积层。换句话说，就是将滤波器的尺寸设置为和输入数据体的尺寸一致了。因为只有一个单独的深度列覆盖并滑过输入数据体，所以输出将变成 ，这个结果就和使用初始的那个全连接层一样了。

全连接层转化为卷积层：在两种变换中，将全连接层转化为卷积层在实际运用中更加有用。假设一个卷积神经网络的输入是224x224x3的图像，一系列的卷积层和汇聚层将图像数据变为尺寸为7x7x512的激活数据体（在AlexNet中就是这样，通过使用5个汇聚层来对输入数据进行空间上的降采样，每次尺寸下降一半，所以最终空间尺寸为224/2/2/2/2/2=7）。从这里可以看到，AlexNet使用了两个尺寸为4096的全连接层，最后一个有1000个神经元的全连接层用于计算分类评分。我们可以将这3个全连接层中的任意一个转化为卷积层：

• 针对第一个连接区域是[7x7x512]的全连接层，令其滤波器尺寸为 ，这样输出数据体就为[1x1x4096]了。
• 针对第二个全连接层，令其滤波器尺寸为 ，这样输出数据体为[1x1x4096]。
• 对最后一个全连接层也做类似的，令其 ，最终输出为[1x1x1000]

实际操作中，每次这样的变换都需要把全连接层的权重W重塑成卷积层的滤波器。那么这样的转化有什么作用呢？
它在下面的情况下可以更高效：让卷积网络在一张更大的输入图片上滑动（译者注：即把一张更大的图片的不同区域都分别带入到卷积网络，得到每个区域的得分），得到多个输出，这样的转化可以让我们在单个向前传播的过程中完成上述的操作。

举个例子，如果我们想让224x224尺寸的浮窗，以步长为32在384x384的图片上滑动，把每个经停的位置都带入卷积网络，最后得到6x6个位置的类别得分。上述的把全连接层转换成卷积层的做法会更简便。如果224x224的输入图片经过卷积层和汇聚层之后得到了[7x7x512]的数组，那么，384x384的大图片直接经过同样的卷积层和汇聚层之后会得到[12x12x512]的数组（因为途径5个汇聚层，尺寸变为384/2/2/2/2/2 = 12）。然后再经过上面由3个全连接层转化得到的3个卷积层，最终得到[6x6x1000]的输出（因为(12 - 7)/1 + 1 = 6）。这个结果正是浮窗在原图经停的6x6个位置的得分！（译者注：这一段的翻译与原文不同，经过了译者较多的修改，使更容易理解）

面对384x384的图像，让（含全连接层）的初始卷积神经网络以32像素的步长独立对图像中的224x224块进行多次评价，其效果和使用把全连接层变换为卷积层后的卷积神经网络进行一次前向传播是一样的。

自然，相较于使用被转化前的原始卷积神经网络对所有36个位置进行迭代计算，使用转化后的卷积神经网络进行一次前向传播计算要高效得多，因为36次计算都在共享计算资源。这一技巧在实践中经常使用，一次来获得更好的结果。比如，通常将一张图像尺寸变得更大，然后使用变换后的卷积神经网络来对空间上很多不同位置进行评价得到
分类评分，然后在求这些分值的平均值。

最后，如果我们想用步长小于32的浮窗怎么办？用多次的向前传播就可以解决。比如我们想用步长为16的浮窗。那么先使用原图在转化后的卷积网络执行向前传播，然后分别沿宽度，沿高度，最后同时沿宽度和高度，把原始图片分别平移16个像素，然后把这些平移之后的图分别带入卷积网络。（译者注：这一段的翻译与原文不同，经过了译者较多的修改，使更容易理解）

参考台湾大学李宏毅老师的机器学习课程
参考由杜客和猴子翻译，堃堃和李艺颖进行校对修改的cs231n笔记。来自网址:https://zhuanlan.zhihu.com/p/22038289
图片分别平移16个像素，然后把这些平移之后的图分别带入卷积网络。（译者注：这一段的翻译与原文不同，经过了译者较多的修改，使更容易理解）

参考台湾大学李宏毅老师的机器学习课程
参考由杜客和猴子翻译，堃堃和李艺颖进行校对修改的cs231n笔记。来自网址:https://zhuanlan.zhihu.com/p/22038289

2021-6-15

1 卷积神经网络是什么？

卷积神经网络(Convolution Neural Network)可以简单理解为包含卷积操作且具有深度结构的网络，通过权值共享和局部连接的方式对数据进行特征提取并进行预测的过程。在实际应用中往往采用多层网络结构，因此又被称为深度卷积神经网络。卷积神经网络通过反馈修正卷积核和偏置参数使输出与预测偏差减小。所以，构建卷积神经网络进行深度学习开发其实并不复杂。可以从四个方面展开：输入输出、网络结构、损失函数、评价指标。

2 卷积神经网络的输入输出

卷积神经网络的输入分为两部分，一是数据，二是标签。针对计算机视觉任务来说，通常数据指的是图像数据。标签是针对图像的真实值，针对不同任务有着不同的标签，例如图像分类任务的标签是图像的类别，目标检测任务的标签是图像中的目标的类别和坐标信息等。这类标签信息一般通过人工标定方式(或者自动标定工具)生成。例如VIA标注工具。

3、卷积神经网络的网络结构

卷积神经网络的基本结构由以下几个部分组成：输入层（input layer），卷积层（convolution layer），池化层（pooling layer），激活函数层和全连接层（full-connection layer）。下面以图像分类任务简单介绍一下卷积神经网络结构，具体结构如下图所示。

3.1 输入层

图像分类任务是输入层是$H\ast W\ast C$的图像，其中H是指图像的长度，W是图像的宽度，C指的是图像的channel数，一般灰度图的channel数为1，彩色图的channel数为3。

3.2 卷积层

卷积神经网络的核心是卷积层，卷积层的核心部分是卷积操作。
卷积层有四个重要的超参数：卷积核的大小F、卷积核的个数K、卷积的步长S和零填充数量P。
假设输入的参数为：$H\times W\times D$的一个Tensor，则经过一个大小为、个数为K，步长为S和零填充数量为P的卷积操作后输出的参数为：

$$\begin{array}{c}{H}^{\prime }=(H-F+2P)/S+1\\ W^{\prime }=(W-F+2P)/S+1\\ D^{\prime }=K\end{array}$$
关于卷积计算可以参考这篇文章，我的下面图片就引自该问文，链接: 原来卷积是这么计算的_月来客栈。
其中卷积层的操作可分为四种，分别为：

• 单输入单输出（输入channel数为1，且只有1个卷积核）
• 单输入多输出（输入channel数为1，并有n(n>1)个卷积核）
• 多输入单输出（输入channel数>1,只有1个卷积核）
• 多输入多输出（输入channel数>1,并有n(n>1)个卷积核）

3.2.1 单输入单输出

channel数为1的图像的单一卷积核的计算过程如下图所示：

具体计算过程如下图：

channel数为3的图像的单一卷积核的计算过程如下图所示：

具体计算过程如下图：

channel数为3的图像的多卷积核的计算过程如下图所示：

计算得到的结果如下图：

3.3 池化层

池化操作将输入矩阵某一位置相邻区域的总体统计特征作为该位置的输出，主要有平均池化（Average Pooling）、最大池化（Max Pooling）等。卷积的作用为：对每一个特征响应图独立进行， 降低特征响应图组中每个特征响应图的宽度和高度，减少后续卷积层的参数的数量， 降低计算资源耗费，进而控制过拟合，简单来说池化就是在该区域上指定一个值来代表整个区域。
池化层的超参数：池化窗口和池化步长。
池化操作也可以看做是一种卷积操作，下面我们以最大池化来解释池化操作，具体操作如下图所示：

3.4 激活函数层

激活函数（非线性激活函数，如果激活函数使用线性函数的话，那么它的输出还是一个线性函数。）但使用非线性激活函数可以得到非线性的输出值。常见的激活函数有Sigmoid、tanh和Relu等。一般我们使用Relu作为卷积神经网络的激活函数。
Relu激活函数提供了一种非常简单的非线性变换方法，它的公式为：
$$f(u)=max(0,u)$$
函数图像如下所示：

ReLU激活函数相比Sigmoid、tanh等有的优点为：
1、速度快，和sigmoid函数需要计算指数和倒数相比，relu函数其实就是一个$max(0,u)$，计算代价小。
2、稀疏性，通过对大脑的研究发现，大脑在工作的时候只有大约5%的神经元是激活的，而采用sigmoid激活函数的激活率大约是50%。有论文声称人工神经网络在15%-30%的激活率时是比较理想的。因为Relu函数在输入小于0时是完全不激活的，因此可以获得一个更低的激活率。
3、ReLU的求导特性也非常的好。当输⼊为负时， ReLU函数的导数为0，⽽当输⼊为正时， ReLU函数的导数为1。这就意味着要么让参数消失，要么让参数通过。并且ReLU减轻了困扰以往神经⽹络的梯度消失问题。
注意： ReLU函数有许多变体，包括参数化ReLU（Parameterized ReLU， pReLU）函数。该变体为ReLU增减了一个线性项，因此即使参数是负的，某些信息仍然可以通过：
$$pReLU=max(0,x)+\alpha min(0,x)$$

3.5 全连接层

全连接层在卷积神经网络中起到分类器的作用，如果说卷积层、池化层和激活函数层等操作是将原始数据映射到隐层特征空间的话，全连接层则起到将学到的“分布式特征表示”映射到样本标记空间的作用。

3 卷积神经网络的损失函数

在卷积神经网络中，我们会使用如梯度下降法(Gradient Descent) 等方法去最小化目标函数。但怎样来衡量优化目标函数的好坏呢，这就用到了损失函数。卷积神经网络中损失函数是用于衡量模型所作出的预测值和真实值(Ground Truth)之间的偏离程度，大致可分为两种：分类损失（针对离散型量）和回归损失（针对连续型变量）。

3.1分类损失

3.1.1 熵（Entropy）

即“熵”，熵的概念最早起源于物理学，用于度量一个热力学系统的无序程度。在信息论里面， 熵是用于描述对事件不确定性的度量，它的计算公式如下：
$$Entropy,H(p)=-\Sigma p(x_i)\ast lo{g}_2(p(x_i))$$
其中$p(i)$为事件的概率分布，下面以一个例子来解释一下该公式。
假设气象台告知我们明天晴天的概率为25%，下雨的概率为75%，则气象站传输给我们的信息熵为：
$$-(0.25\ast log2(0.25)+0.75\ast log2(0.75))=0.81$$
如下图所示：

在卷积神经网络中，比如分类任务中，其实也是在做一个判断一个物体到底是不是属于某个类别，其中不确定性就越大，其信息量越大，它的熵值就越高。

3.1.2 相对熵

相对熵又称KL散度，用于衡量对于同一个随机变量x的两个分布p(x)和q(x)之间的差异。在机器学习中，p(x)常用于描述样本的真实分布，例如[1,0,0,0]表示样本属于第一类，而q(x)则常常用于表示预测的分布，例如[0.7,0.1,0.1,0.1]。显然使用q(x)来描述样本不如p(x)准确，q(x)需要不断地学习来拟合准确的分布p(x)。
KL散度的计算公式为：
$$D_{KL}(p||q)=\sum _{i=1}^{n}p(x_i)lo{g}_2(\frac{p(x_i)}{q(x_i)})$$
KL散度的值越小表示两个分布越接近。

3.1.3 交叉熵（Cross Entropy）

我们将KL散度的公式进行变形，得到：
$$D_{KL}(p||q)=\sum _{i=1}^{n}p(x_i)lo{g}_2(p(x_i))-\sum _{i=1}^{n}p(x_i)lo{g}_2(q(x_i))=-H(p(x))+[-\sum _{i=1}^{n}p(x_i)lo{g}_2(q(x_i))]$$

前半部分就是p(x)的熵，它是一个定值，后半部分就是我们的交叉熵：
$$CrossEntropy,H(p,q)=-\sum _{i=1}^{n}p(x_i)lo{g}_2(q(x_i))$$
我们常常使用KL散度来评估predict和label之间的差别，但是由于KL散度的前半部分是一个常量，所以我们常常将后半部分的交叉熵作为损失函数。假设我们当前做一个3个类别的图像分类任务，如猫、狗、猪。给定一张输入图片其真实类别是猫，模型通过训练用Softmax分类后的输出结果为：｛“cat”: 0.3, “dog”: 0.45, “pig”: 0.25｝，那么此时交叉熵为：-1 * log(0.3) = 1.203。当输出结果为：｛“cat”: 0.5, “dog”: 0.3, “pig”: 0.2｝时，交叉熵为：-1 * log(0.5) = 0.301。可以发现，当预测值接近真实值时，损失将接近0。

3.2 回归损失（Regression Loss）

3.2.1 L1损失

也称为Mean Absolute Error，即平均绝对误差（MAE），它衡量的是预测值与真实值之间距离的平均误差幅度，作用范围为0到正无穷。其公式如下：
$$loss=\sum _{i=1}^n|y_i-{\hat{y}}_i|$$

3.2.2 L2损失

也称为Mean Squred Error，即均方差（MSE），它衡量的是预测值与真实值之间距离的平方和，作用范围同为0到正无穷。其公式如下：
$$loss=\sum _{i=1}^n(y_i-{\hat{y}}_i{)}^2$$

3.2.3 L1与L2损失函数对比

L1损失函数相比于L2损失函数的鲁棒性更好，因为L2将误差平方化（如果误差大于1，则误差会放大很多），模型的误差会比L1范数大的多，因此模型会对这种类型的样本更加敏感，这就需要调整模型来最小化误差。
但L2收敛速度快，能够对梯度给予合适的惩罚权重，而不是“一视同仁”，使梯度更新的方向可以更加精确。

3.2.4 Smooth L1损失

即平滑的L1损失（SLL），出自Fast RCNN。SLL通过综合L1和L2损失的优点，在0点处附近采用了L2损失中的平方函数，解决了L1损失在0点处梯度不可导的问题，使其更加平滑易于收敛。此外，在|x|>1的区间上，它又采用了L1损失中的线性函数，使得梯度能够快速下降。
$$smoot{h}_L(x)=x=\{\begin{array}{ll}0.5x^2& \text{if }|x|<1\\ |x|-0.5& \text{otherwise}\end{array}$$

4 卷积神经网络的评价指标

评价指标是用来定量衡量模型的性能的，是作为各种模型比较的一个标准。卷积神经网络评价指标分为分类任务评价指标和回归任务评价指标。

4.1 分类任务评价指标

4.1.1 准确率/召回率/精确度/F1-score

混淆矩阵是最基础的概念，也是最重要的概念。混淆矩阵如下表所示：

	正例（预测值）	反例（预测值）
正例（真实值）	TP(True Positive)	FN(False Negative)
反例（真实值）	FP(False Positive)	TN(True Negative)

准确率(Accuracy)：
$$Accuracy=\frac{(TP+TN)}{(TP+FN+FP+TN)}=\frac{预测正确样本数}{总的样本数}$$
精确度：
$$Precision=\frac{TP}{TP+FP}=\frac{预测正确的正样本数}{预测为正的样本数}$$
或
$$Precision=\frac{TN}{TN+FN}=\frac{预测正确的正样本数}{预测为负的样本数}$$

召回率：
$$Recall=\frac{TP}{TP+FN}=\frac{预测正确的正样本数}{真实标签为正确的样本数}$$
F1-score：
$$F1score=\frac{2\ast Precision\ast Recall}{Precision+Recall}$$

4.1.2 Precision/Recall（P-R）曲线

Precision/Recall曲线也叫做P-R曲线，其代表的是精准率（查准率）与召回率（查全率）的关系，Precision与Recall是一对矛盾的变量。如下图所示：

其中，曲线与坐标值面积越大，性能越好（能更大的提升精确度和召回率）；但是有时面积不好计算，那么就选择$y=x$与P-R曲线的交点也叫作平衡点（BEP）比较BEP，越大的学习器越优。
但PR曲线对正负样本不均衡问题较敏感。

4.1.3 ROC曲线

ROC曲线的横坐标是false positive rate（FPR）：
$$FPR=\frac{FP}{FP+TN}=\frac{将反例预测为正例的样本数}{标签为反的样本数}$$
纵坐标为true positive rate（TPR）：
$$TPR=\frac{TP}{TP+FN}=\frac{将正例预测为正例的样本数}{标签为正的样本数}$$

其中ROC曲线对正负样本不均衡问题不敏感。

4.2回归任务评价指标

4.2.1 IOU（Intersection-over-Union）交并比

IOU多用于检测、分割任务中，它的计算公式如下所示:

$$IOU=\frac{A\bigcap B}{A\bigcup B}$$

4.2.2 AP

PR曲线下的面积就定义为AP，由于计算积分相对困难，因此引入插值法，计算AP公式如下：
$$AP=\sum _{k=1}^N\underset{k^{\prime }\ge k}{\max }P(k^{\prime })\Delta r(k)$$

计算面积：

计算公式：

5 总结

在这篇文章中，亦岚君首先引入了卷积的四个主要知识：输入输出、网络结构、损失函数和评价指标。然后围绕着这五个问题依次做了简单介绍。本次内容就到此结束，感谢您的阅读！如果你觉得上述内容对你有所帮助，欢迎关注并传播本文！