Python----神经网络（《Inverted Residuals and Linear Bottlenecks》论文概括和MobileNetV2网络）

一、论文

MobileNetV2 论文提出了一种新的移动架构，该架构提高了移动模型在多个任务和基准测试中的性能，以及在各种不同模型大小范围内的性能. 该架构基于倒残差结构，其中 shortcut 连接在 thin bottleneck 层之间. 中间的 expansion 层使用轻量级 depthwise 卷积来过滤特征，作为非线性的来源. 此外，作者发现，为了保持表示能力，重要的是要移除 narrow 层中的非线性. 论文展示了这种架构在 ImageNet 分类、COCO 目标检测和 VOC 图像分割任务中的有效性. 论文评估了准确性、计算成本（以 multiply-adds 衡量）、延迟和参数数量之间的权衡. 该论文的关键贡献是具有线性 bottleneck 的倒残差模块，它可以实现高效的推理并减少内存占用.

1.1、基本信息

标题： MobileNetV2: Inverted Residuals and Linear Bottlenecks
作者： Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, Liang-Chieh Chen
单位： Google Inc.
主要贡献： 提出了一种新的移动架构，MobileNetV2，它提高了移动模型在多个任务和基准测试中的性能，以及不同模型大小范围内的性能。

1.2、主要内容

1.2.1、倒残差块和线性瓶颈

MobileNetV2 的核心创新在于“倒残差块”。传统的残差块（如 ResNet 中的）连接的是较宽的层，而倒残差块连接的是较窄的 bottleneck 层。中间的 expansion 层负责扩展通道维度。
这些块使用深度可分离卷积以提高效率。
一个关键要素是“线性 bottleneck”。论文认为，ReLU 非线性激活在低维空间中可能会破坏信息。因此，每个块的最后一层是线性的（没有 ReLU），以保留信息。

1.2.2、架构设计

MobileNetV2 在 MobileNetV1 的深度可分离卷积的基础上构建。
该架构由一个初始卷积层、一系列倒残差块和一个最终卷积层组成。
平均池化层和全连接层用于分类。
使用宽度乘数和分辨率乘数来创建更小、计算量更少的模型。

1.2.3、效率

倒残差结构旨在实现高内存效率，这对于移动设备至关重要。它可以减少内存占用和对昂贵的内存访问的需求。
与标准卷积相比，深度可分离卷积显着减少了参数数量和计算量。

1.2.4、性能

论文表明，MobileNetV2 在 ImageNet 分类任务上比 MobileNetV1 实现了更高的准确率和效率。
它还在目标检测（使用 SSDLite）和语义分割（使用 Mobile DeepLabv3）方面取得了出色的效果。

1.3、作用

MobileNetV2 旨在为移动和资源受限环境提供高效的卷积神经网络。它在准确性和计算成本之间实现了有效的权衡。

1.4、影响

MobileNetV2 改进了 MobileNetV1 的架构，并在多个任务和基准测试中实现了最先进的性能。它为在资源受限的设备上部署深度学习模型提供了一种有效的方法。

1.5、优点

效率： MobileNetV2 通过使用 depthwise separable 卷积和 inverted residuals，显著减少了计算需求和内存占用。
性能： MobileNetV2 在图像分类、目标检测和语义分割等任务中表现出色。
可调性： 宽度乘数和分辨率乘数允许轻松调整模型大小，以适应不同的资源约束。
内存效率： 倒残差 bottleneck 层允许特别节省内存的实现，这对于移动应用程序非常重要。

1.6、缺点

复杂性： 与 MobileNetV1 相比，MobileNetV2 引入了 inverted residual 块，这可能会使模型架构更复杂。
权衡： 虽然宽度乘数和分辨率乘数提供了灵活性，但它们需要在准确性和效率之间进行仔细的权衡。

论文地址：

[1801.04381] MobileNetV2: Inverted Residuals and Linear Bottlenecks

二、MobileNetV2

2.1、网络的背景

MobileNetV1网络的depthwise部分的卷积核容易参数为0，导致浪费掉。 MobileNetV2网络是由谷歌团队在2018年提出的，它对于MobileNetV1而言，有着更高的准确率和更小的网络模型。

2.2、Inverted Residuals（倒残差结构）

在MobileNetV2 中，是先升维，再降维的操作，所以该结构叫倒残差结构，网络结构表格中的 bottleneck就是倒残差结构。

