🧠 端侧推理的自适应模型选择：在精度、延迟和能耗之间做选择题

这一篇在干嘛？

本文讲解 ACM Transactions on Embedded Computing Systems（TECS）19 卷 1 期文章 2《Optimizing Deep Learning Inference on Embedded Systems Through Adaptive Model Selection》（Sanz Marco、Taylor、Wang、Elkhatib，2020 年 2 月，28 页）。 端侧推理的核心矛盾是：大模型精度高但跑不动，小模型跑得动但精度差，压缩能提速却掉点，卸载到云端又受隐私和延迟限制。 论文的思路是：与其训练一个”万能模型”，不如同时准备多个预训练好的模型，再用机器学习训一个轻量的”预模型（premodel）“，在运行时刻根据输入特征和当前的评价标准，自动挑出”能答对的最快那个”。 在 NVIDIA Jetson TX2 上实测：图像分类比最强的单一模型精度提升 7.52%，同时推理时间缩短 1.8 倍；机器翻译比最强的单一模型快 1.34 倍而译文质量基本不变，能耗降低 1.39 倍（跳过无望样本时可达 1.48 倍）。

一、背景：为什么嵌入式端跑深度学习这么纠结

如果你只在服务器或云上跑过深度学习，很容易形成这样一个印象：模型越大越准，显卡越多越快，剩下的问题只是”什么时候训完”。但把同样的深度神经网络（Deep Neural Network, DNN）搬到一块嵌入式板子上，这套经验立刻失效。

1.1 端侧的三重硬约束

在嵌入式设备上做推理（inference），你会同时被三根绳子勒住：

• 算力（compute）：一块 Jetson TX2 的 GPU 是 256 核 Pascal，主频 1.3 GHz；CPU 是双核 Denver2 + 四核 ARM Cortex-A57，主频 2.0 GHz。这和服务器上的 V100/A100 不是一个量级。一个 ResNet_v2_152 在 TX2 上跑一张图要 2 026 ms——也就是两秒多，对任何”实时”场景都太慢了。
• 内存（memory）：板载 8 GB LPDDR4，看起来不少，但模型权重、激活值、运行时框架、操作系统要一起挤在里面。ResNet_v2_152 的模型文件就有 691 MB，而且如果按本文的思路同时驻留多个模型，内存会立刻变成瓶颈。
• 功耗（power）：设备靠电池供电，能耗和延迟高度相关但不等价——本文后面会看到，某模型只比另一个快 1.24 倍，能耗却低了 1.90 倍，因为快慢不同的模型对 CPU/GPU 的压榨程度完全不同。

这三根绳子和”精度”是天然对立的。 想提高精度，直观做法就是加深加宽网络、加注意力、加层数；而每一次”加深”都在同时拉高算力、内存和功耗三条曲线。

1.2 三条老路，各有各的坑

面对这个矛盾，工业界和学术界此前主要走三条路：

第一条：压缩（compression）。 剪枝、量化、哈夫曼编码那一套（代表作 deep compression）。它的效果很实在——论文给出 ResNet_v2_152 压缩后的实测数据：

体积确实小了三倍，但代价是精度下降。论文实测：两种压缩叠加后，top-1 精度直接掉 34.32%。这在多数场景是不可接受的。压缩本质是”用固定比例的精度，换固定比例的速度”，是一锤子买卖。

第二条：卸载到云（cloud offloading）。 把输入传到服务器，算完传回来。这条路有四个致命场景：隐私数据出不了本地（医疗、人脸、工业现场）、网络延迟不可控、没有网络覆盖、以及带宽成本。论文明确指出，对智能嵌入式感知来说，卸载”often unacceptable”。

第三条：架构专用优化。 针对特定硬件手工写 kernel、调线程粒度、做算子融合。这类方法有效，但和硬件绑定，换一块板子就要重来，缺乏通用性。

1.3 本文的第四条路

论文提出的核心洞察其实非常朴素，朴素到有点反直觉：

“最优模型”不是模型的固有属性，而是「输入 × 评价标准」的函数。

换句话说，不存在一个”在所有输入上都最优”的模型。一张光线充足、背景干净、主体突出的照片，用最小的 MobileNet 就够了；一张主体和背景融为一体的照片，才需要动用最贵的 ResNet-152。 同理，一句只有九个单词的简单英文，用 3 层翻译模型就能翻对；一句带引号、带年份、带非词典词的长句，才需要 8 层 GNMT。

那么问题就变成了：能不能训练一个”调度员”，在每次推理之前，花极小的代价判断”这个输入该交给哪个模型”？

这就是本文的 premodel（预模型）。

二、动机实验：最优模型取决于「输入 × 评价标准」

论文先做了两组非常小的实验，用来证明上面那句话不是拍脑袋。实验平台就是后文统一的 NVIDIA Jetson TX2，用 GPU 推理。

2.1 图像分类：三张图，四个模型，结论完全不同

实验用了四个已在 ImageNet ILSVRC 2012 上预训练好的 CNN（Convolutional Neural Network，卷积神经网络）：MobileNet_v1_025（宽度乘子 0.25 的 MobileNet）、ResNet_v1_50、Inception_v2、ResNet_v2_152。

先明确评价标准。每个模型输出一个按置信度降序排列的标签列表：

• top-1 分：列表第一个标签（置信度最高的）是否命中真实标签；
• top-5 分：真实标签是否出现在列表前五个里。

显然 top-5 宽松、top-1 严格。

