[人工智能] 经典论文-MobileNetV2论文及实践

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 人工智能 -> 经典论文-MobileNetV2论文及实践 -> 正文阅读

[人工智能]经典论文-MobileNetV2论文及实践

**### 2019-MobileNetV2

MobileNetV2: Inverted Residuals and Linear Bottlenecks

MobileNetV2: 倒置残差和线性瓶颈

作者：Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, Liang-Chieh Chen
单位：Google

论文地址： https://arxiv.org/pdf/1801.04381.pdf
项目地址：https://github.com/d-li14/mobilenetv2.pytorch

摘要

在本文中，描述了一种新的移动端架构，MobileNetV2，它提高了移动端模型在多个任务和基准测试以及跨不同模型尺寸范围内的最佳性能。此外还描述了一个称为SSDLite的新框架，将这些移动模型应用于对象检测的有效方法。此外，还演示了如何通过DeepLabv3的简化形式，称之为移动DeepLabv3来构建移动语义分割模型。

MobileNetV2是基于倒置残差(inverted residual )结构，其中快捷连接(shortcut connections)在窄的瓶颈(1x1)层之间。中间扩展层使用轻量级的深度卷积来过滤作为非线性来源的特征。此外，还发现，为了保持具有代表性的能力，去除窄层中的非线性是很重要的。最后演示了这能提高性能，并提供了导致这种设计的直觉。

最后，我们的方法允许将输入/输出域与转换的表达性解耦，这为进一步的分析提供了一个方便的框架。我们在ImageNet[1]分类、COCO目标检测[2]、VOC图像分割[3]数据集上测试了模型的性能。我们评估了在精度和乘加(multiply-adds, MAdd)操作数量之间的权衡，以及实际的延迟和参数数量之间的权衡。

1 简介

神经网络已经彻底改变了机器智能的许多领域，使具有挑战性的图像识别任务获得了超过常人的准确性。然而，提高准确性的努力往往需要付出代价：现代先进网络需要超出许多移动和嵌入式应用能力之外的高计算资源。

本文介绍了一种专门针对移动和资源受限环境而定制的新的神经网络架构。我们的网络通过显著减少所需的操作数量和内存，同时保持相同的准确性，推动了移动定制计算机视觉模型的最先进水平。

我们的主要贡献是一个新的层模块：具有线性瓶颈的倒置残差。该模块将一个低维压缩表示作为输入，首先扩展到高维，并使用轻量级的深度卷积进行过滤。特征随后被投影回一个具有线性卷积的低维表示形式。官方实现可作为[4]中TensorFlow-Slim模型库的一部分。

这个模块可以在任何现代框架中使用标准操作有效地实现，并允许新模型使用标准基准在多个性能点上击败最新的状态。此外，这个卷积模块特别适用于移动设计，因为它允许通过从不完全实现大型中间张量，显著减少推理期间所需的内存占用。这减少了许多嵌入式硬件设计中对主内存访问的需求，这些硬件设计提供了少量非常快的软件控制缓存内存。

2 相关工作

调整深度神经结构以达到准确性和性能之间的最佳平衡一直是一个活跃的研究领域。由许多团队进行的人工架构搜索和训练算法的改进，都导致了对早期设计的巨大改进，如AlexNet[5]，VGGNet[6]，GoogLeNet[7]和ResNet[8]。最近在算法架构探索方面取得了很多进展，包括超参数优化[9，10，11]、各种网络修剪方法[12，13，14，15，16，17]和连接学习[18，19]。也有大量的工作致力于改变内部卷积块的连接结构如ShuffleNet[20]或引入稀疏性[21]和其他[22]。

最近，[23,24,25,26]开辟了一个将遗传算法和强化学习等优化方法引入架构搜索的新方向。然而，其中的一个缺点是，由此产生的网络最终会非常复杂。在本文中，追求的目标是发展更好的关于神经网络如何操作的直觉，并使用它来指导最简单的可能的网络设计。我们的方法应该被视为对[23]和相关工作中描述的方法的互补。在这方面，我们的方法类似于[20,22]所采取的方法，并允许进一步提高性能，同时可以一睹其内部的运行。网络设计是基于MobileNetV1[27]。它保持了它的简单性，不需要任何特殊的操作符，同时显著提高了其精度，实现了对移动应用的多重图像分类和检测任务的最先进水平。

3 前期准备工作，讨论和直觉

3.1 深度可分离卷积|Depthwise Separable Convolutions

深度可分离卷积是许多高效的神经网络架构[27,28,20]的关键组成部分，我们在目前的工作中也使用了它们。其基本思想是用一个分解的版本替换一个完整的卷积算子，它将卷积分割成两个单独的层。第一层称为深度卷积，它通过在每个输入通道上应用一个卷积滤波器来执行轻量级滤波。第二层是一个1×1的卷积，称为逐点卷积，它负责通过计算输入通道的线性组合来构建新的特征。

标准卷积使用 $KaTeX parse error: Expected 'EOF', got '}' at position 12: h_ixw_jxd_i}?$ 的输入张量 $L_i$ ，并对其应用卷积核 $K∈R^{k×k×d_i×d_j}$ 来产生 $h_i×w_i×d_j$ 维的输出张量 $L_j$ 。标准卷积层的计算代价为 $h_i?w_i?d_i?d_j?k?k$ 。

深度可分离卷积是标准卷积层的替代。根据经验，它们的工作原理几乎和常规卷积一样好，但其成本：

在这里插入图片描述

这是深度卷积和1×1逐点卷积的总和。与传统层相比，**有效的深度可分离卷积减少了几乎 $k^2$ 倍的计算量。**MobileNetV2使用了k=3（3×3深度可分离卷积），因此计算成本是标准卷积的8到9倍，而精度仅略有降低[27]。

3.2 线性瓶颈|Linear Bottlenecks

考虑一个由n层组成的深度神经网络，每个层都有一个 $h_ixw_ixd_i$ 维数的激活张量。在本节中，将讨论这些激活张量的基本性质，把它们视为具有 $d_i$ 维的 $h_ixw_i$ “像素”的容器。非正式地，对于输入的一组真实图像，我们说该层激活集合(对于任何层 $L_i$ )形成了一个“感兴趣的流形”。长久以来，人们一直认为神经网络中的流形可以嵌入到低维子空间中。换句话说，当查看深层卷积层的所有单独的d通道像素时，在这些值中编码的信息实际上位于某个流形中，这反过来又可嵌入到低维子空间中。

乍一看，实例可以通过简单地减少层的维度来捕获和利用，从而降低操作空间的维度。这已被MobileNetV1[27]成功地利用，通过一个宽度乘数参数有效地在计算和精度之间进行权衡，并已被纳入其他网络[20]的高效模型设计中。根据这种直觉，**宽度乘法方法允许降低激活空间的维数，直到感兴趣的流形跨越了整个空间为止。**然而，当回想到深度卷积神经网络实际上具有每个坐标的非线性变换时（ReLU），这种直觉就失效。例如，在1维空间中的一行应用ReLU会产生一个ray, 在 $R^n$ 空间中，通常会产生一个带有n个关节的分段线性曲线。