残差结构的过程是：

        1、1x1卷积降维

        2、3x3卷积

        3、1x1卷积升维

即对输入特征矩阵进行利用1x1卷积进行降维，减少输入特征矩阵的channel，然后通过3x3的卷积核进行处理提取特征，最后通过1x1的卷积核进行升维，那么它的结构就是两边深，中间浅的结构。

在MobileNetV2网络结构中，采用了倒残差结构，从名字可以联想到，它的结构应该是中间深，两边浅，它的结构如下图所示：

倒残差结构的过程是：

        1、首先会通过一个1x1卷积层来进行升维处理，在卷积后会跟有BN和Relu6激活函数

        2、紧接着是一个3x3大小DW卷积，卷积后面依旧会跟有BN和Relu6激活函数

        3、最后一个卷积层是1x1卷积，起到降维作用，注意卷积后只跟了BN结构，并没有使用Relu6激活函数

在MobileNetV1中，DW卷积的个数局限于上一层的输出通道数，无法自由改变，但是加入PW卷积之后，也就是升维卷积之后，DW卷积的个数取决于PW卷积的输出通道数，而这个通道数是可以任意指定的，因此解除了3x3卷积核个数的限制。

2.3、Relu6

因为在低维空间使用非线性函数（如Relu）会损失一些信息，高维空间中会损失得相对少一些，因此引入Inverted Residuals，升维之后再卷积，能够更好地保留特征。

在移动端设备float16的低精度的时候，也能有很好的数值分辨率，如果对Relu的激活范围不加限制，输出范围为0到正无穷，如果激活值非常大，分布在一个很大的范围内，则低精度的float16无法很好地精确描述如此大范围的数值，带来精度损失，所以在量化过程中，Relu6能够有更好的量化表现和更小的精度下降。

2.4、Linear Bottlenecks

2.5、Shortcut

注意：Shortcut并不是该网络提出的，而是残差结构提出的。

这里由于具有倒残差结构，所以也会有shortcut操作，如下图所示，左侧为有 shortcut连接的倒残差结构，右侧是无shortcut连接的倒残差结构：

shortcut将输入与输出直接进行相加，可以使得网络在较深的时候依旧可以进行训练。

注意：这里只有stride=1且输入特征矩阵与输出特征矩阵shape相同时才有 shortcut连接。

2.6、拓展因子

举例：

假如输入特征矩阵是128维的，隐藏层个数是256，条件1是输出必须有128个为正，并且这128个输出为正的神经元的应该是非线性相关的。

~~~~当隐藏层m远大于输入n，那么更容易让ReLU保持可逆。

在训练前和训练后，各个层是否发生了不可逆的情况，如下图所示：

在训练前，由于都是初始化的，所以激活为正的特征个数都比较集中，图中虚线是信息会丢失的阈值，纵坐标低于该虚线，会导致信息丢失。在训练后，平均值变化较小，但是两级分化较为严重，有一些最小值已经低于了阈值，就会造成信息丢失，但是绝大多数层还是可逆的。

2.7、网络的结构

Input是每一层结构的输入矩阵尺寸和channel；

Operator是操作；

t是拓展因子；

c是输出特征矩阵channel；

n是bottleneck的重复次数；

s是步距，如果bottleneck重复，但只针对于第一次bottleneck的DW卷积，其他为 1。

由网络结构的图可以看到最后一层是卷积层，但是其实就是一个全连接层的作用，k 是输出的类别，如果是ImageNet数据集，那么k就是1000。

注意：

在每个DW卷积之后都有batchNorm操作，这里组件中为了减少学习者工作量并没有体现该结构，但是学习者需要知道。

注意：

在第一个bottleneck结构中，由于t=1,所以并没有进行升维操作，即没有第一个Conv2D层。

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchsummary import summary


# 定义一个辅助函数，用于确保通道数可以被 divisor 整除，这对于硬件优化很重要
def _make_divisible(v, divisor, min_value=None):
    """
    确保通道数 v 可以被 divisor 整除，如果需要可以指定最小值 min_value。
    这个技巧在移动端神经网络设计中常用，有助于硬件加速。
    """
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    # 为了避免向下取整过多导致信息损失，进行一个小的调整
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v

