设想一家餐厅的后厨。主厨是个聪明人，他发现客人点的 12 道“招牌小炒”——宫保鸡丁、鱼香肉丝、回锅肉、麻婆豆腐……虽然名字不同，但底料几乎一样：葱姜蒜爆香、同一锅酱汁、同一个翻炒手法。真正不同的，只是最后的配菜。 以前的厨师很老实，每道菜都从洗菜、切菜、起锅烧油开始，12 道菜要花 12 份功夫。而这位主厨做了一个大胆的决定：只精心烹饪 4 份“万能底料”，剩下 8 道菜，用底料加不同配菜、快炒 30 秒出锅。客人尝了之后，几乎分不出差别，后厨的出餐速度却快了近三倍。 这个故事，正是计算机视觉中 Ghost Module 的灵感来源。在卷积神经网络里，卷积层会生成大量特征图，其中很多通道彼此相似——就像那些底料相同的菜。Ghost Module 只让标准卷积“精心制作”少量核心特征图，再用极其廉价的线性变换把剩下的“相似菜品”快速补齐。最终，模型输出的特征图数量不变，但 FLOPs（浮点计算量）和参数量大幅下降，精度几乎无损。 看完这篇文章，你会理解：特征图为什么有冗余、Ghost Module 如何拆解计算、它比标准卷积省多少账、怎样嵌入现有网络，以及它和 MobileNet 里深度可分离卷积的“省钱思路”有何不同。

岗位关联

掌握 Ghost Module，你就能在动手设计轻量网络时多一把“结构性省算力”的利器——不伤精度地砍计算量，让模型跑进手机、汽车摄像头等边缘设备。

目录
  1. 可视化演示
  2. 冗余特征图：大厨深夜发现的秘密
  3. Ghost模块结构：只做底料，再翻版上菜
  4. 廉价线性变换：翻版的秘诀
  5. 计算复杂度分析：后厨的大账本
  6. 网络集成方式：把翻版写进标准菜谱
  7. 轻量化收益：客人更多，厨房更省
  8. 与其他模块对比：别的厨师的省钱妙招
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

展示CNN特征图冗余现象，以及Ghost Module通过少量原始卷积加廉价线性变换生成完整特征图的两阶段机制。

本节配有交互动效（进入视口后自动加载，约 3KB）。

特征图通道冗余现象 CNN特征图中大量通道彼此高度相似，存在显著冗余 冗余特征可通过对原始特征的简单线性变换生成 仅用少量卷积即可覆盖大部分特征信息 冗余率 ≈ 50% Ghost Module利用冗余性大幅降低计算量。

冗余特征图：大厨深夜发现的秘密

深夜打烊后，主厨翻看这一天的订单，发现了一个“浪费”的秘密：客人点的 12 道招牌小炒，从宫保鸡丁到鱼香肉丝，每一道都从切菜、起锅烧油开始，可真正不同的只有最后的配菜和酱料。12 份重复劳动里，有 8 份其实是在重复同样的底料工序。这个故事放在卷积神经网络里同样成立：卷积层输出的特征图，往往存在大量“长得像”的通道。比如识别一只猫，有的通道响应猫的轮廓，有的通道响应猫的毛发纹理，还有的通道几乎只是前者的左右翻转、明暗平移。

在神经网络中，特征图（Feature Map）是卷积核扫描输入后留下的“响应地图”。冗余特征图指那些与其他通道高度相似、可以通过变换被再次生成的通道。如果模型对每一张特征图都用标准卷积从头计算，就像给每道菜都重新洗切炒一遍——大量的计算被花在了本可复用的信息上。Ghost Module 的出发点是：真正独特的信息只需要 m 张核心特征图，其他 n-m 张都可以由核心特征廉价变换出来。这里的冗余度可以写成一个比例：若 n 是输出通道总数，m 是核心通道数，则冗余比例 r 为：