很容易看出，如果层变换ReLU（Bx）的结果具有非零的体积S，映射到内部S的点通常通过输入的线性变换B获得，因此表明与全维度输出相对应的输入空间的一部分受限于线性变换。换句话说，深层网络只在输出域的非零体积部分具有线性分类器的能力。我们将在补充材料中进行更正式的说明。

另一方面，当ReLU破坏该通道时，它不可避免地会丢失该通道中的信息。然而，如果我们有很多通道，并且在激活流形中有一个结构，那么信息可能仍然被保存在其他通道中。在补充材料中，证明了如果输入流形可以嵌入到激活空间的显著低维子空间中，那么ReLU变换能保留信息的同时，将所需的复杂性引入到可表达的函数集中。

总之，我们强调了两个特性，它们表明了感兴趣的流形应该位于高维激活空间的低维子空间中：

1.如果感兴趣的流形在ReLU转换后保持非零体积，则其对应于线性转换；
2.只有当输入流形位于输入空间的低维子空间时，ReLU能够保存关于输入流形的完整信息；

这两个见解为我们为优化现有的神经结构提供了经验提示：假设感兴趣的流形是低维的，可以通过在卷积块中插入线性瓶颈层来捕获这一点。实验证据表明，使用线性层是至关重要的，因为它可以防止非线性破坏太多的信息。在第6节中，通过经验表明，在瓶颈中使用非线性层确实会使性能降低几个百分点，进一步证实了我们的假设。我们注意到[29]中也报告了非线性的类似报告，其中从传统残差块的输入中去除非线性，从而提高了CIFAR数据集的性能。

对于本文的其余部分，将利用瓶颈卷积。我们将把输入瓶颈的大小与内部大小之间的比率称为扩展比率（expansion ratio）。

在这里插入图片描述

注：如果当前激活空间内兴趣流形完整度较高，经过ReLU，可能会让激活空间坍塌，不可避免的会丢失信息，所以我们设计网络的时候，想要减少运算量，就需要尽可能将网络维度设计的低一些但是维度如果低的话，激活变换ReLU函数可能会滤除很多有用信息。然后我们就想到了，反正ReLU另外一部分就是一个线性映射，那么如果我们全用线性分类器，会不会就不会丢失一些维度信息，同时可以设计出维度较低的层呢？

所以论文针对这个问题使用Linear Bottleneck（即不使用ReLU激活，做了线性变换）的来代替原本的非线性激活变换。到此，优化网络架构的思想也出来了：通过在卷积模块中后插入linear bottleneck来捕获兴趣流形。实验证明，使用linear bottleneck 可以防止非线性破坏太多信息。

从linear bottleneck 到深度卷积之间的维度比成为Expansion factor（扩展系数），该系数控制了整个block 的通道数。

3.3 倒置残差| Inverted residuals

瓶颈模块与残差模块类似，其中每个模块包含一个输入，然后是几个瓶颈，然后是扩展[8]。然而，受直觉的启发，瓶颈实际上包含了所有必要的信息，而扩展层只是作为一个伴随着张量的非线性变换的实现细节，我们直接在瓶颈之间使用快捷连接。

图3提供了设计差异的示意图。插入快捷方式的动机类似于经典的残差连接：我们希望提高梯度在乘数层之间传播的能力。然而，倒置设计的内存效率要高得多（详见第5节），而且在我们的实验中效果稍好。

在这里插入图片描述

图3：残差块[8，30]和倒置残差之间的差异。对角阴影线层不使用非线性。用每个块的厚度来表明其相对数量的通道。注意经典残差是如何将通道数量较多的层连接起来的（1x1 3x3 1x1），而倒置残差则是连接瓶颈（1x1 3x3depth 1x1）。最好通过颜色看。

瓶颈卷积的运行时间和参数计数。基本的实现结构如表1所示，对于大小为 $h \times w$ 、扩展因子 $t$ 和卷积核大小 $k$ 以及 $KaTeX parse error: Expected group after '^' at position 2: d^?'$ 维度输入通道和 $KaTeX parse error: Expected group after '^' at position 2: d^?''$ 输出通道，所需的乘加操作数为 $KaTeX parse error: Expected group after '^' at position 6: h\cdotw\cdotd^?'\cdott\cdot(d^'+k^2+d'\dots$ 。与（1）相比，这个表达式有一个额外的项，因为确实有一个额外的1×1卷积，但是我们的网络的本质允许我们使用更小的输入和输出维度。在表3中，比较了MobileNetV1、MobileNetV2和ShuffleNet之间的每个分辨率所需的尺寸。

在这里插入图片描述

MobileNet V2 的网络模块样式，其样式如下（和上面差不多，不过我这里拿了网页的图）：

MobileNetV1 网络主要思想就是深度可分离的卷积的堆叠。在V2的网络设计中，我们除了继续使用深度可分离（中间那个）结构之外，还使用了Expansion layer 和Projection layer。这个projection layer 也使用1*1 的网络结构将高维空间映射到低维空间的设计，有些时候我们也将其称之为Bottleneck layer。

而Expansion layer 的功能正好相反，使用1*1 的网络结构，目的是将低维空间映射到高维空间。这里Expansion 有一个超参数是维度扩展几倍。可以根据实际情况来做调整的，默认是6，也就是扩展6倍。

此图也更加详细的展示了整个模块的结构。我们输入是24维，最后输出也是24维。但这个过程中，我们扩展了6倍，然后应用深度可分离卷积进行处理。整个网络是中间胖，两头窄，像一个纺锤型。而ResNet中bottleneck residual block 是两头胖中间窄，在MobileNet V2中正好相反，所以我们MobileNet V2中称为inverted rediduals。另外，residual connection 是在输入和输出的部分进行连接。而linear bottleneck 中最后projection conv 部分，我们不再使用ReLU激活函数而是使用线性激活函数。

3.4 信息流解释|Information flflow interpretation

我们的体系结构的一个有趣的特性是，它提供了构建块（瓶颈层）的输入/输出域和层转换之间的自然分离——这是一个将输入转换为输出的非线性函数。前者可以看作是网络在每一层的容量，而后者可以看作是表达能力。这与传统的卷积模块（无论是规则的还是可分离的）形成了对比，其中表现力和容量都缠结在一起并且是输出层深度的函数。

特别是，在我们的例子中，当内层深度为0时，由于快捷连接，基础卷积是恒等函数。当展开比小于1时，这是一个经典的残差卷积模块[8,30]。但是，就我们的目的而言，我们表明扩大比率大于1是最有用的。

这种解释使我们能够将网络的表达能力与其容量分开进行研究，我们相信，进一步探索这种分离是有必要的，以便更好地理解网络的属性。

4 模型架构

现在，将详细地描述我们的体系结构。正如前一节所讨论的那样，基本构件块是一个瓶颈深度可分离的残差卷积。该模块的详细结构如表1所示。MobileNetV2的架构包含32个滤波器的初始全卷积层，然后是表2中描述的19个残差瓶颈层，其中t是扩展比，c是block的输出特征的channel大小，n是block的重复次数，s是stride。我们使用ReLU6作为非线性，因为用于低精度计算时它的鲁棒性[27]。总是使用现代网络中的标准核尺寸3×3，并在训练过程中使用dropout和Batch normalization。

4.1 模型选择

首先，展示具有深度可分离卷积的MobileNet与具有完全卷积的模型相比的结果。在表4中，可以看到，与完全卷积相比，使用深度可分离卷积在ImageNet上只会减少1%的准确率但极大地节省了大量的mult-adds操作和参数。接下来，展示**使用宽度乘数的较瘦模型和使用较少层的较浅模型的比较结果。**为了使MobileNet更浅，去掉了表1中特征尺寸为14×14×512的5层可分离滤波器。表5显示，在相似的计算和参数数量下，使MobileNets变瘦比使其变浅要好3%

在这里插入图片描述

除了第一层之外，在整个网络中使用恒定的扩展速率。在我们实验中，发现5到10之间的扩展率导致几乎相同的性能曲线，较小的网络以较小的扩展速率更好，而较大的网络在较大扩展速率时具有稍微更好的性能。

在我们所有的主要实验中，使用膨胀因子6应用于输入张量的大小。例如，对于采用64通道输入张量并产生128通道张量的瓶颈层，中间扩展层为$64·6=384通道。

权衡超参数。和[27]一样，我们通过使用输入图像分辨率和宽度倍数作为可调超参数来调整我们的架构以适应不同的性能点，这些参数可以根据期望的精度/性能权衡进行调整。主要网络（宽度乘数1，224×224）的计算成本为3亿次乘法，并使用了340万个参数。我们研究了性能权衡，输入分辨率从96到224，宽度乘数从0.35到1.4。网络计算成本范围从7次乘法增加到585百万次乘加操作，而模型大小在1.7M个参数和6.9M个参数之间变化。

与[27]的一个小的实现差异是，对于小于1的乘数，我们将宽度乘数应用于除最后一个卷积层以外的所有层。这可以提高更小模型的性能。

5 实现说明

5.1 内存有效推断

倒置的残差颈层允许特定地内存有效的实现，这对于移动应用非常重要。使用TensorFlow[31]或Caffe[32]等标准高效的推断实现，构建了一个有向无环计算超图G，由表示运算的边和表示中间计算张量的节点组成。预定计算是为了最小化需要存储在内存中的张量总数。在最一般的情况下，它会搜索所有合理的计算顺序 $Σ (G)$ ，并选择最小化。

在这里插入图片描述

其中 $\pi, G)$ 是连接到任何 $\pi_{i}\dots \pi_{n}$ 节点的中间张量列表， $∣ A ∣$ 表示张量 $A$ 的大小， $s i ze (i)$ 是操作 $i$ 期间内部存储所需的总内存量。

