大模型生成文字，就像施工队拿到一张建筑图纸：模型脑子里装的不是一个现成答案，而是一张“概率图纸”——它只告诉你下一个词大概是谁、什么风格。真正把图纸变成一句完整的话，要靠解码（decoding）这个施工环节。施工队有两种干法。自回归解码像传统砌砖：师傅拿着一层层往上盖，砌第 3 层之前一定要先看第 2 层真实砌出来的样子，所以工序一环扣一环，稳当但费时。非自回归解码像预制装配式施工：先在工厂按统一设计图批量生产每一面墙、每一块楼板，运到现场用吊车一天之内全部就位，速度快得惊人——但如果你把总楼层数（目标序列长度）猜错了，或者墙与墙之间的接缝对不齐，整栋楼就会出现裂缝。本文用“盖房子”这个比喻贯穿始终：先看两边各自怎么“施工”，再对比工期与质量，最后给你一张选型清单——什么时候逐层砌，什么时候装配拼装，什么时候两者混着来。

岗位关联

掌握两种解码路线的优劣对比和选型逻辑，你就能在大模型推理加速的技术评估中快速判断该上哪种方案：既保住生成质量，又把延迟和算力成本稳稳压下来。这是推理优化工程师的核心判断力。

目录
  1. 可视化演示
  2. 任务与瓶颈
  3. 自回归原理
  4. 非自回归原理
  5. 并行度对比
  6. 质量效果对比
  7. 选型决策指南
  8. 混合前沿方案
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

交互式对比自回归解码与非自回归解码的核心差异，展示串行生成与并行生成的速度-质量权衡，以及Speculative Decoding等混合策略如何兼顾效率与准确性。

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

自回归解码 逐个token生成，每个token依赖前序所有token 生成质量高，但速度慢（O(n)步） 适合对质量要求高的任务（翻译、摘要）

任务与瓶颈

大模型拿到你的问题 X 后，脑子里装的其实不是一个现成答案，而是一张“概率图纸”——它知道下一个词可能是什么、大概什么风格。真正把图纸变成一句完整的话，靠的就是解码。想象甲方递来一栋楼的设计图，施工队要做无数个决策：墙往哪砌、门开在哪、楼层多高，每个决策都对应着一次“词的选择”。

解码的本质是在词表组成的巨大空间里搜索最可能的那条输出序列。模型每算一步，只会给出“下一个位置各候选词的概率分布”，并不会一次性吐出一整句话。这让推理阶段的耗时和序列长度强相关——句子越长，要做的串行决策越多。GPU 算得再快，也躲不开“一步等一步”的物理上限，这就是推理加速要解决的核心瓶颈。

根据“一次生成几个词、要不要等前文”，解码策略分成两大流派：自回归像一层层砌砖，非自回归像预制装配。下面四节，我们分别看它俩怎么施工、快多少、稳不稳，最后拿出选型清单做决策。

施工方式决定了工期和验收质量。理解了“解码 = 在概率图纸上施工”，后面再看 AR 与 NAR 的原理，就只是在看两种不同的施工队手册了。

Y^=arg⁡max⁡YP(Y∣X)\displaystyle \hat{Y} = \arg\max_{Y} P(Y \mid X)
解码就是要在所有可能的输出序列里，找到让条件概率最大的那一条序列 Y。
  1. 条件分布 P(Y|X)给定输入 X 后，模型为每条可能的输出序列 Y 打分。先看 X 再谈输出，这和盖房子前必须先看甲方给的图纸是一个道理。
    P(Y∣X)P(Y \mid X)
  2. 目标序列 YY 是一串词 y₁, y₂, …, y_N，序列里每个位置对应房子的每一层，顺序本身就有意义。
    Y=y1y2⋯yNY = y_1 y_2 \cdots y_N
  3. argmax 搜索在所有候选序列里挑概率最大的那条。候选数量是词表大小的 N 次方，根本没法穷举，于是才需要各种解码策略来近似搜索。
    Y^=arg⁡max⁡YP(Y∣X)\hat{Y} = \arg\max_{Y} P(Y \mid X)

