从V1到V3，手把手教你用PyTorch复现MobileNet系列（附完整代码与CIFAR10实战）

从V1到V3：PyTorch实战MobileNet系列架构演进与优化

在移动端和嵌入式设备上部署高效的计算机视觉模型一直是工业界和学术界关注的焦点。MobileNet系列作为轻量级卷积神经网络的代表，通过深度可分离卷积、倒残差结构等创新设计，在保持较高精度的同时大幅降低了计算量和参数量。本文将带您从零开始，用PyTorch完整实现MobileNet V1到V3的演进过程，并通过CIFAR10分类任务验证模型性能。

1. 环境准备与基础工具

在开始构建MobileNet系列模型前，我们需要配置好开发环境并了解几个关键工具。推荐使用Python 3.8+和PyTorch 1.10+版本，这些组合在稳定性和功能支持上都有良好表现。

核心工具安装：

pip install torch torchvision torchsummary tqdm matplotlib

表：环境配置检查清单

提示：如果使用GPU加速训练，请确保安装对应版本的CUDA工具包。虽然MobileNet设计用于移动设备，但在开发阶段使用GPU可以显著加快实验迭代速度。

数据准备方面，我们将使用CIFAR10数据集，它包含10个类别的6万张32x32彩色图像。PyTorch的torchvision模块已经内置了这个数据集，可以通过以下代码自动下载：

from torchvision import datasets, transforms transform = transforms.Compose([ transforms.Resize(224), # MobileNet标准输入尺寸 transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) train_set = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform) test_set = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)

2. MobileNet V1：深度可分离卷积的革命

MobileNet V1的核心创新在于深度可分离卷积(Depthwise Separable Convolution)的引入，它将标准卷积分解为两个步骤：深度卷积(Depthwise Convolution)和逐点卷积(Pointwise Convolution)。这种设计大幅减少了计算量和参数数量。

2.1 深度可分离卷积实现

让我们先实现这个关键模块：

import torch.nn as nn class DepthwiseSeparableConv(nn.Module): def __init__(self, in_channels, out_channels, stride=1): super().__init__() self.depthwise = nn.Sequential( nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=stride, padding=1, groups=in_channels, bias=False), nn.BatchNorm2d(in_channels), nn.ReLU6(inplace=True) ) self.pointwise = nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False), nn.BatchNorm2d(out_channels), nn.ReLU6(inplace=True) ) def forward(self, x): x = self.depthwise(x) x = self.pointwise(x) return x

表：标准卷积与深度可分离卷积计算量对比

2.2 完整MobileNet V1架构

基于深度可分离卷积，我们可以构建完整的MobileNet V1：

class MobileNetV1(nn.Module): def __init__(self, num_classes=1000): super().__init__() def conv_bn(inp, oup, stride): return nn.Sequential( nn.Conv2d(inp, oup, 3, stride, 1, bias=False), nn.BatchNorm2d(oup), nn.ReLU6(inplace=True) ) self.model = nn.Sequential( conv_bn(3, 32, 2), DepthwiseSeparableConv(32, 64, 1), DepthwiseSeparableConv(64, 128, 2), DepthwiseSeparableConv(128, 128, 1), DepthwiseSeparableConv(128, 256, 2), DepthwiseSeparableConv(256, 256, 1), DepthwiseSeparableConv(256, 512, 2), *[DepthwiseSeparableConv(512, 512, 1) for _ in range(5)], DepthwiseSeparableConv(512, 1024, 2), DepthwiseSeparableConv(1024, 1024, 1), nn.AdaptiveAvgPool2d(1) ) self.fc = nn.Linear(1024, num_classes) def forward(self, x): x = self.model(x) x = x.view(-1, 1024) x = self.fc(x) return x

使用torchsummary可以查看模型结构：

from torchsummary import summary model = MobileNetV1(num_classes=10).to('cuda' if torch.cuda.is_available() else 'cpu') summary(model, (3, 224, 224))

3. MobileNet V2：倒残差与线性瓶颈

MobileNet V2在V1基础上引入了两个关键改进：线性瓶颈(Linear Bottleneck)和倒残差结构(Inverted Residual)，进一步提升了模型效率和性能。

3.1 倒残差块实现

倒残差结构的核心是先扩展后压缩，与传统的残差结构相反：