其中 s = n/m 表示每个核心特征平均翻版成多少份。当 s=4 时，75% 的特征图都是“可再生的冗余”。这解释了为什么精简计算大有可为。

主厨看到这个秘密，立刻算了一笔账：省下 8 份重复工序，厨房效率几乎翻三倍。Ghost Module 正是顺着这条思路，把“底料复用”变成了网络结构。

r=n−mn=s−1s\displaystyle r = \frac{n - m}{n} = \frac{s-1}{s}
  1. 输出特征图总数 n卷积层最终输出的通道数量，对应餐厅菜单上的“12 道菜”。
    nn
  2. 核心特征图数 m承载不可再生的独特信息、必须由标准卷积生成的通道数量，对应“4 份底料”。
    mm
  3. 翻版倍数 sn 与 m 的比值，表示每个核心特征图平均要派生出的特征份数。
    s=nms = \frac{n}{m}
  4. 冗余比例 r全部特征中可由其他特征再生的比例，反映出标准卷积里被浪费的计算份额。
    r=n−mn=s−1sr = \frac{n - m}{n} = \frac{s-1}{s}

Ghost模块结构：只做底料，再翻版上菜

改革后的主厨，后厨流程只剩两步：先花 30 分钟炒好 4 份万能底料，然后往底料里加不同的配菜，8 道翻版菜在 30 秒内依次出锅。Ghost Module 把这两步原封不动搬进了神经网络。

第一步，用一个普通的标准卷积生成 m 张核心特征图。这些特征图虽然数量少，但保留了最关键的结构信息，类似于“底料”的葱姜蒜和核心酱汁。第二步，对每一张核心特征图施加若干次“廉价线性变换”，生成 s-1 张派生特征图。每一次变换都像“加配菜”，计算量远小于重新做一道菜。最后，把核心特征和派生特征在通道维度上拼接起来，得到 n = m·s 张输出特征图。整个流程可以写成：

方括号表示通道维度的拼接（Concatenation）。前半部分是标准卷积生成的核心特征 y_1 到 y_m；后半部分是每个核心特征经过廉价变换 Φ 得到的派生特征。由于每个核心特征产生 s-1 个派生特征，加上自身共 s 个，最终输出通道数恰好是 m·s = n。

这个结构最精妙的地方在于：输入输出通道数完全不变，网络的其他部分根本不需要调整。就像菜谱上依然写着“招牌小炒 12 道”，只是后厨内部换了更省的流程。主厨的翻版手法，本质上是一场“无痛改革”。

Y=[ y1, y2, …, ym,Φ1,1(y1), …, Φm,s−1(ym) ]\displaystyle Y = \left[\, y_{1},\ y_{2},\ \dots,\ y_{m},\quad \Phi_{1,1}(y_{1}),\ \dots,\ \Phi_{m,s-1}(y_{m})\, \right]
  1. 核心特征图 y_i由标准卷积生成的第 i 张“底料”特征，数量为 m，承载最不可替代的结构信息。
    yi(i=1,2,…,m)y_{i} \quad (i = 1, 2, \ldots, m)
  2. 廉价变换符号 Φ表示对核心特征进行的小规模线性运算，比如深度卷积，负责把底料“翻版”成新菜。
    Φi,j(⋅)\Phi_{i,j}(\cdot)
  3. 派生特征生成每个核心特征 y_i 派生出 s-1 张新特征，下标 j 表示第几次翻版。
    Φi,j(yi)(j=1,…,s−1)\Phi_{i,j}(y_i) \quad (j = 1, \ldots, s-1)
  4. 通道拼接 [ ]将核心特征与全部派生特征沿通道方向合并，得到输出张量 Y，最终通道数为 ms。
    Y=[ Ycore, Ycheap ]Y = \left[\, Y_{\text{core}},\ Y_{\text{cheap}}\, \right]

廉价线性变换：翻版的秘诀