自回归原理

传统砌砖法讲究“一层一世界”。老师傅砌第 3 层砖时，一定要先看看第 1、2 层真实砌出来的样子——第 2 层的墙稍微偏了，第 3 层就得跟着调整。自回归解码就是这个思路：生成第 t+1 个词之前，把已经生成的前 t 个词全部当成已知条件，一步一个脚印往前走。

数学上，自回归用链式法则把整句概率拆成一步步条件概率的乘积：第 1 个词只看输入 X，第 2 个词看 X 和第 1 个词，第 3 个词看 X 和前两个词……每一部“续写”都在已知前文的框架下做选择。这种概率分解不是近似，而是对联合分布的精确展开。

这个特性带来两个直接结果。一是生成质量有保障：上下文天然连贯，不会写出“我很好快”这种句子。二是串行执行：第 t 步没算完，第 t+1 步永远不能开工。GPU 再快，也只能等前一步的真实结果落地，就像再快的吊车也得等混凝土干透才能吊下一层。

砌砖法稳，但慢。如果一层楼要浇 50 天，盖 50 层就得 2500 天——这正是自回归在大模型推理中的真实瓶颈，也是所有加速方案要撬动的那块最硬的石头。

P(Y∣X)=∏t=1NP(yt∣y<t,X)\displaystyle P(Y \mid X) = \prod_{t=1}^{N} P(y_t \mid y_{<t}, X)
自回归把整句概率拆成“已知前文、预测下一词”的连乘，每一步都依赖前面所有真实输出。
  1. 第 t 个词 y_t序列中的第 t 个位置，代表“当前正在盖的这一层”。自回归强调顺序，每个词的位置不能乱。
    yty_t
  2. 前文 y_{<t}前 t−1 个已生成的词。砌第 3 层砖时，第 1、2 层已经真实存在，这就是“已知前文”的含义。
    y<t=y1,y2,…,yt−1y_{<t} = y_1, y_2, \dots, y_{t-1}
  3. 连乘 ∏把每个位置的条件概率全部乘起来得到整句概率。乘积结构说明每一步都不能跳步，跳一步整句概率就错了。
    ∏t=1NP(yt∣y<t,X)\prod_{t=1}^{N} P(y_t \mid y_{<t}, X)

非自回归原理

预制装配式施工换了个思路：先在工厂按统一设计图批量生产每一面墙、每一块楼板——它们互不打听邻居长什么样——运到现场后用吊车同一天内全部就位。非自回归解码同样“批量生产”：所有位置的词一次性并行生成，谁也不用等谁。

数学上，NAR 把整句概率近似为每个位置在给定输入 X 下的条件概率乘积，直接丢掉 y_{<t} 前缀依赖。为了让这个近似可用，它还需要一个前置环节：目标长度预测。就像装配式施工必须先确定总楼层数，才能决定生产多少块预制板；长度猜错，所有构件都得重做。常见做法是训练一个轻量分类头先预测序列长度 N，再构造 N 个位置的并行解码。

实际落地时，CTC（连接时序分类）和掩码语言模型式训练都是这类思路的典型实现：模型学着从输入直接预测整句，而不是从左到右逐字续写。代价也很直白——每个位置的选择都“闭着眼”，不看邻居。

装配法快得惊人——一栋楼的主体一天立起来。但代价也显而易见：每块板之间没有咬合，接缝质量全凭运气。下一节我们就看看这个“运气”到底差多少。

P(Y∣X)≈∏t=1NP(yt∣X)\displaystyle P(Y \mid X) \approx \prod_{t=1}^{N} P(y_t \mid X)
非自回归假设每个输出位置只依赖输入 X，互相独立，因此所有位置可以同时计算。注意这里是近似等号，不是精确等式。
  1. 去掉前文条件每个 y_t 只依赖输入 X。工厂里每一块预制板都按同一份总设计图生产，彼此不打听邻居。
    P(yt∣X)P(y_t \mid X)
  2. 近似等号 ≈这是对真实分布的简化假设，而不是精确成立。它丢掉了词与词之间的依赖信息。
    ≈\approx
  3. 可并行的乘积N 个条件是互相独立的，可以同时计算。一次前向推理就能拿到全部位置的结果。
    ∏t=1NP(yt∣X)\prod_{t=1}^{N} P(y_t \mid X)