对于仅具有平凡并行结构（例如残差连接）的图，只有一个非平凡的可行计算顺序，因此可以简化计算图G推断所需的内存总量和界限：

在这里插入图片描述

或者，内存量只是所有操作中组合输入和输出的最大总大小。在下文中，我们将展示如果将瓶颈残差模块视为单一操作（并将内部卷积视为一次性张量），则总内存量将由瓶颈张量的大小决定，而不是瓶颈的内部张量的大小（更大）。

瓶颈残差块 图3b中所示的F(x)可以表示为三个运算符的组合 $F (x) = [A ° N ° B] x$ ，其中AA是线性变换 $A:R^{s×s×k}→R^{s×s×n}$ ，N是一个非线性的每个通道的转换： $N:R^{s×s×n}→R^{s′×s′×n}，B是输出域的线性转换：$ B:R^{{s′×s′×n}→R}{s′×s′×k′}$。

对于我们的网络， $N = R e LU 6 ° d w i se ° R e LU 6$ ，但结果适用于任何的按通道转换。假设输入域的大小是 $∣ x ∣$ 并且输出域的大小是 $∣ y ∣$ ，那么计算 $F (X)$ (X)所需的内存可以低至$|s^2k|+|s{′2}k^′|+O(max(s2,s^{′2}))。

该算法基于以下事实：内部张量 $\cal I$ 可以表示为 $t$ 张量的连接，每个大小为 $n / t$ ，则我们的函数可以表示为

在这里插入图片描述

通过累加和，我们只需要将一个大小为 $n / t$ 的中间块始终保留在内存中。使用 $n = t$ ，最终只需要保留中间表示的单个通道。使我们能够使用这一技巧的两个约束是（a）内部变换（包括非线性和深度）是每个通道的事实，以及（b）连续的非按通道运算符具有显著的输入输出大小比。对于大多数传统的神经网络，这种技巧不会产生显著的改善。

我们注意到，使用t路分割计算F(X)所需的乘加运算符的数目是独立于t的，然而，在现有的实现中，我们发现用几个较小的矩阵乘法替换一个矩阵乘法会损害运行时性能，这是由于增大的缓存未命中。我们发现这种方法最有用，t是2和5之间的一个小常数。它显著降低了内存需求，但仍然可以利用深度学习框架提供的高度优化的矩阵乘法和卷积算子来获得的大部分效率。如果特殊的框架级优化可能导致进一步的运行时改进，这个方法还有待观察。

6 实验

6.1 图像分类

训练设置。我们使用TensorFlow[31]来训练我模型，使用标准的RMSProp优化器，衰减和动量都设置为0.9。在每一层之后使用批归一化（batch normalization），标准权重衰减设置为0.00004。与MobileNetV1[27]设置相同，使用的初始学习率为0.045，每个epoch的学习率衰减率为0.98，使用16个GPU异步工作worker，batch size设置为96。

结果。我们将我们的网络与MobileNetV1、ShuffleNet和NASNet-A模型进行了比较，统计数据如表4所示，完整的性能图如图5所示

在这里插入图片描述

表4：比较不同网络在ImageNet上的性能。正如操作数的常见做法一样，计算Multiply-Adds的总数。在最后一列中，报告了Google Pixel 1手机上的一个大型核心（使用TF-Lite）的运行时间，以毫秒（ms）为单位。没有报告ShuffleNet的结果，因为高效的群组卷积和混排尚未支持。

在这里插入图片描述

图5：MobileNetV2与MobileNetV1，ShuffleNet，NAS的性能曲线。对于我们的网络，对所有分辨率使用乘数0.35，0.5，0.75，1.0，对于分辨率为224，使用乘数1.4。

6.2 目标检测

我们基于SSD算法(Single Shot Detector)[34]架构评估和比较了MobileNetV2和MobileNetV1作为目标检测特征提取器[33]的性能，使用的数据集是COCO数据集[2]。我们还将YOLOv2[35]和原始SSD（以VGG-16[6]为backbone）作为基准进行比较。由于专注于移动/实时模型，因此不会与Faster-RCNN[36]和RFCN[37]等其它架构进行比较。