客人吃不出差别，是因为主厨的翻版有讲究：宫保鸡丁和鱼香肉丝用的是同一锅底料，只换了花生米和笋丝；直接照搬底料的是“原味版”，换个配菜的是“加料版”。在 Ghost Module 里，这两种翻版分别对应恒等映射和深度卷积。

首先，恒等映射（Identity Mapping）意味着直接把核心特征图保留下来——它本身就算一张输出特征。其次，对核心特征图做 3×3 深度卷积（Depthwise Convolution）：卷积核只在单张特征图的内部滑动，不与其他通道混合。深度卷积的每个输出像素只做 3×3=9 次乘法，而普通卷积要对所有 c 个输入通道求和，计算量是深度卷积的 c 倍。正因为如此便宜，它被称为“廉价线性变换”。用公式定义第 i 张核心特征的第 j 个派生特征：

这里 j=0 对应“原味底料”恒等分支，j≥1 对应“加配料”深度卷积分支。每个核心特征图通过这 s 条分支，最终贡献 s 张输出特征图。实际实现中，深度卷积的小卷积核往往也被学习出来，让网络自行决定如何“翻版”最逼真。

主厨的翻版妙就妙在“几乎不增加成本”：底料还是那锅底料，多的只是撒一把配菜的时间。深度卷积正是那把“撒配菜的手”。

\displaystyley'_{i,j} = \Phi_{i,j}(y_i) =\begin{cases}y_i, & j = 0 \\\operatorname{DWConv}_{i,j}(y_i), & j = 1, 2, \dots, s-1\end{cases}
  1. 恒等分支 j=0核心特征图原样作为输出，保证关键信息不因变换而丢失。
    yi,0′=yiy'_{i,0} = y_i
  2. 深度卷积分支 j≥1在单张特征图内部做 d×d 卷积，生成与核心特征相似但略有差异的“变体”。
    yi,j′=DWConv⁡i,j(yi)y'_{i,j} = \operatorname{DWConv}_{i,j}(y_i)
  3. Φ_{i,j} 整体含义每个核心特征图被扩展成 s 张输出，额外计算却只有 (s-1) 次单通道小卷积。
    Φi,j: yi↦yi,j′\Phi_{i,j}: \ y_i \mapsto y'_{i,j}

计算复杂度分析：后厨的大账本

主厨喜欢算总账：改革前，12 道菜每道 30 分钟，合计 360 分钟；改革后，4 道底料各 30 分钟，8 道翻版菜各 1 分钟，合计 128 分钟，总耗时降为原来的三分之一。FLOPs（浮点运算次数）就是神经网络的“做菜时间”。

标准卷积输出 n 张 h'×w' 的特征图，每个输出位置都要与 c 个输入通道的 k×k 窗口做乘加运算，因此总 FLOPs 为：

Ghost Module 把这一大笔账拆成两笔：第一步只生成 m=n/s 张核心特征，成本是 (n/s)·h'w'·c·k²；第二步对每张核心特征做 s-1 次 d×d 的深度卷积，成本是 (s-1)·(n/s)·h'w'·d²。总成本为：

两者相除就是加速比。当深度卷积核大小与标准卷积一致（d=k）时，公式可以大幅化简：

由于深度卷积的输入通道 c 通常远大于 s（比如 c=64、s=4），加速比非常接近 s。也就是说，理论计算量大约降为原来的 1/s——主厨的后厨时间真的省下了三分之二甚至更多。

