一、论文
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层。
python
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)))
python
----------------------------------------------------------------
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
----------------------------------------------------------------