SSDLite，在本文中，我们介绍了常规SSD的移动友好型变种。在SSD预测层中用可分离卷积（深度卷积后接1×1 逐点卷积）替换所有常规卷积。这种设计符合MobileNets的整体设计，并且在计算上效率更高。我们将其称之为修改版本的SSDLite。与常规SSD相比，SSDLite显著降低了参数计数和计算成本，如表5所示。

在这里插入图片描述

表5：使用MobileNetV2配置的SSDLite和常规SSD之间的大小和计算成本。

对于MobileNetV1，按照[33]中的设置进行。对于MobileNetV2，SSDLite的第一层被附加到层15的扩展（输出步长为16）。SSDLite层的第二层和其余层连接在最后一层的顶部（输出步长为32）。此设置与MobileNetV1一致，因为所有层都附加到相同输出步长的特征图上。

MobileNet模型都经过了开源TensorFlow目标检测API的训练和评估[38]。 两个模型的输入分辨率为320×320。进行了基准测试并比较了mAP（COCO挑战度量标准），参数数量和Multiply-Adds数量。结果如表6所示。MobileNetV2 SSDLite不仅是最高效的模型，而且也是三者中最准确的模型。值得注意的是，MobileNetV2 SSDLite效率高20倍，模型要小10倍，但仍优于COCO数据集上的YOLOv2。

在这里插入图片描述

表6：MobileNetV2+SSDLite和其他实时检测器在COCO数据集目标检测任务中的性能比较。MobileNetV2+SSDLite以更少的参数和更小的计算复杂性实现了具有竞争力的精度。所有模型都在trainval35k上进行训练，并在test-dev上进行评估。SSD/YOLOv2的数字来自于[35]。使用内部版本的TF-Lite引擎，并记录了在Google Pixel 1手机的CPU推理的运行时间。

6.3 语义分割

在本节中，我们使用MobileNetV1和MobileNetV2网络作为特征提取器与DeepLabv3[39]在移动语义分割任务上进行比较。DeepLabv3采用了空洞卷积[40,41,42]，这是一种显式控制计算特征映射分辨率的强大工具，并构建了五个平行头部，包括（a）包含三个具有不同空洞率的 $3 \times 3$ 卷积的Atrous Spatial Pyramid Pooling模块(ASPP)[43]，（b）1×1卷积头部，以及（c）图像级特征[44]。对于分辨率，用输出步长来表示输入图像空间分辨率与最终输出分辨率的比值，该分辨率通过适当地应用空洞卷积来控制。对于语义分割，通常使用输出stride=16或8来获取更密集的特征映射。在PASCAL VOC 2012数据集[3]上进行实验，使用[45]中的额外标注图像和评估指标mIOU。

为了构建移动模型，我们尝试了三种设计变体：（1）不同的特征提取器，（2）简化DeepLabv3头部以加快计算速度，以及（3）提高性能的不同推断策略。结果总结在表7中。可以观察到：

（a）包括多尺度输入和添加左右翻转图像的推断策略显著增加了乘加操作次数，因此不适合于在设备上应用
（b）使用输出步长16比使用输出步长8更有效率
（c）MobileNetV1已经是一个强大的特征提取器，并且只需要比ResNet-101少约4.9-5.7倍的MAdd[8]（例如，mIOU：78.56 vs 82.70 和 MAdds：941.9B vs 4870.6B）
（d）在MobileNetV2的倒数第二个特征映射的顶部构建DeepLabv3头部比在原始的最后一个特征映射上更高效，因为倒数第二个特征映射包含320个通道而不是1280个通道，这样就可以达到类似的性能，但是要比MobileNetV1的通道少2.5倍
（e）DeepLabv3头部的计算成本很高，移除ASPP模块会显著减少MAdd并且只会稍微降低性能。
在表7末尾，鉴定了一个设备上的潜在候选应用，该应用可以达到75.32%mIOU并且只需要2.75B MAdds。

在这里插入图片描述

表7：PASCAL VOC 2012验证集上的MobileNet+DeepLabv3推断策略。MNet V2*：用于DeepLabv3头部的倒数第二个特征映射，其中包括（1）Atrous Spatial Pyramid Pooling（ASPP）模块和（2）1×1卷积以及图像池化功能。OS：控制分割映射输出分辨率的输出步长。MF：测试期间多尺度和左右翻转输入。所有的模型都在COCO上进行预训练。设备上的潜在候选应用以粗体显示。PASCAL图像的尺寸为 $512 x 512$ ，而空洞卷积使得我们可以在不增加参数数量的情况下控制输出特征分辨率。

在这里插入图片描述

6.4 消融实验

倒置残差连接。残差连接的重要性已被广泛研究[8，30，46]。本文报告的新结果是连接瓶颈的快捷连接性能优于连接扩展层的的快捷连接（请参见图6b以供比较）。

在这里插入图片描述

线性瓶颈的重要性。线性瓶颈模型的严格来说比非线性模型要弱一些，因为激活总是可以在线性状态下进行，并对偏差和缩放进行适当的修改。然而，在图6a中展示的实验表明，线性瓶颈改善了性能，为非线性破坏低维空间中的信息提供了支持。

7 总结及将来工作

我们描述了一个非常简单的网络架构，它允许我们建立一个高效的移动模型家族。提出的基本构造单元，有几个属性，使它特别适合移动应用程序。它允许非常高效的推理，并依赖于利用所有神经框架中的标准操作。

对于ImageNet数据集，本文提出的架构改善了许多性能点的最新技术水平。对于目标检测任务，我们的网络在精度和模型复杂度方面都优于COCO数据集上的最新实时检测器。值得注意的是，基于MobileNetV2基础架构的SSDLite检测模块相比YOLOv2，计算量少20倍，参数少10倍。

理论上：所提出的卷积块具有独特的属性，允许将网络表现力（由扩展层编码）与其容量（由瓶颈输入编码）分开。探索这个是未来研究的重要方向。