FLOPsstd=n⋅h′⋅w′⋅c⋅k⋅k\mathrm{FLOPs}_{\mathrm{std}} = n \cdot h' \cdot w' \cdot c \cdot k \cdot k
FLOPsghost=nsh′w′ck2+(s−1)nsh′w′d2\mathrm{FLOPs}_{\mathrm{ghost}} = \frac{n}{s} h' w' c k^2 + (s-1)\frac{n}{s} h' w' d^2
r=FLOPsstdFLOPsghost=sck2ck2+(s−1)d2  ≈d=k  scs+c−1≈s(c≫s)r = \frac{\mathrm{FLOPs}_{\mathrm{std}}}{\mathrm{FLOPs}_{\mathrm{ghost}}} = \frac{s c k^2}{c k^2 + (s-1) d^2}\;\overset{d=k}{\approx}\;\frac{s c}{s + c - 1} \approx s \quad (c \gg s)
  1. 标准卷积 FLOPs 四要素输出通道 n、输出面积 h'w'、输入通道 c、卷积核面积 k²，四者相乘就是“12 道菜全量做”的总工时。
    FLOPsstd=n⋅h′⋅w′⋅c⋅k⋅k\mathrm{FLOPs}_{\mathrm{std}} = n \cdot h' \cdot w' \cdot c \cdot k \cdot k
  2. Ghost 第一步成本只算 n/s 张核心特征，对应“4 份底料”的烹饪成本。
    nsh′w′ck2\frac{n}{s} h' w' c k^2
  3. Ghost 第二步成本派生特征只做单通道深度卷积，去掉了 c 这个乘法因子，这是省钱的关键。
    (s−1)nsh′w′d2(s-1)\frac{n}{s} h' w' d^2
  4. 加速比近似令 d=k 并约去公共项，当 c 远大于 s 时，比值约等于 s，即计算量降为约 1/s。
    r≈scs+c−1≈sr \approx \frac{s c}{s + c - 1} \approx s

网络集成方式：把翻版写进标准菜谱

主厨没有把翻版手法藏着掖着，而是把它写进了餐厅的标准化流程（SOP）：以后所有需要“小炒”的菜，都按“底料+翻版”执行。这样整个菜单的出品速度都能提升。

在神经网络中，Ghost Module 同样被设计成可插拔的标准件。最常见的用法是替换残差网络中的标准卷积层：输入输出通道数不变，直接换成 Ghost 卷积，精度损失很小。更进一步的用法是构造 Ghost Bottleneck——一种类似于 ResNet 残差块的结构：先用一个 Ghost 卷积扩展通道数，再用另一个 Ghost 卷积压缩回原通道数，中间夹着批量归一化和 ReLU，最后加上残差捷径（Shortcut）。当 stride=2 时，捷径上还会加一个步长为 2 的 1×1 卷积来对齐尺寸。整个模块可以写成：

这里的 F_Ghost 表示 Ghost Bottleneck 内部的两步 Ghost 卷积组合，x 是输入，y 是输出。残差连接让梯度在后厨（反向传播）里畅通无阻，训练更稳定。

这种“换汤不换药”的集成方式，让 Ghost 思想可以嵌入 ResNet、MobileNet、检测和分割网络。主厨的 SOP 一旦推行，整家餐厅的菜单都受益。

y=FGhost(x)+x\displaystyle y = \mathcal{F}_{\text{Ghost}}(x) + x
  1. 输入特征 x进入模块的特征图，对应待加工的食材，尺寸与输出通常保持一致。
    xx
  2. Ghost 复合函数 F_Ghost两个 Ghost 卷积分别负责扩展与压缩，是“底料+翻版”的标准工序。
    FGhost(x)\mathcal{F}_{\text{Ghost}}(x)
  3. 残差捷径 +x把输入原样加到输出上，让梯度直接流过，缓解深层网络退化。
    y=FGhost(x)+xy = \mathcal{F}_{\text{Ghost}}(x) + x

轻量化收益：客人更多，厨房更省

推行新 SOP 后，餐厅的翻台率明显提升：接待的客人变多了，后厨的人手却没增加。GhostNet 在 ImageNet 上的实验也印证了这一点：用相近的 FLOPs 预算，GhostNet 的 top-1 精度超过了 MobileNetV3；与 ResNet-50 相比，GhostNet 的 FLOPs 只有前者的约 1/10，精度却几乎持平。

