想象一家不断扩张的餐厅：菜单上新菜层出不穷，厨房里的设备也从燃气灶换成了电磁炉、烤箱甚至分子料理机。过去，每道菜都有一张“模板菜谱”——由资深厨师手工写好框架，只留几个空格（比如“蒜：2~6 瓣”“火候：3~5 档”）让后来者填。可一旦来一道全新的菜，或者换一台从没见过的设备，模板就失效了，只能重新请专家来写。TVM 编译器曾经就面临同样的困境：它用 AutoTVM 的调度模板来优化算子，但每个算子和每种硬件都需要专家手工编写模板，成本极高。Ansor 的出现，相当于请来一位真正的“大厨”：它不看模板，只凭计算表达式这份“原料清单”，就能系统性地设计候选菜谱——先搭建烹饪框架（草图），再填上精确的火候与用量（参数），用“直觉”（代价模型）预判哪份菜谱最快，最后通过反复试菜（进化搜索与真机实测）敲定最佳方案。这就是无模板搜索的魔法。

岗位关联

对 AI 从业者的价值：理解 Ansor 能帮你摆脱手工调优的束缚，在 GPU/CPU 等多后端快速交付高性能算子，是踏入深度学习编译器核心世界的必修课。

目录
  1. 可视化演示
  2. 背景与动机：模板菜谱的失灵时刻
  3. 整体架构：从原料清单到成品菜
  4. 程序采样：海量候选菜谱从哪里来
  5. 代价模型：还没下锅就能预知味道
  6. 进化搜索：反复试菜，优中选优
  7. 核心优势：无模板为何更可靠
  8. 工程效果：真实厨房里的成绩单
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

动态展示Ansor自动推导的搜索空间(≥AutoTVM)、草图-标注两阶段搜索机制、代价模型驱动的迭代搜索收敛、以及CNN算子加速效果(Speedup=T_baseline/T_Ansor)四个核心视角。

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

背景与动机：模板菜谱的失灵时刻

在 Ansor 诞生之前，TVM 的自动调优依赖 AutoTVM 的模板机制。这就像一本厚厚的手工菜谱：针对卷积、矩阵乘这些常见算子，专家预先写好调度模板——也就是决定算子如何在硬件上执行（循环顺序、并行方式、数据分块等）的框架——并标出哪些参数可以调整：分块大小填 8 到 128，展开因子填 1 到 8。调优器要做的，只是在这个模板的“空格”里搜索最优组合。听起来不错，但现实是：新算子层出不穷，比如各种融合算子、动态形状算子，每种算子的计算结构都不一样，现成模板往往没有对应项。

更棘手的是硬件碎片化。GPU、x86 CPU、ARM 移动芯片、专用 NPU，各有各的并行模型与内存层次。同一个卷积算子，在 GPU 上要考线程绑定，在 CPU 上要考向量化和 Cache 分块。为每个平台、每个算子手工编写模板，需要同时精通硬件架构和 TVM 调度 API，人力成本极高。AutoTVM 的模板还彼此割裂，覆盖不到的结构就永远不会被尝试。于是 Ansor 提出了一个大胆目标：让系统自动生成搜索空间，彻底拿掉“模板”这个人工拐杖。

从数学上看，调优问题可以形式化为一个最小化问题：在可行调度集合中，寻找执行时间最短的那个。这个集合在 AutoTVM 中由模板展开得到，在 Ansor 中则由程序采样自动构建：

回到餐厅的比喻：AutoTVM 的模板像是几本固定菜谱，遇到新菜只能干瞪眼；Ansor 则换了一种思路——不再依赖别人的菜谱，而是让系统自己发明菜式。接下来的每一节，我们都会看到这位“大厨”完整的创作流程。

