• MobileNetV3

    相对重量级网络而言，轻量级网络的特点是参数少、计算量小、推理时间短。更适用于存储空间和功耗受限的场景，例如移动端嵌入式设备等边缘计算设备。因此轻量级网络受到了广泛的关注，其中MobileNet可谓是其中的佼佼者。MobileNetV3经过了V1和V2前两代的积累，性能和速度都表现优异，MobileNetV3 参数是由NAS（network architecture search）搜索获取的，又继承的V1和V2的一些实用成果，并引人SE通道注意力机制，可谓集大成者。本文以应用为主，结合代码剖析MobileNetV3的网络结构。

    主要特点

    1. 论文推出两个版本：Large 和 Small，分别适用于不同的场景;
    2. 使用NetAdapt算法获得卷积核和通道的最佳数量;
    3. 继承V1的深度可分离卷积;
    4. 继承V2的具有线性瓶颈的残差结构;
    5. 引入SE通道注意力结构;
    6. 使用了一种新的激活函数h-swish(x)代替Relu6，h的意思表示hard;
    7. 使用了Relu6(x + 3)/6来近似SE模块中的sigmoid;
    8. 修改了MobileNetV2后端输出head

    整体结构

     上图为MobileNetV3的网络结构图，large和small的整体结构一致，区别就是基本单元bneck的个数以及内部参数上，主要是通道数目。（左图为small，右图为large）

    上表为具体的参数设置，其中bneck是网络的基本结构。SE代表是否使用通道注意力机制。NL代表激活函数的类型，包括HS(h-swish),RE(ReLU)。NBN 代表没有BN操作。 s 是stride的意思，网络使用卷积stride操作进行降采样，没有使用pooling操作。

     

    pytorch官方代码MobileNetV3

    给出修改后的 代码

    1. from typing import Callable, List, Optional
    2.  
    3. import torch
    4. from torch import nn, Tensor
    5. from torch.nn import functional as F
    6. from functools import partial
    7.  
    8.  
    9. def _make_divisible(ch, divisor=8, min_ch=None):
    10.     """
    11.     This function is taken from the original tf repo.
    12.     It ensures that all layers have a channel number that is divisible by 8
    13.     It can be seen here:
    14.     https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
    15.     """
    16.     if min_ch is None:
    17.         min_ch = divisor
    18.     new_ch = max(min_ch, int(ch + divisor / 2) // divisor * divisor)
    19.     # Make sure that round down does not go down by more than 10%.
    20.     if new_ch < 0.9 * ch:
    21.         new_ch += divisor
    22.     return new_ch
    23.  
    24.  
    25. class ConvBNActivation(nn.Sequential):
    26.     def __init__(self,
    27.                  in_planes: int,
    28.                  out_planes: int,
    29.                  kernel_size: int = 3,
    30.                  stride: int = 1,
    31.                  groups: int = 1,
    32.                  norm_layer: Optional[Callable[..., nn.Module]] = None,
    33.                  activation_layer: Optional[Callable[..., nn.Module]] = None):
    34.         padding = (kernel_size - 1) // 2
    35.         if norm_layer is None:
    36.             norm_layer = nn.BatchNorm2d
    37.         if activation_layer is None:
    38.             activation_layer = nn.ReLU6
    39.         super(ConvBNActivation, self).__init__(nn.Conv2d(in_channels=in_planes,
    40.                                                          out_channels=out_planes,
    41.                                                          kernel_size=kernel_size,
    42.                                                          stride=stride,
    43.                                                          padding=padding,
    44.                                                          groups=groups,
    45.                                                          bias=False),
    46.                                                norm_layer(out_planes),
    47.                                                activation_layer(inplace=True))
    48.  
    49.  
    50. class SqueezeExcitation(nn.Module):
    51.     def __init__(self, input_c: int, squeeze_factor: int = 4):
    52.         super(SqueezeExcitation, self).__init__()
    53.         squeeze_c = _make_divisible(input_c // squeeze_factor, 8)
    54.         self.fc1 = nn.Conv2d(input_c, squeeze_c, 1)
    55.         self.fc2 = nn.Conv2d(squeeze_c, input_c, 1)
    56.  
    57.     def forward(self, x: Tensor) -> Tensor:
    58.         scale = F.adaptive_avg_pool2d(x, output_size=(1, 1))
    59.         scale = self.fc1(scale)
    60.         scale = F.relu(scale, inplace=True)
    61.         scale = self.fc2(scale)
    62.         scale = F.hardsigmoid(scale, inplace=True)
    63.         return scale * x
    64.  
    65.  
    66. class InvertedResidualConfig:
    67.     def __init__(self,
    68.                  input_c: int,
    69.                  kernel: int,
    70.                  expanded_c: int,
    71.                  out_c: int,
    72.                  use_se: bool,
    73.                  activation: str,
    74.                  stride: int,
    75.                  width_multi: float):
    76.         self.input_c = self.adjust_channels(input_c, width_multi)
    77.         self.kernel = kernel
    78.         self.expanded_c = self.adjust_channels(expanded_c, width_multi)
    79.         self.out_c = self.adjust_channels(out_c, width_multi)
    80.         self.use_se = use_se
    81.         self.use_hs = activation == "HS"  # whether using h-swish activation
    82.         self.stride = stride
    83.  
    84.     @staticmethod
    85.     def adjust_channels(channels: int, width_multi: float):
    86.         return _make_divisible(channels * width_multi, 8)
    87.  
    88.  
    89. class InvertedResidual(nn.Module):
    90.     def __init__(self,
    91.                  cnf: InvertedResidualConfig,
    92.                  norm_layer: Callable[..., nn.Module]):
    93.         super(InvertedResidual, self).__init__()
    94.  
    95.         if cnf.stride not in [1, 2]:
    96.             raise ValueError("illegal stride value.")
    97.  
    98.         self.use_res_connect = (cnf.stride == 1 and cnf.input_c == cnf.out_c)
    99.  
    100.         layers: List[nn.Module] = []
    101.         activation_layer = nn.Hardswish if cnf.use_hs else nn.ReLU
    102.  
    103.         # expand
    104.         if cnf.expanded_c != cnf.input_c:
    105.             layers.append(ConvBNActivation(cnf.input_c,
    106.                                            cnf.expanded_c,
    107.                                            kernel_size=1,
    108.                                            norm_layer=norm_layer,
    109.                                            activation_layer=activation_layer))
    110.  
    111.         # depthwise
    112.         layers.append(ConvBNActivation(cnf.expanded_c,
    113.                                        cnf.expanded_c,
    114.                                        kernel_size=cnf.kernel,
    115.                                        stride=cnf.stride,
    116.                                        groups=cnf.expanded_c,
    117.                                        norm_layer=norm_layer,
    118.                                        activation_layer=activation_layer))
    119.  
    120.         if cnf.use_se:
    121.             layers.append(SqueezeExcitation(cnf.expanded_c))
    122.  
    123.         # project
    124.         layers.append(ConvBNActivation(cnf.expanded_c,
    125.                                        cnf.out_c,
    126.                                        kernel_size=1,
    127.                                        norm_layer=norm_layer,
    128.                                        activation_layer=nn.Identity))
    129.  
    130.         self.block = nn.Sequential(*layers)
    131.         self.out_channels = cnf.out_c
    132.         self.is_strided = cnf.stride > 1
    133.  
    134.     def forward(self, x: Tensor) -> Tensor:
    135.         result = self.block(x)
    136.         if self.use_res_connect:
    137.             result += x
    138.  
    139.         return result
    140.  
    141.  
    142. class MobileNetV3(nn.Module):
    143.     def __init__(self,
    144.                  inverted_residual_setting: List[InvertedResidualConfig],
    145.                  last_channel: int,
    146.                  num_classes: int = 1000,
    147.                  block: Optional[Callable[..., nn.Module]] = None,
    148.                  norm_layer: Optional[Callable[..., nn.Module]] = None):
    149.         super(MobileNetV3, self).__init__()
    150.  
    151.         if not inverted_residual_setting:
    152.             raise ValueError("The inverted_residual_setting should not be empty.")
    153.         elif not (isinstance(inverted_residual_setting, List) and
    154.                   all([isinstance(s, InvertedResidualConfig) for s in inverted_residual_setting])):
    155.             raise TypeError("The inverted_residual_setting should be List[InvertedResidualConfig]")
    156.  
    157.         if block is None:
    158.             block = InvertedResidual
    159.  
    160.         if norm_layer is None:
    161.             norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.01)
    162.  
    163.         layers: List[nn.Module] = []
    164.  
    165.         # building first layer
    166.         firstconv_output_c = inverted_residual_setting[0].input_c
    167.         layers.append(ConvBNActivation(3,
    168.                                        firstconv_output_c,
    169.                                        kernel_size=3,
    170.                                        stride=2,
    171.                                        norm_layer=norm_layer,
    172.                                        activation_layer=nn.Hardswish))
    173.         # building inverted residual blocks
    174.         for cnf in inverted_residual_setting:
    175.             layers.append(block(cnf, norm_layer))
    176.  
    177.         # building last several layers
    178.         lastconv_input_c = inverted_residual_setting[-1].out_c
    179.         lastconv_output_c = 6 * lastconv_input_c
    180.         layers.append(ConvBNActivation(lastconv_input_c,
    181.                                        lastconv_output_c,
    182.                                        kernel_size=1,
    183.                                        norm_layer=norm_layer,
    184.                                        activation_layer=nn.Hardswish))
    185.         self.features = nn.Sequential(*layers)
    186.         self.avgpool = nn.AdaptiveAvgPool2d(1)
    187.         self.classifier = nn.Sequential(nn.Linear(lastconv_output_c, last_channel),
    188.                                         nn.Hardswish(inplace=True),
    189.                                         nn.Dropout(p=0.2, inplace=True),
    190.                                         nn.Linear(last_channel, num_classes))
    191.  
    192.         # initial weights
    193.         for m in self.modules():
    194.             if isinstance(m, nn.Conv2d):
    195.                 nn.init.kaiming_normal_(m.weight, mode="fan_out")
    196.                 if m.bias is not None:
    197.                     nn.init.zeros_(m.bias)
    198.             elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
    199.                 nn.init.ones_(m.weight)
    200.                 nn.init.zeros_(m.bias)
    201.             elif isinstance(m, nn.Linear):
    202.                 nn.init.normal_(m.weight, 0, 0.01)
    203.                 nn.init.zeros_(m.bias)
    204.  
    205.     def _forward_impl(self, x: Tensor) -> Tensor:
    206.         x = self.features(x)
    207.         x = self.avgpool(x)
    208.         x = torch.flatten(x, 1)
    209.         x = self.classifier(x)
    210.  
    211.         return x
    212.  
    213.     def forward(self, x: Tensor) -> Tensor:
    214.         return self._forward_impl(x)
    215.  
    216.  
    217. def mobilenet_v3_large(num_classes: int = 1000,
    218.                        reduced_tail: bool = False) -> MobileNetV3:
    219.     """
    220.     Constructs a large MobileNetV3 architecture from
    221.     "Searching for MobileNetV3" .
    223.     weights_link:
    224.     https://download.pytorch.org/models/mobilenet_v3_large-8738ca79.pth
    226.     Args:
    227.         num_classes (int): number of classes
    228.         reduced_tail (bool): If True, reduces the channel counts of all feature layers
    229.             between C4 and C5 by 2. It is used to reduce the channel redundancy in the
    230.             backbone for Detection and Segmentation.
    231.     """
    232.     width_multi = 1.0
    233.     bneck_conf = partial(InvertedResidualConfig, width_multi=width_multi)
    234.     adjust_channels = partial(InvertedResidualConfig.adjust_channels, width_multi=width_multi)
    235.  
    236.     reduce_divider = 2 if reduced_tail else 1
    237.  
    238.     inverted_residual_setting = [
    239.         # input_c, kernel, expanded_c, out_c, use_se, activation, stride
    240.         bneck_conf(16, 3, 16, 16, False, "RE", 1),
    241.         bneck_conf(16, 3, 64, 24, False, "RE", 2),  # C1
    242.         bneck_conf(24, 3, 72, 24, False, "RE", 1),
    243.         bneck_conf(24, 5, 72, 40, True, "RE", 2),  # C2
    244.         bneck_conf(40, 5, 120, 40, True, "RE", 1),
    245.         bneck_conf(40, 5, 120, 40, True, "RE", 1),
    246.         bneck_conf(40, 3, 240, 80, False, "HS", 2),  # C3
    247.         bneck_conf(80, 3, 200, 80, False, "HS", 1),
    248.         bneck_conf(80, 3, 184, 80, False, "HS", 1),
    249.         bneck_conf(80, 3, 184, 80, False, "HS", 1),
    250.         bneck_conf(80, 3, 480, 112, True, "HS", 1),
    251.         bneck_conf(112, 3, 672, 112, True, "HS", 1),
    252.         bneck_conf(112, 5, 672, 160 // reduce_divider, True, "HS", 2),  # C4
    253.         bneck_conf(160 // reduce_divider, 5, 960 // reduce_divider, 160 // reduce_divider, True, "HS", 1),
    254.         bneck_conf(160 // reduce_divider, 5, 960 // reduce_divider, 160 // reduce_divider, True, "HS", 1),
    255.     ]
    256.     last_channel = adjust_channels(1280 // reduce_divider)  # C5
    257.  
    258.     return MobileNetV3(inverted_residual_setting=inverted_residual_setting,
    259.                        last_channel=last_channel,
    260.                        num_classes=num_classes)
    261.  
    262.  
    263. def mobilenet_v3_small(num_classes: int = 1000,
    264.                        reduced_tail: bool = False) -> MobileNetV3:
    265.     """
    266.     Constructs a large MobileNetV3 architecture from
    267.     "Searching for MobileNetV3" .
    269.     weights_link:
    270.     https://download.pytorch.org/models/mobilenet_v3_small-047dcff4.pth
    272.     Args:
    273.         num_classes (int): number of classes
    274.         reduced_tail (bool): If True, reduces the channel counts of all feature layers
    275.             between C4 and C5 by 2. It is used to reduce the channel redundancy in the
    276.             backbone for Detection and Segmentation.
    277.     """
    278.     width_multi = 1.0
    279.     bneck_conf = partial(InvertedResidualConfig, width_multi=width_multi)
    280.     adjust_channels = partial(InvertedResidualConfig.adjust_channels, width_multi=width_multi)
    281.  
    282.     reduce_divider = 2 if reduced_tail else 1
    283.  
    284.     inverted_residual_setting = [
    285.         # input_c, kernel, expanded_c, out_c, use_se, activation, stride
    286.         bneck_conf(16, 3, 16, 16, True, "RE", 2),  # C1
    287.         bneck_conf(16, 3, 72, 24, False, "RE", 2),  # C2
    288.         bneck_conf(24, 3, 88, 24, False, "RE", 1),
    289.         bneck_conf(24, 5, 96, 40, True, "HS", 2),  # C3
    290.         bneck_conf(40, 5, 240, 40, True, "HS", 1),
    291.         bneck_conf(40, 5, 240, 40, True, "HS", 1),
    292.         bneck_conf(40, 5, 120, 48, True, "HS", 1),
    293.         bneck_conf(48, 5, 144, 48, True, "HS", 1),
    294.         bneck_conf(48, 5, 288, 96 // reduce_divider, True, "HS", 2),  # C4
    295.         bneck_conf(96 // reduce_divider, 5, 576 // reduce_divider, 96 // reduce_divider, True, "HS", 1),
    296.         bneck_conf(96 // reduce_divider, 5, 576 // reduce_divider, 96 // reduce_divider, True, "HS", 1)
    297.     ]
    298.     last_channel = adjust_channels(1024 // reduce_divider)  # C5
    299.  
    300.     return MobileNetV3(inverted_residual_setting=inverted_residual_setting,
    301.                        last_channel=last_channel,
    302.                        num_classes=num_classes)

  • 相关阅读:
    【纯虚函数，final/override关键字】
    数据生产流程——采集、清洗、分析
    【Docker】从零开始：4.为什么Docker会比VM虚拟机快
    UE5 GAS 学习笔记 10.3 LyraStarter案例解析(中)
    全渠道商城授权管控经销商，渠道商管理系统助力医药企业快速扩大渠道规模
    实现一个深克隆
    厨神之蛋糕制作
    G1垃圾收集器
    离线数仓搭建_04_zookeeper-flume-kafka框架配置
    如何用python搭建神经网络,python实现人工神经网络
  • 原文地址：https://blog.csdn.net/qq_46454669/article/details/134027933