为什么能省这么多？从第 4 节的加速比公式看，s 取 4 时理论加速比约为 3.4 倍；参数量也会同步压缩——标准卷积的参数是 n·c·k²，Ghost 模块则是 (n/s)·c·k² + (s-1)(n/s)·d²，两者相比同样接近 s 倍。更关键的是精度的保持策略：卷积特征天生存在冗余，浅层特征图边缘细节丰富、冗余少，深层语义特征冗余高。因此成熟的 GhostNet 会在浅层保留标准卷积，在深层大量使用 Ghost 卷积，把 s 控制在 2~4 之间，避免核心特征太少导致表达能力不足。

这张“精打细算”的收益表背后有个前提：特征冗余确实存在，而且可以被廉价变换捕捉。一旦 s 过大，核心特征图 m 过少，翻版菜就会变得千篇一律，精度就会明显下滑——就像主厨如果只做一锅底料却硬要翻出 20 道菜，客人也会吃腻。

与其他模块对比：别的厨师的省钱妙招

主厨的“底料翻版”不是唯一的省钱法。街对面还有一位厨师用了“预制菜包”的思路：把做菜的工序拆成“备菜”和“装盘”两步，每次做菜只需从菜包里拿出切好的食材，快速装盘即可。这就是深度可分离卷积（Depthwise Separable Convolution）的思想，也是 MobileNet 的省钱基石。

深度可分离卷积把一个标准卷积拆成两层：Depthwise 卷积只处理单张特征图内部的空间信息，Pointwise 卷积则用 1×1 卷积混合通道。它省钱的原理是“空间与通道解耦”——不再让每个输出像素同时扫描所有通道。Ghost Module 的省钱原理则是“冗余特征廉价再生”——承认很多特征图是相似的，只算少量核心特征再翻版。两者都依赖逐通道的深度卷积，但设计动机不同：前者改变计算分解方式，后者改变特征的生成数量。因此 Ghost 模块不是深度可分离卷积的简单变形，它们可以组合使用：Ghost 模块里的廉价变换本身就可以用一个深度卷积来实现。

实际选型时，如果任务的特征冗余度高（比如深层分类网络），Ghost 模块更划算；如果希望算子实现简单、硬件友好，深度可分离卷积的 DW+PW 结构更成熟。两位厨师的妙招各有主场，聪明的老板会按菜品结构来选择。

AI 应用场景

场景1：手机端实时菜品识别

阶段：模型轻量化部署与端侧推理

解决的问题：传统大模型（如 ResNet-50）在手机上单帧推理需数百毫秒、内存占用高，难以支持相机实时识别。Ghost 模块把大量冗余卷积替换为廉价变换，在接近原精度的前提下把 FLOPs 压缩到约 1/3~1/4，让移动端流畅运行。

具体案例：某餐饮 App 用 GhostNet 部署菜品识别模型：输入 224×224 图片，模型 FLOPs 约 226M，在骁龙 845 手机上单帧推理约 40ms。用户举起手机对准餐桌，App 实时显示菜品名称与热量估算。

场景2：自动驾驶实时语义分割

阶段：模型加速与在线推理

解决的问题：语义分割网络（如 DeepLabV3）感受野大但计算重，无法在车载嵌入式 GPU 上跑实时。用 Ghost Module 替换骨干网络中的 3×3 卷积，能显著减少 FLOPs 且保持分割边界质量。

具体案例：在 Cityscapes 数据集上，把 ResNet-50 骨干的卷积替换为 Ghost 卷积构建分割模型，mIoU 从 71.2% 降到 69.8%，但推理帧率从 18 FPS 提升到 42 FPS，满足 L2 级辅助驾驶的实时要求。

场景3：边缘盒子目标检测

阶段：边缘端模型压缩与部署

解决的问题：工厂质检、智慧安防的嵌入式盒子算力有限，直接跑 YOLO 会发热降频。利用 Ghost 卷积重构检测颈部网络，可降低算力需求并保留小目标检测能力。