s∗=arg⁡min⁡s∈S  T(s,硬件)\displaystyle s^{*} = \arg\min_{s \in \mathcal{S}} \; T(s, \text{硬件})
也就是说，我们要在所有候选调度 s 中，找到让目标硬件执行时间 T 最小的那一个。
  1. 最优调度 s\*最终要找的“最佳菜谱”，能让算子在这台硬件上跑得最快。
    s∗s^{*}
  2. argmin 最小化运算在候选集合里逐一比较，挑出耗时最小的成员。
    arg⁡min⁡s∈S\arg\min_{s \in \mathcal{S}}
  3. 搜索空间 S所有候选调度的集合。Ansor 用程序采样自动生成它，相当于一个自动扩充的菜谱库。
    S\mathcal{S}
  4. 执行时间 T调度在具体硬件上的真实运行耗时，是整个优化过程的唯一裁判。
    T(s,硬件)T(s, \text{硬件})

整体架构：从原料清单到成品菜

Ansor 的工作流程很像一位大厨从接到原料清单到端出成菜的完整创作。它的输入是计算表达式——TVM 中描述算子的方式，只说明“要算什么”，比如“对两个矩阵做乘加”。这相当于菜谱里的原料清单：牛肉、洋葱、酱油都齐了，至于先切还是先腌、用什么锅，一概不管。

整个系统是两阶段流水线。第一阶段叫程序采样（Program Sampling）：自动生成大量候选程序，构成搜索空间。这些候选像大厨头脑中冒出的各种做法：有的先炒后炖，有的直接进烤箱，有的切丁，有的切片。第二阶段叫性能微调（Performance Fine-Tuning）：借助代价模型和进化搜索，从海量候选中快速锁定最优调度。两阶段一前一后，构成 Ansor 的完整闭环。

形式化地看，整个流程可以写成一条链：

这条流水线就像大厨先海量地设计方案，再用经验和直觉快速筛选、反复试菜，最终定稿。空间的生成（采样）与方案的打磨（微调）职责清晰，这正是 Ansor 能同时应对多样算子与多样硬件的根基。

Expr→程序采样Sp→性能微调s∗\displaystyle \text{Expr} \xrightarrow{\text{程序采样}} \mathcal{S}_{p} \xrightarrow{\text{性能微调}} s^{*}
计算表达式先经过程序采样变成搜索空间，再经过性能微调得到最优调度。
  1. Expr 输入TVM 中的计算表达式，比如 C = A @ B，是调度搜索的起点。
    Expr\text{Expr}
  2. 程序采样第一阶段把表达式展开成大量候选程序，构造出搜索空间。
    →程序采样Sp\xrightarrow{\text{程序采样}} \mathcal{S}_{p}
  3. 性能微调第二阶段用代价模型与进化搜索，从空间中筛出最优解。
    →性能微调s∗\xrightarrow{\text{性能微调}} s^{*}
  4. 最优调度 s\*最终输出，可直接交给代码生成器编译执行。
    s∗s^{*}

程序采样：海量候选菜谱从哪里来

程序采样要回答一个关键问题：一个算子到底有哪些可能的实现方式？Ansor 的做法是分层展开。第一步叫草图生成（Sketch Generation），用一组规则把计算表达式展开成若干高层循环结构——就像决定这道菜是炒、炸、炖还是蒸。不同的草图体现不同的并行与复用策略：多层分块对应“分批下锅”，算子融合对应“一锅出”，虚拟线程对应“多个帮厨同时动手”。

第二步叫参数注解（Annotation）。每张草图上还有很多待填参数：分块大小、展开因子、向量宽度、线程绑定方式。Ansor 为每个参数位随机或按启发式选取若干候选值，就像大厨给“加盐少许”填上精确的“3 克、4 克或 5 克”。草图与注解组合起来，一个庞大的搜索空间就诞生了。

搜索空间的大小可以这样计算：假设生成了 K 张草图，第 k 张草图上留有 m_k 个参数位，每个参数位有若干可选值，那么总候选数就是：