class InvertedResidual(nn.Module): def __init__(self, inp, oup, stride, expand_ratio): super().__init__() hidden_dim = int(inp * expand_ratio) self.use_res_connect = stride == 1 and inp == oup layers = [] if expand_ratio != 1: layers.extend([ nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False), nn.BatchNorm2d(hidden_dim), nn.ReLU6(inplace=True) ]) layers.extend([ nn.Conv2d(hidden_dim, hidden_dim, 3, stride, 1, groups=hidden_dim, bias=False), nn.BatchNorm2d(hidden_dim), nn.ReLU6(inplace=True), nn.Conv2d(hidden_dim, oup, 1, 1, 0, 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)

3.2 MobileNet V2完整架构

基于倒残差块构建的MobileNet V2：

class MobileNetV2(nn.Module): def __init__(self, num_classes=1000, width_mult=1.0): super().__init__() block = InvertedResidual input_channel = 32 last_channel = 1280 interverted_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], ] input_channel = int(input_channel * width_mult) self.last_channel = int(last_channel * max(1.0, width_mult)) self.features = [conv_bn(3, input_channel, 2)] for t, c, n, s in interverted_residual_setting: output_channel = int(c * width_mult) for i in range(n): stride = s if i == 0 else 1 self.features.append(block(input_channel, output_channel, stride, t)) input_channel = output_channel self.features.append(conv_1x1_bn(input_channel, self.last_channel)) self.features = nn.Sequential(*self.features) self.classifier = nn.Sequential( nn.Dropout(0.2), nn.Linear(self.last_channel, num_classes), ) def forward(self, x): x = self.features(x) x = x.mean([2, 3]) x = self.classifier(x) return x

4. MobileNet V3：搜索与注意力机制

MobileNet V3结合了神经网络架构搜索(NAS)和手工设计，引入了SE(Squeeze-and-Excitation)注意力模块和h-swish激活函数。

4.1 SE模块实现

SE模块通过自适应地重新校准通道特征响应来提升模型表现：

class SEModule(nn.Module): def __init__(self, channels, reduction=4): super().__init__() self.avg_pool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Sequential( nn.Linear(channels, channels // reduction, bias=False), nn.ReLU(inplace=True), nn.Linear(channels // reduction, channels, bias=False), nn.Sigmoid() ) def forward(self, x): b, c, _, _ = x.size() y = self.avg_pool(x).view(b, c) y = self.fc(y).view(b, c, 1, 1) return x * y.expand_as(x)

4.2 h-swish激活函数

h-swish在保持性能的同时减少了计算开销：

class HSwish(nn.Module): def forward(self, x): return x * nn.functional.relu6(x + 3, inplace=True) / 6

4.3 MobileNet V3块结构

结合了SE模块和h-swish的V3块：

class MobileNetV3Block(nn.Module): def __init__(self, inp, oup, kernel_size, stride, exp_size, use_se, use_hs, activation=nn.ReLU): super().__init__() assert stride in [1, 2] self.use_res_connect = stride == 1 and inp == oup layers = [] if exp_size != inp: layers.append(conv_1x1_bn(inp, exp_size, activation=activation)) layers.extend([ nn.Conv2d(exp_size, exp_size, kernel_size, stride, (kernel_size-1)//2, groups=exp_size, bias=False), nn.BatchNorm2d(exp_size), activation(inplace=True) if activation == nn.ReLU else HSwish() ]) if use_se: layers.append(SEModule(exp_size)) layers.append(conv_1x1_bn(exp_size, oup, activation=None)) self.conv = nn.Sequential(*layers) def forward(self, x): if self.use_res_connect: return x + self.conv(x) else: return self.conv(x)

5. 训练策略与性能优化

实现模型架构后，我们需要设计有效的训练策略来充分发挥模型潜力。

5.1 学习率调度

使用余弦退火学习率调度：

from torch.optim.lr_scheduler import CosineAnnealingLR optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-5) scheduler = CosineAnnealingLR(optimizer, T_max=epochs, eta_min=1e-6)

5.2 数据增强

针对CIFAR10的增强策略：

train_transform = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.Resize(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ])

5.3 混合精度训练

使用AMP加速训练：

from torch.cuda.amp import GradScaler, autocast scaler = GradScaler() for epoch in range(epochs): for inputs, targets in train_loader: optimizer.zero_grad() with autocast(): outputs = model(inputs) loss = criterion(outputs, targets) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() scheduler.step()

6. 模型对比与部署考量

经过完整训练后，我们可以对比三个版本的性能差异：

表：MobileNet系列在CIFAR10上的表现对比

在实际部署时，还需要考虑以下因素：

1. 量化部署：使用PyTorch的量化工具可以进一步减小模型大小

   model_quantized = torch.quantization.quantize_dynamic( model, {nn.Linear, nn.Conv2d}, dtype=torch.qint8 )

2. ONNX导出：转换为通用格式便于跨平台部署

   torch.onnx.export(model, dummy_input, "mobilenet.onnx", input_names=["input"], output_names=["output"])

3. 剪枝优化：移除不重要的连接来压缩模型

   from torch.nn.utils import prune parameters_to_prune = [(module, 'weight') for module in model.modules() if isinstance(module, nn.Conv2d)] prune.global_unstructured(parameters_to_prune, pruning_method=prune.L1Unstructured, amount=0.2)

在移动端部署时，V3通常是最佳选择，它在保持较高精度的同时具有最低的计算开销。而如果需要更好的兼容性或更简单的实现，V1仍然是可靠的选择。