# 定义一个卷积 + BatchNorm + ReLU6 的基本块
class ConvBNReLU(nn.Sequential):
    def __init__(self, in_planes, out_planes, kernel_size, stride, groups=1):
        """
        卷积、批归一化和 ReLU6 激活函数的组合。
        groups 参数用于实现分组卷积（当 groups > 1 时）或深度可分离卷积（当 groups 等于输入通道数时）。
        """
        padding = (kernel_size - 1) // 2
        super(ConvBNReLU, self).__init__(
            nn.Conv2d(in_planes, out_planes, kernel_size, stride, padding, groups=groups, bias=False),
            nn.BatchNorm2d(out_planes),
            nn.ReLU6(inplace=True) # ReLU6 激活函数，限制输出范围在 [0, 6]
        )

# 定义 MobileNetV2 的核心模块：倒置残差块 (Inverted Residual Block)
class InvertedResidual(nn.Module):
    def __init__(self, inp, oup, stride, expand_ratio):
        """
        倒置残差块是 MobileNetV2 的基本构建单元。
        它首先通过一个扩展层增加通道数，然后进行深度可分离卷积，最后通过一个投影层减少通道数。
        如果输入和输出的形状相同且步长为 1，则使用残差连接。

        Args:
            inp (int): 输入通道数
            oup (int): 输出通道数
            stride (int): 卷积步长 (1 或 2)
            expand_ratio (int): 扩展率，中间层的通道数是输入通道数的 expand_ratio 倍
        """
        super(InvertedResidual, self).__init__()
        self.stride = stride
        assert stride in [1, 2]

        hidden_dim = int(round(inp * expand_ratio)) # 中间扩展层的通道数
        self.use_res_connect = self.stride == 1 and inp == oup # 判断是否使用残差连接

        layers = []
        if expand_ratio != 1:
            # 扩展层：1x1 卷积增加通道数
            layers.append(ConvBNReLU(inp, hidden_dim, kernel_size=1, stride=1))
        layers.extend([
            # 深度可分离卷积：一个深度卷积和一个逐点卷积的组合
            # 深度卷积 (Depthwise Convolution): 每个输入通道应用一个独立的卷积核
            ConvBNReLU(hidden_dim, hidden_dim, kernel_size=3, stride=stride, groups=hidden_dim),
            # 逐点卷积 (Pointwise Convolution): 1x1 卷积用于线性地组合深度卷积的输出
            nn.Conv2d(hidden_dim, oup, kernel_size=1, stride=1, bias=False),
            nn.BatchNorm2d(oup),
        ])
        self.conv = nn.Sequential(*layers)

    def forward(self, x):
        if self.use_res_connect:
            return x + self.conv(x) # 如果满足条件，使用残差连接
        else:
            return self.conv(x)