为了保证不同结构都被探索到，Ansor 还引入了多样化控制：避免搜索空间被少数结构相似的草图主导。这好比大厨设计菜单时，刻意保证蒸、炒、炖、烤各占一席，而不是全做成炒菜。多样化的空间，正是后面进化搜索能够“广撒网、再收网”的前提。

∣Sp∣=∑k=1K∏j=1mk∣Ak,j∣\displaystyle |\mathcal{S}_{p}| = \sum_{k=1}^{K} \prod_{j=1}^{m_k} |\mathcal{A}_{k,j}|
每一张草图下，把所有参数位的可选个数相乘，再把各草图的结果相加，就是搜索空间的总体规模。
  1. 草图总数 K系统生成的互不相同的顶层循环结构数量，好比菜单上几种烹饪流派。
    KK
  2. 参数位数量 m_k第 k 张草图上的可调参数位个数，如分块、展开、向量化各占一席。
    mkm_k
  3. 单参数候选数第 k 张草图第 j 个参数位的可选值数量，比如分块大小可以取 8/16/32。
    ∣Ak,j∣|\mathcal{A}_{k,j}|
  4. 总候选数把各草图下参数组合数相乘后再求和，得到百万量级的搜索空间。
    ∑k=1K∏j=1mk∣Ak,j∣\sum_{k=1}^{K} \prod_{j=1}^{m_k} |\mathcal{A}_{k,j}|

代价模型：还没下锅就能预知味道

搜索空间动辄百万候选，如果每一份菜谱都真刀真枪炒一遍再评判，时间成本不可接受。Ansor 的解决办法，是训练一个“预知味觉”的代价模型（Cost Model）——它能在不执行程序的前提下，预估一份候选在目标硬件上大概跑多久，就像经验丰富的大厨看一眼菜谱，就能估出这道菜大约需要几分钟。

代价模型的做法是：先提取候选程序的特征——循环层数、分块大小、展开因子、向量宽度、内存访问模式等，这些特征构成一个向量；再用 XGBoost 这样的梯度提升树模型，把特征映射为预测耗时。模型的训练数据来自真实设备上的实测样本：每测一个程序，就多一条标注数据，模型随之迭代更新，越用越准。

形式化地，代价模型可以写成：

有了这个“预知味觉”，性能微调阶段就能把百万候选先筛掉 99%，只留下最有希望的一小撮，再上真锅真灶验证。换句话说，代价模型不是替代测量，而是让每一次测量都花在刀刃上——这正是它被称为“廉价排序器”的原因。

t^(p)=fθ(ϕ(p)),θ∗=arg⁡min⁡θ∑i∈D(ti−t^(pi))2\displaystyle \hat{t}(p) = f_{\theta}\left(\phi(p)\right), \qquad \theta^{*} = \arg\min_{\theta} \sum_{i \in \mathcal{D}} \left( t_i - \hat{t}(p_i) \right)^2
模型根据程序特征预测耗时，并通过最小化预测值与实测值的平方误差来不断校准自己。
  1. 特征提取 φ(p)把程序结构转化为特征向量，类似于把菜谱抽象成“时长、火候、配料数”等数字。
    ϕ(p)\phi(p)
  2. 模型预测 f_θXGBoost 模型读入特征，输出一个预测耗时。
    t^(p)=fθ(ϕ(p))\hat{t}(p) = f_{\theta}(\phi(p))
  3. 训练数据 D已经实测过的“（程序，真实耗时）”样本集合，是模型的品菜记录。
    D\mathcal{D}
  4. 误差最小化调整模型参数，让预测值尽量贴近实测值，也就是让残差平方和最小。
    arg⁡min⁡θ∑i∈D(ti−t^(pi))2\arg\min_{\theta} \sum_{i \in \mathcal{D}} \left( t_i - \hat{t}(p_i) \right)^2

进化搜索：反复试菜，优中选优

有了代价模型，Ansor 还需要一套搜索策略在巨大空间里穿行。它选择了进化搜索（Evolutionary Search），这就像大厨不断改良菜谱：先做出一批初版，尝一口记下好坏，然后把几道菜的优点拼在一起，或者小幅调整火候用量，再做下一批。如此往复，菜越做越好。

