NAS加速：架构搜索效率优化策略

可视化演示

展示权重共享超网络加速评估、代理模型预测架构性能与多阶段搜索流水线，切换模式查看NAS加速核心技术。

搜索空间瘦身

阿明面对的调味料、辅料与火候组合超过一亿种，但他没有立刻开火试菜，而是先“钉菜单框架”：把重复出现的食材搭配打包成固定积木块，只在这些积木的边界内做变化。框架一钉，候选配方瞬间从“亿”级掉到“千”级，研发一下子有了抓手。

在 NAS 里，这个“框架”就是搜索空间——所有候选网络结构的集合。搜索空间的大小直接决定总预算：空间越大，需要评估的候选越多。而评估一个候选（完整训练一个网络）恰恰是 NAS 最烧钱的部分。所以聪明的第一步不是改进搜索算法，而是让搜索空间本身更小：能设计为重复单元的，就不要让每一层都独立搜索。

经典做法是把宏观（macro）搜索和单元（cell）搜索分开。宏观搜索让每一层都从操作集里自由选，层数一多空间就爆炸；单元搜索只设计一个含 B 个块的小单元，再把单元堆叠重复组成完整网络，空间从指数级压缩到可枚举。再加上结构约束（如限制分支数不超过 4）和操作集简化（剔除极少被选中的操作），规模进一步收缩。

$$\displaystyle |\mathcal{S}_{\text{macro}}| = O^{L}, \qquad |\mathcal{S}_{\text{cell}}| = O^{B}, \qquad \frac{|\mathcal{S}_{\text{macro}}|}{|\mathcal{S}_{\text{cell}}|} = \frac{5^{20}}{5^{5}} = 5^{15} \approx 3.05 \times 10^{10}$$

1. 宏观搜索规模：每层从 O 种操作中任选一种，L 层串联时组合数相乘，构成指数级空间。

$$|\mathcal{S}_{\text{macro}}| = O^{L}$$

2. 单元搜索规模：只设计一个含 B 个块的小单元，每块仍是 O 选一，层数不再进入指数。

$$|\mathcal{S}_{\text{cell}}| = O^{B}$$

3. 压缩倍率：取 O=5、L=20、B=5 代入，两个空间的比值约三千亿倍，说明“重复结构打包”的威力。

$$\frac{|\mathcal{S}_{\text{macro}}|}{|\mathcal{S}_{\text{cell}}|} = \frac{5^{20}}{5^{5}} = 5^{15}$$

从此阿明只设计一张“单元菜卡”——一荤一素一汤的固定三角组合，重复叠出整桌套餐。搜索从“在整本食谱里翻”变成“在设计一张卡片时斟酌”，研发效率自然不可同日而语。

参数共享加速

如果每道新菜都要从熬高汤开始，厨师迟早累垮。阿明的秘诀是：所有配方共用同一锅老汤底，试菜时只换辅料与火候。这锅老汤越熬越有滋味，而每道菜省掉了从零备汤的几小时——这正是参数共享的精髓。

NAS 最昂贵的部分，是每个候选网络都要“从零训练”。ENAS（高效神经架构搜索）提出超网络（supernet）概念：把搜索空间里所有子网络看成同一张大图的不同子图，所有子网络共享一套权重。评估一个子网络，等价于在大图上摘一条路径做前向与反向传播，而不是独立训练一个完整模型。相当于从“每道菜单独起灶”变成“都在同一锅高汤里涮”。

训练方式采用路径采样：每步随机采一个子网络（一条路径），用它更新共享参数；控制器（一个 RNN 策略网络）根据反馈调整采样概率，让更优结构获得更多采样机会。搜索结束后，再把最优子网络从超网络中“继承”出来做独立重训。注意：共享权重给出的分数是相对排名参考，不是最终成绩单——这点在后面的误区里还会强调。

$$\displaystyle \theta^{*} = \arg\min_{\theta}\ \mathbb{E}_{a \sim \pi(a; \alpha)} \left[\, \mathcal{L}_{\text{train}}\big( a(\theta) \big) \,\right]$$

1. 共享参数目标：θ\* 表示超网络最终收敛的那套共享权重，所有子结构都从它身上“借参数”。

$$\theta^{*} = \arg\min_{\theta}$$

2. 期望损失：优化目标是对控制器采样出的所有子结构损失取期望，而非每个子结构各自最小化。

$$\mathbb{E}_{a \sim \pi(a; \alpha)}$$

3. 共享结构前向：a(θ) 表示从超网络大图中摘出的子结构，它只激活路径上的参数参与计算。

$$\mathcal{L}_{\text{train}}\big(a(\theta)\big)$$

高汤在每道试菜间传承、积累风味；超网络权重在每次路径采样间共享、逐步泛化。代价是单菜精度不如“专锅专炖”，但换来的是把几千口灶台压缩成一口老汤锅。

