• Pytorch之MobileNetV3图像分类

    • 💂 个人主页:风间琉璃
    • 🤟 版权: 本文由【风间琉璃】原创、在CSDN首发、需要转载请联系博主
    • 💬 如果文章对你有帮助、欢迎关注、点赞、收藏(一键三连)和订阅专栏哦

    目录​​​​​​​​​​​​​​

    前言

     一、MobileNet v1

    1.深度可分离卷积

     (1)深度卷积(Depthwise convolution)

    (2)逐点卷积(Pointwise convolution)

    (3)计算量对比

    2.MobileNet v1网络结构

    (1)核心层（深度可分离卷积层）​​编辑

    (2)宽度因子和分辨率因子

    (3)网络结构

    3.创新点

    二、MobileNet v2

    1.Linear Bottlenecks

    2.Inverted Residuals

    3.MobileNet v2网络结构

    三、MobileNet v3

    1.SE模块

    2.耗时层结构

    3.ReLu6和h-swish激活函数

    4.网络总体结构

     四、MobileNet网络实现

    1.构建MobileNet网络

    2.加载数据集

    3.训练和测试模型

    五、实现图像分类

    前言

    由于传统卷积神经网络， 内存需求大、 运算量大导致无法在移动设备以及嵌入式设备上运行。VGG16的权重大小有450M，而ResNet中152层的模型，其权重模型644M，这么大的内存需求是明显无法在嵌入式设备上进行运行的。而网络应该服务于生活，所以轻量级网络的很重要的。

    MobileNet 模型是 google 在 2017 年针对手机或者嵌入式提出轻量级模型。MobileNet是一系列的轻量化神经网络，包括MobileNet v1、MobileNet v2和MobileNet v3。

    MobileNet v1是在VGG网络的基础上引入了深度可分离卷积（Depthwise Separable Convolutions），从而使得卷积参数大大减少，达到轻量化的效果。

    MobileNet v2在v1的基础上引入了倒残差结构（Bottleneck Residual Block），并加入了shortcut连接，以进一步提高网络的性能。

    MobileNet v3使用了 NAS 和 NetAdapt 算法搜索最优的模型结构，同时对模型一些结构进行了改进，例如在 MobileNet v2 的 Bottleneck Residual Block 基础上引入 Squeeze-and-Excitation

     一、MobileNet v1

    Mobilenet v1是一种轻量级的神经网络结构，用于图像分类和目标检测任务。它的设计目标是在保持较高准确率的同时，减少了模型的计算复杂度和参数量。

    Mobilenet v1使用了深度可分离卷积（depthwise separable convolution）来减少计算量。深度可分离卷积将标准卷积分为深度卷积和逐点卷积两个步骤，从而降低了计算量和参数量。此外，Mobilenet v1还使用了全局平均池化来减少全连接层的数量，进一步减小了模型的规模。

    介绍MobileNet v1可以使用一句话概括，MobileNet v1只要将把VGG中的标准卷积层换成深度可分离卷积即可。

    1.深度可分离卷积

    MobileNet模型是基于深度可分离卷积，这是一种分解卷积的形式。这种形式将标准卷积分解为一个深度卷积和一个称为逐点卷积的1x1的卷积。

    所以深度可分离卷积应该由两个部分组成，即深度卷积和逐点卷积。用下图直观进行表示：

    ​

    ​ 

    先了解标准卷积的计算过程：对所有输入通道用相同的卷积核得到不同通道特征，将不同通道特征组合起来使得输出特征包含每个输入的特征。

    ​ 

    特点：

    • 输入特征矩阵channel = 卷积核channel
    • 卷积核个数 = 输出特征矩阵channel

     (1)深度卷积(Depthwise convolution)

    深度卷积对每一个输入通道应用一个单独的卷积核（与标准卷积不同，标准卷积对每一个输入通道应用同一个卷积核）得到特征图，此时，每张特征图仅与一个输入通道和其对应卷积核相关，各个通道之间特征图不关联。

    DW卷积中的每一个卷积核，只会和输入特征矩阵的一个channel进行卷积计算，所以输出的特征矩阵就等于输入的特征矩阵。

    特点：

    • 卷积核channel=1
    • 输入特征矩阵channel=卷积核个数=输出特征矩阵channel

    (2)逐点卷积(Pointwise convolution)

    点卷积（1x1卷积）将深度卷积的输出特征图进行线性组合后再输出，使得最后的输出特征都包含每个输入特征，即将深度卷积输出的不关联的特征图关联起来。

    点卷积将标准卷积层中卷积核大小换成1x1即可得到，其主要作用就是对特征图进行升维和降维。

    ​

    (3)计算量对比

    图为标准卷积与深度可分离卷积对应的计算量

    ​

    其中D_{F} 为输入Feature Map的宽度和高度（假设输入特征图与使用的卷积核均为正方形），

    M为输入通道数 / 输入Feature Map深度），N为输出通道数，D_{K}​为卷积核大小。

    然后引入计算量的定义：

    参数数量（params）：关系到模型大小，单位通常为M，通常参数用 float32 表示，所以模型大小是参数数量的 4 倍。

    FLOPS(floating point operations per second)：注意全大写，指每秒浮点运算次数，理解为计算速度，是一个衡量硬件性能的指标。

    FLOPs(floating point operations)：注意s小写（s表复数），指浮点运算数，理解为计算量。

    可以用来衡量算法/模型的复杂度。这关系到算法速度，大模型的单位通常为 G，小模型单位通常为 M。

    注意在深度学习中，我们用FLOPs，也就是计算量，用来衡量算法/模型的复杂度。

     不同神经网络层的参数数量和计算量估计方法：

    Conv2d标准卷积层：
    Input: H ∗ W ∗ N 
    Output:H ∗ W ∗ M 
    Filters: K ∗ K
    ==>
    Params: K ∗ K ∗ M ∗ N 
    FLOPs: H ∗ W ∗ K ∗ K ∗ M ∗ N 

    FC全连接层：
    Input: N
    Output: M 
    ==>
    Params: M ∗ N 
    FLOPs: M ∗ N

    Depthwise conv2d深度卷积:
    Input: H ∗ W ∗ M 
    Output: H ∗ W ∗ M
    Filters: K ∗ K
    ==>
    Params: K ∗ K ∗ M 
    FLOPs: H ∗ W ∗ K ∗ K ∗ M  

    Pointwise conv2d点卷积：
    将标准卷积层中卷积核大小换成1x1即可得到
    Params: M ∗ N
    FLOPs: H ∗ W ∗ M ∗ N

    从上面我们可以得到，使用深度可分离卷积后得到的总计算量为DF*DF*DK*DK + DF*DF*M*N。

    将深度可分离卷积的总计算量与标准卷积相比较，可以得到下面式子，


    深度可分离卷积的计算量是标准卷积 的 1/N +1/( Dk * Dk)倍。通常情况下，N (输出通道）远大于卷积核尺寸，故1/N +1/( Dk * Dk) 近似等于 1/( Dk * Dk)。

    当卷积核的大小为Dk =3 时，深度可分离卷积的计算量约为标准卷积的1/9倍。

    2.MobileNet v1网络结构

    (1)核心层（深度可分离卷积层）
    ​

    上图左边是标准卷积层，右边是V1的卷积层。V1的卷积层，首先使用3×3的深度卷积提取特征，接着是BN层、ReLU层，这里的第一个ReLU是指的ReLU6，在之后是逐点卷积，BN和ReLU。这也很符合深度可分离卷积，将左边的标准卷积拆分成右边的一个深度卷积和一个逐点卷积。

    Relu6（抑制其最大值）：

    公式：当 x > 6时，其导数也为0。

    主要是为了在移动端float16的低精度的时候，也能有很好的数值分辨率，如果对ReLu的输出值不加限制，那么输出范围就是0到正无穷，而低精度的float16无法精确描述其数值，带来精度损失。

    ReLU和ReLU6图表对比：

    (2)宽度因子和分辨率因子

     MobileNetV1还使用宽度因子和分辨率因子进一步减小模型参数数量和计算量，当然，在一定程度上会降低模型精确度。

    宽度因子Width Multiplier(α):
    α ∈ ( 0 , 1 ]作用于通道数量上，通常取1, 0.75, 0.5和0.25

    由上式可得，模型计算量和参数量大约降低a^{2}

    分辨率因子Resolution Multiplier(ρ)
    ρ ∈ ( 0 , 1 ] 作用于输入图像上，通常取为224,192,160和128（常隐式表示），作用后模型大小，参数量不变，计算量降低为\rho ^{2}   

    (3)网络结构

    MobileNetV1 网络结构如下图所示，其中 Conv 表示普通卷积，Conv dw 表示 DW 卷积操作。

    整个MobileNet v1网络除了平均池化层和softmax输出层外，共28层，其中深度卷积层有13层。

    第1层为3x3的标准卷积，s2进行下采样。接下来26层为核心层结构（深度可分离卷积层），并且其中的部分深度卷积会利用s2进行下采样。最后采用平均池化层将feature变成1x1，根据预测类别大小全连接层加softmax层输出


    除全连接层不使用激活函数，而使用softmax进行分类之外，其他所有层都使用BatchNorm和ReLU。

    MobileNet v1网络有一个缺点：DW 卷积核很容易废掉，即卷积核参数大部分为 0。

    3.创新点

    (1)MobileNetV1提出了深度可分离卷积的概念，替代了标准卷积操作，大大减少了参数数量和计算量。


    (2)提出两个超参数宽度因子和分辨率因子,可根据现实情况需求，调整输入输出通道数量和输入图像尺寸，可自由权衡精度与参数数量，计算量。


    (3)使用BN加快模型收敛速度，提高模型精度和泛化能力。
     

    二、MobileNet v2

    在MobileNet v1的实际训练过程中，深度卷积时卷积核特别容易废掉，即训练完成后卷积核参数是大部分为0。

    在 2018 年 googleNet 提出了 v2 版本的 mobileNet，v2认为是Relu函数造成这样的原因：在输入维度是2，3时，输出和输入相比丢失了较多信息；但是在输入维度是15到30时，输出则保留了输入的较多信息。如下图所示，

    所以在使用Relu函数时，当输入的维度较低时，会丢失较多信息，因此我们这里可以想到两种思路，一是把Relu激活函数替换成别的，二是通过升维将输入的维度变高。

    1.Linear Bottlenecks

    从v1可知，深度可分离卷积层的构成：首先是一个3x3的深度卷积，其次是BN、Relu层，接下来是1x1的逐点卷积，最后又是BN和Relu层。

    既然是ReLU导致的信息损耗，将ReLU替换成线性激活函数。但是需要注意的是，并不是将所有的Relu激活都换成了线性激活，而是将最后一个ReLU6变成线性激活函数，如下图。变换后的模块称为Linear Bottlenecks。

    线性瓶颈(Linear Bottlenecks) 在高维空间上，如 ReLU 这种激活函数能有效增加特征的非线性表达，但是仅限于高维空间中，如果降低维度，再使用 ReLU 则会破坏特征。

    因此在 mobileNets V2 中提出了 Linear Bottlenecks 结构，在执行了降维的卷积层后面，不再加入类似 ReLU 等的激活函数进行非线性转化，这样做的目的是尽可能的不造成信息的丢失。

    2.Inverted Residuals

    Inverted Residuals(倒残差结构)，通过下图可以看出，左侧为ResNet中的残差结构，其结构为1x1卷积降维--->3x3卷积--->1x1卷积升维；右侧为MobileNetV2中的倒残差结构，其结构为1x1卷积升维--->3x3DW卷积--->1x1卷积降维。V2先使用1x1卷积进行升维的原因是高维信息通过ReLU激活函数后丢失的信息更少。

    倒残差结构(Inverted residual) 在 ResNet 为了构建更深的网络，提出了 ResNet 的另一种形式，一个 bottleneck 由一个 1 x 1 卷积(降维)，3 x 3 卷积和 1 x 1 卷积(升维)构成。

    在 MobileNet 中，DW 卷积的层数是输入通道数，本身就比较少，如果跟残差网络中 bottleneck 一样，先压缩，后卷积提取，可得到特征就太少了。采取了一种逆向的方法—先升维，卷积，再降维。

    ResNet网络：残差结构是先用1*1卷积降维，3x3卷积，1x1卷积升维，两头大中间小。

    MobileNet v2：残差结构是先用1*1卷积升维，dw卷积，1x1卷积降维，两头小中间大。

    所以MobileNet v1和v2的block如下：

    左边是v1的block，没有Shortcut并且带最后的ReLU6。

    右边是v2的加入了1×1升维，引入Shortcut并且将最后的ReLU改为Linear。步长为1时，先进行1×1卷积升维，再进行深度卷积提取特征，再通过Linear的逐点卷积降维。将input与output相加，形成残差结构。

    步长为2时，因为input与output的尺寸不符，因此不添加shortcut结构，其余均一致。当stride=1且输入特征矩阵与输出特征矩阵shape相同时才有shortcut链接。

    3.MobileNet v2网络结构

    MobileNet v2网络结构如下图所示，其中 conv2d表示普通卷积，bottleneck表示右边的block。

    上图是MobileNet v2网络的结构表，其中t代表的是扩展因子（倒残差结构中第一个1x1卷积的扩展因子），c代表输出特征矩阵的channel，n代表倒残差结构重复的次数，s代表步距（注意：当有多个bottleneck,  s只针对第一个bottleneck这里的步距只是针对重复n次的第一层倒残差结构，后面的都默认为1）。

    三、MobileNet v3

    MobileNetV3，是谷歌在2019年3月21日提出的网络架构。首先，引入眼帘的是这篇文章的标题"Searching for MobileNetV3"，“searching”一词就把V3的论文的核心观点展示了出来——用神经结构搜索（NAS）来完成V3参数的设计。

    想较于之前的网络，不管是VGG、ResNet、MobileNetV1、MobileNetV2，网络结构都是我们自己手动去设计的，如网络的层数、卷积核大小、步长等等参数都需要自己设置。而NAS通过计算机来实现最优的参数设定，通过比较不同参数的网络模型效果，从而选择最优的参数设置。但是这也对计算机的性能要求也特别的高。
     

    主要特点：

    ①论文推出两个版本：Large 和 Small，分别适用于不同的场景。

    ②使用NetAdapt算法获得卷积核和通道的最佳数量。

    ③继承V1的深度可分离卷积。

    ④继承V2的具有线性瓶颈的残差结构。

    ⑤引入SE通道注意力结构。

    ⑥使用了一种新的激活函数h-swish(x)代替Relu6，h的意思表示hard。

    ⑦使用了Relu6(x + 3)/6来近似SE模块中的sigmoid。

    ⑧修改了MobileNetV2后端输出head。

    1.SE模块

    引入SE模块，主要为了利用结合特征通道的关系来加强网络的学习能力。它首先是将特征图的每个通道都进行平均池化，然后进行两个全连接层得到一个输出结果，这个结果会和原始的特征图进行相乘，得到新的特征图。

    网络的左半部分是一个传统的卷积变换，忽略掉这一部分并不会影响我们的SE模块的理解。直接看一下后半部分，其中 U 是一个 W×H×C 的Feature Map， (W,H) 是图像的尺寸， C是图像的通道数。 

     首先是Fsq(⋅) （Squeeze操作），顺着空间维度来进行特征压缩，将每个二维的特征通道变成一个 1×1×C 的特征向量，特征向量的值由U确定。这个实数某种程度上具有全局的感受野，并且输出的维度和输入的特征通道数相匹配。它表征着在特征通道上响应的全局分布，而且使得靠近输入的层也可以获得全局的感受野，这一点在很多任务中都是非常有用的。

    Squeeze部分的作用是获得Feature Map U的每个通道的全局信息嵌入（特征向量）。在SE block中，这一步通过VGG中引入的Global Average Pooling（GAP）实现的，即通过求每个通道C Feature Map的平均值。

    其次是 Excitation 操作，它是一个类似于循环神经网络中门的机制。通过参数 w 来为每个特征通道生成权重，其中参数 w 被学习用来显式地建模特征通道间的相关性。

     最后是一个 Reweight 的操作，将 Excitation 的输出的权重看做是经过特征选择后的每个特征通道的重要性，然后通过乘法逐通道加权到先前的特征上，完成在通道维度上的对原始特征的重标定。

    以在Mobilenetv3中的应用为例进行理解，

    首先下图左上角表示为四个通道的特质图，经平均池化后得到左下角的图；再次经过两次全连接层后，转化成了右下角的图，最后用右下角的0.5、0.3，0.1，0.2（Conv1每个channel的权值系数）分别乘原始的特质图，则得到最终的右上角的图。

    2.耗时层结构

    在MobileNet v3中，作者重新设计耗时层结构，首先减少第一个卷积层卷积核个数，从原来的32个变为16个，使用ReLU或者swich，其准确率几乎相同，并且节省了2ms和1000万madds。

    其次，精简了Last Stage。Original Last Stage是通过NAS算出来的，但最后实际测试发现Efficient Last Stage结构可以在不损失精度情况下去除一些多余的层，如下图所示，

    移除之前的瓶颈层连接，进一步降低网络参数。可以有效降低11%的推理耗时，而性能几乎没有损失。 

    3.ReLu6和h-swish激活函数

    在v1和v2版本中用到的Relu激活函数是Relu6激活函数，ReLu6激活函数如下图所示，在ReLU的基础上加了最大值6进行限制。

    v3版本使用的激活函数为h-swish,其图像和表达式如下图所示：图中包括了一些其他相关的一些函数表达式及图像。

    采用h-swish(hardswish)，计算速度相对较快，有利于量化 。

    h-swish是基于swish的改进，swish最早是在谷歌大脑2017的论文Searching for Activation functions所提出 。

    swish论文的作者认为，Swish具备无上界有下界、平滑、非单调的特性。并且Swish在深层模型上的效果优于ReLU。仅仅使用Swish单元替换ReLU就能把MobileNet,NASNetA在 ImageNet上的top-1分类准确率提高0.9%，Inception-ResNet-v的分类准确率提高0.6%。

    v3也利用swish当作为ReLU的替代时，它可以显著提高神经网络的精度。但是呢，作者认为这种非线性激活函数虽然提高了精度，但在嵌入式环境中，是有不少的成本的。原因就是在移动设备上计算sigmoid函数是非常明智的选择。所以提出了h-swish。

    可以用一个近似函数来逼近swish，作者选择的是基于ReLU6，作者认为几乎所有的软件和硬件框架上都可以使用ReLU6的优化实现。其次，它能在特定模式下消除了由于近似sigmoid的不同实现而带来的潜在的数值精度损失。

    作者认为随着网络的深入，应用非线性激活函数的成本会降低，能够更好的减少参数量。作者发现swish的大多数好处都是通过在更深的层中使用它们实现的。因此，在V3的架构中，只在模型的后半部分使用h-swish(HS)。 

    4.网络总体结构

    MobileNet v3特有的block结构如下，

    当stride=1且输入特征矩阵与输出特征矩阵shape相同时才有shortcut链接。

    作者针对不同需求，通过NAS得到两种结构，一个是MobilenetV3-Large，结构如下图：

    ①Input表示输入尺寸
    ②Operator中的NBN表示不使用BN，最后的conv2d 1x1相当于全连接层的作用
    ③exp size表示bottleneck中的第一层1x1卷积升维，维度升到多少(第一个bottleneck没有1x1卷积升维操作)
    ④out表示bottleneck输出的channel个数
    ⑤SE表示是否使用SE模块

    ⑥NL表示使用何种激活函数，HS表示HardSwish，RE表示ReLu
    ⑦s表示步长(s=2，长宽变为原来一半)

     四、MobileNet网络实现

    1.构建MobileNet网络

    MobileNet网络Inverted Residuals(倒残差结构)如下所示：

    1. # 倒残差结构
    2. class InvertedResidual(nn.Module):
    3.     def __init__(self, in_channel, out_channel, stride, expand_ratio):
    4.         super(InvertedResidual, self).__init__()
    5.         # expand_ratio：扩展因子
    6.         hidden_channel = in_channel * expand_ratio  # output: h x w x （tk=hidden_channel)
    7.         # 是否使用shortcut :当stride=1而且输入特征矩阵和输出特征矩阵shape相同时才有shortcut
    8.         self.use_shortcut = (stride == 1 and in_channel == out_channel)
    9.  
    10.         layers = []
    11.         if expand_ratio != 1:
    12.             # 1x1 pointwise conv
    13.             layers.append(ConvBNReLU(in_channel, hidden_channel, kernel_size=1))
    14.         layers.extend([
    15.             # 3x3 depthwise conv
    16.             ConvBNReLU(hidden_channel, hidden_channel, stride=stride, groups=hidden_channel),
    17.             # 1x1 pointwise conv(linear) 这里激活函数为linear(y=x)，所以不做任何处理
    18.             nn.Conv2d(hidden_channel, out_channel, kernel_size=1, bias=False),
    19.             nn.BatchNorm2d(out_channel),
    20.         ])
    21.  
    22.         self.conv = nn.Sequential(*layers)
    23.  
    24.     def forward(self, x):
    25.         if self.use_shortcut:
    26.             return x + self.conv(x)
    27.         else:
    28.             return self.conv(x)

     依据论文中表格网络配置MobileNetV2

    1. # 将ch调整为divisor最近的的整数倍
    2. def _make_divisible(ch, divisor=8, min_ch=None):
    3.     """
    4.     This function is taken from the original tf repo.
    5.     It ensures that all layers have a channel number that is divisible by 8
    6.     It can be seen here:
    7.     https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
    8.     """
    9.     if min_ch is None:
    10.         min_ch = divisor
    11.     new_ch = max(min_ch, int(ch + divisor / 2) // divisor * divisor)
    12.     # Make sure that round down does not go down by more than 10%.
    13.     if new_ch < 0.9 * ch:
    14.         new_ch += divisor
    15.     return new_ch
    16.  
    17.  
    18. # 执行流程：Conv-->BN-->ReLU6
    19. class ConvBNReLU(nn.Sequential):
    20.     # groups=1:普通卷积；groups = in_channel：DW卷积
    21.     def __init__(self, in_channel, out_channel, kernel_size=3, stride=1, groups=1):
    22.         # kernel_size=3时padding=1，kernel_size=1时padding=0
    23.         padding = (kernel_size - 1) // 2
    24.         super(ConvBNReLU, self).__init__(
    25.             nn.Conv2d(in_channel, out_channel, kernel_size, stride, padding, groups=groups, bias=False),
    26.             nn.BatchNorm2d(out_channel),
    27.             nn.ReLU6(inplace=True)
    28.         )
    29.  
    30.  
    31.  
    32. class MobileNetV2(nn.Module):
    33.     # alpha:宽度因子，卷积核个数的倍率，也就是输出通道数
    34.     def __init__(self, num_classes=1000, alpha=1.0, round_nearest=8):
    35.         super(MobileNetV2, self).__init__()
    36.         block = InvertedResidual
    37.         # 第一层所使用卷积核的个数，_make_divisible：将卷积核个数调整为_make_divisible的整数倍
    38.         input_channel = _make_divisible(32 * alpha, round_nearest)
    39.         last_channel = _make_divisible(1280 * alpha, round_nearest)
    40.  
    41.         # 查表可得下面的配置
    42.         inverted_residual_setting = [
    43.             # t(扩展因子), c(输出特征矩阵深度channel), n(bottleneck的重复次数), s(步矩，针对第一层，其他为1)
    44.             [1, 16, 1, 1],   # bottleneck1
    45.             [6, 24, 2, 2],   # bottleneck2
    46.             [6, 32, 3, 2],   # bottleneck3
    47.             [6, 64, 4, 2],   # bottleneck4
    48.             [6, 96, 3, 1],   # bottleneck5
    49.             [6, 160, 3, 2],  # bottleneck6
    50.             [6, 320, 1, 1],  # bottleneck7
    51.         ]
    52.  
    53.         features = []
    54.         # conv1 layer
    55.         features.append(ConvBNReLU(3, input_channel, stride=2))
    56.         # building inverted residual residual blockes
    57.         for t, c, n, s in inverted_residual_setting:
    58.             # 调整输出后的channel
    59.             output_channel = _make_divisible(c * alpha, round_nearest)
    60.             # 重复n次bottleneck
    61.             for i in range(n):
    62.                 # i=0，为第一层，则strider=s，其余stride=1
    63.                 stride = s if i == 0 else 1
    64.                 features.append(block(input_channel, output_channel, stride, expand_ratio=t))
    65.                 input_channel = output_channel  # 更新，作为下一层的输入
    66.         # building last several layers
    67.         features.append(ConvBNReLU(input_channel, last_channel, 1))
    68.         # combine feature layers
    69.         self.features = nn.Sequential(*features)
    70.  
    71.         # building classifier 分类器
    72.         self.avgpool = nn.AdaptiveAvgPool2d((1, 1))  # 自适应平均池化下采样
    73.         self.classifier = nn.Sequential(
    74.             nn.Dropout(0.2),
    75.             nn.Linear(last_channel, num_classes)
    76.         )
    77.  
    78.         # weight initialization
    79.         for m in self.modules():
    80.             if isinstance(m, nn.Conv2d):
    81.                 nn.init.kaiming_normal_(m.weight, mode='fan_out')
    82.                 if m.bias is not None:
    83.                     nn.init.zeros_(m.bias)
    84.             elif isinstance(m, nn.BatchNorm2d):
    85.                 nn.init.ones_(m.weight)
    86.                 nn.init.zeros_(m.bias)
    87.             elif isinstance(m, nn.Linear):
    88.                 nn.init.normal_(m.weight, 0, 0.01)
    89.                 nn.init.zeros_(m.bias)
    90.  
    91.     def forward(self, x):
    92.         x = self.features(x)
    93.         x = self.avgpool(x)
    94.         x = torch.flatten(x, 1)
    95.         x = self.classifier(x)
    96.         return x

    MobileNetV3的InvertedResidual结构如下：

    注意力机制SE模块配置：

    1. # SE模块即注意力机制模块
    2. class SqueezeExcitation(nn.Module):
    3.     def __init__(self, input_c: int, squeeze_factor: int = 4):  # squeeze_factor 第一个全连接层是输入特征矩阵的1/4
    4.         super(SqueezeExcitation, self).__init__()
    5.         # 将squeeze_c调整为离8最近的整数倍
    6.         squeeze_c = _make_divisible(input_c // squeeze_factor, 8)
    7.         self.fc1 = nn.Conv2d(input_c, squeeze_c, 1)  # 使用卷积层代替全连接层
    8.         self.fc2 = nn.Conv2d(squeeze_c, input_c, 1)
    9.  
    10.     def forward(self, x: Tensor) -> Tensor:
    11.         # 自适应平均池化操作：将特征矩阵调整为1x1的大小
    12.         scale = F.adaptive_avg_pool2d(x, output_size=(1, 1))
    13.         scale = self.fc1(scale)
    14.         scale = F.relu(scale, inplace=True)
    15.         scale = self.fc2(scale)
    16.         scale = F.hardsigmoid(scale, inplace=True)
    17.         return scale * x  # 将输出的权重，通过乘法逐通道加权到先前的特征上，完成在通道维度上的对原始特征的重标定。

    InvertedResidual结构：

    1. # 将ch调整为divisor最近的的整数倍
    2. def _make_divisible(ch, divisor=8, min_ch=None):
    3.     """
    4.     This function is taken from the original tf repo.
    5.     It ensures that all layers have a channel number that is divisible by 8
    6.     It can be seen here:
    7.     https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
    8.     """
    9.     if min_ch is None:
    10.         min_ch = divisor
    11.     new_ch = max(min_ch, int(ch + divisor / 2) // divisor * divisor)
    12.     # Make sure that round down does not go down by more than 10%.
    13.     if new_ch < 0.9 * ch:
    14.         new_ch += divisor
    15.     return new_ch
    16.  
    17.  
    18. # 处理流程Conv-->BN-->activation
    19. class ConvBNActivation(nn.Sequential):
    20.     def __init__(self,
    21.                  in_planes: int,
    22.                  out_planes: int,
    23.                  kernel_size: int = 3,
    24.                  stride: int = 1,
    25.                  groups: int = 1,
    26.                  # Optional[Callable[..., nn.Module]]类型注释表示一个可选的参数，
    27.                  # 该参数可以是一个可调用的对象，这个可调用的对象可以接受任意数量和类型的参数，并且它的返回值应该是一个 nn.Module 类型的对象
    28.                  # 通常用于描述神经网络模型构建函数的参数，以允许用户选择是否提供一个自定义的函数或方法来创建神经网络的一部分
    29.                  norm_layer: Optional[Callable[..., nn.Module]] = None,
    30.                  activation_layer: Optional[Callable[..., nn.Module]] = None):
    31.         padding = (kernel_size - 1) // 2
    32.         # 无norm_layer使用BatchNorm2d
    33.         if norm_layer is None:
    34.             norm_layer = nn.BatchNorm2d
    35.         # 无activation_layer使用ReLU6
    36.         if activation_layer is None:
    37.             activation_layer = nn.ReLU6
    38.         super(ConvBNActivation, self).__init__(nn.Conv2d(in_channels=in_planes,
    39.                                                          out_channels=out_planes,
    40.                                                          kernel_size=kernel_size,
    41.                                                          stride=stride,
    42.                                                          padding=padding,
    43.                                                          groups=groups,
    44.                                                          bias=False),
    45.                                                norm_layer(out_planes),
    46.                                                activation_layer(inplace=True))
    47.  
    48. # MobilenetV3 InvertedResidual的结构
    49. class InvertedResidual(nn.Module):
    50.     def __init__(self,
    51.                  cnf: InvertedResidualConfig,
    52.                  norm_layer: Callable[..., nn.Module]):
    53.         super(InvertedResidual, self).__init__()
    54.  
    55.         # stride参数检测
    56.         if cnf.stride not in [1, 2]:
    57.             raise ValueError("illegal stride value.")
    58.  
    59.         # shortcut分支
    60.         self.use_res_connect = (cnf.stride == 1 and cnf.input_c == cnf.out_c)
    61.  
    62.         layers: List[nn.Module] = []
    63.         activation_layer = nn.Hardswish if cnf.use_hs else nn.ReLU
    64.  
    65.         # expand：除了第一个bottleneck没有1x1卷积升维操作
    66.         if cnf.expanded_c != cnf.input_c:
    67.             layers.append(ConvBNActivation(cnf.input_c,
    68.                                            cnf.expanded_c,
    69.                                            kernel_size=1,
    70.                                            norm_layer=norm_layer,
    71.                                            activation_layer=activation_layer))
    72.  
    73.         # depthwise
    74.         layers.append(ConvBNActivation(cnf.expanded_c,
    75.                                        cnf.expanded_c,
    76.                                        kernel_size=cnf.kernel,
    77.                                        stride=cnf.stride,
    78.                                        groups=cnf.expanded_c,  # 卷积核组数：DW卷积
    79.                                        norm_layer=norm_layer,
    80.                                        activation_layer=activation_layer))
    81.         # SE模块
    82.         if cnf.use_se:
    83.             layers.append(SqueezeExcitation(cnf.expanded_c))
    84.  
    85.         # project：降维
    86.         layers.append(ConvBNActivation(cnf.expanded_c,
    87.                                        cnf.out_c,
    88.                                        kernel_size=1,
    89.                                        norm_layer=norm_layer,
    90.                                        activation_layer=nn.Identity))  # Identity 线性激活y=x
    91.  
    92.         self.block = nn.Sequential(*layers)
    93.         self.out_channels = cnf.out_c
    94.         self.is_strided = cnf.stride > 1
    95.  
    96.     def forward(self, x: Tensor) -> Tensor:
    97.         result = self.block(x)
    98.         if self.use_res_connect:   # shortcut
    99.             result += x
    100.  
    101.         return result

    MobileNetV3网络配置：

    1. # MobileNetV3网络模型结构
    2. class MobileNetV3(nn.Module):
    3.     def __init__(self,
    4.                  inverted_residual_setting: List[InvertedResidualConfig],
    5.                  last_channel: int,  # 倒数第二个全连接层
    6.                  num_classes: int = 1000,
    7.                  block: Optional[Callable[..., nn.Module]] = None,
    8.                  norm_layer: Optional[Callable[..., nn.Module]] = None):
    9.         super(MobileNetV3, self).__init__()
    10.  
    11.         # inverted_residual_setting参数检测：列表
    12.         if not inverted_residual_setting:
    13.             raise ValueError("The inverted_residual_setting should not be empty.")
    14.         elif not (isinstance(inverted_residual_setting, List) and
    15.                   all([isinstance(s, InvertedResidualConfig) for s in inverted_residual_setting])):
    16.             raise TypeError("The inverted_residual_setting should be List[InvertedResidualConfig]")
    17.  
    18.         if block is None:
    19.             block = InvertedResidual
    20.  
    21.         if norm_layer is None:
    22.             norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01)
    23.  
    24.         layers: List[nn.Module] = []
    25.  
    26.         # building first layer第一个卷积层
    27.         firstconv_output_c = inverted_residual_setting[0].input_c
    28.         layers.append(ConvBNActivation(3,
    29.                                        firstconv_output_c,
    30.                                        kernel_size=3,
    31.                                        stride=2,
    32.                                        norm_layer=norm_layer,
    33.                                        activation_layer=nn.Hardswish))
    34.         # building inverted residual blocks
    35.         for cnf in inverted_residual_setting:
    36.             layers.append(block(cnf, norm_layer))
    37.  
    38.         # building last several layers最后几层：卷积+全连接
    39.         lastconv_input_c = inverted_residual_setting[-1].out_c
    40.         lastconv_output_c = 6 * lastconv_input_c  # 6倍关系
    41.         layers.append(ConvBNActivation(lastconv_input_c,
    42.                                        lastconv_output_c,
    43.                                        kernel_size=1,
    44.                                        norm_layer=norm_layer,
    45.                                        activation_layer=nn.Hardswish))
    46.         self.features = nn.Sequential(*layers)
    47.         self.avgpool = nn.AdaptiveAvgPool2d(1)
    48.         self.classifier = nn.Sequential(nn.Linear(lastconv_output_c, last_channel),  # conv2d 1x1即全连接层
    49.                                         nn.Hardswish(inplace=True),
    50.                                         nn.Dropout(p=0.2, inplace=True),
    51.                                         nn.Linear(last_channel, num_classes))
    52.  
    53.         # initial weights
    54.         for m in self.modules():
    55.             if isinstance(m, nn.Conv2d):
    56.                 nn.init.kaiming_normal_(m.weight, mode="fan_out")
    57.                 if m.bias is not None:
    58.                     nn.init.zeros_(m.bias)
    59.             elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
    60.                 nn.init.ones_(m.weight)
    61.                 nn.init.zeros_(m.bias)
    62.             elif isinstance(m, nn.Linear):
    63.                 nn.init.normal_(m.weight, 0, 0.01)
    64.                 nn.init.zeros_(m.bias)
    65.  
    66.     def _forward_impl(self, x: Tensor) -> Tensor:
    67.         x = self.features(x)
    68.         x = self.avgpool(x)
    69.         x = torch.flatten(x, 1)
    70.         x = self.classifier(x)
    71.  
    72.         return x
    73.  
    74.     def forward(self, x: Tensor) -> Tensor:
    75.         return self._forward_impl(x)

     实例化MobileNetV3，并根据网络配置MobileNetV3-Large表格设计网络

    1. # MobilenetV3-Large
    2. def mobilenet_v3_large(num_classes: int = 1000,
    3.                        reduced_tail: bool = False) -> MobileNetV3:
    4.     """
    5.     Constructs a large MobileNetV3 architecture from
    6.     "Searching for MobileNetV3" .
    8.     weights_link:
    9.     https://download.pytorch.org/models/mobilenet_v3_large-8738ca79.pth
    11.     Args:
    12.         num_classes (int): number of classes
    13.         reduced_tail (bool): If True, reduces the channel counts of all feature layers
    14.             between C4 and C5 by 2. It is used to reduce the channel redundancy in the
    15.             backbone for Detection and Segmentation.
    16.     """
    17.     width_multi = 1.0  # 阿尔法超参数
    18.     bneck_conf = partial(InvertedResidualConfig, width_multi=width_multi)
    19.     adjust_channels = partial(InvertedResidualConfig.adjust_channels, width_multi=width_multi)
    20.  
    21.     # 修改表格中的配置，为1和原论文中的一致
    22.     reduce_divider = 2 if reduced_tail else 1
    23.  
    24.     # MobilenetV3-Large表格配置，在论文表格中有：每一个bneck结构配置
    25.     inverted_residual_setting = [
    26.         # input_c, kernel, expanded_c, out_c, use_se, activation, stride
    27.         bneck_conf(16, 3, 16, 16, False, "RE", 1),
    28.         bneck_conf(16, 3, 64, 24, False, "RE", 2),  # C1
    29.         bneck_conf(24, 3, 72, 24, False, "RE", 1),
    30.         bneck_conf(24, 5, 72, 40, True, "RE", 2),  # C2
    31.         bneck_conf(40, 5, 120, 40, True, "RE", 1),
    32.         bneck_conf(40, 5, 120, 40, True, "RE", 1),
    33.         bneck_conf(40, 3, 240, 80, False, "HS", 2),  # C3
    34.         bneck_conf(80, 3, 200, 80, False, "HS", 1),
    35.         bneck_conf(80, 3, 184, 80, False, "HS", 1),
    36.         bneck_conf(80, 3, 184, 80, False, "HS", 1),
    37.         bneck_conf(80, 3, 480, 112, True, "HS", 1),
    38.         bneck_conf(112, 3, 672, 112, True, "HS", 1),
    39.         bneck_conf(112, 5, 672, 160 // reduce_divider, True, "HS", 2),  # C4
    40.         bneck_conf(160 // reduce_divider, 5, 960 // reduce_divider, 160 // reduce_divider, True, "HS", 1),
    41.         bneck_conf(160 // reduce_divider, 5, 960 // reduce_divider, 160 // reduce_divider, True, "HS", 1),
    42.     ]
    43.     last_channel = adjust_channels(1280 // reduce_divider)  # C5
    44.  
    45.     return MobileNetV3(inverted_residual_setting=inverted_residual_setting,
    46.                        last_channel=last_channel,
    47.                        num_classes=num_classes)
    48.  
    49.  
    50. # mobilenet_v3_small
    51. def mobilenet_v3_small(num_classes: int = 1000,
    52.                        reduced_tail: bool = False) -> MobileNetV3:
    53.     """
    54.     Constructs a large MobileNetV3 architecture from
    55.     "Searching for MobileNetV3" .
    57.     weights_link:
    58.     https://download.pytorch.org/models/mobilenet_v3_small-047dcff4.pth
    60.     Args:
    61.         num_classes (int): number of classes
    62.         reduced_tail (bool): If True, reduces the channel counts of all feature layers
    63.             between C4 and C5 by 2. It is used to reduce the channel redundancy in the
    64.             backbone for Detection and Segmentation.
    65.     """
    66.     width_multi = 1.0
    67.     bneck_conf = partial(InvertedResidualConfig, width_multi=width_multi)
    68.     adjust_channels = partial(InvertedResidualConfig.adjust_channels, width_multi=width_multi)
    69.  
    70.     reduce_divider = 2 if reduced_tail else 1
    71.  
    72.     inverted_residual_setting = [
    73.         # input_c, kernel, expanded_c, out_c, use_se, activation, stride
    74.         bneck_conf(16, 3, 16, 16, True, "RE", 2),  # C1
    75.         bneck_conf(16, 3, 72, 24, False, "RE", 2),  # C2
    76.         bneck_conf(24, 3, 88, 24, False, "RE", 1),
    77.         bneck_conf(24, 5, 96, 40, True, "HS", 2),  # C3
    78.         bneck_conf(40, 5, 240, 40, True, "HS", 1),
    79.         bneck_conf(40, 5, 240, 40, True, "HS", 1),
    80.         bneck_conf(40, 5, 120, 48, True, "HS", 1),
    81.         bneck_conf(48, 5, 144, 48, True, "HS", 1),
    82.         bneck_conf(48, 5, 288, 96 // reduce_divider, True, "HS", 2),  # C4
    83.         bneck_conf(96 // reduce_divider, 5, 576 // reduce_divider, 96 // reduce_divider, True, "HS", 1),
    84.         bneck_conf(96 // reduce_divider, 5, 576 // reduce_divider, 96 // reduce_divider, True, "HS", 1)
    85.     ]
    86.     last_channel = adjust_channels(1024 // reduce_divider)  # C5
    87.  
    88.     return MobileNetV3(inverted_residual_setting=inverted_residual_setting,
    89.                        last_channel=last_channel,
    90.                        num_classes=num_classes)

    2.加载数据集

    这里使用花朵数据集，数据集制造和数据集使用的脚本的参考：Pytorch之AlexNet花朵分类_风间琉璃•的博客-CSDN博客

     加载数据集和测试集，并进行相应的预处理操作。

    1.     batch_size = 16
    2.     epochs = 100
    3.  
    4.     data_transform = {
    5.         "train": transforms.Compose([transforms.RandomResizedCrop(224),
    6.                                      transforms.RandomHorizontalFlip(),
    7.                                      transforms.ToTensor(),
    8.                                      transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),
    9.         "val": transforms.Compose([transforms.Resize(256),
    10.                                    transforms.CenterCrop(224),
    11.                                    transforms.ToTensor(),
    12.                                    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])}
    13.  
    14.     # 数据集根目录
    15.     data_root = os.path.abspath(os.getcwd())
    16.     print(os.getcwd())
    17.     # 图片目录
    18.     image_path = os.path.join(data_root, "data_set", "flower_data")
    19.     print(image_path)
    20.     assert os.path.exists(image_path), "{} path does not exit.".format(image_path)
    21.  
    22.     # 准备数据集
    23.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
    24.                                          transform=data_transform["train"])
    25.     train_num = len(train_dataset)
    26.  
    27.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
    28.                                             transform=data_transform["val"])
    29.     val_num = len(validate_dataset)
    30.  
    31.     # 定义一个包含花卉类别到索引的字典:雏菊,蒲公英,玫瑰,向日葵,郁金香
    32.     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
    33.     # 获取包含训练数据集类别名称到索引的字典，这通常用于数据加载器或数据集对象中。
    34.     flower_list = train_dataset.class_to_idx
    35.     # 创建一个反向字典，将索引映射回类别名称
    36.     cla_dict = dict((val, key) for key, val in flower_list.items())
    37.     # 将字典转换为格式化的JSON字符串，每行缩进4个空格
    38.     json_str = json.dumps(cla_dict, indent=4)
    39.     # 打开名为 'class_indices.json' 的JSON文件，并将JSON字符串写入其中
    40.     with open('class_indices.json', 'w') as json_file:
    41.         json_file.write(json_str)
    42.  
    43.     batch_size = 32
    44.     nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
    45.     print("using {} dataloader workers every process".format(nw))
    46.  
    47.     # 加载数据集
    48.     train_loader = torch.utils.data.DataLoader(train_dataset,
    49.                                                batch_size=batch_size, shuffle=True,
    50.                                                num_workers=nw)
    51.  
    52.     validate_loader = torch.utils.data.DataLoader(validate_dataset,
    53.                                                   batch_size=4, shuffle=False,
    54.                                                   num_workers=nw)
    55.  
    56.     print("using {} images for training, {} images for validation.".format(train_num, val_num))

    3.训练和测试模型

    数据集预处理完成后，就可以进行网络模型的训练和验证。

    1.     # create model
    2.     net = MobileNetV2(num_classes=5)
    3.  
    4.     # load pretrain weights
    5.     # download url: https://download.pytorch.org/models/mobilenet_v2-b0353104.pth
    6.     model_weight_path = "./mobilenet_v2-pre.pth"
    7.     assert os.path.exists(model_weight_path), "file {} dose not exist.".format(model_weight_path)
    8.     pre_weights = torch.load(model_weight_path, map_location='cpu')
    9.  
    10.     # delete classifier weights
    11.     # 遍历预训练权重字典（pre_weights），只保留那些与当前模型（net）中同名参数具有相同尺寸的键-值对，并将它们保存在pre_dict中
    12.     pre_dict = {k: v for k, v in pre_weights.items() if net.state_dict()[k].numel() == v.numel()}
    13.     # 将上一步筛选出的pre_dict中的权重加载到模型net中，strict=False表示允许加载不完全匹配的权重，可能会有一些不匹配的权重被忽略
    14.     missing_keys, unexpected_keys = net.load_state_dict(pre_dict, strict=False)
    15.  
    16.     # 冻结了网络中的特征提取器（features）的权重，使其在训练过程中不再更新
    17.     for param in net.features.parameters():
    18.         param.requires_grad = False
    19.  
    20.     net.to(device)
    21.  
    22.     # define loss function
    23.     loss_function = nn.CrossEntropyLoss()
    24.  
    25.     # construct an optimizer
    26.     params = [p for p in net.parameters() if p.requires_grad]
    27.     optimizer = optim.Adam(params, lr=0.0001)
    28.  
    29.     best_acc = 0.0
    30.     save_path = './MobileNetV2.pth'
    31.     train_steps = len(train_loader)
    32.     for epoch in range(epochs):
    33.         # train
    34.         net.train()
    35.         running_loss = 0.0
    36.         train_bar = tqdm(train_loader, file=sys.stdout)
    37.         for step, data in enumerate(train_bar):
    38.             images, labels = data
    39.             optimizer.zero_grad()
    40.             logits = net(images.to(device))
    41.             loss = loss_function(logits, labels.to(device))
    42.             loss.backward()
    43.             optimizer.step()
    44.  
    45.             # print statistics
    46.             running_loss += loss.item()
    47.  
    48.             train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
    49.                                                                      epochs,
    50.                                                                      loss)
    51.  
    52.         # validate
    53.         net.eval()
    54.         acc = 0.0  # accumulate accurate number / epoch
    55.         with torch.no_grad():
    56.             val_bar = tqdm(validate_loader, file=sys.stdout)
    57.             for val_data in val_bar:
    58.                 val_images, val_labels = val_data
    59.                 outputs = net(val_images.to(device))
    60.                 # loss = loss_function(outputs, test_labels)
    61.                 predict_y = torch.max(outputs, dim=1)[1]
    62.                 acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
    63.  
    64.                 val_bar.desc = "valid epoch[{}/{}]".format(epoch + 1,
    65.                                                            epochs)
    66.         val_accurate = acc / val_num
    67.         print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
    68.               (epoch + 1, running_loss / train_steps, val_accurate))
    69.  
    70.         if val_accurate > best_acc:
    71.             best_acc = val_accurate
    72.             torch.save(net.state_dict(), save_path)
    73.  
    74.     print('Finished Training')

    这里使用了官方的预训练权重，在其基础上训练自己的数据集。训练100epoch的准确率能到达90%左右。

    五、实现图像分类

    利用上述训练好的网络模型进行测试，验证是否能完成分类任务。

    1. def main():
    2.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    3.  
    4.     data_transform = transforms.Compose(
    5.         [transforms.Resize(256),
    6.          transforms.CenterCrop(224),
    7.          transforms.ToTensor(),
    8.          transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
    9.  
    10.     # 加载图片
    11.     img_path = 'rose.jpg'
    12.     assert os.path.exists(img_path), "file: '{}' does not exist.".format(img_path)
    13.     image = Image.open(img_path)
    14.  
    15.     # image.show()
    16.     # [N, C, H, W]
    17.     img = data_transform(image)
    18.     # 扩展维度
    19.     img = torch.unsqueeze(img, dim=0)
    20.  
    21.     # 获取标签
    22.     json_path = 'class_indices.json'
    23.     assert os.path.exists(json_path), "file: '{}' does not exist.".format(json_path)
    24.     with open(json_path, 'r') as f:
    25.         # 使用json.load()函数加载JSON文件的内容并将其存储在一个Python字典中
    26.         class_indict = json.load(f)
    27.  
    28.     # 加载网络
    29.     model = MobileNetV2(num_classes=5).to(device)
    30.  
    31.     # 加载模型文件
    32.     weights_path = "./MobileNetV2.pth"
    33.     assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
    34.     model.load_state_dict(torch.load(weights_path, map_location=device))
    35.  
    36.     model.eval()
    37.     with torch.no_grad():
    38.         # 对输入图像进行预测
    39.         output = torch.squeeze(model(img.to(device))).cpu()
    40.         # 对模型的输出进行 softmax 操作，将输出转换为类别概率
    41.         predict = torch.softmax(output, dim=0)
    42.         # 得到高概率的类别的索引
    43.         predict_cla = torch.argmax(predict).numpy()
    44.  
    45.     res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)], predict[predict_cla].numpy())
    46.     draw = ImageDraw.Draw(image)
    47.     # 文本的左上角位置
    48.     position = (10, 10)
    49.     # fill 指定文本颜色
    50.     draw.text(position, res, fill='red')
    51.     image.show()
    52.     for i in range(len(predict)):
    53.         print("class: {:10}   prob: {:.3}".format(class_indict[str(i)], predict[i].numpy()))

     测试结果：

    结束语

    感谢阅读吾之文章，今已至此次旅程之终站 🛬。

    吾望斯文献能供尔以宝贵之信息与知识也 🎉。

    学习者之途，若藏于天际之星辰🍥，吾等皆当努力熠熠生辉，持续前行。

    然而，如若斯文献有益于尔，何不以三连为礼？点赞、留言、收藏 - 此等皆以证尔对作者之支持与鼓励也 💞。

    ​

  • 相关阅读:
    Flink 读写 Ceph S3入门学习总结
    30.3.2 使用GRANT语句为用户授权
    【AGC】质量服务2-性能管理示例
    文字转图片，文字水印图片，合成图片，教你 Python 生成网站原创配图！
    三相智能电表逆相序的原因及解决方法
    Linux笔记--文件内容的查阅与统计
    【ChatGPT】ChatGPT的自定义指令
    深度学习系列1——Pytorch 图像分类(LeNet)
    PHP如何对二维数组(多维数组)进排序
    软件测试面试题--自用
  • 原文地址：https://blog.csdn.net/qq_53144843/article/details/133420764