当前位置：首页 > news >正文

保姆级教程：用PyTorch从零搭建MobileNetV3-Small，并在自定义数据集上完成图像分类任务

news 2026/6/5 20:18:08

从零构建MobileNetV3-Small：PyTorch实战图像分类全流程解析

当你面对一个自定义图像分类任务时，如何在保证精度的同时兼顾计算效率？MobileNetV3-Small作为轻量级卷积神经网络的代表，通过神经网络架构搜索(NAS)和多项创新设计，在移动端设备上实现了优异的性能平衡。本文将带你从PyTorch环境搭建开始，完整实现模型构建、数据预处理、训练优化的全流程。

1. 环境准备与模型设计基础

在开始编码之前，我们需要明确MobileNetV3-Small的核心创新点。与V2版本相比，V3主要引入了三项关键改进：

h-swish激活函数：在保持swish函数优势的同时降低计算成本
SE注意力模块：通过通道注意力机制提升特征表达能力
精简网络结构：优化首尾层设计减少冗余计算

先确保你的Python环境已安装以下依赖：

pip install torch==1.10.0 torchvision==0.11.1 matplotlib tqdm

提示：建议使用Python 3.8+环境以避免兼容性问题。如果使用GPU训练，需额外安装对应版本的CUDA工具包。

MobileNetV3-Small的典型应用场景包括：

移动端图像分类
实时物体检测的backbone
边缘设备上的视觉任务
需要平衡精度与速度的嵌入式应用

2. 模型架构深度解析与实现

2.1 核心组件实现

我们先实现三个关键组件：h-swish激活函数、SE模块和基础瓶颈块。

h-swish激活函数类：

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

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), nn.ReLU(inplace=True), nn.Linear(channels // reduction, channels), HSigmoid() ) 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)

2.2 瓶颈块(Bottleneck)设计

MobileNetV3的核心构建块是改进的瓶颈结构，相比V2主要增加了SE模块和灵活的激活函数选择：

class Bottleneck(nn.Module): def __init__(self, in_channels, exp_channels, out_channels, kernel_size, stride, use_se, activation): super().__init__() self.use_se = use_se self.stride = stride self.in_channels = in_channels self.out_channels = out_channels # 扩展层 self.conv1 = nn.Conv2d(in_channels, exp_channels, 1, bias=False) self.bn1 = nn.BatchNorm2d(exp_channels) self.act1 = activation # 深度可分离卷积 padding = (kernel_size - 1) // 2 self.conv2 = nn.Conv2d( exp_channels, exp_channels, kernel_size, stride=stride, padding=padding, groups=exp_channels, bias=False ) self.bn2 = nn.BatchNorm2d(exp_channels) self.act2 = activation # SE模块 if use_se: self.se = SEModule(exp_channels) # 输出层 self.conv3 = nn.Conv2d(exp_channels, out_channels, 1, bias=False) self.bn3 = nn.BatchNorm2d(out_channels) # 捷径连接 self.shortcut = (stride == 1) and (in_channels == out_channels) def forward(self, x): out = self.act1(self.bn1(self.conv1(x))) out = self.act2(self.bn2(self.conv2(out))) if self.use_se: out = self.se(out) out = self.bn3(self.conv3(out)) if self.shortcut: out += x return out

2.3 完整MobileNetV3-Small实现

根据论文中的结构表，我们构建完整模型：

class MobileNetV3_Small(nn.Module): def __init__(self, num_classes=1000): super().__init__() self.features = nn.Sequential( # 初始卷积层 nn.Conv2d(3, 16, 3, stride=2, padding=1, bias=False), nn.BatchNorm2d(16), HSwish(), # 瓶颈块序列 self._make_layer(16, 16, 16, 3, 2, False, nn.ReLU()), self._make_layer(16, 72, 24, 3, 2, False, nn.ReLU()), self._make_layer(24, 88, 24, 3, 1, False, nn.ReLU()), self._make_layer(24, 96, 40, 5, 2, True, HSwish()), self._make_layer(40, 240, 40, 5, 1, True, HSwish()), self._make_layer(40, 240, 40, 5, 1, True, HSwish()), self._make_layer(40, 120, 48, 5, 1, True, HSwish()), self._make_layer(48, 144, 48, 5, 1, True, HSwish()), self._make_layer(48, 288, 96, 5, 2, True, HSwish()), self._make_layer(96, 576, 96, 5, 1, True, HSwish()), self._make_layer(96, 576, 96, 5, 1, True, HSwish()), # 最后几层 nn.Conv2d(96, 576, 1, stride=1, padding=0, bias=False), nn.BatchNorm2d(576), HSwish(), SEModule(576), nn.AdaptiveAvgPool2d(1), nn.Conv2d(576, 1024, 1, bias=False), HSwish() ) self.classifier = nn.Sequential( nn.Linear(1024, num_classes) ) self._init_weights() def _make_layer(self, in_c, exp_c, out_c, kernel_size, stride, use_se, activation): return Bottleneck( in_c, exp_c, out_c, kernel_size, stride, use_se, activation ) def _init_weights(self): for m in self.modules(): if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out') if m.bias is not None: nn.init.zeros_(m.bias) elif isinstance(m, nn.BatchNorm2d): nn.init.ones_(m.weight) nn.init.zeros_(m.bias) elif isinstance(m, nn.Linear): nn.init.normal_(m.weight, 0, 0.01) if m.bias is not None: nn.init.zeros_(m.bias) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x

3. 数据准备与增强策略

3.1 自定义数据集处理

假设我们有一个自定义图像分类数据集，结构如下：

custom_dataset/ train/ class1/ img1.jpg img2.jpg ... class2/ ... val/ class1/ ... class2/ ...

创建PyTorch数据集类：

from torchvision.datasets import ImageFolder from torch.utils.data import DataLoader train_transforms = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) val_transforms = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) train_dataset = ImageFolder('custom_dataset/train', train_transforms) val_dataset = ImageFolder('custom_dataset/val', val_transforms) train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4) val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=4)