代理模型预测

阿明认识一群老饕，闻香、看色、听“滋滋”声，就能把一道菜预测个八九不离十。于是他不等每道菜完整出锅，先请老饕打分，只对高分候选进入实操。这个“只动嘴不动锅”的环节，就是代理模型。

代理模型（surrogate model）是“架构描述 → 验证精度”的近似函数：先用少量真实评估数据拟合它，再用它对大量未评估架构快速打分排序。预测器可以选高斯过程、图神经网络或随机森林。另一个常用技巧是学习曲线外推：只训练少量轮数，把“轮数-精度”曲线按幂律规律外推，估算完整训练的饱和精度——相当于只让小份试味冒个泡，就预判大份成品的成色。

代理模型通常配合主动采样形成闭环：每次用采集函数挑出“最值得验证”的候选做真实评估，把新样本喂回代理模型更新预测，再进入下一轮。预测器越来越准，需要完整训练的候选越来越少。

$$\displaystyle \mathrm{Acc}(t) \;\approx\; a \;-\; b \cdot t^{-c}$$

1. 曲线模型：用幂律函数近似“轮数-精度”曲线，这是学习曲线外推的基本假设。

$$\mathrm{Acc}(t) \approx a - b \cdot t^{-c}$$

2. 饱和上限：当训练轮数趋于无穷时，t 的负 c 次幂趋向零，精度收敛到 a，即该架构潜力上限。

$$\lim_{t \to \infty} \mathrm{Acc}(t) = a$$

3. 外推截断：只训练少量轮数拟合参数，再外推出大 t 下的期望精度，省下完整训练的时间。

$$b \cdot t^{-c} \to 0, \quad t \gg 1$$

老饕的预判不完美，但能快速把几百道菜筛到三五道“值得下锅”。真正的味道永远以完整试吃为准——就像代理预测后仍需真实评估兜底。

早停策略

阿明给试菜立了条规矩：第一口寡淡无层次，立刻倒掉换配方，绝不为了“万一后面变好”硬撑到出锅。省下的灶台时间，用来试更多可能的配方。

NAS 里大量候选架构注定是低分选手，完整训练它们纯属烧钱。早停策略的思想就是：用训练早期的表现预判终局成色，没有希望的候选提前终止，把预算留给更有潜力的候选。著名的实现包括 ASHA（异步连续减半算法）与 Hyperband 的中位数停止法则。做法是设定若干检查点（如第 1、2、4、8 轮），每到检查点就把同一预算档位的候选放在一起比“期中成绩”。

中位数停止法则的具体判定是：候选的当前精度若低于同预算群体精度中位数，直接淘汰；若达标，则晋级并翻倍训练预算。这就像全班统一考试划一条及格线，不过线的不给补考机会，过线的进入下一轮加时赛。多阶段筛选层层收窄，最终只留个位数的候选进入完整训练。

$$\displaystyle \begin{cases} \text{继续训练，预算翻倍}, & \mathrm{Acc}_{i}(t_k) \;\ge\; \mathrm{median}\left\{\mathrm{Acc}_{j}(t_k)\right\} \\[4pt] \text{早停淘汰}, & \text{否则}\end{cases}$$

1. 检查点定义：训练进行到第 k 个预设轮数时做一次“期中考核”，所有同级候选一起比较。

$$t_k \in \{ 1, 2, 4, 8, \dots \}$$

2. 晋级条件：候选 i 的精度不低于同预算候选的中位数，则获得翻倍预算继续训练。

$$\mathrm{Acc}_{i}(t_k) \;\ge\; \mathrm{median}\left\{\mathrm{Acc}_{j}(t_k)\right\}$$

3. 淘汰条件：低于中位数者立即终止，避免在注定平庸的架构上浪费训练资源。

$$\mathrm{Acc}_{i}(t_k) < \mathrm{median}\left\{\mathrm{Acc}_{j}(t_k)\right\} \;\Rightarrow\; \text{终止}$$

早停不是武断的一刀切，而是把“试吃一口”变成制度化的筛选闸门。被淘汰的鸭汤不会被端上桌，却为真正的好菜省出了灶台时间。

渐进式搜索

阿明研发套餐时从不一次性设计十道完整大菜。他先做一道小份前菜试水，反响好，再把同一个配方逻辑放大成主菜；小菜单里验证过的元素，才允许进入大菜单。

渐进式搜索（如 PNAS、DARTS 的逐步放宽）遵循同样的“由浅入深”信念：先在小规模单元上搜索，确认方向正确后，逐步增加单元块数、网络深度与输入分辨率。每一阶段都继承上一阶段找到的精英结构——这叫作精英保留（elitism）——只扩展新的自由度，绝不推倒重来。搜索从中途到收尾越来越贵，但每一步都站在上一次最优的肩膀上。