图 1(a) 样本一：一只棉尾兔，主体清晰、背景对比强——简单样本

图 1(b) 样本二：识别难度中等，最小模型已经答不对

图 1(c) 样本三：主体与背景颜色接近——困难样本

图 1(d) 四个模型在这三张图上的推理时间对比

三张图的结论汇总成下面这张表（表 1，列出能给出正确预测的模型）：

把表和图 1(d) 的时间数据合起来读，会出现三个层次的结论：

1. 简单样本：四个模型全对。此时最优模型是最便宜的 MobileNet_v1_025——它比 ResNet_v2_152 快 6.13 倍。用大模型纯属浪费。
2. 中等样本：MobileNet_v1_025 无论按哪个标准都答错了。这时必须换 Inception_v2，代价是比 MobileNet 慢 3.24 倍。
3. 困难样本：最优模型随评价标准而变。按 top-5 判，ResNet_v1_50 就够，比 ResNet_v2_152 快 2.06 倍；按 top-1 判，只有最贵的 ResNet_v2_152 能答对，比 MobileNet 慢 6.14 倍。

注意第 3 点的含义：同一张图，仅仅因为你把门槛从 top-5 改成 top-1，最优模型就换了一个。 这直接否定了”离线挑一个折中模型然后一劳永逸”的做法。

2.2 机器翻译：三句话，评价标准改变最优解

第二个领域是神经机器翻译（Neural Machine Translation, NMT），用四个模型：3_layer、gnmt_2_layer、gnmt_4_layer、gnmt_8_layer（前缀 gnmt_ 表示使用了 Google NMT 的注意力机制，数字是层数）。

机器翻译没有 top-1/top-5，论文用了两个指标：

• BLEU（Bilingual Evaluation Understudy，越高越好）：译文与参考译文的 n-gram 重合度，取值 0~1，1 分几乎不可能达到；
• BLEU-PS（BLEU per second，越高越好）：把 BLEU 和时间一起衡量，形式类似处理器领域常用的能量延迟积 EDP（Energy Delay Product）：

$$\text{BLEU-PS}=\frac{\text{BLEU}\times \text{BLEU}}{\text{Infer.Time}}$$

实验用的三句话（表 2）：

图 2(a) 三句话在四个翻译模型上的推理时间与”最优模型”标注

图 2(b) 三句话在各模型上的 BLEU 分数

结果同样出人意料：

• 句子 1（最短最简单）：所有指标下的最优模型都是最便宜的 3_layer。更戏剧性的是，最复杂的 gnmt_8_layer 在这句上翻车了——用最便宜的模型反而又准又快，快 1.66 倍。
• 句子 3：最优模型是 gnmt_4_layer，此时最便宜的 3_layer 会失败。选对模型可以在不掉精度的前提下快 1.15 倍。
• 句子 2（最长、标点最多、含 2008、TV 这类非词典词）：最优模型再次随指标变化。若优化 BLEU-PS，选 gnmt_2_layer，比 gnmt_8_layer 快 1.31 倍；若只想最大化准确率，则必须用 gnmt_8_layer。

2.3 小结：我们需要一个自动调度员

两组实验指向同一个结论：

最优模型 = f（输入复杂度，评价标准，可用资源）。这个函数的形状无法靠人工规则写死。

所以论文的目标不是”造一个更好的模型”，而是造一个会自动选模型的调度员。下一节看它的结构。

三、核心思路：给一堆模型配一个「预模型」

图 3 / 图 4（原论文 Fig. 3 与 Fig. 4）整体工作流 + 多分类器预模型结构

3.1 工作流：五步走

论文的做法可以拆成五个阶段，其中前四步全部离线完成，只有第五步在设备上跑：

1. 准备候选模型池：收集 N 个已经在目标领域预训练好的 DNN（可以是不同架构，也可以是同一个模型的不同压缩版本）。这一步不修改任何模型，也不重新训练任何 DNN。
2. 生成训练数据：把一批有代表性的输入喂给每一个候选模型，记录各自的推理时间和预测结果。
3. 标注”最优模型”：对每个输入，找出”在满足精度门槛的前提下耗时最短”的那个模型，作为该输入的标签。
4. 训练预模型：用「输入特征 → 最优模型标签」这批数据，训练一个轻量分类器。
5. 在线推理：新输入进来 → 抽取特征 → 预模型预测该用哪个 DNN → 把输入交给它 → 返回结果。

关键在于第 3 步。 所谓”最优”，论文的判据可以写成这样一个带约束的最优化问题：

$$m^{\star }(x)=\underset{m\in \mathcal{M}}{\mathrm{argmin}}T(m,x)\text{s.t.}\text{score}(m,x)\ge \tau$$

其中 $\mathcal{M}$ 是候选模型集合，$T(m,x)$ 是模型 $m$ 在输入 $x$ 上的实测推理时间，$\text{score}$ 是精度指标（top-1 / top-5 / BLEU），$\tau$ 是用户给出的精度门槛。“最优模型”= 达标模型里最快的那个。

如果你想在精度和时间之间做连续权衡，而不是设一个硬门槛，可以改写成加权代价的形式：

$$\text{cost}(m,x)=w_1\cdot \hat{T}(m,x)+w_2\cdot (1-\hat{A}(m,x))$$