3.2 数据增强技巧

针对小规模数据集，推荐使用以下增强组合：

基础增强：
- 随机大小裁剪(RandomResizedCrop)
- 水平翻转(RandomHorizontalFlip)
- 颜色抖动(ColorJitter)
高级增强（可选）：
- CutMix/MixUp
- 随机擦除(RandomErasing)
- 自动增强(AutoAugment)

# 高级增强示例 from timm.data.auto_augment import rand_augment_transform rand_augment = rand_augment_transform( config_str='rand-m9-mstd0.5', hparams={'translate_const': 100} ) train_transforms.transforms.insert(0, rand_augment)

4. 模型训练与优化策略

4.1 训练配置

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = MobileNetV3_Small(num_classes=len(train_dataset.classes)).to(device) # 损失函数与优化器 criterion = nn.CrossEntropyLoss() optimizer = torch.optim.RMSprop( model.parameters(), lr=0.001, alpha=0.9, momentum=0.9, eps=0.001, weight_decay=1e-5 ) # 学习率调度器 scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( optimizer, mode='max', factor=0.5, patience=3, verbose=True )

4.2 训练循环实现

def train_epoch(model, loader, criterion, optimizer, device): model.train() running_loss = 0.0 correct = 0 total = 0 for inputs, labels in tqdm(loader, desc='Training'): inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() _, predicted = outputs.max(1) total += labels.size(0) correct += predicted.eq(labels).sum().item() train_loss = running_loss / len(loader) train_acc = 100. * correct / total return train_loss, train_acc def validate(model, loader, criterion, device): model.eval() running_loss = 0.0 correct = 0 total = 0 with torch.no_grad(): for inputs, labels in tqdm(loader, desc='Validating'): inputs, labels = inputs.to(device), labels.to(device) outputs = model(inputs) loss = criterion(outputs, labels) running_loss += loss.item() _, predicted = outputs.max(1) total += labels.size(0) correct += predicted.eq(labels).sum().item() val_loss = running_loss / len(loader) val_acc = 100. * correct / total return val_loss, val_acc

4.3 训练过程监控

使用TensorBoard记录训练指标：

from torch.utils.tensorboard import SummaryWriter writer = SummaryWriter('runs/mobilenetv3_small') for epoch in range(50): train_loss, train_acc = train_epoch(model, train_loader, criterion, optimizer, device) val_loss, val_acc = validate(model, val_loader, criterion, device) writer.add_scalar('Loss/train', train_loss, epoch) writer.add_scalar('Accuracy/train', train_acc, epoch) writer.add_scalar('Loss/val', val_loss, epoch) writer.add_scalar('Accuracy/val', val_acc, epoch) scheduler.step(val_acc) print(f'Epoch {epoch+1}: Train Loss: {train_loss:.4f} Acc: {train_acc:.2f}% | ' f'Val Loss: {val_loss:.4f} Acc: {val_acc:.2f}%') # 保存最佳模型 if val_acc > best_acc: best_acc = val_acc torch.save(model.state_dict(), 'best_model.pth')

5. 模型评估与部署优化

5.1 性能评估指标

除了准确率，还应关注：

混淆矩阵：分析各类别的分类情况
推理速度：测量单张图片处理时间
模型大小：参数量和计算量(FLOPs)

from sklearn.metrics import confusion_matrix import seaborn as sns import matplotlib.pyplot as plt def plot_confusion_matrix(model, loader, device, class_names): model.eval() all_preds = [] all_labels = [] with torch.no_grad(): for inputs, labels in loader: inputs = inputs.to(device) outputs = model(inputs) _, preds = outputs.max(1) all_preds.extend(preds.cpu().numpy()) all_labels.extend(labels.numpy()) cm = confusion_matrix(all_labels, all_preds) plt.figure(figsize=(10, 8)) sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=class_names, yticklabels=class_names) plt.xlabel('Predicted') plt.ylabel('True') plt.show() plot_confusion_matrix(model, val_loader, device, train_dataset.classes)

5.2 模型量化与优化

为移动端部署，可使用PyTorch的量化工具：

# 动态量化 quantized_model = torch.quantization.quantize_dynamic( model, {nn.Linear, nn.Conv2d}, dtype=torch.qint8 ) # 保存量化模型 torch.jit.save(torch.jit.script(quantized_model), 'quantized_model.pt')

5.3 实际部署建议

ONNX导出：实现跨平台部署
TensorRT优化：提升NVIDIA设备上的推理速度
CoreML转换：在Apple设备上部署
TFLite转换：Android设备部署

# ONNX导出示例 dummy_input = torch.randn(1, 3, 224, 224).to(device) torch.onnx.export( model, dummy_input, "mobilenetv3_small.onnx", input_names=["input"], output_names=["output"], dynamic_axes={"input": {0: "batch"}, "output": {0: "batch"}} )

在实际项目中，MobileNetV3-Small的典型推理速度（在骁龙865上）可以达到约15ms每帧，满足大多数实时应用的需求。相比V2版本，在相同精度下可减少约20%的计算量，这使得它成为边缘设备上图像分类任务的理想选择。

查看全文

http://www.jsqmd.com/news/957214/