并行度对比

把两条施工线放到同一个工地看工期：AR 是 N 个工作日逐层砌筑，NAR 是 1 个工作日吊装完毕。理想状态下，NAR 的加速比约等于序列长度 N，这就是它最诱人的地方。

但“并行度”要分两层看。GPU 层面，一次前向推理本身就能并行处理很多位置的计算，NAR 把这个能力吃满；AR 却因为每个位置依赖前序真实输出，只能把并行能力用在“同一步里的一个词”上。批量层面，AR 可以同时对多条序列求并行来提升吞吐，但单条序列的延迟仍然串行累积，用户感受到的“首字到整句的时间”并没有变短。

工程上还要计入长度预测、显存调度等固定开销 c。理论上 NAR 一步出结果，实际延迟 = 一次前向 + c；AR 延迟 = N 次前向累加。两条路线的延迟差距随 N 增大越拉越大，这正是机器翻译、语音合成等行业选择 NAR 的根本动力。

一句话总结并行度：NAR 赢在“少跑很多趟”，AR 输在“每趟都省不掉”。但快不等于好——接下来“验收”会揭穿装配式房子的裂缝。

S=N⋅ττ+c≈N\displaystyle S = \frac{N \cdot \tau}{\tau + c} \approx N
理想加速比约等于序列长度 N：自回归要串行 N 步，非自回归只需一步加上少量固定开销。
  1. 分子 N×τ自回归要串行走 N 步，每步一次前向推理耗时 τ，总工期是单步时间的 N 倍。
    N×τN \times \tau
  2. 分母 τ + c非自回归只做一次前向推理就能产出所有位置。τ 是这次前向的时间，c 是长度预测、拼装调度等额外开销。
    τ+c\tau + c
  3. 理想加速比 ≈ N序列越长、开销 c 越小，加速越接近 N 倍。工程中质量补偿和迭代轮次会让实际加速打折。
    S≈NS \approx N

质量效果对比

房子立起来了，开始收房验质量。逐层砌的 AR 楼，每一层都根据真实下层施工，墙面垂直、管线对齐；装配式的 NAR 楼，预制板之间常有裂缝——反映到文本里就是“我 好 快 的”这种读不通的句子。

原因在于条件独立假设丢了词间依赖。真实语言里，“很”后面大概率是“好”，但在 NAR 看来，“很”和“好”是各自独立选的，于是经常出现重复、语序错乱、前后矛盾。另一个典型问题是重复词堆积：每个位置都倾向选高频词，导致一串“好的好的好的”，就像整栋楼都用同一块预制板拼出来的。

于是工程上发展出各种“装修补偿”手段：迭代精炼（装配完让监理一轮轮检查修补）、知识蒸馏（让 NAR 学生模型模仿 AR 教师模型的输出分布）、半自回归分块（小块内保留依赖）。这些手段用额外时间换质量，把 NAR 从“不能看”拉回“能商用”。但装修能遮裂缝，遮不住结构本身的差距。

质量差距的本质是近似误差：条件独立的乘积永远不等于真实联合概率。装修能遮裂缝，但结构隐患还在——这也决定了两种路线各自的用武之地。

Δ=P(y1,…,yN∣X)−∏t=1NP(yt∣X)\displaystyle \Delta = P(y_1, \dots, y_N \mid X) - \prod_{t=1}^{N} P(y_t \mid X)
Δ 表示“真实联合概率”与“独立假设概率”之间的误差，词间依赖越强，这个洞越大。
  1. 真实联合概率左边是词与词相互影响下的真实概率，代表“好房子”应该有的整体结构，所有楼层协同受力。
    P(y1,…,yN∣X)P(y_1, \dots, y_N \mid X)
  2. 独立假设概率右边按条件独立假设算出的概率，词之间不协作，接缝处容易开裂。
    ∏t=1NP(yt∣X)\prod_{t=1}^{N} P(y_t \mid X)
  3. 误差 Δ两者之差衡量近似的失真。词间依赖越强（比如“很”后面常接“好”），Δ 越大，质量损失越明显。
    Δ=P真实−P独立\Delta = P_{\text{真实}} - P_{\text{独立}}