其中 $\hat{T}$ 和 $\hat{A}$ 分别是归一化后的延迟和精度，$w_1$、$w_2$ 是权重。调大 $w_1$ 就是”我要快”，调大 $w_2$ 就是”我要准”。 论文在实验里用不同的评价标准（top-1 / top-5 / BLEU / BLEU-PS）来实现同一件事。

3.2 预模型必须满足两个条件

设计预模型时有两条硬约束，缺一不可：

• 预测要准。预模型选错模型，轻则慢一点，重则直接答错。
• 自身要极快。如果预模型自己比它要挑的那堆模型还慢，那整个方案就没有意义了。

第二条尤其重要。论文最终的实测开销是：图像分类场景预模型 + 特征提取占端到端时间的 28%（在平均不到 1 秒的总时间里），机器翻译场景预模型 + 特征提取不到 6 ms，只占 0.5%。

于是完整的端到端延迟是三项之和：

$$T_{\text{total}}(x)=T_{\text{feat}}(x)+T_{\text{pre}}(x)+T(\hat{m},x)$$

其中 $T_{\text{feat}}$ 是特征提取时间，$T_{\text{pre}}$ 是预模型预测时间，$\hat{m}$ 是预模型选出的模型。注意 $T_{\text{pre}}$ 是”纯赚的开销”，必须从加速比里扣掉——论文在所有实验数据里都包含了这部分开销，这点非常严谨。

3.3 两种预模型架构

论文考察了两种结构：

架构 A：单分类器（single classifier）。 用一个多分类模型，直接输出”该用第几个 DNN”。简单直接。

架构 B：多分类器串联（multiple classifier）。 如图 4 所示，为每个候选 DNN 配一个二分类器，串成一条链：

• 输入先进 KNN-1，它回答”这个输入该不该交给 Model-1”；
• 若回答”是”，就返回 Model-1，结束；
• 若回答”否”，特征传给 KNN-2，问同样的问题；
• 一路问到 KNN-n。如果连最后一个都说”不”，则按用户预设处理：要么退回一个保底模型强行出结果，要么干脆不推理、直接报告失败。

第二个出口是个很巧妙的设计：当预模型判断”所有模型都搞不定这个输入”时，直接跳过推理，省下这笔功耗。 论文实测这一招能把机器翻译的能耗再降到原来的 1/1.48。

架构 B 还有个工程上的好处：如果所有层级都用 KNN，近邻距离只需要算一次，各层共享同一批近邻，换个标签就行。所以”层数增加”几乎不增加运行时间——这也是论文最终在图像分类上选择 KNN.KNN.KNN 的原因之一。

论文候选的分类器有四种：K 近邻（k-nearest neighbor, KNN）、决策树（decision tree, DT）、朴素贝叶斯（naive Bayes, NB）、支持向量机（support vector machine, SVM）。

四、候选模型集合怎么挑：贪心模型选择算法

手里有 14 个（图像分类）或 15 个（机器翻译）预训练模型，全塞进预模型显然不行——内存吃不消，而且类别太多会让预模型的选择任务变得极难。所以需要一个算法来挑出一个”小而互补”的子集。

4.1 贪心选择的伪代码

论文给出的算法 1 是一个标准的前向贪心（forward greedy selection）：

ALGORITHM 1: Model Selection
Require: data, θ, selection_method
 1: Model_1_DNN = most_optimum_DNN(data)      # 第一步：挑"最常被认为最优"的模型
 2: curr_DNNs.add(Model_1_DNN)
 3: curr_acc = get_acc(curr_DNNs)             # 当前集合能达到的精度
 4: acc_diff = 100
 5: while acc_diff > θ do                     # 精度提升还够大就继续加
 6:     improvement_metric = next_selection_metric(selection_method)
 7:     next_DNN = greatest_improvement_DNN(data, curr_DNNs, improvement_metric)
 8:     curr_DNNs.add(next_DNN)                # 加入"边际收益最大"的那个
 9:     new_acc = get_acc(curr_DNNs)
10:     acc_diff = new_acc - curr_acc
11:     curr_acc = new_acc
12: end while

三个输入参数：

• data：每个输入在每个候选 DNN 上的输出结果；
• θ：终止阈值，当新一轮加入带来的精度提升低于 θ% 就停手；
• selection_method：每轮用什么样的”改进指标”来选模型。

4.2 三种选择策略

三者的性格差异在后文图 12 的敏感性分析里看得清清楚楚：Optimal 整体最快但 top-1 精度最低；Accuracy 能拿到最高的 top-1，代价是慢——为了 2% 的精度提升要多付 1.26 倍的时间；Alternate 夹在中间。

4.3 走一遍图像分类的例子

图 5 在训练数据上，每个 CNN 被判为”top-1 标准下最优模型”的频率

设置 θ = 0.5，selection_method = Accuracy。

• 第一个模型：按定义选”在训练数据上最常被判为最优”的那个。图 5 显示 MobileNet_v1_100 在 70.75% 的训练样本上是最优模型，所以它成为 Model-1。
• 第二轮：如果按 Optimal 策略，下一个会选 Inception_v1——但这样会不断加入”便宜但也不准”的模型，集合会退化。Accuracy 策略不这么干：它去看剩下 29.25% 的、MobileNet 会答错的样本，找”能把其中最多一部分救回来”的模型。

图 7(a) 所有候选 CNN 的 top-1 精度与推理时间散点图（左下角又快又准，是理想区）

图 7(b) 只看 MobileNet_v1_100 答错的那些图，各 CNN 的 top-1 精度