参考文献

Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. Imagenet large scale visual recognition challenge. Int. J. Comput. Vision, 115(3):211–252, December 2015.
Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dolla?r, and C Lawrence Zitnick. Microsoft COCO: Common objects in context. In ECCV, 2014.
Mark Everingham, S. M. Ali Eslami, Luc Van Gool, Christopher K. I. Williams, John Winn, and Andrew Zisserma. The pascal visual object classes challenge a retrospective. IJCV, 2014.
Mobilenetv2 source code. Available from https://github.com/tensorflow/models/tree/master/research/slim/nets/mobilenet.
Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In Bartlett et al. [48], pages 1106–1114.
Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014.
Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2015, Boston, MA, USA, June 7-12, 2015, pages 1–9. IEEE Computer Society, 2015.
Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015.
James Bergstra and Yoshua Bengio. Random search for hyper-parameter optimization. Journal of Machine Learning Research, 13:281–305, 2012.
Jasper Snoek, Hugo Larochelle, and Ryan P. Adams. Practical bayesian optimization of machine learning algorithms. In Bartlett et al. [48], pages 2960–2968.
Jasper Snoek, Oren Rippel, Kevin Swersky, Ryan Kiros, Nadathur Satish, Narayanan Sundaram, Md. Mostofa Ali Patwary, Prabhat, and Ryan P. Adams. Scalable bayesian optimization using deep neural networks. In Francis R. Bach and David M. Blei, editors, Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, volume 37 of JMLR Workshop and Conference Proceedings, pages 2171–2180. JMLR.org, 2015.
Babak Hassibi and David G. Stork. Second order derivatives for network pruning: Optimal brain surgeon. In Stephen Jose Hanson, Jack D. Cowan, and C. Lee Giles, editors, Advances in Neural Information Processing Systems 5, [NIPS Conference, Denver, Colorado, USA, November 30 - December 3, 1992], pages 164–171. Morgan Kaufmann, 1992.
Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In David S. Touretzky, editor, Advances in Neural Information Processing Systems 2, [NIPS Conference, Denver, Colorado, USA, November 27-30, 1989], pages 598–605. Morgan Kaufmann, 1989.
Song Han, Jeff Pool, John Tran, and William J. Dally. Learning both weights and connections for efficient neural network. In Corinna Cortes, Neil D. Lawrence, Daniel D. Lee, Masashi Sugiyama, and Roman Garnett, editors, Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pages 1135–1143, 2015.
Song Han, Jeff Pool, Sharan Narang, Huizi Mao, Shijian Tang, Erich Elsen, Bryan Catanzaro, John Tran, and William J. Dally. DSD: regularizing deep neural networks with dense-sparse-dense training flow. CoRR, abs/1607.04381, 2016.
Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient dnns. In Daniel D. Lee, Masashi Sugiyama, Ulrike von Luxburg, Isabelle Guyon, and Roman Garnett, editors, Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, pages 1379–1387, 2016.
Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. CoRR, abs/1608.08710, 2016.
Karim Ahmed and Lorenzo Torresani. Connectivity learning in multi-branch networks. CoRR, abs/1709.09582, 2017.
Tom Veniat and Ludovic Denoyer. Learning time-efficient deep architectures with budgeted super networks. CoRR, abs/1706.00046, 2017.
Xiangyu Zhang, Xinyu Zhou, Mengxiao Lin, and Jian Sun. Shufflenet: An extremely efficient convolutional neural network for mobile devices. CoRR, abs/1707.01083, 2017.
Soravit Changpinyo, Mark Sandler, and Andrey Zhmoginov. The power of sparsity in convolutional neural networks. CoRR, abs/1702.06257, 2017.
Min Wang, Baoyuan Liu, and Hassan Foroosh. Design of efficient convolutional layers using single intra-channel convolution, topological subdivisioning and spatial ”bottleneck” structure. CoRR, abs/1608.04337, 2016.
Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V. Le. Learning transferable architectures for scalable image recognition. CoRR, abs/1707.07012, 2017.
Lingxi Xie and Alan L. Yuille. Genetic CNN. CoRR, abs/1703.01513, 2017.
Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Jie Tan, Quoc V. Le, and Alexey Kurakin. Large-scale evolution of image classifiers. In Doina Precup and Yee Whye Teh, editors, Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, volume 70 of Proceedings of Machine Learning Research, pages 2902–2911. PMLR, 2017.
Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. CoRR, abs/1611.01578, 2016.
Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam.
Mobilenets: Efficient convolutional neural networks for mobile vision applications. CoRR, abs/1704.04861, 2017.
Francois Chollet. Xception: Deep learning with depthwise separable convolutions. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.
Dongyoon Han, Jiwhan Kim, and Junmo Kim. Deep pyramidal residual networks. CoRR, abs/1610.02915, 2016.
Saining Xie, Ross B. Girshick, Piotr Dolla ?r, Zhuowen Tu, and Kaiming He. Aggregated residual transformations for deep neural networks. CoRR, abs/1611.05431, 2016.
Mart?n Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane?, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Vie?gas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. Software available from tensorflow.org.
Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross Girshick, Sergio Guadarrama, and Trevor Darrell. Caffe: Convolutional architecture for fast feature embed- ding. arXiv preprint arXiv:1408.5093, 2014.
Jonathan Huang, Vivek Rathod, Chen Sun, Men- glong Zhu, Anoop Korattikara, Alireza Fathi, Ian Fischer, Zbigniew Wojna, Yang Song, Sergio Guadarrama, et al. Speed/accuracy trade-offs for modern convolutional object detectors. In CVPR, 2017.
Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, and Alexander C Berg. Ssd: Single shot multibox detector. In ECCV, 2016.
Joseph Redmon and Ali Farhadi. Yolo9000: Better, faster, stronger. arXiv preprint arXiv:1612.08242, 2016.
Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In Advances in neural information processing systems, pages 91–99, 2015.
Jifeng Dai, Yi Li, Kaiming He, and Jian Sun. R-fcn: Object detection via region-based fully convolutional networks. In Advances in neural information processing systems, pages 379–387, 2016.
Jonathan Huang, Vivek Rathod, Derek Chow, Chen Sun, and Menglong Zhu. Tensorflow object detection api, 2017.
Liang-Chieh Chen, George Papandreou, Florian Schroff, and Hartwig Adam. Rethinking atrous convolution for semantic image segmentation. CoRR, abs/1706.05587, 2017.
Matthias Holschneider, Richard Kronland-Martinet, Jean Morlet, and Ph Tchamitchian. A real-time algorithm for signal analysis with the help of the wavelet transform. In Wavelets: Time-Frequency Methods and Phase Space, pages 289–297. 1989.
Pierre Sermanet, David Eigen, Xiang Zhang, Michae?l Mathieu, Rob Fergus, and Yann LeCun. Overfeat: Integrated recognition, localization and detection using convolutional networks. arXiv:1312.6229, 2013.
George Papandreou,Iasonas Kokkinos, and Pierre Andre Savalle. Modeling local and global deformations in deep learning: Epitomic convolution, multiple instance learning, and sliding window detection. In CVPR, 2015.
Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. TPAMI, 2017.
Wei Liu, Andrew Rabinovich, and Alexander C. Berg. Parsenet: Looking wider to see better. CoRR, abs/1506.04579, 2015.
Bharath Hariharan, Pablo Arbela?ez, Lubomir Bourdev, Subhransu Maji, and Jitendra Malik. Semantic contours from inverse detectors. In ICCV, 2011.
Christian Szegedy, Sergey Ioffe, and Vincent Vanhoucke. Inception-v4, inception-resnet and the impact of residual connections on learning. CoRR, abs/1602.07261, 2016.
Guido Montu?far, Razvan Pascanu, Kyunghyun Cho, and Yoshua Bengio. On the number of linear regions of deep neural networks. In Proceedings of the 27th International Conference on Neural Information Processing Systems, NIPS’14, pages 2924–2932, Cambridge, MA, USA, 2014. MIT Press.
Peter L. Bartlett, Fernando C. N. Pereira, Christopher J. C. Burges, Le?on Bottou, and Kilian Q. Weinberger, editors. Advances in Neural Information Processing Systems 25: 26th Annual Conference on Neural Information Processing Systems 2012. Proceedings of a meeting held December 3-6, 2012, Lake Tahoe, Nevada, United States, 2012.