具体来说，进化搜索从代价模型预测最优的一批候选初始化种群；每一代执行两类操作——变异（Mutate）随机改动某个参数，比如把分块大小翻倍、换一种向量宽度；交叉（Crossover）从两个父代各取一部分“基因”重组出新个体。随后，按代价模型的预测对子代与父代统一排序，保留前若干名作为下一代种群，并从预测最优的一小撮中挑出数个候选做真机实测，用实测数据反馈更新代价模型。

一代代的种群更替可以写成：

值得注意的是，进化搜索并不是碰运气。它的每一步都由代价模型“导航”，只在结构化空间内做局部扰动，并且每一轮都有真机实测兜底。这就像大厨的试菜不是乱改，而是基于对火候、用料的专业判断，在关键维度上精准试错——所以往往几十代之内，就能收敛到令人满意的方案。

Pt+1=Select(Pt∪Mut(Pt)∪Xover(Pt))\displaystyle P_{t+1} = \mathrm{Select}\left( P_t \cup \mathrm{Mut}(P_t) \cup \mathrm{Xover}(P_t) \right)
新种群由旧种群、变异个体、交叉个体共同参与选择产生，选择依据是代价模型的预测。
  1. 种群 P_t第 t 代候选程序集合，好比一批正在试验的菜谱。
    PtP_t
  2. 变异操作 Mut随机改动一个或多个参数，产生“微调版”新菜谱。
    Mut(Pt)\mathrm{Mut}(P_t)
  3. 交叉操作 Xover取两个父代的不同部分重组，产生“混合版”新菜谱。
    Xover(Pt)\mathrm{Xover}(P_t)
  4. 选择操作 Select按代价模型预测排序，截取前若干名进入下一代。
    Pt+1=Select(⋅)P_{t+1} = \mathrm{Select}(\cdot)

核心优势：无模板为何更可靠

Ansor 与 AutoTVM 最本质的区别，就像一位自创菜谱的大厨和一本固定模板菜谱的差别。前者面对任何原料都能展开思路，后者则被模板的边界牢牢框住。AutoTVM 的空间由专家手工模板展开，模板覆盖不到的结构永远不可能被找到；Ansor 的空间由程序采样自动生成，从规则层面覆盖了主流调度结构。用集合的语言说：

这种“超集”性质带来三个直接好处：一是免模板——新算子出现时，系统自动补齐搜索空间，工程师无需介入；二是分层调度——草图层决定结构、注解层决定参数，搜索因此更高效，也更容易理解和调试；三是跨后端——草图与注解规则与具体硬件解耦，同一套流水线稍作适配即可用于 GPU、CPU 与 ARM。

打个比方：模板方案像是只会照本宣科的学徒，Ansor 则是一套完整的“烹饪方法论”——它不绑定任何具体菜谱，但能针对任何原料组合和任何灶具，系统性地得出最优做法。当然，超集并不等于免费午餐：更大的空间意味着更棘手的寻优难度，这正是 Ansor 用代价模型加进化搜索这套组合拳来应对的原因。空间更大但收敛更快，才是它真正厉害的地方。

SAnsor⊇⋃τ∈TSτ\displaystyle \mathcal{S}_{\text{Ansor}} \supseteq \bigcup_{\tau \in \mathcal{T}} \mathcal{S}_{\tau}
Ansor 的搜索空间是全部手工模板空间并集的超集，这意味着它至少不输给任何模板方案。
  1. 模板空间 S_τ每个手工模板 τ 展开得到的候选集合。
    Sτ\mathcal{S}_{\tau}
  2. 模板并集所有手工模板覆盖范围的汇总。
    ⋃τ∈TSτ\bigcup_{\tau \in \mathcal{T}} \mathcal{S}_{\tau}
  3. 超集关系Ansor 的自动空间包含全部模板空间。
    SAnsor⊇⋯\mathcal{S}_{\text{Ansor}} \supseteq \cdots
  4. 数学保证只要模板能找到的解，Ansor 都能找到；模板之外的结构，Ansor 也照样搜。
    ⊇\supseteq