图 7(c) 只看 MobileNet 和 Inception 都答错的那些图，各 CNN 的 top-1 精度

• 具体数字：图 7(b) 中 Inception_v4 表现最好，能正确分类 MobileNet 失败样本中的 43.91%，给整个预模型带来 +12.84% 的精度提升，于是成为 Model-2。
• 第三轮：重复同样的逻辑（图 7(c)），ResNet_v1_152 入选，再带来 +2.55% 的提升。
• 终止：再迭代一轮，精度提升已经低于 θ = 0.5%，停。

最终预模型只有三个成员：MobileNet_v1_100 → Inception_v4 → ResNet_v1_152。一个”快而糙”打底，一个”中档”补位，一个”慢而精”兜底。

4.4 训练流程与训练开销

图 6 预模型的完整训练流程；对每一种评价标准（top-1 / top-5 / BLEU …）都独立走一遍

训练流程有四个要点：

1. 生成训练数据是唯一的大头。要把每个候选 DNN 在每个输入上都跑一遍，记录时间和结果。论文用一台多核服务器 + NVIDIA P40 GPU，不到一天完成。这是一次性成本。
2. 可以在强机器上训练，在弱设备上部署。因为论文依赖的是模型之间的相对快慢关系，而这个关系在不同硬件上相当稳定。
3. 新增一个候选模型很便宜：只需要把这个新模型在全部输入上跑一遍、测同样的指标，不用动已有的东西。
4. 模型选择和超参调优的时间可以忽略：不到 2 小时，相比生成训练数据完全是大头与小头的关系。

部署侧的封装也很干净：用户只是调用一个 predict() 函数，输入输出的格式和直接用单个 DNN 完全一样，内部的选择过程对用户透明。

五、特征工程：把一张图 / 一句话压成几个数字

预模型不能把原始图片或原始句子当输入——那等于又要跑一个 DNN。它需要的是能刻画”这个输入有多难”的少量标量特征，而且计算这些特征必须非常便宜。

5.1 图像分类：29 个候选 → 7 个

论文初选了 29 个候选特征（表 3），选它们的依据有两条：一是已有图像特征研究的结论（比如边缘越多图越复杂），二是第二节动机实验给出的直觉（比如对比度越低越难看清内容）。

筛选第一步：相关性去冗余。 用皮尔逊积矩相关系数（Pearson product-moment correlation, PCC）算两两相关性矩阵：

$${\rho }_{X,Y}=\frac{\mathrm{cov}(X,Y)}{{\sigma }_X{\sigma }_Y}$$

$\rho$ 取值 −1 到 +1，绝对值越接近 1 相关性越强。设阈值 0.75，凡是绝对值超过它的特征对，砍掉其中一个。被砍掉的（表 4）：

可以看到，hue2 到 hue6 和 hue1 的相关系数高达 0.99——留一个就够了。这一步后剩下 17 个特征。

筛选第二步：贪心重要性搜索。 用 k 折交叉验证训练预模型并记录精度；然后逐个删掉某个特征、重训、看精度掉了多少；掉得多说明重要。按重要性从低到高一个一个删，直到再删就明显掉点。最终剩下 7 个（表 5）：

筛选第三步：特征缩放。 把每个特征线性压到 0~1，避免量纲大的特征”天然更重要”：

$$x^{\prime }=\frac{x-x_{\min }}{x_{\max }-x_{\min }}$$

其中 $x_{\min }$、$x_{\max }$ 取自训练集，部署时用同一组值去缩放新数据。缩放不改变分布和方差。

图 9(a) 图像分类：去掉某个最终特征后预模型精度的损失（只画了最重要的 5 个）

图 13 图像分类：所有候选特征的重要性排序，第 8 个特征（hue7）之后出现断崖式下跌

图 14 图像分类：特征数量对预模型运行时间和 top-1 精度的影响

图 13 和 14 一起回答了”为什么是 7 个”：

• 前 7 个特征重要性最高，第 8 个（hue7）开始断崖式下跌；
• 减到 5 个特征，top-1 精度直接掉 13.9%，而提取时间几乎没省——不划算；
• 继续增加特征，开销略微上升，但 top-1 精度反而小幅下降 0.4%（过拟合）。

所以 7 个是甜点。

5.2 机器翻译：11 个候选 + 词袋 → 3 个 + 词袋

翻译任务的候选特征（表 7）主要围绕句子长度和词性密度：

相关性筛选砍掉两个高度冗余的（表 8）：

剩下 9 个，再经贪心搜索减到 3 个（表 6）：n_words、avg_adj，外加一个**词袋（Bag of Words, BoW）**表示。

BoW 是这里的关键补充。 只用 n_words 这类标量，其实是在赌”长句难、短句易”，信息量有限。BoW 把句子表示成一个基于词表的出现向量，能刻画”这句里到底有哪些词”。论文用卡方检验（Chi2）对 BoW 向量做降维，取 top-k 维。

图 9(b) 机器翻译：去掉三个最终特征之一后的精度损失；可以看出 BoW 的贡献远大于另外两个

图 15 机器翻译：各特征的重要性（去掉后的精度损失）

图 16 机器翻译：BoW 取不同 k 值时的精度损失，基线为 k = 2 000

图 16 给出了 k 的取值规律，非常有代表性：

• k > 2 000：精度损失接近 4% 并随 k 继续增大而迅速恶化——典型的过拟合，特征维度太高而训练样本太少；
• k = 1 500：只有很小的损失；
• k = 500：损失达到 5.75%——欠拟合，信息量不够。