# 定义 MobileNetV2 网络结构
class MobileNetV2(nn.Module):
    def __init__(self, num_classes=1000, width_mult=1.0, inverted_residual_setting=None, round_nearest=8):
        """
        MobileNet V2 的主体网络结构。

        Args:
            num_classes (int): 分类的类别数
            width_mult (float): 宽度乘数，用于调整网络中所有层的通道数，控制模型大小
            inverted_residual_setting (list of list): 倒置残差块的配置列表，每个子列表包含 [t, c, n, s]，
                                                     分别表示扩展率 (t)，输出通道数 (c)，重复次数 (n)，步长 (s)。
            round_nearest (int): 将通道数调整为最接近的 round_nearest 的倍数，有助于硬件优化。
        """
        super(MobileNetV2, self).__init__()

        if inverted_residual_setting is None:
            # 默认的 MobileNetV2 结构参数
            input_channel = 32
            last_channel = 1280
            inverted_residual_setting = [
                # t, c, n, s
                [1, 16, 1, 1],
                [6, 24, 2, 2],
                [6, 32, 3, 2],
                [6, 64, 4, 2],
                [6, 96, 3, 1],
                [6, 160, 3, 2],
                [6, 320, 1, 1],
            ]
        else:
            # 如果提供了自定义的 inverted_residual_setting，则使用它
            if len(inverted_residual_setting) != 7:
                raise ValueError("inverted_residual_setting 应该包含 7 个层级的配置")

        # 构建网络的第一个卷积层
        input_channel = _make_divisible(input_channel * width_mult, round_nearest)
        self.last_channel = _make_divisible(last_channel * max(1.0, width_mult), round_nearest)
        features = [ConvBNReLU(3, input_channel, kernel_size=3, stride=2)] # 输入通道数为 3 (RGB)，输出通道数为调整后的 input_channel，步长为 2

        # 构建倒置残差块
        for t, c, n, s in inverted_residual_setting:
            output_channel = _make_divisible(c * width_mult, round_nearest)
            for i in range(n):
                stride = s if i == 0 else 1 # 只有每个模块的第一个残差块使用指定的步长，其余步长都为 1
                features.append(InvertedResidual(input_channel, output_channel, stride, expand_ratio=t))
                input_channel = output_channel # 更新下一个残差块的输入通道数
        # 构建最后一个卷积层
        features.append(ConvBNReLU(input_channel, self.last_channel, kernel_size=1, stride=1))
        # 将特征提取层封装成 Sequential 容器
        self.features = nn.Sequential(*features)

        # 构建分类器
        self.classifier = nn.Sequential(
            nn.Dropout(0.2), # Dropout 正则化，防止过拟合
            nn.Linear(self.last_channel, num_classes), # 全连接层，将特征映射到类别数
        )

        # 初始化权重
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out') # 使用 Kaiming 正态分布初始化卷积层权重
                if m.bias is not None:
                    nn.init.zeros_(m.bias) # 如果有偏置，初始化为 0
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.ones_(m.weight) # BatchNorm 的权重初始化为 1
                nn.init.zeros_(m.bias) # BatchNorm 的偏置初始化为 0
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01) # 全连接层的权重使用均值为 0，标准差为 0.01 的正态分布初始化
                nn.init.zeros_(m.bias) # 全连接层的偏置初始化为 0

    def _forward_impl(self, x):
        # 前向传播的实现
        x = self.features(x) # 通过特征提取层
        x = F.adaptive_avg_pool2d(x, 1) # 自适应平均池化，将特征图尺寸变为 1x1
        x = torch.flatten(x, 1) # 将特征图展平成一维向量
        x = self.classifier(x) # 通过分类器
        return x

    def forward(self, x):
        # 定义前向传播函数
        return self._forward_impl(x)