具体案例：在某工业质检项目中，把 YOLOv5s 的 3×3 卷积替换为 Ghost 卷积，模型大小从 14 MB 降到 5.8 MB，在瑞芯微 RK3588 盒子上推理速度从 28 ms 提升到 12 ms，漏检率仅上升 0.3 个百分点。

Python 演示

python38 行
"""Ghost Module 原理演示: 用 FLOPs 估算展示轻量化收益"""import numpy as np  def conv_flops(out_channels, in_channels, ksize, height, width):    """估算一个标准卷积层的 FLOPs(乘加合计)"""    return 2 * out_channels * in_channels * ksize * ksize * height * width  def ghost_flops(in_channels, height, width, out_channels, ksize, s):    """拆解 Ghost 模块: 核心卷积 + (s-1) 组逐通道深度卷积"""    m = out_channels // s    core_cost = conv_flops(m, in_channels, ksize, height, width)    cheap_cost = conv_flops(out_channels - m, 1, ksize, height, width)    return core_cost + cheap_cost, m, out_channels - m  def main():    c_in, h, w, c_out, k, s = 16, 8, 8, 32, 3, 4    std = conv_flops(c_out, c_in, k, h, w)    ghost, m, d = ghost_flops(c_in, h, w, c_out, k, s)    ratio = std / ghost     print(f"标准卷积 FLOPs : {std:>10,}")    print(f"Ghost 模块 FLOPs: {ghost:>10,}")    print(f"加速比           : {ratio:.2f}x")    print(f"核心特征 {m} 张 + 派生特征 {d} 张 = 输出 {m + d} 张")     # 用随机数据模拟"廉价生成"的相似特征图    np.random.seed(7)    core = np.random.randn(m, h, w)    ghost_feats = np.concatenate([core, np.flip(core, axis=2)], axis=0)    print(f"拼接到特征图形状: {ghost_feats.shape}, "          f"其中 {m} 张由全卷积生成, 其余由线性翻转生成")  if __name__ == "__main__":    main()
目的：用 FLOPs 公式拆解标准卷积与 Ghost 模块，量化加速比，并模拟“少量核心特征 + 廉价变换”生成完整特征图的过程。
  1. def conv_flops(out_channels, in_channels, ksize, height, width)估算标准卷积 FLOPs，把输出通道、输入通道、卷积核面积全部乘起来。
  2. m = out_channels // s核心特征数 m，相当于主厨只做的“4 份底料”。
  3. cheap_cost = conv_flops(out_channels - m, 1, ksize, height, width)派生特征只走单通道深度卷积，成本里不再出现输入通道 c。
  4. std = conv_flops(c_out, c_in, k, h, w)先算标准卷积的总成本，作为对比基线。
  5. ghost, m, d = ghost_flops(c_in, h, w, c_out, k, s)拆解 Ghost 的两步成本，同时返回核心与派生数量。
  6. ratio = std / ghost两者的商就是加速比，验证“计算量约降为 1/s”。
  7. np.concatenate([core, np.flip(core, axis=2)], axis=0)用翻转模拟一个最简单的“廉价线性变换”，生成相似特征图。

常见误区

误区我理解 Ghost Module 就是训练后把不重要的通道剪掉，模型变小，相当于自动剪枝。

正解完全不同。剪枝是训练后“删除”已存在的通道，属于后处理，通常需要微调；Ghost Module 是在网络结构设计时，主动用少量标准卷积生成核心特征，再通过廉价变换“再造”出其他特征，不删除任何信息。它像主厨“用底料翻版”，而不是把菜单上几道菜划掉。剪枝是减法，Ghost 是“廉价加法”。

为何常见：两者都使得最终模型更小、计算更少，初学者容易把“减少冗余”混为一谈。

误区把 c 通道先压到 m 再扩回 n，不就是 1×1 卷积做通道压缩嘛，Ghost 应该是这个吧。