选型决策指南

甲方需求永远决定施工方案。赶工期的售楼处样板间，用装配式；要拿奖的地标建筑，老老实实逐层砌。大模型解码选型也一样，先问两个问题：延迟能不能忍？质量让不让步？

延迟敏感、输出偏短、语义依赖弱的场景——实时语音合成、短句翻译、关键词抽取——NAR 一马当先。质量优先、输出很长、强语义场景——开放域对话、长文写作、代码生成——AR 依然是事实标准。长度可控是另一个关键信号：固定长度的任务（语音帧、定长短语）天然适合 NAR，因为长度预测的不确定性被任务本身消除了。

还有一个量化判据：当输出长度 N 超过某个阈值后，NAR 的延迟优势才明显。短到几个词时，NAR 的长度预测和调度开销反而可能让两者打平甚至更慢。工程上常用小流量灰度对比真实延迟与质量分，再决定是否切换，而不是拍脑袋选型。

说到底，选型不是“哪个好”，而是“哪个更贴需求”。把延迟预算、质量底线、长度分布三个参数摆上桌，答案自然会浮现出来。

τNAR<τAR  ⟺  N>1+cτ\displaystyle \tau_{NAR} < \tau_{AR} \iff N > 1 + \frac{c}{\tau}
非自回归占优的条件是序列长度 N 足够大。N 越大，NAR 省下的串行步数越多。
  1. 自回归延迟 τ_AR = N·τ总延迟是 N 次前向推理累加，序列越长等待越久。
    τAR=N⋅τ\tau_{AR} = N \cdot \tau
  2. 非自回归延迟 τ_NAR = τ + c约等于一次前向加上少量固定开销，与序列长度几乎无关。
    τNAR=τ+c\tau_{NAR} = \tau + c
  3. 阈值条件当 N 超过 1 + c/τ 时，NAR 开始占优；短序列两者差距不大，甚至 AR 更省心。
    N>1+cτN > 1 + \frac{c}{\tau}

混合前沿方案

聪明的施工队开始混合作战：先用一夜把预制主体立起来，再让监理逐层验收、局部返工，最终交付的房子又快又体面。迭代式 NAR 就是这条路：先并行生成初稿，再反复做“检查—修正”。

迭代式 NAR 每轮都把所有位置重新预测一遍，第 i+1 轮能看到第 i 轮的完整输出，相当于把 AR 的时序依赖“复制”进多轮并行里。轮数 K 是速度与质量的旋钮：K=1 接近纯 NAR，K 增大逐步逼近 AR。半自回归则换了个切法——把序列切成块，块内用自回归保证连贯、块间用并行抢时间，两边各取一半。

知识蒸馏做的是“师带徒”：让一个 NAR 小模型去拟合 AR 大模型的输出分布，把难以学到的词间依赖压缩进先验。三种方案不是互斥的，工业界常常组合使用，例如“长度预测 + 迭代精炼 + 蒸馏”三件套，几乎能把 NAR 质量拉到接近 AR，同时保留大部分速度优势。

混合方案展示了工程的美感：不执著于某一种施工法的纯粹，而是把“快”和“稳”拧成一股绳。合上图纸你会发现，解码选型永远是在时间、质量、成本之间画那条最舒服的曲线。

Titer=K⋅(τ+c)≪N⋅τ\displaystyle T_{\text{iter}} = K \cdot (\tau + c) \ll N \cdot \tau
迭代式非自回归的时间 = 每轮一次并行前向 × K 轮。只要轮数 K 远小于序列长度 N，就仍然比自回归快。
  1. K 轮迭代迭代式 NAR 每轮做一次并行前向，共做 K 轮，质量随轮数提升。K 就是“监理验收了几轮”。
    Titer=K⋅(τ+c)T_{\text{iter}} = K \cdot (\tau + c)
  2. 对比自回归右边 N·τ 是自回归的串行总时间。只要 K 明显小于 N，左边就远小于右边。
    K⋅(τ+c)≪N⋅τK \cdot (\tau + c) \ll N \cdot \tau
  3. 工程平衡点K 一般从 1 调到 10 以内，“修补轮数”越多越接近 AR 质量，这给了工程师一个调节速度与质量的旋钮。
    K∈[1,10]K \in [1, 10]

