深度可分离卷积与MobileNet演进

可视化演示

对比标准卷积与深度可分离卷积的参数压缩效果，展示MobileNet从v1到v3的架构演进路线，交互式调节卷积参数感受轻量化设计的核心思想。

标准卷积瓶颈

还记得那位手忙脚乱的主厨吗？他做菜的方式，就是标准卷积的工作方式：每出一道菜（每个输出通道），都要把桌上所有食材（所有输入通道）挨个处理一遍，而且每道菜用的都是独门刀法（独立的卷积核）。想象一桌十几种食材，要做二十几道菜，主厨得记住几百套刀法，案板都不够用。

在卷积网络里，这个“案板不够用”的代价是实打实的。一个卷积层的参数量等于卷积核大小平方乘以输入与输出通道数之积。通道数一多，参数和计算量就像滚雪球一样膨胀。以常见的 3×3 卷积为例，输入输出各 256 通道时，单层的参数量高达 589,824 个，乘上浮点运算量更是以亿为单位起步。

$$\displaystyle P_{\text{std}} = K \times K \times C_{\text{in}} \times C_{\text{out}}$$

移动端的小厨房可没有这么多“案板”——手机芯片算力有限、内存有限、电池更是耗不起。于是问题来了：能不能把主厨的活儿拆开，让每个帮厨各管一摊，最后再统一调配？答案就是深度可分离卷积，一套让工作量直接砍掉八九成的“流水线刀法”。

深度卷积原理

流水线的第一步，叫深度卷积（Depthwise Convolution），我们把主厨的刀法拆给一群帮厨：每个帮厨只负责一种食材，全程只切自己面前的那一种，刀法也自始至终只有一种。对应到卷积里，就是每个输入通道配一个独立的空间卷积核，各通道内部做自己的 3×3 卷积，互不串门。

这一步的好处立竿见影：参数量从“所有通道互相纠缠”变成“每个通道只配一把刀”，一下子降到原来的 K 平方分之一。3×3 卷积的话，就是九分之一。

$$\displaystyle P_{\text{DW}} = K \times K \times C_{\text{in}}$$

但帮厨们各切各的，有一个明显缺陷：食材之间完全没有交流。青椒和肉丝切好了，却没人把它们搭配到一起。卷积核只在自己的通道内移动，学不到“哪些通道的组合是有意义的”。如果只用深度卷积，网络会变成一群各自为战的孤岛，特征表达力会严重受损。因此我们需要第二步——把切好的菜统一调配。

逐点卷积融合

流水线的第二步叫逐点卷积（Pointwise Convolution），它请来一位调菜师傅：不碰刀，只拿一个小勺在每个位置把所有食材各取一点，按配比拌匀。这里的小勺就是 1×1 卷积核，它不看局部邻域，只看“这一个像素点上所有通道的数值组合”。

1×1 卷积做的事，本质上是对通道维度做加权求和，也就是跨通道的线性组合。它把深度卷积输出的、彼此孤立的各种特征图，按学习到的权重融合成新的特征表示。参数上，每个输出通道需要一套 1×1 权重，数量等于输入通道数，比 3×3 核轻得多。

$$\displaystyle P_{\text{PW}} = C_{\text{in}} \times C_{\text{out}}$$

深度卷积负责“切”，逐点卷积负责“拌”，两段配合正好复刻了标准卷积的完整功能，但参数和计算的花销却小了一个数量级。这就是整套流水线的基本逻辑——主厨一个人干的活，被拆成了“各切各的 + 统一调配”，效率自然天差地别。

参数压缩比

流水线到底省了多少人力？我们把两部分参数加起来：深度卷积的 K×K×Cin 加上逐点卷积的 Cin×Cout。把它跟标准卷积的 9×Cin×Cout 放在一个比式里看，就能算出压缩倍数。

$$\displaystyle R = \frac{K^2 \times C_{\text{out}}}{K^2 + C_{\text{out}}}$$

1. 分子 K²×Cout：标准卷积的参数量，去掉共同的 Cin 因子后剩下的部分，代表标准卷积的“人均工作量”。

$$\displaystyle K^2 \times C_{\text{out}}$$

2. 分母 K² + Cout：深度可分离卷积的参数总量（同样约去 Cin），包括深度卷积的 K² 个空间权重和逐点卷积的 Cout 个输出权重。

$$\displaystyle K^2 + C_{\text{out}}$$

3. 当 Cout 远大于 K² 时：分母的 K² 可以忽略，比值趋近于 K²，即 3×3 卷积约压缩 9 倍——输出通道越多，压缩效果越接近这个上限。

$$\displaystyle K^2 + C_{\text{out}} \approx C_{\text{out}}$$

以 3×3、输入 64 通道、输出 128 通道为例：标准卷积要 73,728 个参数，深度可分离卷积只需 8,768 个，压缩比约 8.4 倍。计算量也因为同样的结构缩减而同比例下降，这正是 MobileNet 能在手机上跑起来的根基。代价是什么呢？每层的表达能力略有下降，但深度网络靠堆层数完全可以弥补，这就要看 MobileNet 怎么把流水线盖成高楼了。