所以最优 k 落在 1 500 ~ 2 000 之间，论文取 k = 2 000（§6.1.1 中记为词向量长度 1 500，与此处基线值存在细微出入，属于论文自身的表述不一致）。

另外图 15 显示：保留 avg_sat_adj 能让预模型精度提升 2.9%，但论文仍然砍掉了它——因为有 BoW 在场时它的边际贡献可以忽略，不值得为它多付一次特征提取的开销。这是很值得学习的一种取舍思路：不只看”有没有用”，还看”在有其他特征的前提下还有没有用”。

六、实测结果：两个案例的完整数据

统一实验设置（第 4 节）：

• 硬件：NVIDIA Jetson TX2 —— 64 位双核 Denver2 + 64 位四核 ARM Cortex-A57 @ 2.0 GHz，256 核 NVIDIA Pascal GPU @ 1.3 GHz，8 GB LPDDR4，96 GB 存储（32 GB eMMC + 64 GB SD 卡）。
• 软件：Ubuntu 16.04，Linux 内核 4.4.15，TensorFlow 1.0.1，cuDNN 6.0，CUDA 8.0.64；预模型用 scikit-learn 实现；特征提取基于 OpenCV 和 SimpleCV。
• 评估方法：10 折交叉验证（图像分类把 5 万张验证图分成 10 份，每份 5 000 张，轮流做测试集）。推理时间和能耗反复测量，直到每模型每输入的 95% 置信区间小于 5%。能耗用板载传感器以 1 000 次/秒采样，并扣除系统空闲时的静态功耗。注意：所有数据都包含了预模型本身的开销，只排除了模型加载时间（实际只加载一次）。

文中还出现了一个重要基线 Oracle：一个”理论上完美的预测器”，每次都能选中真正最优的模型。它代表了这套方法的上限。

6.1 案例一：图像分类

候选池是 TensorFlow-Slim 库里的 14 个预训练 CNN，全部在 ImageNet ILSVRC 2012 训练集上训练。预模型最终形态：多个 KNN 串联（KNN.KNN.KNN），成员为 MobileNet_v1_100 / Inception_v4 / ResNet_v1_152。

图 8(a) 图像分类：推理时间对比（含预模型开销）

图 8(b) 图像分类：能耗对比

图 8(c) 图像分类：top-1 与 top-5 精度对比，右端为 Oracle 上限

图 8(d) 图像分类：精确率、召回率与 F1 分数

推理时间：MobileNet_v1_100 最快，比 Inception_v4 快 2.8 倍、比 ResNet_v1_152 快 2 倍，但它也最不准。本文方法的平均推理时间不到 1 秒，比 MobileNet 的 0.4 秒长（因为偶尔会调用贵模型、还要付特征提取的钱），但比最准的单一模型 Inception_v4 快 1.8 倍。

能耗：在 TX2 上能耗基本与推理时间成正比。相比 Inception_v4 和 ResNet_v1_152，本文方法能耗降低超过 2 倍。而预模型本身的能耗只有 MobileNet 的 1/4、ResNet 的 1/24——因为它跑在 CPU 上，功耗比 GPU 低一个量级，所以它的”能耗占比”比”时间占比”小得多。

精度：这是最反直觉的部分——用多个模型轮换，整体精度反而比任何一个单一模型都高。原因是：不同模型失败的样本并不重合，ResNet_v1_152 能对一部分 Inception_v4 答错的图给出正确答案。

具体提升：

• 相比 MobileNet_v1_100：top-1 +16.6%，top-5 +6%；
• 相比 ResNet_v1_152：top-1 +10.7%；
• 相比 Inception_v4：top-1 +7.6%，top-5 只 +0.34%——但同时快 2 倍；
• 与 Oracle 相比：top-1 86.3% vs 91.2%，top-5 95.4% vs 98.3%，达到理论上限的 96% 以上。

Oracle 为什么不是 100%？因为存在”所有模型都答错”的样本。这提醒我们：轮换模型能互补，但不能无中生有。

综合结论（图像分类）：相比最强的单一 DNN，精度提升 7.52%，推理时间缩短 1.8 倍，整体 top-1 精度达到 87.44% 以上。

精确率 / 召回率 / F1：图 8(d) 显示本文方法精确率最高，因此 F1 也最高。高精确率意味着更少的误报——对视频监控这类场景价值极大，因为每一个误报都要人工复核。

6.2 案例二：机器翻译

候选池是 15 个用 TensorFlow-NMT 训练的 NMT 模型，命名规则 {gnmt_}N_layer（gnmt_ 前缀表示用了 GNMT 注意力机制）。训练集 WMT09–WMT14 英德 newstest，预模型训练与测试用 WMT15/16。预模型最终形态：单个朴素贝叶斯分类器（因为翻译只有 5 000 句训练数据，是图像分类的十分之一，简单模型更抗过拟合），成员为 gnmt_2_layer / gnmt_8_layer / gnmt_3_layer。

图 10(a) 机器翻译：推理时间对比

图 10(b) 机器翻译：能耗对比

图 10(c) 机器翻译：BLEU、Rouge 与 F1 对比

推理时间：3_layer 最快，比 Oracle 快 1.55 倍、比最复杂的 gnmt_8_layer 快 2.05 倍，但它精度最差。本文方法的推理时间和 Oracle、gnmt_2_layer 非常接近，但精度优于 gnmt_2_layer。预模型本身 < 1 ms，特征提取 < 5 ms/句。