正解1×1 卷积是跨通道融合，会把所有输入通道的信息混在一起；Ghost 的核心变换是深度卷积（Depthwise Conv），只在每个通道内部滑动，不跨通道。只有逐个通道独立变换，才能把每张核心特征图“翻版”成多张相似特征。如果换成 1×1 卷积，计算成本不会降到 c 倍以下，也就失去了“廉价”的意义。

为何常见：Ghost 模块第一步确实用普通卷积减少通道，许多人误以为整个模块就是“通道压缩再扩张”的老套路。

误区公式显示加速比约等于 s，那把 s 设成 16 甚至 32，FLOPs 不就能降几十倍吗？

正解s 增大的同时，核心特征数 m = n/s 急剧减少。核心特征太少，就像主厨只炒一锅底料却要翻出 32 道菜，每道菜都寡淡无味。特征多样性不足会导致精度明显下滑。论文中的 s 通常取 2~4，且需要在浅层保留标准卷积。FLOPs 的公式只回答“省了多少”，不回答“模型还有多强”。

为何常见：只盯着复杂度公式，忽略了特征表达能力这个隐藏约束。

误区MobileNet 用深度卷积降低计算量，Ghost 也用深度卷积，所以它们是一个东西。

正解深度可分离卷积把标准卷积拆成“逐通道空间卷积 + 1×1 通道融合”两步，改变的是计算分解方式；Ghost Module 则先只算 m 张核心特征，再用深度卷积补出 s-1 张冗余特征，改变的是特征生成数量。前者问“每一步怎么算”，后者问“哪些特征值得算”。两者都以深度卷积为部件，但设计动机与结构完全不同。

为何常见：都使用了 Depthwise Convolution，且都在轻量化领域，表面相似让人误以为同源。

误区模型 FLOPs 降低 3 倍，我在 GPU 上测推理速度应该也能快 3 倍。

正解FLOPs 是理论计算量，实际推理速度还受内存访存、算子调度、并行度影响。Ghost 的深度卷积是逐通道小算子，在 GPU 上可能没有把 Tensor Core 喂满，加速比往往低于理论值；在 CPU/移动端则可能接近。要获得真实加速，需要用部署框架做算子融合和通道对齐。

为何常见：理论值与工程实现之间的差距，是所有轻量化网络的共性陷阱。

面试题

Q1. Ghost Module 降低计算量的核心思路是？

单选题 · easy

  • A.仅使用 1×1 卷积替代大卷积
  • B.利用特征图冗余生成低成本特征← 正确答案
  • C.减少输入图片的分辨率
  • D.使用更大的 batch 并行计算

答案：B。Ghost Module 的出发点正是卷积特征中大量通道彼此相似、存在冗余，于是只生成少量核心特征，再用廉价变换补全。1×1 卷积是 MobileNet 式的通道压缩，降分辨率或加大 batch 都不属于结构级省算力。

Q2. Ghost Module 中“廉价线性变换”通常指？

单选题 · easy

  • A.全连接层变换
  • B.深度卷积逐通道变换← 正确答案
  • C.ReLU 激活函数
  • D.全局平均池化

答案：B。廉价变换的核心是深度卷积（Depthwise Conv），只在单个通道内部滑动，成本只有普通卷积的 1/c。全连接层、ReLU、池化都不能把一张特征图“翻版”成多张相似特征图。

Q3. 若输出特征图总数 n=32，Ghost 超参数 s=4，则核心特征图数量 m 是多少？

单选题 · mid

  • A.4 张
  • B.8 张← 正确答案
  • C.16 张
  • D.32 张

答案：B。核心特征图数量 m = n/s = 32/4 = 8 张，其余 (s-1)·m = 24 张由廉价变换派生。主厨只做 8 份底料，却要端出 32 道菜。

Q4. 当 s=4、c=16 时，Ghost 模块的理论加速比约为多少？