工程效果：真实厨房里的成绩单

理论再漂亮，终究要在真实厨房里见分晓。Ansor 在 TVM 生态中完成了端到端集成：从 Relay 计算图输入，到算子层自动调优，再到代码生成，全流程无需人工干预。在论文报告的基准测试中，Ansor 在多个模型上超过了手工优化库与 AutoTVM 模板调优方案，尤其在卷积、矩阵乘等核心算子上优势明显。

性能提升可以用加速比来衡量：

除了性能数字，工程上更重要的是调优门槛的下降：无需模板工程师，一只脚本即可对一批算子自动调优；代价模型让大多数候选不必实测，调优时间从数天压缩到数小时；搜索空间自动适配新硬件，为平台快速迭代提供了保障。这些特性使 Ansor 在工业界的训练与推理部署中得到了广泛验证。

回到餐厅的比喻：Ansor 不是某一道菜的冠军菜谱，而是一套能让任何新菜在陌生灶台上快速达到最佳风味的完整方法论。对 AI 编译器而言，这意味着“性能优化”从一门依赖专家经验的手艺，变成了一条可自动运转的流水线——这正是无模板搜索最大的价值所在。

Speedup=TbaselineTAnsor\displaystyle \text{Speedup} = \frac{T_{\text{baseline}}}{T_{\text{Ansor}}}
加速比是基线耗时的倍数，大于 1 表示 Ansor 比基线更快。
  1. 基线耗时默认调度或手工优化库的执行时间，作为对比基准。
    TbaselineT_{\text{baseline}}
  2. Ansor 耗时Ansor 搜索得到的最优调度的执行时间。
    TAnsorT_{\text{Ansor}}
  3. 加速比两者相除得到性能倍数，比如 2.5 就表示快了 2.5 倍。
    Speedup=TbaselineTAnsor\text{Speedup} = \frac{T_{\text{baseline}}}{T_{\text{Ansor}}}

AI 应用场景

新算子自动适配，无需模板工程师

阶段：算子开发与部署

解决的问题：传统 AutoTVM 面对新融合算子（如注意力机制与卷积融合）时，需要专家手工编写调度模板，动辄数周；Ansor 自动从计算表达式生成搜索空间，几小时内就能找到可用调度，彻底解放模板工程师。

具体案例：某推理引擎团队上线视觉大模型，遇到自定义下采样与归一化融合算子。团队用 Ansor 自动采样上千个候选草图与参数组合，经代价模型筛选加真机实测，一个工作日内完成调优，性能超越手工版本 30%。

一次开发，多硬件自动部署

阶段：跨平台部署

解决的问题：同一模型要部署到 NVIDIA GPU、x86 CPU、ARM 开发板，手工调优需要为每个平台重复劳动；Ansor 为每个后端自动生成搜索空间并调优，一套流程覆盖全部平台。

具体案例：自动驾驶算法团队把目标检测模型部署到车载 ARM 平台，用 Ansor 自动搜索分块与向量化参数，相比人工调优提速 2.1 倍，且团队无需深入了解 ARM 汇编细节。

持续集成中的性能守护

阶段：CI/CD 性能回归

解决的问题：模型结构频繁迭代，每次改动都要重新调优，手工方式跟不上节奏；Ansor 将搜索与编译自动接入 CI，每晚自动重新调优并报告性能变化。

具体案例：推荐系统团队在 CI 流水线中加入 Ansor 调优任务，每次模型变更自动生成性能报告，曾及时发现一次算子融合引入的 15% 性能回退，及时回滚避免了线上事故。

Python 演示