MobileNet v1

2017 年，Google 的工程师把上面这套流水线正式装进了一栋楼，取名 MobileNet v1。这栋楼的每一层都用深度可分离卷积替换掉标准卷积，核心公式就是四字口诀：先 DW，后 PW。整栋楼不需要任何花哨设计，光靠这一步就把计算量从几十亿压到了几亿浮点运算，精度只损失了两三个百分点，移动端实时推理第一次变得可行。

v1 还给了两个“施工旋钮”，方便不同场景按需调节房子的规模。第一个是宽度乘子 α，取值范围通常为 0.25 到 1.0，它把每一层的通道数按比例缩小，等于把整栋楼的房间数砍掉，参数和计算量大约按 α 的平方缩减。

$$\displaystyle C_{\text{out}}' = \alpha \times C_{\text{out}}$$

1. 宽度乘子 α：一个介于 0 和 1 之间的缩放系数，0.5 表示所有层的通道数减半，可理解成把每层的“食材种类”减半。

$$\displaystyle 0 < \alpha \leq 1$$

2. 缩放后的输出通道 Cout′：原先的通道规划统一乘以 α，整个网络的参数与计算量因此随 α² 缩减。

$$\displaystyle \alpha^2$$

3. 精度与效率的权衡：α 越小模型越轻，但特征表达越弱。0.5 的模型比 1.0 轻约四倍，精度却只掉几个点，是移动端最常用的档位。

$$\displaystyle \text{FLOPs}' \approx \alpha^2 \times \text{FLOPs}$$

第二个旋钮是分辨率乘子 ρ，它直接缩放输入图片的分辨率，比如 224×224 缩到 192×192。分辨率变低，卷积在空间上的扫描面积也随之缩小，计算量约按 ρ² 缩减。两个旋钮配合，MobileNet v1 能在一个模型框架内覆盖从“旗舰机重精度”到“手环上跑得动”的整个谱系，这种按需裁剪的思想至今仍是轻量化设计的教科书。

MobileNet v2

v1 上线后，工程师们发现了流水线的一个隐患：帮厨在切完菜后会用一种叫 ReLU 的“高压锅”处理食材——所有负值直接清零。高压锅在信息充足的大通道里没事，但在 v1 的窄瓶颈层里，信息本来就只有薄薄一层，被 ReLU 一压，一半特征直接蒸发了。实验发现，如果瓶颈层通道数很少，ReLU 会造成严重的信息丢失。解决思路因此诞生：在这层不用 ReLU，改用“透明管道”直接线性输出，这就是线性瓶颈（Linear Bottleneck）。

v2 的第二个改动是反向残差（Inverted Residual）。普通残差块是“先压缩再扩张”——先用 1×1 把通道压窄，卷积完再扩回来，像走一条细脖子隧道。v2 把它倒过来：先扩张 6 倍，再深度卷积，最后用 1×1 把通道压回原来的数量，同时旁边架一条残差捷径直通输出。通道维度变化呈两端细中间粗的“枣核形”，和普通残差的“哑铃形”正好相反。

$$\displaystyle C_{\text{mid}} = t \times C_{\text{in}}, \quad C_{\text{out}} = C_{\text{in}}$$

1. 扩展因子 t（默认 6）：把瓶颈层中间的通道数放大到输入的 6 倍，相当于把食材种类先扩充，便于在小空间里也切出足够的特征。

$$\displaystyle t = 6$$

2. 中间通道 C_mid：深度卷积在放大后的高维空间里施展，空间特征被充分提取，信息冗余度高，即便后面再过 ReLU 也不怕丢。

$$\displaystyle C_{\text{mid}} = 6 \times C_{\text{in}}$$

3. 输出通道回到 Cin：最后的 1×1 卷积把通道压回输入数，正好和残差捷径相加——两路特征逐元素相加，梯度可以从输出一路畅通无阻地流回输入。

$$\displaystyle y = x + F(x)$$

MobileNet v3

到 v2 为止，流水线已经相当成熟，但工程师们还不满足：楼层怎么盖、通道怎么配、哪里该放激活函数，这些设计决策能不能也让机器自己来？于是 v3 请来了“AI 大厨”——神经架构搜索（NAS）。NAS 像一位不知疲倦的配菜师，它不断尝试各种楼层组合：通道数多少、卷积核大小、该用哪种激活，自动搜索出每一层的“最佳配方”，不再依赖人类手调。

v3 还引入了两位得力助手。第一位是 SE 注意力模块，它像一个品菜师：每做完一道菜，先整体尝一口（全局池化），判断哪几种食材是这道的灵魂（重要通道），然后给它们加权重，下回多放一点。SE 模块的参数量很小，但能显著提升精度——给重要通道“加菜”，给无关通道“减料”。