一个有趣的细节：本文方法甚至比 Oracle 还略快一点——因为预模型经常把 gnmt_2_layer 误判成 gnmt_8_layer（或反之），这类误判占了全部误判的 38.5%，而这两个模型恰好是候选池里的两个极端。这说明预模型的误差模式会直接影响实测收益。

能耗：这里出现了本论文最有意思的一个观察——时间和能耗不成正比。gnmt_2_layer 只比 gnmt_8_layer 快 1.24 倍，能耗却少了 1.90 倍（接近一半）。整体而言，本文方法比最强的单一模型少用 1.39 倍能耗，而 F1 基本不变；如果启用”预测全部失败就跳过推理”，能耗进一步降到 1.48 倍的节省。

BLEU / Rouge / F1：这里 F1 是 BLEU 与 Rouge 的调和平均，形式与图像分类的 F1 完全一致：

$$F_1=2\times \frac{\text{Rouge}\times \text{BLEU}}{\text{Rouge}+\text{BLEU}}$$

Oracle 的 F1 达到 47.54，比 gnmt_8_layer 的 39.71 高出 20%——说明”多模型互补”在翻译上同样成立，只是本文方法只达到了 Oracle F1 的 83%。原因是训练数据太少（5 000 句 vs 50 000 张图），特征维度却很高。

综合结论（机器翻译）：相比最强的单一 DNN，快 1.34 倍而精度基本不变；相比推理时间最接近的单一模型 gnmt_2_layer，精度提升 4%。论文估计，如果有更多训练数据，可以在保持同等加速的同时把 F1 提高 20.51%。

6.3 两个案例的开销汇总

七、深入分析：选型、敏感性、可靠性、资源与压缩

7.1 预模型该用哪种分类器？

图 11(a) 图像分类：不同预模型建模技术的 top-1 精度与运行时间

图 11(b) 机器翻译：不同预模型架构的 F1 与推理时间

记号说明：X.Y.Z 表示三级串联预模型，X、Y、Z 分别是第一、二、三层用的分类器，例如 KNN.SVM.KNN。

图像分类的结论：论文原以为基于 MobileNet 结构的小 CNN 会表现最好（还专门用自动超参调优器训了 500 多轮），结果令人失望——精度没优势，运行开销却大得多。最终 KNN.KNN.KNN 胜出：top-1 精度 87.4%，运行时间 0.20 秒，两者都是最优。三级 KNN 各自的精度分别是 95.8%、80.1%、72.3%（越往后越难，符合直觉）。

机器翻译的结论恰好相反：单分类器架构全面优于多分类器。论文给出的解释是——翻译这边特征维度很高（BoW 上千维）而训练样本只有 5 000 句，串联架构在每个层级上都要拿更少的数据做二分类，更容易过拟合。另外，论文还试了一种叫 feature stacking 的方案（BoW 特征和其他特征各训一个分类器，再用概率融合），结果比所有其他架构都差，说明这些特征还是放在一起用更好。

这张对比很有教学价值：不存在”万能最优”的预模型架构，架构要跟着数据规模走。数据多 → 可以上串联/复杂结构；数据少 → 老老实实用简单模型。

7.2 参数敏感性：θ 和选择策略怎么影响结果

图 12 12 种参数配置（3 种策略 × 4 个 θ）下的推理时间与 top-1 精度

为了排除预模型精度的干扰，这里的实验假设预模型是完美的，单独考察模型选择算法本身。记号 策略-θ，例如 Accuracy-5.0。

结论有三条：

1. θ 越小，入选模型越多。 Alternate 策略下 θ = 5.0 / 2.0 / 1.0 / 0.5 分别选出了 3 / 4 / 5 / 7 个 DNN。模型多了精度更高，但预模型要区分的类别变多、选择更难，而且内存占用上升。
2. 边际收益递减。 从 Optimal-2.0 到 Optimal-1.0，选出的模型集合完全没变——因为下一个能加的模型只能带来 0.488 的提升，卡在 1.0 的门槛外。
3. 三种策略各有性格。 Optimal 整体更快但 top-1 更低；Accuracy 能拿到最高 top-1，但为了 2% 的精度要多付 1.26 倍时间；Alternate 居中。

7.3 预模型会不会选错？可靠性怎么估计

机器学习模型给不出理论上的正确性保证，这是公认的开放难题。论文给了两个经验性的置信度估计手段。

方法一：特征空间距离。 因为图像分类用的是 KNN，可以自然地用”输入与训练样本的欧氏距离”当置信度代理：

$$d(x,x^{\prime })=\sqrt{\sum _{k=1}^n(f_k(x)-f_k(x^{\prime }){)}^2}$$

其中 $f_k(x)$ 是输入 $x$ 的第 $k$ 个特征。

图 17 图像分类 top-1 精度随”允许的最近邻距离半径”的变化

图 17 呈现一个清晰的倒 U 形：距离从 0 增大到 2，精度上升（半径太小根本找不到足够近的邻居）；超过 2 以后精度随距离增大而下降（把不那么相似的样本也拉进来投票了）。所以这个半径可以经验地确定，反过来用作”这次预测可不可信”的指标。

方法二：保形预测（conformal predictor, CP）。 这是一个统计框架，用来量化”新输入与历史训练样本的符合程度”。先学一个非 conformity 函数 $f$，它对每个候选类别给出一个 0~1 的分数：