python88 行
import random  class Candidate:    # 一个候选程序：结构草图 + 三个可调参数    def __init__(self, sketch, tile, unroll, vec):        self.sketch = sketch        self.tile = tile        self.unroll = unroll        self.vec = vec     def key(self):        return (self.sketch, self.tile, self.unroll, self.vec)  def cost_model(c):    # 代价模型：根据特征预测耗时，值越小越好    base = 100.0    return (base + c.tile * 0.6 + c.unroll * 1.2            - c.vec * 3.0 + abs(c.sketch - 2) * 8.0)  def measure(c):    # 真机实测：在预测值附近加一点随机噪声    return max(cost_model(c) + random.uniform(-2, 2), 1.0)  def sample_space(n):    # 程序采样：生成 n 个候选程序    cands = []    for _ in range(n):        sketch = random.randint(0, 4)        tile = random.randint(4, 64)        unroll = random.randint(1, 8)        vec = random.choice([1, 2, 4, 8])        cands.append(Candidate(sketch, tile, unroll, vec))    return cands  def mutate(c):    # 变异：随机改动一个参数    op = random.randint(0, 3)    if op == 0:        return Candidate((c.sketch + random.choice([-1, 1])) % 5,                         c.tile, c.unroll, c.vec)    if op == 1:        return Candidate(c.sketch,                         max(4, c.tile * random.choice([2, 4])),                         c.unroll, c.vec)    if op == 2:        return Candidate(c.sketch, c.tile, random.randint(1, 8), c.vec)    return Candidate(c.sketch, c.tile, c.unroll,                     random.choice([1, 2, 4, 8]))  def crossover(a, b):    # 交叉：从两个父代各取一部分参数重组    return Candidate(        a.sketch if random.random() < 0.5 else b.sketch,        a.tile if random.random() < 0.5 else b.tile,        a.unroll if random.random() < 0.5 else b.unroll,        a.vec if random.random() < 0.5 else b.vec,    )  def evolve(pool, rounds=30, pop=20):    # 进化搜索主循环    pool = sorted(pool, key=cost_model)[:pop]    best, best_time = None, float("inf")    for _ in range(rounds):        children = [mutate(c) for c in pool]        children += [crossover(pool[i], pool[i + 1])                     for i in range(len(pool) - 1)]        pool = sorted(pool + children, key=cost_model)[:pop]        for c in pool[:3]:            t = measure(c)            if t < best_time:                best_time, best = t, c    return best, best_time  if __name__ == "__main__":    random.seed(42)    cands = sample_space(200)    best, real = evolve(cands)    print("best:", best.key())    print("pred:", round(cost_model(best), 2),          "real:", round(real, 2))
目的：用 200 行不到的 Python 复现 Ansor 的核心思想——程序采样构造搜索空间、代价模型预测耗时、进化搜索加真机实测找最优调度。
  1. class Candidate:定义一个候选程序，包含草图编号、分块大小、展开因子、向量宽度四个属性，对应菜谱的“结构加参数”。
  2. def cost_model(c):模拟代价模型：只用特征算出预测耗时，不真正运行程序，对应大厨的“看一眼菜谱估时间”。
  3. def measure(c):模拟真机实测：在预测值附近加随机噪声，代表真实测量不可避免的波动。
  4. def sample_space(n):程序采样：随机生成 n 个候选，对应 Ansor 首先生成海量搜索空间。
  5. def mutate(c):变异算子：随机改动一个参数，产生一个新候选，对应试菜时微调火候。
  6. def crossover(a, b):交叉算子：从两个父代各取一部分参数重组，对应把两道菜的优点拼在一起。
  7. pool = sorted(pool, key=cost_model)[:pop]按代价模型预测排序并截取前 pop 名，对应“廉价排序器”。
  8. children += [crossover(pool[i], pool[i + 1]) for i in range(len(pool) - 1)]对相邻个体两两交叉，丰富下一代种群。
  9. for c in pool[:3]:只对预测最优的前 3 个做真机实测，把有限测量花在刀刃上。
  10. best, best_time = None, float("inf")初始化最优记录，后续每一轮实测都尝试刷新它。