实现

基于torch1.8版本实现

import os
import sys
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from typing import Any

import torch
import torch.nn as nn
import torch.nn.init as init
import torch.nn.functional as f
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import torchvision

# 设置运行环境
os.environ['CUDA_VISIABLE_DIVICES'] = '0, 1'

# 设置超参数
batch_size = 64
lr = 1e-4
num_works = 8
epochs = 100


from torchvision import transforms
from torchvision import datasets

image_size = 224

data_transform = transforms.Compose(
    [transforms.Resize(image_size), transforms.ToTensor()]
    )

# load data
train_data = datasets.CIFAR10(root='../', train=True, download=True, transform=data_transform)
test_data = datasets.CIFAR10(root='../', train=False, download=True, transform=data_transform)


# data loader
train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True, num_workers=num_works, drop_last=True)
test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=True, num_workers=num_works, drop_last=False)

# show a picture
image, label = next(iter(train_loader))
print(image.shape, label.shape)

# plt.imshow(image[0][0], cmap='gray')

from collections import OrderedDict
# 把channel变为8的整数倍
def _make_divisible(ch, divisor=8, min_ch=None):
    if min_ch is None:
        min_ch = divisor
    new_ch = max(min_ch, int(ch + divisor / 2) // divisor * divisor)
    # Make sure that round down does not go down by more than 10%.
    if new_ch < 0.9 * ch:
        new_ch += divisor
    return new_ch

# 定义基本ConvBN+ReLU
class baseConv(nn.Module):
    def __init__(self, in_channels, output_channels, kernel_size, groups=1, stride=1):
        super(baseConv, self).__init__()
        pad = kernel_size // 2
        relu = nn.ReLU6(inplace=True)
        if kernel_size == 1 and in_channels > output_channels:
            relu = nn.Identity()
        self.baseConv = nn.Sequential(
            nn.Conv2d(
                in_channels=in_channels, out_channels=output_channels, kernel_size=kernel_size,
                stride=stride, padding=pad, groups=groups, bias=False),
            nn.BatchNorm2d(output_channels),
            relu
        )
    
    def forward(self, x):
        out = self.baseConv(x)
        return out
    
# 定义残差结构
class Residual(nn.Module):
    def __init__(self, in_channels, expand_rate, out_channels, stride):  # 输入和输出channel都要调整到8的整数倍
        super(Residual, self).__init__()
        expand_channel = int(expand_rate * in_channels)     # 升维后的channel
 
        conv1 = baseConv(in_channels, expand_channel, 1, stride=stride)
        if expand_rate == 1:
            # 此时没有1*1卷积升维
            conv1 = nn.Identity()
 
        # channel 1
        self.block1 = nn.Sequential(
            conv1,
            baseConv(expand_channel, expand_channel, 3, groups=expand_channel, stride=stride),
            baseConv(expand_channel, out_channels, 1)
        )
 
        if stride == 1 and in_channels==out_channels:
            self.has_res = True
        else:
            self.has_res = False
 
    def forward(self,x):
        if self.has_res:
            return self.block1(x) + x
        else:
            return self.block1(x)
        
# 定义mobilenetv2
class MobileNetV2(nn.Module):
    def __init__(self, theta=1, num_classes=10, init_weight=True):
        super(MobileNetV2, self).__init__()
        #[inchannel,t,out_channel,stride]
        net_config = [[32, 1, 16, 1],
                     [16, 6, 24, 2],
                     [24, 6, 32, 2],
                     [32, 6, 64, 2],
                     [64, 6, 96, 1],
                     [96, 6, 160, 2],
                     [160, 6, 320, 1]]
        repeat_num = [1, 2, 3, 4, 3, 3, 1]
 
        module_dic = OrderedDict()
 
        module_dic.update({'first_Conv': baseConv(3, _make_divisible(theta*32), 3, stride=2)})
 
        for idx, num in enumerate(repeat_num):
            parse = net_config[idx]
            for i in range(num):
                module_dic.update({'bottleneck{}_{}'.format(idx,i+1): Residual(
                    _make_divisible(parse[0]*theta), parse[1], _make_divisible(parse[2]*theta), parse[3])})
                parse[0] = parse[2]
                parse[-1] = 1
 
        module_dic.update({'follow_Conv': baseConv(
            _make_divisible(theta*parse[-2]), _make_divisible(1280*theta), 1)})
        module_dic.update({'avg_pool': nn.AdaptiveAvgPool2d(1)})
 
        self.module = nn.Sequential(module_dic)
 
        self.linear = nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(_make_divisible(theta*1280), num_classes)
        )
        #初始化权重
        if init_weight:
            self.init_weight()
 
    def init_weight(self):
        for w in self.modules():
            if isinstance(w, nn.Conv2d):
                nn.init.kaiming_normal_(w.weight, mode='fan_out')
                if w.bias is not None:
                    nn.init.zeros_(w.bias)
            elif isinstance(w, nn.BatchNorm2d):
                nn.init.ones_(w.weight)
                nn.init.zeros_(w.bias)
            elif isinstance(w, nn.Linear):
                nn.init.normal_(w.weight, 0, 0.01)
                nn.init.zeros_(w.bias)
 
 
    def forward(self,x):
        out = self.module(x)
        out = out.view(out.size(0),-1)
        out = self.linear(out)
        return out
    
model = MobileNetV2().cuda()

from torch.utils.tensorboard import SummaryWriter

writer1 = SummaryWriter('./runs/loss')
writer2 = SummaryWriter('./runs/acc')

def train(epoch):
    model.train()
    train_loss = 0
    for data, label in train_loader:
        data, label = data.cuda(), label.cuda()
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, label)
        loss.backward()
        optimizer.step()
        train_loss += loss.item() * data.size(0)
    train_loss = train_loss / len(train_loader.dataset)
    writer1.add_scalar('loss', train_loss, epoch)
    print('Epoch: {} \tTraining Loss: {:.6f}'.format(epoch, train_loss))
    
def val(epoch):
    # 设置评估状态
    model.eval()
    val_loss = 0
    gt_labels = []
    pred_labels = []
    # 不设置梯度
    with torch.no_grad():
        for data, label in test_loader:
            data, label = data.cuda(), label.cuda()
            output = model(data)
            preds = torch.argmax(output, 1)
            gt_labels.append(label.cpu().data.numpy())
            pred_labels.append(preds.cpu().data.numpy())
            loss = criterion(output, label)
            val_loss += loss.item()*data.size(0)
    # 计算验证集的平均损失
    val_loss = val_loss /len(test_loader.dataset)
    writer1.add_scalar('loss', val_loss, epoch)
    gt_labels, pred_labels = np.concatenate(gt_labels), np.concatenate(pred_labels)
    # 计算准确率
    acc = np.sum(gt_labels ==pred_labels)/len(pred_labels)
    writer2.add_scalar('acc', acc, epoch)
    print('Epoch: {} \tValidation Loss: {:.6f}, Accuracy: {:6f}'.format(epoch, val_loss, acc))
    