$$f(x_i,y_i)=1-{\hat{P}}_h(y_i\mid x_i)$$

分数越接近 0，说明这个输入越”符合”该类。其中概率估计由下式给出：

$$p_{x_i}^{y_i}=\frac{|\{z_j\in Z:a_j>a_i^{y_i}\}|}{q+1}+\theta \cdot \frac{|\{z_j\in Z:a_j=a_i^{y_i}\}|+1}{q+1}$$

这里 $Z$ 是 CP 从训练集中划出的校准子集，$q$ 是其长度，$a_i$ 是从训练数据学到的校准分数，$a_i^{y_i}$ 是预测为 $y_i$ 的统计分数，$\theta \in [0,1]$ 是 CP 学到的校准因子。

实测效果：用 SVM 实现保形预测、阈值取 0.5，能以 87.4% 的准确率提前判断”预模型这次会选错”，误报率 5.5%。这意味着你可以在高风险场景下加一道保险：预模型说”我不确定”时，直接退回到最贵的模型。

7.4 该放几个模型？各模型被调用多少？

图 18 使用不同数量 DNN 时的开销与性能，误差棒为跨测试图的时间范围

图 19 预模型中每个 DNN 的实际使用率；Failure 表示”判定所有模型都不合适”而放弃推理

图 18 显示：随着候选模型增加，端到端时间上升（更贵的模型更容易被选中），但 top-1 精度在 3 个 KNN 时就进入平台期（约 87.5%）。再往上加只是花钱买不到精度——这正好印证了 θ = 0.5 的选择。

图 19 给出了实际调用分布：87.5% 的情况会选中某个模型，12.5% 的情况判定为 Failure。这 12.5% 就是”跳过推理省电”策略的用武之地。

7.5 资源占用：CPU、GPU、内存各有各的账

图 20(a) 各模型的平均 CPU 利用率

图 20(b) 各模型的平均 GPU 利用率

图 20(c) 各模型的平均内存占用

• CPU：所有 DNN 主要跑在 GPU 上，所以 CPU 利用率整体都低（没有超过 30% 的）。本文方法是最贵的一档，28.11%，只比 MobileNet_v1（32.63%）和 Inception_v4（29.42%）便宜。原因很直接：我们的特征提取和预模型是在 CPU 上跑的，而且我们还保留了两个最贵的模型。
• GPU：多数 DNN 占用 70%~90%。本文方法只有 37.46%，比最贵的 ResNet_v2_152 低 52.18%。原因是只要能用 MobileNet_v1（GPU 占用仅 10.57%）就用它。
• 内存：这是本文方法唯一变差的指标——因为要同时驻留多个模型。但代价只有”比最贵的单一模型多 16%“，换来的是更低的 CPU/GPU 负载、更快的推理和更高的精度。

论文把这一点说得很直白：本文方法本质上是用内存空间换精度和延迟（trades memory footprints for accuracy and reduced inference time）。 这是一个必须自己权衡的交易。

7.6 与压缩配合：只有一个模型时也能用

如果手上只有一个训练好的模型怎么办？论文的办法是：用压缩造出一族模型，再用本文方法在它们之间选。

以 ResNet_v2_152 为起点（最复杂、最准，但 2 026 ms 最慢），施加两种压缩（deep compression、quantization），得到共 4 个版本的模型，然后套用同一套方法。

图 21 对单个 DNN 施加压缩后的推理时间、top-1 与 top-5 表现

规律很清晰：压缩越多，越快，也越不准。两种压缩叠加会让 top-1 掉 34.32%——单独看是完全不可用的。 但在自适应选择的框架下，这个”又小又蠢”的模型反而有了价值：在它能满足精度门槛的输入上用它，在它搞不定的输入上退回原模型。

最终结果：整体 top-1 只掉 1.76%、top-5 只掉 0.31%，而推理时间缩短 1.52 倍。

这是全篇最漂亮的一招：压缩的收益（快）和代价（不准）被拆开了——在简单的输入上白拿收益，只在困难的输入上付出代价。

八、怎么用到你自己的项目里

把论文的方法抽象成一份可执行的清单：

1. 攒一个候选模型池。 优先找现成的预训练模型（不同架构、不同宽度乘子、不同压缩等级）。这一步不需要你训练任何东西。
2. 跑一遍全矩阵测量。 用几百到几千个有代表性的输入，把每个模型都跑一遍，记录时间和精度。这是唯一的大成本，一次性，可以放到服务器上做。
3. 定义你的”最优”。 是 top-1？还是”90% 置信度就算过”？还是 BLEU-PS 这种复合指标？判据变了，标签就要重算，预模型也要重训。
4. 挑特征。 先凭领域直觉列 2030 个候选特征，然后用「相关性去冗余 → 贪心重要性搜索 → 缩放到 01」三步筛选。特征提取的开销一定要实测，它常常是整套方案里最贵的一环。
5. 用算法 1 挑子集。 先定 θ（论文用 0.5~2.0），再在 Accuracy / Optimal / Alternate 之间按你的偏好选策略。
6. 选预模型架构。 数据多 → 多分类器串联（图像分类）；数据少、特征维度高 → 单个简单分类器（机器翻译）。
7. 测端到端，别忘了把预模型开销算进去。 论文在这一点上做得很扎实，所有数据都含预模型开销。