常见误区

误区Ansor 说不用模板，那不就是把参数随便乱试吗？跟蒙眼猜谜一样，最后全凭运气？

正解Ansor 的“无模板”指不需要人类手工编写调度模板，但搜索空间生成本身高度系统化：先用规则展开产生高质量的“草图”（结构层），再对每张草图做参数注解（参数层），形成分层搜索空间。随机性只出现在部分注解采样中，结构层始终由编译专业知识驱动，绝非盲目乱试。

为何常见：“无模板”字面上容易被理解为“无结构”，实际上没有手工模板不等于没有自动化的结构归纳——就像大厨不用菜谱，但烹饪技法依然有章法。

误区代价模型能预测耗时，那直接相信模型就行，为什么最后还要上真机跑？

正解代价模型只是对真实耗时的近似，误差不可避免。Ansor 的设计是“模型筛、真机定”：先用模型对海量候选做廉价排序，筛出 Top 若干，再在真实设备上实测这些少数候选，并用实测数据更新模型。预测负责排除明显差的选项，真机保证最终答案可信，两者缺一不可。

为何常见：看到“预测”就以为替代了测量，忽略了 Ansor 模型与实测双闭环的设计精髓。

误区自动调优不都是给 GPU 写 kernel 用的吗？CPU 上直接写 C++ 就行，用不上 Ansor。

正解Ansor 的搜索空间生成与后端无关（backend-agnostic）。草图可以表达 CPU 的向量化、多核并行、Cache 分块，也能表达 GPU 的线程绑定、显存共享；论文在 x86 CPU、ARM CPU、GPU 上都验证了显著加速。跨后端复用正是 Ansor 的核心卖点之一。

为何常见：深度学习加速的舆论焦点长期在 GPU，很多人忽略了 TVM 从设计之初就面向多硬件。

误区进化搜索最后不还是随机改动参数吗？多跑几代和穷举有什么区别？

正解进化搜索运行在分层结构化空间上：草图提供合法的高层结构，变异和交叉只在结构内做局部调整；每一代的选择都基于代价模型预测而不是掷骰子，并且用实测反馈修正方向。相比穷举，它在百万级空间里只需几千次评估即可收敛，效率相差几个数量级。

为何常见：只看到变异和交叉中带着随机性，忽视了背后的引导机制和结构约束——随机是手段，结构加引导才是灵魂。

面试题

Q1. Ansor 相对于 AutoTVM 最核心的突破是什么？

单选题 · easy

  • A.把手工模板编写速度提升一倍
  • B.自动生成搜索空间免去手工模板← 正确答案
  • C.用 Python 重写了调度引擎
  • D.把所有算子统一成一种结构

答案：B。Ansor 的突破在于“无模板”：不再需要专家为每个算子和硬件手工编写调度模板，而是由程序采样自动构建搜索空间。A 只是提速模板编写，方向没变；C、D 与 Ansor 核心思想无关。就像大厨不再依赖模板菜谱，而是自己发明菜式。

Q2. Ansor 的两阶段流水线是哪两步？

单选题 · mid

  • A.草图生成与编译优化
  • B.程序采样与性能微调← 正确答案
  • C.特征提取与模型训练
  • D.算子融合与代码生成

答案：B。Ansor 第一阶段是程序采样，负责生成候选程序构成搜索空间；第二阶段是性能微调，用代价模型加进化搜索找最优调度。A、C、D 都只是其中某个环节的局部技术，不能概括整体流水线。

Q3. 程序采样阶段中的“草图”指的是什么？

单选题 · mid

  • A.算子的输入输出张量形状
  • B.顶层循环结构的高层框架← 正确答案
  • C.神经网络的可视化结构图
  • D.编译器的中间表示代码

答案：B。草图是 Ansor 对计算表达式做规则展开后得到的顶层循环结构，例如多层分块、算子融合、虚拟线程等，相当于大厨先决定“炒还是炖”。张量形状是输入信息，可视化图和中间表示都与草图无关。

