PyTorch深度学习框架60天进阶学习计划 - 第48天：移动端模型优化（一）
第一部分：MobileNetV3的NAS搜索实践
欢迎来到我们的第48天学习内容！今天我们将深入探索移动端模型优化的关键技术，特别是MobileNetV3的神经架构搜索(NAS)和TensorFlow Lite量化部署。
在第一部分，我们将聚焦于MobileNetV3的NAS搜索实践。
1. 移动端模型优化概述
移动设备和边缘计算环境对深度学习模型有着严格的约束：计算资源有限、电池容量受限、实时性要求高。因此，我们需要特别优化的模型架构来满足这些需求。MobileNet系列是专为移动设备设计的高效神经网络模型，而其最新版本MobileNetV3通过结合人工设计和神经架构搜索(NAS)取得了显著的性能提升。
1.1 MobileNet系列演进
| 版本 | 发布年份 | 核心创新 | 性能提升 |
|---|---|---|---|
| MobileNetV1 | 2017 | 深度可分离卷积 | 基准模型 |
| MobileNetV2 | 2018 | 线性瓶颈、倒残差结构 | 比V1快约35% |
| MobileNetV3 | 2019 | NAS、硬件感知、SE模块、改进的激活函数 | 比V2快约25% |
MobileNetV3通过NetAdapt和NAS自动化搜索模型架构，再结合人工专家知识进行优化，创建了两个版本：MobileNetV3-Large和MobileNetV3-Small，分别针对不同的资源约束。
2. 神经架构搜索(NAS)基础
神经架构搜索(Neural Architecture Search, NAS)是一种自动化设计神经网络架构的技术，旨在减少人工设计的工作量，同时能够发现性能更优的网络结构。
2.1 NAS的三个关键组成部分
- 搜索空间(Search Space)：定义可能的网络架构集合
- 搜索策略(Search Strategy)：如何在搜索空间中探索
- 性能评估策略(Performance Estimation Strategy)：如何评估候选架构的性能
2.2 主流NAS方法
| 方法 | 特点 | 计算资源需求 |
|---|---|---|
| 强化学习(RL)基础NAS | 使用强化学习来优化架构，如NASNet | 极高(数千GPU天) |
| 进化算法(EA)基础NAS | 使用遗传算法等进化方法优化 | 高(数百GPU天) |
| 梯度基础NAS | 如DARTS，将离散搜索转化为连续优化 | 中(数GPU天) |
| 代理任务NAS | 使用性能预测模型加速评估 | 中低 |
| One-Shot NAS | 训练包含所有可能架构的超网络，如SPOS | 低(单位数GPU天) |
MobileNetV3使用的是基于强化学习的NAS，结合了平台感知的搜索方法，以实现更高效的架构。
3. MobileNetV3中的NAS实践
MobileNetV3结合了多种技术来优化网络架构，特别是针对移动设备的限制。其核心贡献包括：
- 平台感知(Platform-Aware) NAS：直接针对目标硬件平台进行优化
- NetAdapt算法：自动调整每层的通道数来满足延迟约束
- 结合新操作符：引入新的激活函数(h-swish)和注意力模块(SE)
- 网络级优化：重新设计昂贵层的位置和结构
3.1 MobileNetV3的搜索空间
MobileNetV3的搜索空间主要包括：
- 卷积类型：深度可分离卷积、普通卷积
- 核大小：3x3、5x5、7x7
- 扩展比率(expansion ratio)：不同的通道扩展倍数
- SE模块：是否使用以及放置位置
- 激活函数：ReLU、swish、h-swish
3.2 搜索策略
MobileNetV3的NAS搜索分为两个阶段：
- 全局架构搜索：使用基于MnasNet的强化学习(RL)控制器在粗粒度层面确定网络结构
- NetAdapt算法：在第一阶段基础上，通过迭代微调每层的通道数，在延迟约束下优化性能
搜索目标是最大化下面的奖励函数：
reward = accuracy × [latency/target_latency]^w
其中w是权重因子，用于控制延迟的重要性。
4. PyTorch实现MobileNetV3的NAS搜索
下面我们将实现一个简化版的NAS框架，演示如何进行MobileNetV3风格的架构搜索。首先，我们需要构建搜索空间和基本的MobileNetV3模块：
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import numpy as np
import random
import time
import copy
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
# 设置随机种子以确保结果可复现
def set_seed(seed=42):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
set_seed()
# 硬Swish激活函数
class HSwish(nn.Module):
def __init__(self, inplace=True):
super(HSwish, self).__init__()
self.inplace = inplace
def forward(self, x):
return x * F.relu6(x + 3., inplace=self.inplace) / 6.
# 挤压激励(SE)模块
class SEModule(nn.Module):
def __init__(self, channel, reduction=4):
super(SEModule, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.fc = nn.Sequential(
nn.Linear(channel, channel // reduction, bias=False),
nn.ReLU(inplace=True),
nn.Linear(channel // reduction, channel, 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)
# MobileNetV3基本构建块
class MobileBottleneck(nn.Module):
def __init__(self, inp, oup, kernel, stride, exp, se=False, nl='RE'):
super(MobileBottleneck, self).__init__()
assert stride in [1, 2]
assert kernel in [3, 5, 7]
padding = (kernel - 1) // 2
self.use_res_connect = stride == 1 and inp == oup
# 激活函数选择
if nl == 'RE':
activation = nn.ReLU
elif nl == 'HS':
activation = HSwish
else:
raise NotImplementedError
# 构建模块
layers = []
if exp != 1:
# 扩展层 (1x1卷积)
layers.append(nn.Conv2d(inp, inp * exp, 1, 1, 0, bias=False))
layers.append(nn.BatchNorm2d(inp * exp))
layers.append(activation(inplace=True))
# 深度卷积
layers.extend([
# 深度可分离卷积
nn.Conv2d(inp * exp, inp * exp, kernel, stride, padding, groups=inp * exp, bias=False),
nn.BatchNorm2d(inp * exp),
activation(inplace=True)
])
# 添加SE模块（如果需要）
if se:
layers.append(SEModule(inp * exp))
# 投影层 (1x1卷积)
layers.extend([
nn.Conv2d(inp * exp, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup)
])
self.block = nn.Sequential(*layers)
def forward(self, x):
if self.use_res_connect:
return x + self.block(x)
else:
return self.block(x)
# 定义搜索空间
class SearchSpace:
def __init__(self):
self.kernel_sizes = [3, 5, 7]
self.expansion_ratios = [3, 4, 6]
self.se_options = [True, False]
self.activation_functions = ['RE', 'HS'] # RE: ReLU, HS: HSwish
def sample_mobile_bottleneck_config(self):
"""随机采样一个MobileBottleneck配置"""
kernel = random.choice(self.kernel_sizes)
exp_ratio = random.choice(self.expansion_ratios)
se = random.choice(self.se_options)
nl = random.choice(self.activation_functions)
return {
'kernel': kernel,
'exp_ratio': exp_ratio,
'se': se,
'nl': nl
}
def sample_network_config(self, num_blocks=5):
"""随机采样一个完整网络配置"""
config = []
for _ in range(num_blocks):
config.append(self.sample_mobile_bottleneck_config())
return config
# 搜索算法 - 简化版的随机搜索（作为强化学习/进化算法的替代）
class SimpleRandomSearch:
def __init__(self, search_space, num_samples=10):
self.search_space = search_space
self.num_samples = num_samples
self.best_config = None
self.best_reward = -float('inf')
def search(self, evaluate_fn):
"""执行简单随机搜索"""
for _ in range(self.num_samples):
# 采样网络配置
config = self.search_space.sample_network_config()
# 评估配置
accuracy, latency = evaluate_fn(config)
# 计算奖励
target_latency = 10.0 # 假设的目标延迟 (ms)
w = 0.2 # 延迟权重
reward = accuracy * (target_latency / latency) ** w
# 更新最佳配置
if reward > self.best_reward:
self.best_reward = reward
self.best_config = config
print(f"找到更好的配置! 准确率: {accuracy:.2f}%, 延迟: {latency:.2f}ms, 奖励: {reward:.4f}")
return self.best_config, self.best_reward
# 构建可搜索网络
class SearchableMobileNetV3(nn.Module):
def __init__(self, config, num_classes=10):
super(SearchableMobileNetV3, self).__init__()
self.config = config
# 首层标准卷积
self.first_conv = nn.Sequential(
nn.Conv2d(3, 16, 3, 2, 1, bias=False),
nn.BatchNorm2d(16),
HSwish(inplace=True)
)
# 根据配置构建中间层
self.blocks = self._make_blocks(config)
# 最后几层
last_channels = 576
self.last_conv = nn.Sequential(
nn.Conv2d(32, last_channels, 1, 1, 0, bias=False),
nn.BatchNorm2d(last_channels),
HSwish(inplace=True)
)
self.avgpool = nn.AdaptiveAvgPool2d(1)
self.classifier = nn.Sequential(
nn.Linear(last_channels, 1024),
HSwish(inplace=True),
nn.Dropout(0.2),
nn.Linear(1024, num_classes)
)
# 初始化权重
self._initialize_weights()
def _make_blocks(self, config):
blocks = nn.ModuleList()
inp = 16 # 首层输出通道数
# 第一个block使用不同的stride
stride_config = [2, 1, 2, 1, 1]
oup_config = [24, 32, 32, 32, 32] # 简化的输出通道配置
for i, block_config in enumerate(config):
stride = stride_config[i % len(stride_config)]
oup = oup_config[i % len(oup_config)]
blocks.append(MobileBottleneck(
inp=inp,
oup=oup,
kernel=block_config['kernel'],
stride=stride,
exp=block_config['exp_ratio'],
se=block_config['se'],
nl=block_config['nl']
))
inp = oup
return blocks
def _initialize_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.first_conv(x)
for block in self.blocks:
x = block(x)
x = self.last_conv(x)
x = self.avgpool(x)
x = x.view(x.size(0), -1)
x = self.classifier(x)
return x
# 简化版的评估函数
def evaluate_model(config, quick_eval=True):
"""评估网络配置的性能（准确率和延迟）"""
# 构建模型
model = SearchableMobileNetV3(config)
# 测量延迟（模拟）
latency = measure_latency(model)
# 评估准确率（模拟 - 实际应用中应该在真实数据集上评估）
if quick_eval:
# 随机生成一个准确率，但让它与延迟反相关（真实场景是通过在验证集上测试获得）
noise = np.random.normal(0, 5) # 添加一些噪声
accuracy = 85 - latency * 0.5 + noise # 基准准确率 - 延迟惩罚 + 噪声
accuracy = max(min(accuracy, 95), 60) # 限制在合理范围内
else:
# 在真实数据集上评估（这里简化为返回一个固定值）
accuracy = 80.0
return accuracy, latency
# 模拟延迟测量
def measure_latency(model, input_size=(1, 3, 224, 224), num_runs=10):
"""测量模型的推理延迟（毫秒）"""
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
model.eval()
x = torch.randn(input_size).to(device)
# 预热
with torch.no_grad():
for _ in range(5):
_ = model(x)
# 测量时间
start_time = time.time()
with torch.no_grad():
for _ in range(num_runs):
_ = model(x)
end_time = time.time()
# 计算平均延迟（毫秒）
avg_latency = (end_time - start_time) * 1000 / num_runs
# 为了模拟真实场景，加入一些与模型复杂度相关的因素
total_params = sum(p.numel() for p in model.parameters())
se_blocks = sum(1 for block in model.blocks if hasattr(block, 'se') and block.se)
# 复杂的模型会更慢，SE模块也会增加延迟
simulated_latency = avg_latency * (1 + total_params / 1e7) + se_blocks * 0.5
return simulated_latency
# NetAdapt算法（简化版）
def net_adapt(model, target_latency, data_loader, device, steps=5):
"""
NetAdapt算法：逐步减少每层的通道数以满足延迟约束
"""
current_model = copy.deepcopy(model)
current_latency = measure_latency(current_model)
print(f"初始延迟: {current_latency:.2f}ms, 目标延迟: {target_latency:.2f}ms")
# 如果已经满足目标延迟，直接返回
if current_latency <= target_latency:
return current_model
for step in range(steps):
best_model = None
best_latency = float('inf')
best_accuracy = 0
# 尝试减少每个瓶颈层的通道数
for i, block in enumerate(current_model.blocks):
if not hasattr(block, 'block'):
continue
# 找到投影层 (1x1卷积)
for j, layer in enumerate(block.block):
if isinstance(layer, nn.Conv2d) and layer.kernel_size[0] == 1 and j > 0:
# 创建模型副本
test_model = copy.deepcopy(current_model)
test_block = test_model.blocks[i].block[j]
# 减少通道数（简化为减少10%）
current_channels = test_block.out_channels
new_channels = max(int(current_channels * 0.9), 8) # 至少保留8个通道
if new_channels == current_channels:
continue # 无法进一步减少
# 创建新的卷积层
new_conv = nn.Conv2d(
test_block.in_channels,
new_channels,
test_block.kernel_size,
test_block.stride,
test_block.padding,
bias=False
)
# 复制前new_channels个通道的权重
new_conv.weight.data = test_block.weight.data[:new_channels].clone()
# 替换层
test_model.blocks[i].block[j] = new_conv
# 需要同时调整BatchNorm层
if j+1 < len(block.block) and isinstance(block.block[j+1], nn.BatchNorm2d):
new_bn = nn.BatchNorm2d(new_channels)
new_bn.weight.data = block.block[j+1].weight.data[:new_channels].clone()
new_bn.bias.data = block.block[j+1].bias.data[:new_channels].clone()
new_bn.running_mean = block.block[j+1].running_mean[:new_channels].clone()
new_bn.running_var = block.block[j+1].running_var[:new_channels].clone()
test_model.blocks[i].block[j+1] = new_bn
# 测量新模型的延迟
test_latency = measure_latency(test_model)
# 评估准确率（简化 - 实际应在验证集上测试）
test_accuracy = 90 - (current_latency - test_latency) * 0.2 # 随着压缩增加，准确率略微下降
print(f" 尝试减少Block {i} 层 {j}: 通道 {current_channels}->{new_channels}, 延迟: {test_latency:.2f}ms, 估计准确率: {test_accuracy:.2f}%")
# 更新最佳模型
if test_latency < best_latency and test_accuracy > best_accuracy * 0.99: # 允许1%的准确率下降
best_model = test_model
best_latency = test_latency
best_accuracy = test_accuracy
# 如果找到更好的模型，则更新当前模型
if best_model is not None:
current_model = best_model
current_latency = best_latency
print(f"Step {step+1}: 更新模型，当前延迟: {current_latency:.2f}ms")
# 如果达到目标延迟，提前结束
if current_latency <= target_latency:
print(f"已达到目标延迟: {current_latency:.2f}ms <= {target_latency:.2f}ms")
break
else:
print(f"Step {step+1}: 无法找到更好的模型，提前结束")
break
return current_model
# 主函数：执行NAS搜索
def run_nas_search():
print("开始MobileNetV3 NAS搜索...")
# 初始化搜索空间
search_space = SearchSpace()
# 初始化搜索算法
search_algo = SimpleRandomSearch(search_space, num_samples=20)
# 执行搜索
best_config, best_reward = search_algo.search(evaluate_model)
print("\n=== 最佳网络配置 ===")
for i, block in enumerate(best_config):
print(f"Block {i}: Kernel={block['kernel']}, Expansion={block['exp_ratio']}, SE={block['se']}, Activation={block['nl']}")
print(f"最佳奖励值: {best_reward:.4f}")
# 构建最佳模型
best_model = SearchableMobileNetV3(best_config)
accuracy, latency = evaluate_model(best_config, quick_eval=False)
print(f"最佳模型: 准确率={accuracy:.2f}%, 延迟={latency:.2f}ms")
# 使用NetAdapt进一步优化
print("\n=== 使用NetAdapt进一步优化 ===")
target_latency = latency * 0.8 # 目标是比当前延迟再减少20%
# 简化版本，实际应用中需要真实数据集
data_loader = None
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
optimized_model = net_adapt(best_model, target_latency, data_loader, device)
final_latency = measure_latency(optimized_model)
print(f"优化后模型延迟: {final_latency:.2f}ms")
return best_config, optimized_model
# 如果运行该脚本，则执行NAS搜索
if __name__ == "__main__":
best_config, optimized_model = run_nas_search()
上面的代码实现了一个简化版的NAS搜索框架，包括MobileNetV3的基本构建块、搜索空间定义、简单的随机搜索算法以及NetAdapt优化。在实际应用中，我们会使用更复杂的强化学习或进化算法来指导搜索过程，并在真实数据集上评估模型性能。
5. NAS搜索流程可视化
下面是MobileNetV3 NAS搜索的流程图：
6. MobileNetV3的核心创新点分析
MobileNetV3相比前代模型引入了多项创新，下面我们详细分析其核心技术：
6.1 硬激活函数(h-swish)
h-swish是swish激活函数的一个计算效率更高的近似版本：
h-swish(x) = x * ReLU6(x + 3) / 6
相比传统的ReLU，h-swish在轻微增加计算成本的同时，能带来明显的精度提升，特别是在较深的网络中。
# h-swish的PyTorch实现
def h_swish(x, inplace=True):
return x * F.relu6(x + 3., inplace=inplace) / 6.
# 或者作为模块
class HSwish(nn.Module):
def __init__(self, inplace=True):
super(HSwish, self).__init__()
self.inplace = inplace
def forward(self, x):
return x * F.relu6(x + 3., inplace=self.inplace) / 6.
6.2 挤压激励(SE)模块
SE模块通过自适应重新校准通道特征，使网络能够关注更重要的特征通道。MobileNetV3中对SE模块做了两点优化：
- 将SE模块放在非线性激活之后而非之前
- 使用较低的压缩比率（1/4而非1/8）
class SEModule(nn.Module):
def __init__(self, channel, reduction=4):
super(SEModule, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.fc = nn.Sequential(
nn.Linear(channel, channel // reduction, bias=False),
nn.ReLU(inplace=True),
nn.Linear(channel // reduction, channel, 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)
6.3 重新设计的昂贵层
MobileNetV3对计算成本高的层进行了特别设计：
- 首层改进：使用更少的滤波器数和更高的卷积步长
- 尾层改进：移除最后一个昂贵的全连接层，在全局池化后直接使用1x1卷积
- 分类器优化：精简分类器结构
MobileNetV3特别优化了第一层和最后几层，因为这些层通常具有高计算复杂度但对精度影响有限：
# MobileNetV3中优化后的首尾层设计
def build_first_last_layers(input_size=224, num_classes=1000):
# 优化的首层
first_conv = nn.Sequential(
nn.Conv2d(3, 16, kernel_size=3, stride=2, padding=1, bias=False),
nn.BatchNorm2d(16),
HSwish(inplace=True)
)
# 优化的尾层
last_conv = nn.Sequential(
# 最后一个卷积层，通道数减少
nn.Conv2d(576, 1024, kernel_size=1, stride=1, padding=0, bias=False),
nn.BatchNorm2d(1024),
HSwish(inplace=True)
)
# 优化的分类器
classifier = nn.Sequential(
nn.AdaptiveAvgPool2d(1),
nn.Conv2d(1024, num_classes, kernel_size=1, stride=1, padding=0),
# 移除了额外的全连接层和Dropout
)
return first_conv, last_conv, classifier
这些优化减少了约15%的延迟，同时保持了相似的准确率。
7. 实际NAS搜索实验分析
7.1 不同延迟目标下的MobileNetV3搜索结果
下表展示了不同延迟约束下的MobileNetV3-Large和MobileNetV3-Small搜索结果：
| 模型版本 | 目标延迟 | 实际延迟 | ImageNet Top-1准确率 | 参数量 | 计算量 |
|---|---|---|---|---|---|
| MobileNetV3-Large | 80ms | 78ms | 75.2% | 5.4M | 219M |
| MobileNetV3-Large (0.75x) | 60ms | 62ms | 73.3% | 4.0M | 155M |
| MobileNetV3-Small | 40ms | 39ms | 67.4% | 2.9M | 66M |
| MobileNetV3-Small (0.75x) | 30ms | 31ms | 65.4% | 2.4M | 44M |
7.2 MobileNetV3各组件对性能的影响分析
通过消融实验，我们可以分析MobileNetV3中各个组件的贡献：
| 配置变更 | ImageNet Top-1准确率 | 延迟变化 | 结论 |
|---|---|---|---|
| 基线（MobileNetV2） | 72.0% | 基线 | - |
| + NAS搜索 | 73.3% | +5% | 架构搜索提升准确率 |
| + SE模块 | 74.0% | +7% | SE模块提升精度但增加延迟 |
| + h-swish | 74.7% | +1% | 轻微增加延迟但精度显著提升 |
| + 首尾层优化 | 75.2% | -15% | 减少延迟同时保持精度 |
8. 实现自定义移动友好型模块
除了标准的MobileNetV3模块，我们可以创建自定义的移动友好型模块来满足特定需求：
# 深度分离注意力模块（结合深度可分离卷积和轻量级注意力机制）
class DepthwiseSeparableAttention(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, reduction=8):
super(DepthwiseSeparableAttention, self).__init__()
padding = (kernel_size - 1) // 2
self.depthwise = nn.Conv2d(
in_channels, in_channels, kernel_size, stride, padding,
groups=in_channels, bias=False
)
self.bn1 = nn.BatchNorm2d(in_channels)
# 轻量级空间注意力
self.spatial_attention = nn.Sequential(
nn.Conv2d(in_channels, in_channels // reduction, 1, bias=False),
nn.BatchNorm2d(in_channels // reduction),
HSwish(inplace=True),
nn.Conv2d(in_channels // reduction, 1, kernel_size, padding=padding, bias=False),
nn.Sigmoid()
)
self.pointwise = nn.Conv2d(in_channels, out_channels, 1, bias=False)
self.bn2 = nn.BatchNorm2d(out_channels)
self.activation = HSwish(inplace=True)
def forward(self, x):
x = self.depthwise(x)
x = self.bn1(x)
x = self.activation(x)
# 应用空间注意力
attention = self.spatial_attention(x)
x = x * attention
x = self.pointwise(x)
x = self.bn2(x)
x = self.activation(x)
return x
# 特征融合模块（适用于特征金字塔网络）
class MobileFusionModule(nn.Module):
def __init__(self, high_in_channels, low_in_channels, out_channels):
super(MobileFusionModule, self).__init__()
self.high_conv = nn.Sequential(
nn.Conv2d(high_in_channels, out_channels, 1, bias=False),
nn.BatchNorm2d(out_channels),
HSwish(inplace=True)
)
self.low_conv = nn.Sequential(
nn.Conv2d(low_in_channels, out_channels, 1, bias=False),
nn.BatchNorm2d(out_channels),
HSwish(inplace=True)
)
# 轻量级细化模块
self.refine = nn.Sequential(
nn.Conv2d(out_channels, out_channels, 3, padding=1, groups=out_channels, bias=False),
nn.BatchNorm2d(out_channels),
HSwish(inplace=True),
nn.Conv2d(out_channels, out_channels, 1, bias=False),
nn.BatchNorm2d(out_channels),
HSwish(inplace=True)
)
def forward(self, high_feat, low_feat):
high_feat = F.interpolate(high_feat, size=low_feat.shape[2:], mode='bilinear', align_corners=False)
high_feat = self.high_conv(high_feat)
low_feat = self.low_conv(low_feat)
fused_feat = high_feat + low_feat
refined_feat = self.refine(fused_feat)
return refined_feat
9. 将NAS搜索与PyTorch结合的实用技巧
在实际实现MobileNetV3的NAS搜索时，有一些重要的实用技巧可以提高效率：
9.1 权重共享技术
权重共享可以显著加速NAS搜索，通过训练一个包含所有可能子网络的超网络来实现：
class SuperNet(nn.Module):
def __init__(self, num_classes=1000):
super(SuperNet, self).__init__()
# 共享的首层
self.first_conv = nn.Sequential(
nn.Conv2d(3, 16, 3, 2, 1, bias=False),
nn.BatchNorm2d(16),
HSwish(inplace=True)
)
# 共享的MobileNetV3块，包含所有可能的配置
self.blocks = nn.ModuleList()
# 输入通道、输出通道配置
configs = [
# in_ch, out_ch, stride
(16, 16, 1),
(16, 24, 2),
(24, 24, 1),
(24, 40, 2),
(40, 40, 1),
(40, 40, 1),
(40, 80, 2),
(80, 80, 1),
(80, 80, 1),
(80, 112, 1),
(112, 112, 1),
(112, 160, 2),
(160, 160, 1),
(160, 160, 1)
]
# 为每个配置创建共享权重的超级块
for in_ch, out_ch, stride in configs:
self.blocks.append(SuperBlock(in_ch, out_ch, stride))
# 共享的尾层
self.last_conv = nn.Sequential(
nn.Conv2d(160, 960, 1, 1, 0, bias=False),
nn.BatchNorm2d(960),
HSwish(inplace=True)
)
self.avgpool = nn.AdaptiveAvgPool2d(1)
self.classifier = nn.Sequential(
nn.Linear(960, 1280, bias=False),
nn.BatchNorm1d(1280),
HSwish(inplace=True),
nn.Dropout(0.2),
nn.Linear(1280, num_classes)
)
def forward(self, x, arch_config=None):
# 如果没有提供配置，随机采样一个
if arch_config is None:
arch_config = self.random_architecture()
x = self.first_conv(x)
# 根据架构配置使用不同的块配置
for i, block in enumerate(self.blocks):
if i < len(arch_config):
block_config = arch_config[i]
x = block(x, kernel=block_config['kernel'],
exp_ratio=block_config['exp_ratio'],
se=block_config['se'],
nl=block_config['nl'])
else:
# 默认配置
x = block(x)
x = self.last_conv(x)
x = self.avgpool(x)
x = x.view(x.size(0), -1)
x = self.classifier(x)
return x
def random_architecture(self):
"""生成随机架构配置用于训练"""
arch = []
search_space = SearchSpace()
for _ in range(len(self.blocks)):
arch.append(search_space.sample_mobile_bottleneck_config())
return arch
# 可配置的超级块
class SuperBlock(nn.Module):
def __init__(self, inp, oup, stride):
super(SuperBlock, self).__init__()
self.stride = stride
self.inp = inp
self.oup = oup
# 最大扩展率
max_exp = 6
hidden_dim = inp * max_exp
# 扩展层
self.exp_conv = nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False)
self.exp_bn = nn.BatchNorm2d(hidden_dim)
# 深度卷积层（最大核大小）
self.depth_conv3 = nn.Conv2d(hidden_dim, hidden_dim, 3, stride, 1, groups=hidden_dim, bias=False)
self.depth_conv5 = nn.Conv2d(hidden_dim, hidden_dim, 5, stride, 2, groups=hidden_dim, bias=False)
self.depth_bn = nn.BatchNorm2d(hidden_dim)
# SE模块
self.se = SEModule(hidden_dim)
# 激活函数
self.relu = nn.ReLU(inplace=True)
self.hswish = HSwish(inplace=True)
# 线性瓶颈
self.linear_conv = nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False)
self.linear_bn = nn.BatchNorm2d(oup)
# 是否使用残差连接
self.use_res_connect = self.stride == 1 and inp == oup
def forward(self, x, kernel=3, exp_ratio=6, se=True, nl='HS'):
residual = x
# 扩展层
hidden_dim = self.inp * exp_ratio
exp_slice = slice(0, hidden_dim)
if exp_ratio != 1:
x = self.exp_conv(x)[:, exp_slice]
x = self.exp_bn(x)
x = self.hswish(x) if nl == 'HS' else self.relu(x)
# 深度卷积
if kernel == 3:
x = self.depth_conv3(x)
elif kernel == 5:
x = self.depth_conv5(x)
x = self.depth_bn(x)
x = self.hswish(x) if nl == 'HS' else self.relu(x)
# SE模块
if se:
x = self.se(x)
# 线性瓶颈
x = self.linear_conv(x)
x = self.linear_bn(x)
# 残差连接
if self.use_res_connect:
return residual + x
else:
return x
9.2 渐进式NAS与差异化隐私训练
渐进式NAS通过从小模型逐步搜索到大模型，可以显著加速搜索过程：
def progressive_nas(epochs=5, num_blocks_range=(4, 12)):
"""渐进式NAS：从小模型开始，逐步扩展到大模型"""
search_space = SearchSpace()
best_config = []
best_accuracy = 0
# 从较小的块数开始
for num_blocks in range(num_blocks_range[0], num_blocks_range[1] + 1):
print(f"=== 搜索 {num_blocks} 块的网络 ===")
# 如果已经有最佳配置，使用它作为基础
if best_config:
# 保留之前的最佳配置，添加随机新块
base_config = best_config.copy()
while len(base_config) < num_blocks:
base_config.append(search_space.sample_mobile_bottleneck_config())
else:
# 第一次迭代，完全随机配置
base_config = search_space.sample_network_config(num_blocks)
# 为当前大小搜索最佳配置
current_best_config = base_config
current_best_accuracy = evaluate_model(base_config)[0]
# 简单的局部搜索
for _ in range(10): # 每个大小执行10次迭代
# 随机修改一个块的配置
test_config = current_best_config.copy()
block_to_change = random.randint(0, num_blocks - 1)
test_config[block_to_change] = search_space.sample_mobile_bottleneck_config()
# 评估新配置
accuracy, _ = evaluate_model(test_config)
if accuracy > current_best_accuracy:
current_best_config = test_config
current_best_accuracy = accuracy
print(f" 发现更好的 {num_blocks} 块配置, 准确率: {accuracy:.2f}%")
# 如果当前大小的最佳配置优于总体最佳，则更新
if current_best_accuracy > best_accuracy:
best_config = current_best_config
best_accuracy = current_best_accuracy
print(f"更新全局最佳配置, 块数: {num_blocks}, 准确率: {best_accuracy:.2f}%")
else:
print(f"保持之前的最佳配置, 准确率: {best_accuracy:.2f}%")
return best_config, best_accuracy
9.3 硬件感知NAS的延迟测量
为了准确评估不同架构在目标设备上的性能，我们需要实际测量延迟：
def measure_real_device_latency(model, device_type="cpu", num_runs=100):
"""
在实际设备上测量模型延迟
参数:
- model: 待测量的PyTorch模型
- device_type: 设备类型，可选"cpu"、"gpu"或"mobile"
- num_runs: 测量次数
返回:
- 平均延迟(ms)
"""
if device_type == "mobile":
# 对于移动设备，我们需要导出模型并在移动设备上测量
# 这里是一个模拟实现，实际应使用如Android/iOS平台的测量工具
# 或使用第三方库如TFLite Model Benchmark Tool
print("移动设备延迟测量需要额外设置，这里返回模拟值")
# 导出模型大小作为延迟估计的因素之一
dummy_input = torch.randn(1, 3, 224, 224)
torch.onnx.export(model, dummy_input, "temp_model.onnx",
opset_version=11, export_params=True)
model_size = os.path.getsize("temp_model.onnx") / (1024 * 1024) # MB
os.remove("temp_model.onnx")
# 根据模型大小和复杂度估算延迟
estimated_latency = 10 + model_size * 2 # 简单的估计
return estimated_latency
# 对于CPU/GPU设备，直接在PyTorch中测量
device = torch.device(device_type)
model.to(device)
model.eval()
# 准备输入
dummy_input = torch.randn(1, 3, 224, 224, device=device)
# 预热
with torch.no_grad():
for _ in range(10):
_ = model(dummy_input)
# 同步GPU
if device_type == "cuda":
torch.cuda.synchronize()
# 测量时间
start_time = time.time()
with torch.no_grad():
for _ in range(num_runs):
_ = model(dummy_input)
if device_type == "cuda":
torch.cuda.synchronize()
# 计算平均延迟
elapsed_time = time.time() - start_time
avg_latency = (elapsed_time * 1000) / num_runs # 毫秒
return avg_latency
10. MobileNetV3架构搜索与部署的实践建议
基于我们对MobileNetV3的NAS探索，以下是一些实际应用中的建议：
10.1 NAS搜索阶段
-
计算资源有限时的替代方案：
- 使用权重共享和渐进式搜索
- 采用代理任务（如小数据集或少量epochs）加速评估
- 考虑使用已有的开源NAS结果作为起点
-
自定义搜索空间建议：
- 针对应用场景自定义搜索空间，移除不必要的操作
- 为关键层设置更广的搜索空间，为不太重要的层设置更窄的搜索空间
- 添加特定任务的专用操作（如目标检测中的特征金字塔）
-
多目标优化技巧：
- 平衡多个指标（准确率、延迟、能耗）的权重
- 使用帕累托前沿选择多个候选模型
- 考虑在不同设备上的性能表现差异
10.2 评估与选择阶段
-
模型性能评估：
- 在目标设备上实际测量延迟，不仅仅依赖FLOPs
- 测试不同批量大小和输入分辨率下的性能
- 评估量化前后的精度变化
-
应用场景适配：
- 对于实时应用，优先考虑延迟最低的架构
- 对于离线处理，可以选择精度更高的架构
- 考虑不同尺寸模型的集成部署（根据设备能力动态选择）
小结
在第一部分中，我们深入探讨了MobileNetV3的NAS搜索实践，包括搜索空间定义、搜索策略、网络架构设计和优化技巧。MobileNetV3通过结合自动化的NAS搜索和人工专家知识，在移动设备上实现了出色的性能和效率平衡。我们实现了一个简化的NAS框架，展示了如何在PyTorch中进行架构搜索和优化，并提供了实际应用的建议。
在下一部分中，我们将进一步探讨如何将优化后的模型通过TensorFlow Lite量化部署到边缘设备上，包括量化策略、部署流程和实际性能优化技巧。
清华大学全五版的《DeepSeek教程》完整的文档需要的朋友，关注我私信：deepseek 即可获得。
怎么样今天的内容还满意吗？再次感谢朋友们的观看，关注GZH：凡人的AI工具箱，回复666，送您价值199的AI大礼包。最后，祝您早日实现财务自由，还请给个赞，谢谢！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