AI 应用场景

智能客服对话生成（质量优先 → 自回归）

阶段：在线推理 / 流式解码

解决的问题：客服回复必须语义连贯、不能答非所问。若用 NAR 一次吐出整句，经常出现“我 好 快 的”这类接缝错乱的机器味句子；AR 逐词生成能持续参考前文，保证上下文一致。

具体案例：某电商平台的售后机器人把回复解码从 NAR 换成 AR 流式输出后，用户满意度从 68% 提到 82%，虽然单句延迟多了几十毫秒，但对话轮次明显减少，整体体验反而更好。

机器翻译批量流水线（吞吐优先 → 非自回归）

阶段：离线批量推理

解决的问题：跨境电商每天要翻译几十万条商品短标题，AR 要串行跑几十步，GPU 利用率低。NAR 一次前向产出整句，把“一层层砌”改成“吊装拼装”，吞吐量提升数倍。

具体案例：某出海电商团队对长度 ≤ 12 的短语启用 NAR 解码，配合一轮迭代精修，吞吐提升 4 倍，BLEU 只降 0.8，完全在业务可接受范围内。

语音合成与实时字幕（延迟敏感 → 非自回归/混合）

阶段：流式生成 / 端到端合成

解决的问题：语音的每一帧如果都串行生成，人会感到明显卡顿；NAR 把整个音频帧序列一次性并行合成，再配合迭代精修保证音高连贯，兼顾速度与自然度。

具体案例：某语音助手 TTS 模块改用并行合成路线后，单句合成延迟从 300ms 降到 80ms，用户跟读体验显著改善。

Python 演示

python72 行
import randomimport time # simulate one GPU forward pass; cost grows weakly with token countdef forward_pass(tokens):    time.sleep(0.002 + tokens * 0.0001)  VOCAB = ["I", "love", "AI", "study", "very", "good", "fast", "and"] # frequent adjacent pairs, used to measure generation quality roughlyNATURAL_PAIRS = {    ("I", "love"), ("love", "AI"), ("study", "AI"), ("AI", "very"),    ("very", "good"), ("good", "and"), ("fast", "and"),}  def sample_token(prev):    # a tiny bigram-style model: P(next | prev)    if prev == "I":        return random.choice(["love", "study"])    if prev in ("love", "study"):        return random.choice(["AI", "very"])    if prev == "AI":        return random.choice(["very", "good"])    if prev == "very":        return random.choice(["good", "fast"])    if prev in ("good", "fast"):        return random.choice(["and", "I"])    return random.choice(VOCAB)  def consistency(seq):    ok = 0    for a, b in zip(seq, seq[1:]):        if (a, b) in NATURAL_PAIRS:            ok += 1    return ok / max(len(seq) - 1, 1)  def ar_decode(length):    seq = ["I"]    while len(seq) < length:        forward_pass(len(seq))    # serial: one forward per token        seq.append(sample_token(seq[-1]))    return seq  def nar_decode(length):    forward_pass(length)          # parallel: one forward for all tokens    seq = ["I"]    for _ in range(length - 1):        seq.append(random.choice(VOCAB))    return seq  def elapsed(fn):    t0 = time.time()    fn()    return (time.time() - t0) * 1000  if __name__ == "__main__":    random.seed(1)    for n in (4, 8, 16):        t_ar = elapsed(lambda: ar_decode(n))        t_nar = elapsed(lambda: nar_decode(n))        print(f"length {n:2d}: AR {t_ar:6.2f} ms | NAR {t_nar:6.2f} ms | speedup {t_ar / t_nar:5.1f}x")    s_ar = ar_decode(8)    s_nar = nar_decode(8)    print("AR  sample:", " ".join(s_ar), "| consistency %.2f" % consistency(s_ar))    print("NAR sample:", " ".join(s_nar), "| consistency %.2f" % consistency(s_nar))
目的：用一个小型模拟实验对比自回归与非自回归两种解码路线在“耗时”和“连贯度”上的差异，直观验证正文中的加速比与质量损失结论。
  1. def forward_pass(tokens):用 sleep 模拟一次 GPU 前向推理，token 越多耗时略增，体现“一次前向成本近似固定”。
  2. while len(seq) < length:自回归的串行主循环：没凑够长度就继续，每轮只前进一个词。
  3. seq.append(sample_token(seq[-1]))新词只由序列末尾的前文决定，等价于条件概率 P(y_t | y_{<t})。
  4. forward_pass(length)非自回归只调用一次前向，就把整个长度 N 的位置全部算完。
  5. seq.append(random.choice(VOCAB))每个位置独立抽样，等价于条件独立假设 P(y_t | X)。
  6. consistency(seq)统计相邻词对落在常见搭配里的比例，粗略量化“接缝质量”。
  7. elapsed(fn)统一计时，公平对比两种路线在同一输出长度下的耗时。