if __name__ == '__main__':
    model = MobileNetV2()
    print(summary(model,(3,224,224)))

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 32, 112, 112]             864
       BatchNorm2d-2         [-1, 32, 112, 112]              64
             ReLU6-3         [-1, 32, 112, 112]               0
            Conv2d-4         [-1, 32, 112, 112]             288
       BatchNorm2d-5         [-1, 32, 112, 112]              64
             ReLU6-6         [-1, 32, 112, 112]               0
            Conv2d-7         [-1, 16, 112, 112]             512
       BatchNorm2d-8         [-1, 16, 112, 112]              32
  InvertedResidual-9         [-1, 16, 112, 112]               0
           Conv2d-10         [-1, 96, 112, 112]           1,536
      BatchNorm2d-11         [-1, 96, 112, 112]             192
            ReLU6-12         [-1, 96, 112, 112]               0
           Conv2d-13           [-1, 96, 56, 56]             864
      BatchNorm2d-14           [-1, 96, 56, 56]             192
            ReLU6-15           [-1, 96, 56, 56]               0
           Conv2d-16           [-1, 24, 56, 56]           2,304
      BatchNorm2d-17           [-1, 24, 56, 56]              48
 InvertedResidual-18           [-1, 24, 56, 56]               0
           Conv2d-19          [-1, 144, 56, 56]           3,456
      BatchNorm2d-20          [-1, 144, 56, 56]             288
            ReLU6-21          [-1, 144, 56, 56]               0
           Conv2d-22          [-1, 144, 56, 56]           1,296
      BatchNorm2d-23          [-1, 144, 56, 56]             288
            ReLU6-24          [-1, 144, 56, 56]               0
           Conv2d-25           [-1, 24, 56, 56]           3,456
      BatchNorm2d-26           [-1, 24, 56, 56]              48
 InvertedResidual-27           [-1, 24, 56, 56]               0
           Conv2d-28          [-1, 144, 56, 56]           3,456
      BatchNorm2d-29          [-1, 144, 56, 56]             288
            ReLU6-30          [-1, 144, 56, 56]               0
           Conv2d-31          [-1, 144, 28, 28]           1,296
      BatchNorm2d-32          [-1, 144, 28, 28]             288
            ReLU6-33          [-1, 144, 28, 28]               0
           Conv2d-34           [-1, 32, 28, 28]           4,608
      BatchNorm2d-35           [-1, 32, 28, 28]              64
 InvertedResidual-36           [-1, 32, 28, 28]               0
           Conv2d-37          [-1, 192, 28, 28]           6,144
      BatchNorm2d-38          [-1, 192, 28, 28]             384
            ReLU6-39          [-1, 192, 28, 28]               0
           Conv2d-40          [-1, 192, 28, 28]           1,728
      BatchNorm2d-41          [-1, 192, 28, 28]             384
            ReLU6-42          [-1, 192, 28, 28]               0
           Conv2d-43           [-1, 32, 28, 28]           6,144
      BatchNorm2d-44           [-1, 32, 28, 28]              64
 InvertedResidual-45           [-1, 32, 28, 28]               0
           Conv2d-46          [-1, 192, 28, 28]           6,144
      BatchNorm2d-47          [-1, 192, 28, 28]             384
            ReLU6-48          [-1, 192, 28, 28]               0
           Conv2d-49          [-1, 192, 28, 28]           1,728
      BatchNorm2d-50          [-1, 192, 28, 28]             384
            ReLU6-51          [-1, 192, 28, 28]               0
           Conv2d-52           [-1, 32, 28, 28]           6,144
      BatchNorm2d-53           [-1, 32, 28, 28]              64
 InvertedResidual-54           [-1, 32, 28, 28]               0
           Conv2d-55          [-1, 192, 28, 28]           6,144
      BatchNorm2d-56          [-1, 192, 28, 28]             384
            ReLU6-57          [-1, 192, 28, 28]               0
           Conv2d-58          [-1, 192, 14, 14]           1,728
      BatchNorm2d-59          [-1, 192, 14, 14]             384
            ReLU6-60          [-1, 192, 14, 14]               0
           Conv2d-61           [-1, 64, 14, 14]          12,288
      BatchNorm2d-62           [-1, 64, 14, 14]             128
 InvertedResidual-63           [-1, 64, 14, 14]               0
           Conv2d-64          [-1, 384, 14, 14]          24,576
      BatchNorm2d-65          [-1, 384, 14, 14]             768
            ReLU6-66          [-1, 384, 14, 14]               0
           Conv2d-67          [-1, 384, 14, 14]           3,456
      BatchNorm2d-68          [-1, 384, 14, 14]             768
            ReLU6-69          [-1, 384, 14, 14]               0
           Conv2d-70           [-1, 64, 14, 14]          24,576
      BatchNorm2d-71           [-1, 64, 14, 14]             128
 InvertedResidual-72           [-1, 64, 14, 14]               0
           Conv2d-73          [-1, 384, 14, 14]          24,576
      BatchNorm2d-74          [-1, 384, 14, 14]             768
            ReLU6-75          [-1, 384, 14, 14]               0
           Conv2d-76          [-1, 384, 14, 14]           3,456
      BatchNorm2d-77          [-1, 384, 14, 14]             768
            ReLU6-78          [-1, 384, 14, 14]               0
           Conv2d-79           [-1, 64, 14, 14]          24,576
      BatchNorm2d-80           [-1, 64, 14, 14]             128
 InvertedResidual-81           [-1, 64, 14, 14]               0
           Conv2d-82          [-1, 384, 14, 14]          24,576
      BatchNorm2d-83          [-1, 384, 14, 14]             768
            ReLU6-84          [-1, 384, 14, 14]               0
           Conv2d-85          [-1, 384, 14, 14]           3,456
      BatchNorm2d-86          [-1, 384, 14, 14]             768
            ReLU6-87          [-1, 384, 14, 14]               0
           Conv2d-88           [-1, 64, 14, 14]          24,576
      BatchNorm2d-89           [-1, 64, 14, 14]             128
 InvertedResidual-90           [-1, 64, 14, 14]               0
           Conv2d-91          [-1, 384, 14, 14]          24,576
      BatchNorm2d-92          [-1, 384, 14, 14]             768
            ReLU6-93          [-1, 384, 14, 14]               0
           Conv2d-94          [-1, 384, 14, 14]           3,456
      BatchNorm2d-95          [-1, 384, 14, 14]             768
            ReLU6-96          [-1, 384, 14, 14]               0
           Conv2d-97           [-1, 96, 14, 14]          36,864
      BatchNorm2d-98           [-1, 96, 14, 14]             192
 InvertedResidual-99           [-1, 96, 14, 14]               0
          Conv2d-100          [-1, 576, 14, 14]          55,296
     BatchNorm2d-101          [-1, 576, 14, 14]           1,152
           ReLU6-102          [-1, 576, 14, 14]               0
          Conv2d-103          [-1, 576, 14, 14]           5,184
     BatchNorm2d-104          [-1, 576, 14, 14]           1,152
           ReLU6-105          [-1, 576, 14, 14]               0
          Conv2d-106           [-1, 96, 14, 14]          55,296
     BatchNorm2d-107           [-1, 96, 14, 14]             192
