MobileNetV2详细原理（含torch源码）

MobilneNetV2原理
MobileNetV2是由谷歌开发的一种用于移动设备的轻量级卷积神经网络。与传统卷积神经网络相比，它具有更高的计算效率和更小的模型尺寸，可以在移动设备上实现高精度的图像识别任务。

    MobileNetV2的主要原理是使用深度可分离卷积来减少模型的参数数量和计算量。深度可分离卷积将传统的卷积操作分解为两个独立的操作：深度卷积和逐点卷积。深度卷积仅在通道维度上进行卷积操作，而逐点卷积仅在空间维度上进行卷积操作。这种分解能大大降低计算复杂度，同时保持较高的分类精度。

    另外，MobileNetV2还使用了线性瓶颈函数来加速网络训练，以及Inverted Residuals结构来充分使用低维特征信息。

线性瓶颈结构：

MobileNetV2两种残差块：

它还采用了轻量级的特征网络Design Spaces提升性能的策略，优化卷积核大小和数量，调整网络宽度和深度，最终得到一个更加高效的网络。网络结构图如下：

MobileNetV2的创新点：
MobileNetV2相较于MobileNetV1在以下方面进行了创新：

Inverted Residuals：MobileNetV2使用了Inverted Residuals结构，将输入先进行低维变换，再使用残差模块加上上采样，最后使用1x1卷积进行通道变换，从而减少计算量。

Linear Bottlenecks: MobileNetV2使用1x1卷积核将输入通道数缩小到一个较小的值，然后进行卷积操作，最后再使用1x1卷积通道扩展回原来的通道数。这样可以减少计算量和参数量，同时提高模型准确度。

使用深度可分离卷积：MobileNetV2中使用了深度可分离卷积，在计算相同的特征图时用的参数远少于传统卷积。而且，深度可分离卷积允许使用不同的卷积核、池化层和标准化层，从而提高了模型的灵活性。

设计高效的shortcut连接：在MobileNetV2中，shortcut连接采用的是identity mapping方法，使用1x1卷积将跳过的特征图的通道数与当前特征图的通道数对应起来，同时这种结构可以避免梯度消失和梯度爆炸的问题，提高了模型的稳定性。

激活函数采用Scaled Exponential Linear Unit (SELU)：MobileNetV2将激活函数采用了Scaled Exponential Linear Unit (SELU)，可以在不增加计算量的情况下提高模型的准确性。

    总之，MobileNetV2通过使用深度可分离卷积和其他技术来减少计算量和模型尺寸，同时保持高精度的分类任务，是一种非常有前途的轻量级卷积神经网络。

MobileNetV2对比MobileNetV1
MobileNetV2相比于MobileNetV1，主要改进有以下几个方面：

更优的性能：MobileNetV2在ImageNet上的Top-1准确率为72.0%，相比MobileNetV1（70.6%）有显著提升。

更高的效率：MobileNetV2在相同的计算资源下，参数量比MobileNetV1少了40%，计算量比它少了30%。

更好的适应性：MobileNetV2引入了一些新的技术，例如倒置余弦线性单元（Inverted Residuals with Linear Bottlenecks）和线性瓶颈模块（Linear Bottlenecks），使得它更适应于移动设备上的实时推理场景。

更好的鲁棒性：MobileNetV2在对小型变形的物体分类和检测任务上，能够显著提高模型的准确率。

MobilneNetV2源码（torch版）
数据集运行代码时自动下载，如果网络比较慢，可以自行点击我分享的链接下载cifar数据集。

链接：https://pan.baidu.com/s/1kfF4WxfpXr4a-GnEugh3AA?pwd=kd9a#list/path=%2F
提取码：kd9a

此代码是使用的GPU运行的，如果没有GPU导致运行失败，就把代码中的device、.to(device)删除，使用默认CPU运行。

如果使用GPU，GPU显存小导致运行报错，就将主函数main()里面的batch_size调小即可。

from torch.utils.data import DataLoader
from torchvision.datasets import CIFAR10
from torchvision.transforms import transforms
from torch.autograd import Variable


import torch.nn as nn
import torch.nn.functional as F
import torch

class Block(nn.Module):
    def __init__(self, in_planes, out_planes, expansion, stride):
        super(Block, self).__init__()
        self.stride = stride

        planes = expansion * in_planes
        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, groups=planes, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, out_planes, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(out_planes)

        self.shortcut = nn.Sequential()
        if stride == 1 and in_planes != out_planes:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_planes)
            )

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = F.relu(self.bn2(self.conv2(out)))
        out = self.bn3(self.conv3(out))
        out += self.shortcut(x) if self.stride == 1 else out
        return out


class MobileNetV2(nn.Module):
    def __init__(self, num_classes=10):
        super(MobileNetV2, self).__init__()

        self.cfgs = [
            # t, c, n, s
            [1, 16, 1, 1],
            [6, 24, 2, 1],
            [6, 32, 3, 2],
            [6, 64, 4, 2],
            [6, 96, 3, 1],
            [6, 160, 3, 2],
            [6, 320, 1, 1],
        ]

        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(32)
        self.layers = self._make_layers(in_planes=32)
        self.conv2 = nn.Conv2d(320, 1280, kernel_size=1, bias=False)
        self.bn2 = nn.BatchNorm2d(1280)
        self.linear = nn.Linear(1280, num_classes)

    def _make_layers(self, in_planes):
        layers = []
        for t, c, n, s in self.cfgs:
            for i in range(n):
                stride = s if i == 0 else 1
                layers.append(Block(in_planes, c, t, stride))
                in_planes = c
        return nn.Sequential(*layers)

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.layers(out)
        out = F.relu(self.bn2(self.conv2(out)))
        out = F.avg_pool2d(out, 4)
        out = out.view(out.size(0), -1)
        out = self.linear(out)
        return out


if __name__ == '__main__':
    train_data = CIFAR10('cifar', train=True, transform=transforms.ToTensor())
    data = DataLoader(train_data, batch_size=148, shuffle=True)

    device = torch.device("cuda")
    net = MobileNetV2().to(device)
    print(net)
    cross = nn.CrossEntropyLoss().to(device)
    optimizer = torch.optim.Adam(net.parameters(), 0.0001)
    for epoch in range(10):
        for img, label in data:
            img = Variable(img).to(device)
            label = Variable(label).to(device)
            output = net.forward(img)
            loss = cross(output, label)
            loss.backward()
            optimizer.zero_grad()
            optimizer.step()
            pre = torch.argmax(output, 1)
            num = (pre == label).sum().item()
            acc = num / img.shape[0]
        print("epoch:", epoch + 1)
        print("loss:", loss.item())
        print("Accuracy:", acc)

    以上代码采用的是跟PyTorch官方模型一样的模型结构，在_make_layers函数中构建了7个Block块，每个Block块都是跟MobileNetV2一样的结构，通过自定义一个Block类来实现。在forward函数中，通过调用这7个Block块的方式构建整个网络的结构。在最后的分类层中，采用了一个线性层。 

    使用cifar10训练做测试。

训练10个epoch的效果