常见误区

误区“非自回归一次推理出 N 个词，速度应该是自回归的 N 倍吧？那以后全用 NAR 不就完了。”

正解理论加速比 S ≈ N 建立在“零额外开销、零质量补偿”的理想工地上。现实中有长度预测、显存调度，还有为了保质量而加的迭代修补轮，实际加速常见在 2~5 倍。就像装配式楼房虽然快，但入场运输、吊装调度、接缝修补都要算进工期。

为何常见：人们习惯拿理想公式直接套工程现实，忽略了公式里的 c 和 K 这些隐藏开销项。

误区“非自回归生成的东西读不通，肯定只能发论文，上不了线。”

正解NAR 在短句机器翻译、语音合成、关键词抽取等场景已经大规模商用。质量短板主要集中在长序列和强语义依赖场景；用迭代精炼、知识蒸馏、半自回归组合后，质量可拉到接近 AR，速度仍明显占优。装修差的房子重新装好再住，不代表预制房不能住人。

为何常见：拿长文本生成的最坏情况代表所有场景，犯了以偏概全的错误。

误区“自回归模型和非自回归模型，应该是两套不同的网络结构吧？”

正解两者常常是同一个 Transformer 骨架，区别在解码时的依赖关系和训练目标。AR 训练时用前文预测下一个词；NAR 训练时用掩码或 CTC 目标学习从输入直接预测整句。可以说是同一批工人换了两种施工法，而不是换了一家公司。

为何常见：“自回归/非自回归”听起来像模型家族的叫法，实际上它们描述的是解码策略，而不是网络结构。

误区“GPU 有几千个核心，让每个核心生成一个词不就行了？”

正解自回归的每个新词都依赖之前所有词的真实输出，这是数据依赖，不是算力问题。GPU 能并行的是矩阵运算和 batch 内多条序列，但单条序列内部的 token 必须串行等待。再多的工人，第 3 层也要等第 2 层混凝土干透才能开工。

为何常见：混淆了“计算并行”与“数据依赖”，以为硬件算力能打破依赖关系。

面试题

Q1. 自回归解码最核心的执行特征是？

单选题 · easy

  • A.一次并行生成全部 token
  • B.逐 token 串行生成且依赖前序← 正确答案
  • C.随机乱序生成后再排序
  • D.只依赖输入与位置无关

答案：B。自回归就是“已知前文、预测下一个”，每一步都依赖前面所有真实输出，因此必须串行。选项 A 是非自回归，C 不存在这种解码方式，D 是条件独立假设的简化描述。

Q2. 非自回归解码的核心近似假设是？

单选题 · mid

  • A.所有 token 的出现概率相等
  • B.给定输入后 token 间条件独立← 正确答案
  • C.token 间完全独立互不影响
  • D.序列长度必须固定为一