InvertedResidual-108           [-1, 96, 14, 14]               0
          Conv2d-109          [-1, 576, 14, 14]          55,296
     BatchNorm2d-110          [-1, 576, 14, 14]           1,152
           ReLU6-111          [-1, 576, 14, 14]               0
          Conv2d-112          [-1, 576, 14, 14]           5,184
     BatchNorm2d-113          [-1, 576, 14, 14]           1,152
           ReLU6-114          [-1, 576, 14, 14]               0
          Conv2d-115           [-1, 96, 14, 14]          55,296
     BatchNorm2d-116           [-1, 96, 14, 14]             192
InvertedResidual-117           [-1, 96, 14, 14]               0
          Conv2d-118          [-1, 576, 14, 14]          55,296
     BatchNorm2d-119          [-1, 576, 14, 14]           1,152
           ReLU6-120          [-1, 576, 14, 14]               0
          Conv2d-121            [-1, 576, 7, 7]           5,184
     BatchNorm2d-122            [-1, 576, 7, 7]           1,152
           ReLU6-123            [-1, 576, 7, 7]               0
          Conv2d-124            [-1, 160, 7, 7]          92,160
     BatchNorm2d-125            [-1, 160, 7, 7]             320
InvertedResidual-126            [-1, 160, 7, 7]               0
          Conv2d-127            [-1, 960, 7, 7]         153,600
     BatchNorm2d-128            [-1, 960, 7, 7]           1,920
           ReLU6-129            [-1, 960, 7, 7]               0
          Conv2d-130            [-1, 960, 7, 7]           8,640
     BatchNorm2d-131            [-1, 960, 7, 7]           1,920
           ReLU6-132            [-1, 960, 7, 7]               0
          Conv2d-133            [-1, 160, 7, 7]         153,600
     BatchNorm2d-134            [-1, 160, 7, 7]             320
InvertedResidual-135            [-1, 160, 7, 7]               0
          Conv2d-136            [-1, 960, 7, 7]         153,600
     BatchNorm2d-137            [-1, 960, 7, 7]           1,920
           ReLU6-138            [-1, 960, 7, 7]               0
          Conv2d-139            [-1, 960, 7, 7]           8,640
     BatchNorm2d-140            [-1, 960, 7, 7]           1,920
           ReLU6-141            [-1, 960, 7, 7]               0
          Conv2d-142            [-1, 160, 7, 7]         153,600
     BatchNorm2d-143            [-1, 160, 7, 7]             320
InvertedResidual-144            [-1, 160, 7, 7]               0
          Conv2d-145            [-1, 960, 7, 7]         153,600
     BatchNorm2d-146            [-1, 960, 7, 7]           1,920
           ReLU6-147            [-1, 960, 7, 7]               0
          Conv2d-148            [-1, 960, 7, 7]           8,640
     BatchNorm2d-149            [-1, 960, 7, 7]           1,920
           ReLU6-150            [-1, 960, 7, 7]               0
          Conv2d-151            [-1, 320, 7, 7]         307,200
     BatchNorm2d-152            [-1, 320, 7, 7]             640
InvertedResidual-153            [-1, 320, 7, 7]               0
          Conv2d-154           [-1, 1280, 7, 7]         409,600
     BatchNorm2d-155           [-1, 1280, 7, 7]           2,560
           ReLU6-156           [-1, 1280, 7, 7]               0
         Dropout-157                 [-1, 1280]               0
          Linear-158                 [-1, 1000]       1,281,000
================================================================
Total params: 3,504,872
Trainable params: 3,504,872
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 152.87
Params size (MB): 13.37
Estimated Total Size (MB): 166.81
----------------------------------------------------------------