论文的讨论部分还点出了几个可以继续扩展的方向：把特征提取器用 C/C++ 重写并并行化（Python 实现是主要开销来源）；把”本地跑还是卸载到云/边缘”也纳入同一个学习框架（需要能预测网络延迟）；把”用 CPU 还是 GPU 还是 NPU 跑”也交给模型选；用压缩生成共享权重的模型族来摊薄多模型的存储成本。

常见坑

坑一：以为存在一个”全局最优模型”。 本文全部论证都建立在”最优模型随输入和评价标准而变”这个前提上。如果你先入为主地要找”最好的那一个”，就走错方向了。

坑二：忽略预模型自身的开销。 预模型一旦比它挑选的模型还慢，整套方案就是负收益。论文里 KNN 的预测时间必须压到 < 1 ms 才有意义。一定要测端到端，不要只看 DNN 那一段。

坑三：特征维度越高越好。 图 16 是反例：BoW 的 k 从 2 000 往上加，精度反而掉近 4%（过拟合）；从 1 500 往下减也掉（欠拟合）。特征数量要和训练样本量匹配。

坑四：忘了内存是要付钱的。 本文方法 CPU/GPU 负载和延迟都改善了，只有内存占用变多（比最贵单一模型多 16%）。在内存极其紧张的设备上，这可能就是压垮骆驼的最后一根稻草。

坑五：把”精度不下降”想得太绝对。 机器翻译只达到了 Oracle F1 的 83%，原因是训练数据只有 5 000 句。预模型自己也是个机器学习模型，它同样需要数据。 数据不够时，先别怪方法。

通关标准

• 能解释端侧推理三大约束（算力 / 内存 / 功耗）与精度的矛盾，并说出压缩、云卸载、专用优化三条老路各自的代价
• 能说出自适应选择相比”选一个折中模型”好在哪：最优模型是「输入 × 评价标准」的函数，而且多模型失败样本不重合、轮换反而能提精度
• 能复述算法 1 的贪心流程，说清 θ 和三种选择策略（Accuracy / Optimal / Alternate）的作用
• 能说清特征筛选的三步（相关性去冗余 → 贪心重要性搜索 → 缩放）以及为什么 7 个特征是图像分类的甜点
• 能看懂本文的加速比与精度数据：图像分类 +7.52% 精度 / 1.8 倍加速，机器翻译 1.34 倍加速 / 1.39 倍省电，压缩场景 1.52 倍加速只掉 1.76% top-1

自测 1：论文说"最优模型不是模型的固有属性"，请用图 1(c) 那张困难图片举一个具体的例子说明这句话。

答案要点：对同一张图（主体与背景颜色接近），按 top-5 判，ResNet_v1_50 就足够（比 ResNet_v2_152 快 2.06 倍）；按 top-1 判，必须用最贵的 ResNet_v2_152（比 MobileNet_v1_025 慢 6.14 倍）。同一输入、不同评价标准 → 最优模型不同，所以”最优”不能脱离评价标准单独谈。

自测 2：算法 1 的第一行为什么不是"选精度最高的模型"，而是"选最常被判为最优的模型"？

答案要点：因为目标是”在满足精度门槛的前提下最快”，不是”尽可能准”。最常被判为最优的模型（图像分类里是 MobileNet_v1_100，占 70.75%）通常是便宜且覆盖大部分简单样本的；先把它放进去，后续迭代只是在补它答错的那 29.25%。反过来，若按 Optimal 策略一路选下去，会不断加入”便宜但不准”的模型，集合会退化——论文正是因此改用了 Accuracy 策略。

自测 3：图像分类最后为什么是 7 个特征？减到 5 个或加到 10 个分别会怎样？

答案要点：图 13 显示第 8 个特征（hue7）之后重要性断崖式下跌；图 14 显示减到 5 个特征 top-1 掉 13.9%，而提取时间几乎没省；继续增加特征开销略升、top-1 反而降 0.4%（过拟合）。所以 7 个是精度与开销的甜点。

自测 4：机器翻译场景为什么选了"单个朴素贝叶斯"，而图像分类选了"三个 KNN 串联"？

答案要点：关键在于训练数据量与特征维度的比值。机器翻译只有 5 000 句（图像的十分之一），但 BoW 带来上千维特征；串联架构每层都要用更少的数据做二分类，极易过拟合，所以简单模型更好（图 11(b) 显示单分类器全面胜出）。图像分类有 5 万张图、只有 7 个特征，数据充足，串联架构的优势（各层共享 KNN 近邻计算、开销几乎不随层数增长）才能发挥出来。

自测 5：本文方法在哪些指标上变好了、在哪个指标上变差了？如果让你向一个内存只有 512 MB 的 MCU 团队推荐这套方法，你会怎么说？

答案要点：变好的是推理时间（图像分类 1.8 倍、机器翻译 1.34 倍）、能耗（机器翻译省 1.39~1.48 倍，图像分类超 2 倍）、精度（图像分类 +7.52%）、CPU/GPU 利用率（GPU 占用 37.46%，比最贵模型低 52.18%）；变差的是内存（比最贵单一模型多 16%）和存储（要存多个模型）。 对 MCU 团队的建议要谨慎：论文明确说这是”用内存换精度和延迟”的交易，且实测平台是有 8 GB 内存的 TX2。内存极紧时应该走 7.6 节的压缩路线——从一个大模型压出多个共享权重的版本，摊薄存储；同时用算法 1 把候选集压到最小（θ 调大）。若连 2~3 个模型都放不下，则本方法不适用。