第二位助手是 h-swish 激活函数。标准的 swish 激活效果好但计算复杂，v3 把它改成用 ReLU6 拼接出的分段线性近似：效果几乎不变，但在移动端硬件上跑起来便宜得多。v3 把这些组件组合进 NAS 搜索空间，最终产出的网络在同样算力下比 v2 又快又准，还针对手机芯片做了分段优化，成为如今移动端视觉任务最常用的骨干网络之一。

工程实践

这套流水线刀法早已从论文走进了真实世界的厨房。在目标检测领域，SSDLite 用深度可分离卷积替换 SSD 的预测层，配合 MobileNet 骨干，在手机上实现了实时检测——你手机上的“扫一扫识物”“AR 测量”背后往往就有它的身影。语义分割方向，DeepLabV3+ 将 MobileNet 用作编码器，在无人机航拍、卫星影像分析等场景里以极低功耗完成像素级分割。人脸识别门禁、车牌识别闸机等嵌入式设备，更是把 MobileNet 当作默认选择。

实际选型时，三条经验值得记住：极致追求速度、对精度要求不高，选 v1 或 v1-0.5，它结构最简单、延迟最低；希望精度和速度均衡，选 v2，它的反向残差结构在分类、检测上都稳；要榨干每毫瓦算力达到最优精度，选 v3，但它对部署框架的算子支持要求稍高。部署层面还有三件套：int8 量化用 8 位整数替代 32 位浮点，模型体积和推理耗时能再降约四倍；权重剪枝把绝对值接近零的参数直接置零，借助稀疏加速库跑得更快；再用 TensorRT 等推理引擎做层融合与内存复用，把流水线的每一道工序都打磨到极致。说到底，深度可分离卷积教给我们的不只是一套具体结构，更是一种思维：把复杂任务拆成可独立优化的子任务，再让它们各司其职、精密配合——厨房如此，AI 亦如此。

AI 应用场景

Python 演示

"""深度可分离卷积与标准卷积的参数量/计算量对比演示"""import numpy as np def im2col(x, ksize, pad=1):    """将输入图像展开为矩阵列，stride=1 简化实现"""    batch, h, w, cin = x.shape    h_out = h + 2 * pad - ksize + 1    w_out = w + 2 * pad - ksize + 1    x_pad = np.pad(x, ((0, 0), (pad, pad), (pad, pad), (0, 0)), mode="constant")    cols = np.empty((batch, h_out, w_out, ksize, ksize, cin))    for i in range(ksize):        for j in range(ksize):            cols[:, :, :, i, j, :] = x_pad[:, i:i+h_out, j:j+w_out, :]    return cols.reshape(batch, h_out * w_out, ksize * ksize * cin) def depthwise_conv2d(x, dw_w):    """每个输入通道独立应用一个空间卷积核"""    batch, h, w, cin = x.shape    k = dw_w.shape[0]    h_out = h - k + 2    w_out = w - k + 2    cols = im2col(x, k)    out = cols @ dw_w.reshape(-1, 1)    return out.reshape(batch, h_out, w_out, cin) def pointwise_conv2d(x, pw_w):    """1x1卷积：对通道维度做线性融合"""    return x @ pw_w def depthwise_separable_forward(x, dw_w, pw_w):    """深度可分离卷积前向：先DW再PW"""    y = depthwise_conv2d(x, dw_w)    return pointwise_conv2d(y, pw_w) def main():    cin, cout, k, h, w = 8, 16, 3, 16, 16    x = np.random.randn(1, h, w, cin).astype(np.float32)    dw_w = np.random.randn(k, k, cin).astype(np.float32)    pw_w = np.random.randn(cin, cout).astype(np.float32)    y = depthwise_separable_forward(x, dw_w, pw_w)    p_std = k * k * cin * cout    p_dsc = k * k * cin + cin * cout    f_std = h * w * k * k * cin * cout    f_dsc = h * w * (k * k * cin + cin * cout)    print("输出形状:", y.shape)    print("标准卷积参数量: %d" % p_std)    print("深度可分离参数量: %d" % p_dsc)    print("参数压缩比: %.2f 倍" % (p_std / p_dsc))    print("计算量压缩比: %.2f 倍" % (f_std / f_dsc)) if __name__ == "__main__":    main()

1. cols = im2col(x, k)把输入图像每个位置的邻域展开成矩阵列，这是用矩阵乘法实现卷积的经典技巧，像把食材平铺好方便批量加工。
2. out = cols @ dw_w.reshape(-1, 1)深度卷积：每通道只和自己的核做加权和，对应“各切各的菜”。
3. return x @ pw_w逐点卷积：1×1 核在通道维上做线性组合，对应“调菜师傅拌匀”。
4. p_dsc = k * k * cin + cin * cout深度可分离卷积的总参数量，两项分别对应 DW 和 PW 的权重数。
5. f_dsc = h * w * (k * k * cin + cin * cout)总计算量：每个输出像素都要经历空间卷积与通道融合两步。

常见误区

面试题