Q4. Ansor 代价模型的功能包括哪些？

多选题 · mid

  • A.预测候选程序的执行时间← 正确答案
  • B.对海量候选进行廉价排序← 正确答案
  • C.代替真机完成最终评测
  • D.利用实测数据迭代更新← 正确答案

答案：ABD。代价模型基于特征预测耗时，并据此对海量候选排序以筛掉绝大多数差的方案，同时用真机实测数据不断迭代更新参数。但它不会代替真机——最终结论必须由真实设备测量确认，这等于“大厨的直觉不能替代尝菜”。

Q5. 为什么 Ansor 的搜索空间能覆盖手工模板空间？

单选题 · hard

  • A.草图展开涵盖模板的所有结构← 正确答案
  • B.代价模型比模板特征更精确
  • C.进化搜索会访问全部候选点
  • D.采样数量远多于模板枚举

答案：A。Ansor 的草图生成规则（多层分块、融合、虚拟线程等）本身就涵盖了模板能表达的结构模式，注解参数范围也覆盖模板的参数范围，因此搜索空间是模板空间的超集。代价模型精度、采样数量都不是覆盖的原因，进化搜索也不可能访问全部候选点。

Q6. 进化搜索中的“变异”通常改变什么？

单选题 · mid

  • A.目标硬件的功耗和频率
  • B.分块大小展开因子等参数← 正确答案
  • C.算子内部的数学定义
  • D.输入张量存储的具体数值

答案：B。变异是在候选程序的参数层做局部扰动，比如调整分块大小、展开因子或向量宽度，偶尔也改变低层结构。它不触碰硬件配置、算子数学定义或数据内容，就像大厨试菜只调整火候和用量，不会重写食材本身。

Q7. 下列哪些是 Ansor 支持的硬件后端？

多选题 · easy

  • A.NVIDIA GPU 显卡← 正确答案
  • B.ARM 移动端 CPU← 正确答案
  • C.x86 桌面 CPU← 正确答案
  • D.手工计算推导耗时

答案：ABC。Ansor 的搜索空间生成与后端无关，草图能表达 GPU 的线程绑定与共享内存，也能表达 CPU 的向量化与多核并行，实验覆盖了 x86、ARM 与 GPU。D 是干扰项，手工计算不属于任何硬件后端。

Q8. Ansor 中最终确定最优程序的标准是什么？

单选题 · mid

  • A.代价模型给出的预测分数
  • B.在真实设备上的实测耗时← 正确答案
  • C.程序源代码的行数最少
  • D.编译阶段用时最短最快

答案：B。代价模型只负责筛选和排序，最终胜出者必须在真实设备上实测确认，实测耗时才是唯一裁判。代码行数和编译速度与算子执行性能无关，预测分数也只是候选依据而非最终结论。

Q9. 代价模型的训练数据来源于哪里？

单选题 · easy

  • A.专家手工标注的性能数据
  • B.真实设备实测获得的耗时← 正确答案
  • C.理论浮点运算次数折算
  • D.公开数据集中的历史记录

答案：B。Ansor 在搜索过程中不断在真实设备上测量少数候选，把“程序—实测耗时”作为标注样本喂给代价模型，实现迭代更新。模型要预测的是真实执行时间，因此必须用真实测量来训练，而不是靠人工标注或理论折算。

Q10. 关于 Ansor 的正确说法有哪些？

多选题 · hard

  • A.搜索空间由系统自动生成← 正确答案
  • B.进化搜索依赖代价模型引导← 正确答案
  • C.调优全过程不需要真机介入
  • D.分层调度解耦结构与参数← 正确答案

答案：ABD。程序采样自动生成搜索空间，进化搜索每代都按代价模型预测排序选择个体，草图与注解的分层设计把结构决策和参数决策解耦。C 错误：虽然代价模型筛掉了绝大多数候选，但最终少量候选必须真机实测，并用实测数据反馈模型。