答案：B。NAR 假设 P(Y|X) ≈ ∏ P(yₜ|X)，即给定输入 X 后，各位置互相独立（条件独立）。“完全独立”丢掉了 X 这个前提，“概率相等”和“长度固定为 1”都不是领域内的近似假设。

Q3. 理想情况下 NAR 相对 AR 的加速比约为？

单选题 · mid

  • A.与序列长度 N 成正比，约 N 倍← 正确答案
  • B.恒定 2 倍加速
  • C.与词表大小成正比
  • D.与 batch size 成反比

答案：A。AR 串行 N 步、NAR 一步到位，理想加速比 S = N·τ/(τ+c) ≈ N。词表大小和 batch size 虽然影响单次前向速度，但不决定两者之间的相对加速比。

Q4. 非自回归解码常见的质量短板有哪些？

多选题 · mid

  • A.上下文连贯性较差← 正确答案
  • B.容易重复和语序错乱← 正确答案
  • C.生成速度太慢
  • D.对目标长度预测敏感← 正确答案

答案：ABD。NAR 丢失词间依赖，导致连贯性差、重复堆积、语序错乱；长度预测决定“做多少块预制板”，猜错整句崩盘。速度慢是 AR 的短板，不是 NAR 的。

Q5. 为什么 NAR 必须先预测目标长度？

单选题 · hard

  • A.因为并行位置数需要事先确定← 正确答案
  • B.因为词表会随长度动态变化
  • C.因为注意力矩阵必须保持方形
  • D.因为损失函数需要固定维度

答案：A。NAR 是一次性并行生成，必须事先知道生成几个位置才能构造解码空间，就像装配式施工必须先知道总层数才能备料。词表大小、注意力形状都不依赖序列长度。

Q6. 下列哪些是常用的 NAR 质量补偿手段？

多选题 · hard

  • A.迭代式精炼反复重写← 正确答案
  • B.用自回归输出做知识蒸馏← 正确答案
  • C.把 batch size 调到极大
  • D.半自回归分块生成← 正确答案

答案：ABD。迭代精炼用多轮并行修补接缝，蒸馏让 NAR 学生模仿 AR 教师，半自回归在块内保留依赖。调大 batch 提升的是吞吐，不是单句质量，属于并行度层面的手段。

Q7. 质量优先的开放域对话生成通常选择哪种解码？

单选题 · easy

  • A.非自回归解码
  • B.自回归解码← 正确答案
  • C.随机采样零解码
  • D.贪心零步解码

答案：B。开放域对话需要强语义连贯和上下文一致，AR 逐词生成能持续参考前文，是事实标准。NAR 的接缝问题在这种长语义场景最容易暴露。

Q8. 半自回归解码中的“半”指的是？

单选题 · mid

  • A.只生成序列的前一半内容
  • B.以块为单位，块内自回归、块间并行← 正确答案
  • C.一半概率走并行一半走串行
  • D.模型参数量减半

答案：B。半自回归把序列切成块，块内保留完整的自回归依赖以保证连贯，块与块之间并行生成来抢时间。“半”指的是在串行与并行之间取折中，与参数数量或概率无关。

Q9. 上一轮的输出还没算完，下一轮能否提前开工？

单选题 · easy

  • A.可以，GPU 会自动并行
  • B.必须等上一轮结果，存在数据依赖← 正确答案
  • C.取决于 batch 大小
  • D.取决于词表大小

答案：B。自回归的每一个新词都依赖前面所有词的真实输出，这是数据依赖。GPU 能并行矩阵运算，但打破不了“下一层必须等这一层”的施工顺序。

Q10. 在延迟敏感且质量要求也不低的场景，工程上通常怎么做？

多选题 · hard

  • A.用迭代式 NAR 先出初稿再精修← 正确答案
  • B.流式输出让首 token 尽早到达← 正确答案
  • C.用知识蒸馏让小模型提速← 正确答案
  • D.放弃解码直接返回模板

答案：ABC。迭代式 NAR 用少量轮次换接近 AR 的质量，流式输出降低首字延迟，蒸馏用小模型逼近大模型，三者可组合使用。直接返回模板等于放弃生成能力，不是工程方案。