单选题 · mid

  • A.约 1.5 倍
  • B.约 2.0 倍
  • C.约 3.4 倍← 正确答案
  • D.约 4.8 倍

答案：C。加速比 r ≈ sc/(s+c-1) = 4×16/(4+16-1) = 64/19 ≈ 3.37 倍。只有当 c 远大于 s 时，r 才接近 s=4，这里 c 还不够大，所以只有 3.4 倍左右。

Q5. 关于 Ghost Module 与深度可分离卷积，下列说法正确的是？

单选题 · mid

  • A.两者在数学上完全等价
  • B.Ghost 靠冗余而 DW 靠通道空间解耦← 正确答案
  • C.深度可分离卷积 FLOPs 必然更低
  • D.Ghost 只能用于特征提取浅层

答案：B。深度可分离卷积把标准卷积拆成空间卷积和通道融合两步，解决“计算分解方式”；Ghost 则利用特征冗余，解决“哪些特征值得生成”。两者都使用深度卷积，但动机不同，不是等价关系，也不能说谁必然更低。

Q6. Ghost Bottleneck 在结构上最接近以下哪种经典模块？

单选题 · hard

  • A.Inception 多分支结构
  • B.ResNet 残差连接结构← 正确答案
  • C.Transformer 编码器结构
  • D.SE 注意力缩放结构

答案：B。Ghost Bottleneck 由两个 Ghost 卷积组成，并带有残差捷径（Shortcut），整体结构与 ResNet 残差块最接近。Inception 强调多分支、Transformer 强调自注意力、SE 强调通道注意力，都不是 Ghost Bottleneck 的主体骨架。

Q7. Ghost 模块最终输出的特征图由哪两部分拼接而成？

单选题 · easy

  • A.核心特征与派生特征← 正确答案
  • B.高频特征与低频特征
  • C.空间特征与通道特征
  • D.粗特征与细特征

答案：A。输出 = 标准卷积生成的核心特征（底料）+ 廉价变换生成的派生特征（翻版菜），在通道维度拼接后得到完整输出。高频/低频、空间/通道、粗/细都不是 Ghost 的划分方式。

Q8. 下列哪些属于 Ghost Module 的组成部分？

多选题 · mid

  • A.标准卷积生成核心特征← 正确答案
  • B.逐通道线性变换← 正确答案
  • C.恒等映射分支← 正确答案
  • D.全局注意力机制

答案：ABC。Ghost 模块 = 标准卷积生成 m 张核心特征 + 逐通道深度卷积派生特征 + 恒等映射保留原特征。全局注意力（SE）是另一类独立模块，不参与 Ghost 的基础结构。

Q9. 关于 Ghost Module 的收益，下列说法正确的是？

多选题 · hard

  • A.只降低 FLOPs 不影响参数量
  • B.参数和 FLOPs 均显著下降← 正确答案
  • C.精度保持依赖冗余假设成立← 正确答案
  • D.推理速度一定成倍加快

答案：BC。Ghost 的核心卷积只有 n/s 个输出通道，派生卷积又是单通道小卷积，所以参数量和 FLOPs 同步下降；但精度保持依赖特征冗余真实存在。实际推理速度还受硬件与算子实现影响，不能保证成倍加快。

Q10. 在 Ghost Module 中，设输出通道数为 n、超参数为 s，下列关系正确的有？

多选题 · extreme

  • A.派生特征数为 (s-1) 与 m 之积← 正确答案
  • B.派生特征数为 s 与 m 之积
  • C.输出总通道数为 s 与 m 之积← 正确答案
  • D.核心特征数 m 等于 n 除以 s← 正确答案

答案：ACD。m = n/s，每个核心特征派生 s-1 张，所以派生特征总数是 (s-1)·m；输出总通道数 = 核心 m + 派生 (s-1)m = s·m = n。选项 B 把派生数写成了 s·m，混淆了“每个核心变 s 份”与“除了自身还有 s 份”的区别。