具体流程可以描述为：第 k 阶段维护一个精英集合，枚举所有“在精英上加一块”的扩展候选，用代理模型打分过滤，再对少数高分候选做真实训练验证，选出新的精英进入第 k+1 阶段。随着块数增加，搜索空间逐步放大，但候选始终来自精英扩展，而不是全空间重新采样。

$$\displaystyle \mathcal{S}_{k+1} \;=\; \left\{\; \mathrm{expand}(a) \;\middle|\; a \in \mathcal{E}_{k},\; \mathrm{score}(a) \geq \mathrm{threshold} \;\right\}$$

1. 精英集合：E_k 是第 k 阶段表现最好的若干结构，它们是下一轮扩展的种子。

$$\mathcal{E}_{k} = \left\{ a_{1}, a_{2}, \dots, a_{K} \right\}$$

2. 扩展操作：在精英结构上追加一个操作块，生成更复杂的候选，这是“由浅入深”的推进方式。

$$\mathrm{expand}(a): B \mapsto B+1$$

3. 下一阶段搜索空间：新空间只存放精英扩展出的候选，规模远小于全量搜索空间。

$$\mathcal{S}_{k+1} = \left\{ \mathrm{expand}(a) \mid a \in \mathcal{E}_{k} \right\}$$

渐进式如同“小份试菜成功才放量”。每一阶段的灶台投入都以精英为锚点，搜索预算从“撒胡椒面”变成“集中火力”。

评估代价权衡

阿明算过一笔账：完整试做一道菜要 60 分钟、80 元成本；小份试味只要 10 分钟、15 元。先做小份筛选，再对进入决赛的几道做大份完整验证，总成本骤降。这就是评估代价的平衡术。

NAS 的总开销约等于候选数乘以单次评估代价。加速可以压缩候选数（空间瘦身、早停），也可以压缩单次代价。单次评估的压缩手段包括：低精度训练（半精度/混合精度）、降低输入分辨率（如把 224×224 缩到 128×128）、减少通道数、缩短训练轮数。但代价越低，评估偏差通常越大——低分辨率下表现好的结构，高分辨率下未必领先。

工程上常用“由粗到精”的漏斗式管线：先用极廉价评估做大规模海选，再用中档评估复筛，最后对个位数的胜出者做全精度训练与部署测试。预算分配呈漏斗形，越靠近出口的单次评估越贵，但候选数量越少，整体账单被压到最低。

$$\displaystyle S \;=\; \frac{C_{\text{naive}}}{C_{\text{accel}}} \;=\; \frac{N \cdot T_{\text{full}}}{N^{*} \cdot T_{\text{full}} \;+\; N_{\text{stop}} \cdot T_{\text{stop}} \;+\; N_{\text{proxy}} \cdot T_{\text{proxy}}}$$

1. 朴素总代价：没有加速时，N 个候选全部完整训练，总代价是候选数与单次训练时长的乘积。

$$C_{\text{naive}} = N \cdot T_{\text{full}}$$

2. 加速后总代价：只有少数候选完整训练，其余要么被早停中途截断，要么只做廉价代理评估。

$$C_{\text{accel}} = N^{*} \cdot T_{\text{full}} + N_{\text{stop}} \cdot T_{\text{stop}} + N_{\text{proxy}} \cdot T_{\text{proxy}}$$

3. 加速倍率：朴素代价与加速代价之比即为总加速倍数，工程上常期望达到 10 到 1000 倍。

$$S = \frac{C_{\text{naive}}}{C_{\text{accel}}}$$

账算清楚后，阿明把九成预算留给煎炒烹炸的决赛轮，海选只花闻香看色的轻工夫。评估代价的取舍不是“省不省”的问题，而是“把钱花在哪一刀”的艺术。

工程落地实践

研发成功不等于能端上桌。阿明最后要面对现实：后厨人力有限、上菜时长有红线、客人口味分层。他需要把整套加速策略组装成一条可执行的研发流水线。

工程落地 NAS 时，常见的约束是：单卡或少量 GPU、数小时的搜索窗口、明确的延迟与参数量预算。对应策略组合拳是：限定搜索空间（只保留深度可分离卷积、逐点卷积、池化等常用操作）→ 用超网络/代理模型做海选 → 早停筛掉大部分候选 → 对胜出架构独立重训并做部署校准。在资源受限场景下，这套组合拳能把原来“数百 GPU 天”的任务压缩到“数卡小时”。

快速原型验证是另一类典型场景：新业务上线前，用加速 NAS 在几小时内拿到强基线，替代人工试错调参。落地时还必须守住“结果可信评估”三道关：搜索阶段与重训阶段的数据分布一致、用多个随机种子评估稳定性、胜出架构必须独立重训并与人工基线对比。否则，再快的搜索也只是“快而不准”。