for epoch in range(1, epochs):
    train(epoch)
    val(epoch)
  
writer1.close()
writer2.close()

Epoch: 1 	Training Loss: 1.810957
Epoch: 1 	Validation Loss: 1.719430, Accuracy: 0.362200
Epoch: 2 	Training Loss: 1.676903
Epoch: 2 	Validation Loss: 1.608585, Accuracy: 0.402700
Epoch: 3 	Training Loss: 1.576324
Epoch: 3 	Validation Loss: 1.531075, Accuracy: 0.435100
Epoch: 4 	Training Loss: 1.493314
Epoch: 4 	Validation Loss: 1.467211, Accuracy: 0.462900
Epoch: 5 	Training Loss: 1.416125
Epoch: 5 	Validation Loss: 1.421887, Accuracy: 0.479000
Epoch: 6 	Training Loss: 1.350971
Epoch: 6 	Validation Loss: 1.374000, Accuracy: 0.502500
Epoch: 7 	Training Loss: 1.295407
Epoch: 7 	Validation Loss: 1.332756, Accuracy: 0.515400
Epoch: 8 	Training Loss: 1.239381
Epoch: 8 	Validation Loss: 1.299337, Accuracy: 0.533700
Epoch: 9 	Training Loss: 1.196423
Epoch: 9 	Validation Loss: 1.281068, Accuracy: 0.542300
Epoch: 10 	Training Loss: 1.146194
Epoch: 10 	Validation Loss: 1.272490, Accuracy: 0.541300
Epoch: 11 	Training Loss: 1.104716
Epoch: 11 	Validation Loss: 1.239548, Accuracy: 0.550400
Epoch: 12 	Training Loss: 1.060632
Epoch: 12 	Validation Loss: 1.229520, Accuracy: 0.557300
Epoch: 13 	Training Loss: 1.021109
Epoch: 13 	Validation Loss: 1.230691, Accuracy: 0.561600
Epoch: 14 	Training Loss: 0.978715
Epoch: 14 	Validation Loss: 1.227288, Accuracy: 0.567700
Epoch: 15 	Training Loss: 0.946122
Epoch: 15 	Validation Loss: 1.227637, Accuracy: 0.569300
Epoch: 16 	Training Loss: 0.914712
Epoch: 16 	Validation Loss: 1.233961, Accuracy: 0.567700
Epoch: 17 	Training Loss: 0.881835
Epoch: 17 	Validation Loss: 1.236654, Accuracy: 0.573900
Epoch: 18 	Training Loss: 0.853574
Epoch: 18 	Validation Loss: 1.241994, Accuracy: 0.567400
Epoch: 19 	Training Loss: 0.815818
Epoch: 19 	Validation Loss: 1.240301, Accuracy: 0.578300
Epoch: 20 	Training Loss: 0.795989
Epoch: 20 	Validation Loss: 1.246372, Accuracy: 0.577600
Epoch: 21 	Training Loss: 0.762715
Epoch: 21 	Validation Loss: 1.245699, Accuracy: 0.579200
Epoch: 22 	Training Loss: 0.735654
Epoch: 22 	Validation Loss: 1.256266, Accuracy: 0.579300
Epoch: 23 	Training Loss: 0.706454
Epoch: 23 	Validation Loss: 1.264054, Accuracy: 0.588900
Epoch: 24 	Training Loss: 0.688257
Epoch: 24 	Validation Loss: 1.277016, Accuracy: 0.586300
Epoch: 25 	Training Loss: 0.664483
Epoch: 25 	Validation Loss: 1.301662, Accuracy: 0.581400
Epoch: 26 	Training Loss: 0.644624
Epoch: 26 	Validation Loss: 1.305807, Accuracy: 0.585400
Epoch: 27 	Training Loss: 0.622638
Epoch: 27 	Validation Loss: 1.320582, Accuracy: 0.584700
Epoch: 28 	Training Loss: 0.601053
Epoch: 28 	Validation Loss: 1.332019, Accuracy: 0.582500
Epoch: 29 	Training Loss: 0.576634
Epoch: 29 	Validation Loss: 1.346888, Accuracy: 0.584400
Epoch: 30 	Training Loss: 0.563225
Epoch: 30 	Validation Loss: 1.338611, Accuracy: 0.590500
Epoch: 31 	Training Loss: 0.536210
Epoch: 31 	Validation Loss: 1.396149, Accuracy: 0.586900
Epoch: 32 	Training Loss: 0.526350
Epoch: 32 	Validation Loss: 1.393504, Accuracy: 0.584400
Epoch: 33 	Training Loss: 0.510057
Epoch: 33 	Validation Loss: 1.412067, Accuracy: 0.587700
Epoch: 34 	Training Loss: 0.492913
Epoch: 34 	Validation Loss: 1.411729, Accuracy: 0.589900
Epoch: 35 	Training Loss: 0.474919
Epoch: 35 	Validation Loss: 1.455104, Accuracy: 0.589100
Epoch: 36 	Training Loss: 0.461658
Epoch: 36 	Validation Loss: 1.490079, Accuracy: 0.578600
Epoch: 37 	Training Loss: 0.451400
Epoch: 37 	Validation Loss: 1.521622, Accuracy: 0.585800
Epoch: 38 	Training Loss: 0.434309
Epoch: 38 	Validation Loss: 1.481987, Accuracy: 0.600300
Epoch: 39 	Training Loss: 0.420812
Epoch: 39 	Validation Loss: 1.512111, Accuracy: 0.594100
Epoch: 40 	Training Loss: 0.408870
Epoch: 40 	Validation Loss: 1.492593, Accuracy: 0.590200
Epoch: 41 	Training Loss: 0.400788
Epoch: 41 	Validation Loss: 1.523888, Accuracy: 0.594500
Epoch: 42 	Training Loss: 0.386415
Epoch: 42 	Validation Loss: 1.580727, Accuracy: 0.586000
Epoch: 43 	Training Loss: 0.381696
Epoch: 43 	Validation Loss: 1.554854, Accuracy: 0.592400
Epoch: 44 	Training Loss: 0.367677
Epoch: 44 	Validation Loss: 1.630810, Accuracy: 0.584900
Epoch: 45 	Training Loss: 0.359994
Epoch: 45 	Validation Loss: 1.601435, Accuracy: 0.588500
Epoch: 46 	Training Loss: 0.344085
Epoch: 46 	Validation Loss: 1.606170, Accuracy: 0.590800
Epoch: 47 	Training Loss: 0.334941
Epoch: 47 	Validation Loss: 1.626990, Accuracy: 0.594400
Epoch: 48 	Training Loss: 0.327167
Epoch: 48 	Validation Loss: 1.674634, Accuracy: 0.587800
Epoch: 49 	Training Loss: 0.330610
Epoch: 49 	Validation Loss: 1.636740, Accuracy: 0.593300
Epoch: 50 	Training Loss: 0.313765
Epoch: 50 	Validation Loss: 1.644818, Accuracy: 0.587400
Epoch: 51 	Training Loss: 0.308049
Epoch: 51 	Validation Loss: 1.666548, Accuracy: 0.591200
Epoch: 52 	Training Loss: 0.292868
Epoch: 52 	Validation Loss: 1.737115, Accuracy: 0.585000
Epoch: 53 	Training Loss: 0.290087
Epoch: 53 	Validation Loss: 1.723058, Accuracy: 0.591900
Epoch: 54 	Training Loss: 0.283930
Epoch: 54 	Validation Loss: 1.745838, Accuracy: 0.592300
Epoch: 55 	Training Loss: 0.289035
Epoch: 55 	Validation Loss: 1.746200, Accuracy: 0.591200
Epoch: 56 	Training Loss: 0.274887
Epoch: 56 	Validation Loss: 1.702432, Accuracy: 0.595100
Epoch: 57 	Training Loss: 0.265010
Epoch: 57 	Validation Loss: 1.791876, Accuracy: 0.592700
Epoch: 58 	Training Loss: 0.256690
Epoch: 58 	Validation Loss: 1.809799, Accuracy: 0.592200
Epoch: 59 	Training Loss: 0.256642
Epoch: 59 	Validation Loss: 1.809049, Accuracy: 0.596700
Epoch: 60 	Training Loss: 0.256684
Epoch: 60 	Validation Loss: 1.794926, Accuracy: 0.599500
Epoch: 61 	Training Loss: 0.247338
Epoch: 61 	Validation Loss: 1.804069, Accuracy: 0.588100
Epoch: 62 	Training Loss: 0.244381
Epoch: 62 	Validation Loss: 1.832358, Accuracy: 0.592800
Epoch: 63 	Training Loss: 0.233596
Epoch: 63 	Validation Loss: 1.829341, Accuracy: 0.598300
Epoch: 64 	Training Loss: 0.233288
Epoch: 64 	Validation Loss: 1.823511, Accuracy: 0.597300
Epoch: 65 	Training Loss: 0.236817
Epoch: 65 	Validation Loss: 1.848694, Accuracy: 0.596200
Epoch: 66 	Training Loss: 0.220656
Epoch: 66 	Validation Loss: 1.866383, Accuracy: 0.592700
Epoch: 67 	Training Loss: 0.219230
Epoch: 67 	Validation Loss: 1.835766, Accuracy: 0.592400
Epoch: 68 	Training Loss: 0.216084
Epoch: 68 	Validation Loss: 1.876546, Accuracy: 0.589100
Epoch: 69 	Training Loss: 0.210298
Epoch: 69 	Validation Loss: 1.879462, Accuracy: 0.602100
Epoch: 70 	Training Loss: 0.197480
Epoch: 70 	Validation Loss: 1.916892, Accuracy: 0.595500
Epoch: 71 	Training Loss: 0.209614
Epoch: 71 	Validation Loss: 1.877901, Accuracy: 0.601600
Epoch: 72 	Training Loss: 0.201937
Epoch: 72 	Validation Loss: 1.869245, Accuracy: 0.598300
Epoch: 73 	Training Loss: 0.192207
Epoch: 73 	Validation Loss: 1.929820, Accuracy: 0.600200
Epoch: 74 	Training Loss: 0.193890
Epoch: 74 	Validation Loss: 1.905469, Accuracy: 0.601000
Epoch: 75 	Training Loss: 0.194677
Epoch: 75 	Validation Loss: 1.901946, Accuracy: 0.607300
Epoch: 76 	Training Loss: 0.184587
Epoch: 76 	Validation Loss: 1.948870, Accuracy: 0.596900
Epoch: 77 	Training Loss: 0.187412
Epoch: 77 	Validation Loss: 1.941691, Accuracy: 0.603100
Epoch: 78 	Training Loss: 0.189762
Epoch: 78 	Validation Loss: 1.912730, Accuracy: 0.602300
Epoch: 79 	Training Loss: 0.180055
Epoch: 79 	Validation Loss: 1.962166, Accuracy: 0.600800
Epoch: 80 	Training Loss: 0.180275
Epoch: 80 	Validation Loss: 1.942520, Accuracy: 0.596300
Epoch: 81 	Training Loss: 0.171043
Epoch: 81 	Validation Loss: 1.949362, Accuracy: 0.600800
Epoch: 82 	Training Loss: 0.175670
Epoch: 82 	Validation Loss: 1.946251, Accuracy: 0.603200
Epoch: 83 	Training Loss: 0.172893
Epoch: 83 	Validation Loss: 1.928012, Accuracy: 0.599400
Epoch: 84 	Training Loss: 0.154137
Epoch: 84 	Validation Loss: 2.012115, Accuracy: 0.595800
Epoch: 85 	Training Loss: 0.168310
Epoch: 85 	Validation Loss: 2.000640, Accuracy: 0.598800
Epoch: 86 	Training Loss: 0.162197
Epoch: 86 	Validation Loss: 1.978441, Accuracy: 0.604100
Epoch: 87 	Training Loss: 0.166564
Epoch: 87 	Validation Loss: 1.963371, Accuracy: 0.605500
Epoch: 88 	Training Loss: 0.155635
Epoch: 88 	Validation Loss: 2.043188, Accuracy: 0.603600
Epoch: 89 	Training Loss: 0.162715
Epoch: 89 	Validation Loss: 1.977750, Accuracy: 0.601400
Epoch: 90 	Training Loss: 0.152931
Epoch: 90 	Validation Loss: 2.027132, Accuracy: 0.604000
Epoch: 91 	Training Loss: 0.151899
Epoch: 91 	Validation Loss: 2.042946, Accuracy: 0.600300
Epoch: 92 	Training Loss: 0.147288
Epoch: 92 	Validation Loss: 2.039895, Accuracy: 0.601500
Epoch: 93 	Training Loss: 0.155015
Epoch: 93 	Validation Loss: 2.001631, Accuracy: 0.604000
Epoch: 94 	Training Loss: 0.149201
Epoch: 94 	Validation Loss: 2.011332, Accuracy: 0.604600
Epoch: 95 	Training Loss: 0.143354
Epoch: 95 	Validation Loss: 2.041944, Accuracy: 0.606400
Epoch: 96 	Training Loss: 0.142200
Epoch: 96 	Validation Loss: 2.047203, Accuracy: 0.605500
Epoch: 97 	Training Loss: 0.144368
Epoch: 97 	Validation Loss: 2.013619, Accuracy: 0.605800
Epoch: 98 	Training Loss: 0.139549
Epoch: 98 	Validation Loss: 2.079411, Accuracy: 0.602600
Epoch: 99 	Training Loss: 0.137218
Epoch: 99 	Validation Loss: 2.061809, Accuracy: 0.602000

在这里插入图片描述