$$\displaystyle \min_{a \in \mathcal{S}}\; \mathrm{Latency}(a) \quad \mathrm{s.t.} \quad \mathrm{Acc}_{\text{retrain}}(a) \;\ge\; \mathrm{Acc}_{\text{baseline}} + \delta$$

1. 目标函数：在搜索空间 S 中寻找推理延迟最小的架构，满足部署侧的实时性预算。

$$\min_{a \in \mathcal{S}} \; \mathrm{Latency}(a)$$

2. 精度约束：约束使用独立重训后的精度，而不是超网络中共享权重给出的粗略打分。

$$\mathrm{Acc}_{\text{retrain}}(a) \;\ge\; \mathrm{Acc}_{\text{baseline}} + \delta$$

3. 可行解集：最终交付的是“延迟最小且达标”的架构，所有加速策略都是为了更快逼近这个解。

$$a^{*} = \arg\min \left\{ \mathrm{Latency}(a) \;\middle|\; a \in \mathcal{S},\ \text{精度约束成立} \right\}$$

阿明的流水线最终定型：精选菜单（空间瘦身）、老汤共享（参数共享）、老饕预判（代理模型）、试吃闸门（早停）、小份放量（渐进搜索）、账单管控（代价权衡）。每一环都为着一个目标——在灶台和时间有限的前提下，端出比旧菜单更受欢迎的新招牌菜。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-"""Lightweight NAS demo: proxy screening + early stopping."""import numpy as npfrom sklearn.datasets import make_classificationfrom sklearn.neural_network import MLPClassifier SCREEN_EPOCHS = 2        # proxy-like cheap screeningFULL_EPOCHS = 20         # full evaluation budgetPATIENCE = 4             # early stopping toleranceTOP_K = 3                # survival count after screening def make_data():    X, y = make_classification(n_samples=800, n_features=12,                               n_informative=8, random_state=42)    split = int(0.7 * len(X))    return (X[:split], y[:split]), (X[split:], y[split:]) def train_acc(config, X_train, y_train, X_val, y_val, epochs):    model = MLPClassifier(hidden_layer_sizes=config["hidden"],                          learning_rate_init=config["lr"],                          max_iter=1, warm_start=True)    best_acc = 0.0    no_improve = 0    used = 0    for epoch in range(epochs):        model.partial_fit(X_train, y_train, classes=np.unique(y_train))        acc = model.score(X_val, y_val)        used = epoch + 1        if acc > best_acc:            best_acc = acc            no_improve = 0        else:            no_improve += 1        if no_improve >= PATIENCE:            break    return best_acc, used def main():    (X_train, y_train), (X_val, y_val) = make_data()    configs = [        {"hidden": (16,), "lr": 0.010},        {"hidden": (32, 16), "lr": 0.001},        {"hidden": (64, 32, 16), "lr": 0.003},        {"hidden": (8, 8), "lr": 0.010},        {"hidden": (128,), "lr": 0.0005},        {"hidden": (32,), "lr": 0.005},    ]     print("== proxy screening (2 epochs) ==")    scored = []    for cfg in configs:        acc, _ = train_acc(cfg, X_train, y_train, X_val, y_val, SCREEN_EPOCHS)        print("  %-16s screen=%.4f" % (str(cfg["hidden"]), acc))        scored.append((cfg, acc))    scored.sort(key=lambda pair: pair[1], reverse=True)    kept = [cfg for cfg, _ in scored[:TOP_K]]     print("== full evaluation with early stopping ==")    total_budget = len(kept) * FULL_EPOCHS    used_budget = 0    for cfg in kept:        acc, used = train_acc(cfg, X_train, y_train, X_val, y_val, FULL_EPOCHS)        used_budget += used        print("  %-16s full=%.4f used_epochs=%d" % (str(cfg["hidden"]), acc, used))    print("  saved %.1f%% of full epochs" % (100.0 * (1 - used_budget / total_budget))) if __name__ == "__main__":    main()

1. model = MLPClassifier(..., max_iter=1, warm_start=True)构建带热启动的模型，每次只训一个 epoch，便于模拟“评估一个候选结构”。
2. model.partial_fit(X_train, y_train, classes=np.unique(y_train))每调用一次只推进一个 epoch，多个候选共享同一套训练流程。
3. used = epoch + 1记录真实消耗的轮数，早停越早触发，used 越小。
4. if no_improve >= PATIENCE: break连续若干轮无提升即早停，这就是“尝一口寡淡就换配方”。
5. scored.sort(key=lambda pair: pair[1], reverse=True)按代理分数降序排列，模拟老饕先打分。
6. kept = [cfg for cfg, _ in scored[:TOP_K]]只保留前 3 名进入决赛，对应漏斗式筛选。
7. used_budget += used累加决赛阶段真实消耗的轮数，用于计算节省的训练量。

常见误区

面试题