---
tags: [AI, 生成, 采样]
阶段: 05-Transformer与LLM原理
难度: ★★☆
created: 2026-10-18
related: "[[Transformer架构详解]], [[GPT系列架构]], [[KV缓存]]"
---

# 自回归生成与采样

## 定义

**自回归生成**（autoregressive generation）指用一个已训练的条件分布 $p_\theta(x_t\mid x_{<t})$ 反复作用于不断增长的前缀，依次抽取 $x_1,x_2,\dots,x_T$，从而得到联合分布

$$ p_\theta(x_{1:T})=\prod_{t=1}^{T}p_\theta(x_t\mid x_{<t}) $$

的一个样本的过程；**解码策略**（decoding strategy，亦称采样策略）指把第 $t$ 步的 logits 向量映射为"取哪个 token"的规则，它在模型分布 $p_\theta$ 之上引入一个替代分布 $\pi_t$ 或一个确定性选择函数。

符号约定如下。

| 符号 | 含义 |
|---|---|
| $T$ | 生成序列长度，即条件分布的相乘次数 |
| $x_t$ | 第 $t$ 个 token 的取值，取自词表 $\mathcal{V}$ |
| $x_{<t}$ | 前缀 $(x_1,\dots,x_{t-1})$，$t=1$ 时为空 |
| $\mathcal{V}$、$V$ | 词表与词表大小，$V=\lvert\mathcal{V}\rvert$ |
| $\mathbf{z}_t\in\mathbb{R}^{V}$ | 第 $t$ 步的 **logits**，即输出投影在 softmax 之前的实数向量 |
| $p_t$ | 经 softmax 后的条件分布，$p_t=\mathrm{softmax}(\mathbf{z}_t)$ |
| $\tau$ | **温度**（temperature），正实数。文献常用 $T$ 表示，本篇改用 $\tau$ 以免与序列长度冲突 |
| $\pi_t$ | 解码策略实际使用的采样分布，一般 $\pi_t\neq p_t$ |
| $k$ | top-k 采样的保留个数 |
| $\rho$ | top-p（核采样）的累积概率阈值，文献常记作 $p$ |
| $\gamma$ | 重复惩罚系数，$\gamma>1$ |
| $\alpha_p$、$\alpha_f$ | presence penalty 与 frequency penalty 的强度 |
| $s(Y)$ | 候选序列 $Y$ 的打分，束搜索用 $\log p_\theta(Y)$ 或其长度归一化形式 |
| $b$ | 束宽（beam size），束中同时保留的候选数 |
| $\alpha$ | 长度归一化指数，$\alpha=1$ 时打分等于平均对数概率 |
| $L$ | 解码器层数，决定每步前向的计算量与参数量 $N$ |

其余术语在正文首次出现处定义：**教师强制**（teacher forcing）指训练时以数据中的真实前缀作为条件，而不是以模型自己生成的 token 作为条件；**曝光偏差**（exposure bias）指训练与推理所面对的前缀分布不一致；**束**（beam）指束搜索同时维护的 $b$ 条部分序列；**核**（nucleus）指 top-p 采样保留的最小高概率 token 集合。

## 为什么重要

生成是语言模型推理中必须串行的环节，它的代价与质量都由本篇的两个对象决定：每步的条件分布，以及从该分布取 token 的规则。

第一项后果是延迟与成本。参数量为 $N$ 的模型处理一个 token 的前向计算量约为 $2N$ 次浮点运算，生成 $T$ 个 token 需要 $T$ 次这样的前向，且第 $t$ 步必须等第 $t-1$ 步的输出，无法并行。以 GPT-3 175B 为例，$2N\approx3.5\times10^{11}$，生成 500 个 token 约需 $1.75\times10^{14}$ 次浮点运算；若不做 KV 缓存，每步还要重算整个前缀的注意力，总代价从 $O(T^{2})$ 上升到 $O(T^{3})$，见 [[KV缓存]]。采样策略在这条链上不改变计算量，但 top-k、top-p 与重复惩罚都要遍历词表，属于每步的固定开销。

第二项后果是输出分布。同一模型、同一提示，贪心解码给出确定且常陷入循环的结果；温度提高后多样性上升而事实一致性下降。生产系统的 `temperature`、`top_p` 参数是直接面向用户的质量开关，而不是实现细节。评测同样受影响：生成式任务的指标对解码配置敏感，报告结果时必须同时报告温度、top-k/top-p、束宽与最大长度，否则结果不可复现。

在本库中的位置：[[Transformer架构详解]] 说明 logits 如何由 $L$ 层解码器产生，本篇说明 logits 如何变成 token；[[因果注意力与多头注意力]] 的掩码保证训练时一次前向可以并行计算 $T$ 个位置，这是训练与推理不对称的来源；[[GPT系列架构]] 的零样本与上下文学习行为要在固定的解码策略下比较才有意义；[[从零实现小型GPT指南]] 的采样函数按本篇第 6 至 8 节实现；[[Prompt工程]] 中的参数建议以本篇的分布分析为依据。对应学习目标中的"懂原理"与"会评估"：能推导温度与 top-p 的分布变化，能判断一个生成结果异常来自模型还是解码配置。

## 原理与推导

### 1 链式分解：逐位生成的合法性

对任意联合分布，概率的乘法公式给出

$$ p(x_{1:T})=p(x_1)\,p(x_2\mid x_1)\cdots p(x_T\mid x_{1:T-1})=\prod_{t=1}^{T}p(x_t\mid x_{<t}). $$

该分解不依赖任何独立性假设，只要求条件分布有定义。语言模型的做法是只参数化右侧的每个条件因子：把 $x_{<t}$ 送入因果掩码的 Transformer，取最后一个位置的隐藏状态 $\mathbf{h}_t\in\mathbb{R}^{d}$，经输出投影得到

$$ \mathbf{z}_t=\mathbf{W}_o\mathbf{h}_t+\mathbf{b}_o,\qquad p_\theta(x_t=v\mid x_{<t})=\frac{\exp(z_{t,v})}{\sum_{u\in\mathcal{V}}\exp(z_{t,u})}. $$

逐位采样的正确性可由归纳说明。设前 $t$ 个位置已按 $\prod_{s\le t}p(x_s\mid x_{<s})$ 抽出，则再按 $p(\cdot\mid x_{\le t})$ 抽 $x_{t+1}$ 后，前缀 $x_{\le t+1}$ 的概率恰为原乘积乘以该条件因子，与联合分布在该前缀上的边际一致。因此只要每步都从精确的条件分布采样，输出序列就服从 $p_\theta(x_{1:T})$。

误差有三个来源，必须分开讨论：模型分布 $p_\theta$ 与真实语言分布不同；解码策略使实际采样分布 $\pi_t\neq p_t$；数值实现（浮点、随机数）与理论分布的差异。把生成质量的问题一律归因于"模型不行"或"参数没调好"，通常是因为没有区分这三层。

### 2 训练与推理的不对称

训练时输入整段 $x_{1:T}$，一次前向即得到全部 $T$ 个位置的 logits。因果掩码保证位置 $t$ 的表示只依赖 $x_{\le t}$，因此位置 $t$ 的输出可以直接与 $x_{t+1}$ 比较，$T$ 个位置同时产生监督信号：

$$ \mathcal{L}(\theta)=-\frac{1}{T}\sum_{t=1}^{T}\log p_\theta(x_t\mid x_{<t}). $$

这里的条件用的是数据中的真实前缀，即教师强制。一次前向的计算量约为 $2N\cdot T$，反向约为前向的两倍，训练一步合计约 $6N\cdot T$。

推理时第 $t$ 步的输入包含第 $t-1$ 步的采样结果，必须串行执行 $T$ 次前向。设生成长度为 $T$，则：

- 无缓存：第 $t$ 步要对长度 $t$ 的前缀重算隐藏状态，线性层代价 $\propto t$，注意力代价 $\propto t^{2}$；总计 $\sum_{t\le T}t^{2}\approx T^{3}/3$。
- 有 KV 缓存：第 $t$ 步只处理 1 个新 token，线性层代价为常数，注意力只需与已缓存的 $t$ 个键值做内积，代价 $\propto t$；总计 $\sum_{t\le T}t\approx T^{2}/2$。

两者相差一个 $T$ 因子，这是 [[KV缓存]] 成为推理必备优化的原因。

训练与推理的第二个差异是前缀分布。训练时前缀永远来自数据，推理时前缀包含模型自己的输出；一旦某步偏离数据分布，后续输入就落在训练中少见的区域，错误会被放大。若把每步"选对"的概率粗略记为 $q$，长度 $T$ 全部选对的概率为 $q^{T}$：$q=0.99$、$T=100$ 时为 $0.366$，$T=500$ 时为 $0.0066$。这一项误差不能靠解码策略消除，只能靠更好的模型、更多的数据或对齐训练缓解；解码策略能做的是避免在每一步主动选择低概率 token。

### 3 贪心解码

贪心解码取每步概率最大的 token：

$$ x_t=\arg\max_{v\in\mathcal{V}}\;p_\theta(v\mid x_{<t}). $$

它没有超参数、结果确定、计算最省。问题在于局部最优不等于全局最优：序列概率是各步条件概率的乘积，某步的次优选择可能使后续所有步骤的概率显著更高。

两步反例。词表 $\{a,b,c\}$，第一步分布为 $(0.50,0.35,0.15)$，第二步的条件分布为

| $x_1$ | $p(x_2=a)$ | $p(x_2=b)$ | $p(x_2=c)$ |
|---|---|---|---|
| a | 0.40 | 0.30 | 0.30 |
| b | 0.10 | 0.85 | 0.05 |
| c | 0.20 | 0.20 | 0.60 |

贪心第一步取 $a$，第二步在 $a$ 的条件下取 $a$，序列 $aa$ 的概率为 $0.50\times0.40=0.20$。而序列 $bb$ 的概率为 $0.35\times0.85=0.2975$，比贪心结果高 48.75%，却在第一步就被排除。九条序列的完整概率为 $bb\,0.2975$、$aa\,0.20$、$ab\,0.15$、$ac\,0.15$、$cc\,0.09$、$ba\,0.035$、$ca\,0.03$、$cb\,0.03$、$bc\,0.0175$，可见贪心取到的不是最大概率序列。

贪心的第二个问题是退化。若某 token 一旦出现就使自身概率进一步升高，贪心会进入固定循环。「例子与代码」中例 4 的玩具模型上，贪心输出 `a b a b a b a b a b a b`，12 步内没有产生句号；这是开放式生成中重复现象的确定性版本。

温度不改变排序（$\tau>0$ 时 $z_i/\tau$ 与 $z_i$ 同序），因此任意正温度下的 argmax 与贪心相同；温度只在 $\tau\to0$ 的极限下与贪心一致，见第 6 节。

### 4 束搜索

束搜索在每步保留 $b$ 条部分序列，用对数概率之和打分：

$$ s(Y)=\sum_{t=1}^{\lvert Y\rvert}\log p_\theta(y_t\mid y_{<t})=\log p_\theta(Y). $$

用对数而非概率连乘，是因为长度为 1000、每步概率 0.01 的序列概率为 $10^{-2000}$，在 float64 下下溢为 0，而对数和为 $-4605$，仍在可表示范围内。

算法如下。

```
BEAM-SEARCH(model, prefix, b, T_max):
  live   ← [(prefix, 0.0)]                 # (序列, 对数概率和)
  done   ← []                              # 已生成结束符的候选
  for step in 1..T_max:
    cand ← []
    for (Y, s) in live:
      logits ← model(Y)                    # 一次前向；b 条可拼成一个 batch
      for v in TOP-B(logits):              # 实践中只取前若干名，避免 O(b·V) 全排序
        cand.append((Y + [v], s + log p(v)))
    sort cand by score descending
    for (Y, s) in cand:
      if Y ends with EOS: done.append((Y, s))
      else if len(live) < b: live.append((Y, s))
    if live is empty: break
  return best of done ∪ live by length-normalized score
```

原始对数概率随长度单调不增（每项 $\le0$），直接比较会系统性偏好短序列：2 个 token、概率 0.2 的序列对数和为 $-1.609$，5 个 token、每步 0.6 的序列为 $-2.554$，后者虽然每步都更可能，总和却更低。两种常用的长度归一化是

$$ s_{\text{pow}}(Y)=\frac{s(Y)}{\lvert Y\rvert^{\alpha}},\qquad \mathrm{lp}(Y)=\frac{(5+\lvert Y\rvert)^{\alpha}}{(5+1)^{\alpha}},\quad s_{\text{gnmt}}(Y)=\frac{s(Y)}{\mathrm{lp}(Y)}, $$

其中 $\alpha$ 为长度惩罚指数，$\alpha=1$ 时 $s_{\text{pow}}$ 就是平均对数概率；$\mathrm{lp}$ 是 GNMT 使用的形式，常数 5 使短序列的惩罚较平缓。上例中平均对数概率分别为 $-0.805$ 与 $-0.511$，排序与原始总和相反。

束宽 $b$ 的代价是线性的：每步需要 $b$ 次前向（可拼成一个 batch 提高吞吐，但单请求延迟仍随 $b$ 增长），KV 缓存显存也按 $b$ 倍增长。质量上，机器翻译等封闭任务中 $b$ 从 1 增到 5 至 10 通常带来稳定提升，继续增大收益递减；开放式生成中增大 $b$ 反而使输出更短、更通用、更重复，原因见下一节。

实现上有三个必须处理的细节。第一，已完成的候选要留在集合中参与最终比较，否则先结束的短序列会被丢弃。第二，同一父节点扩展出的前 $b$ 个候选可能全部来自同一个父节点，此时束退化为贪心加长；标准做法是在全部 $b\times V$ 个扩展中统一排序，而不是每个父节点各取前几名。第三，若词表中有多个 token 映射到相同字符串，或解码时不按 token 边界截断，输出可能出现重复片段；束本身不保证候选字符串互异。

### 5 束搜索为何不适合开放式生成

束搜索优化的目标是序列概率 $p_\theta(Y)$ 最大。对机器翻译这类"正确答案大致唯一"的任务，最大概率序列与参考译文的距离较小；对开放式生成，最大概率序列具有系统性偏差。

第一，高概率文本不等于人类文本。语言模型的训练目标是拟合语料分布，而分布的众数（mode）是一段具体的、往往最保守的文本。Holtzman 等人的分析指出，贪心与束搜索产生的是分布的众数附近区域，其困惑度低于人类文本、但词频分布与人类文本偏离；人类文本的每个 token 并不取自最大概率处，而取自分布中概率适中的区域。第二，概率随长度指数衰减，束搜索在固定长度下倾向于选择"每步都很安全"的续写，表现为泛化、空洞、重复。第三，束搜索的多样性为 1：它输出单一序列，无法用于需要多样本的任务（自洽性投票、候选重排、数据合成）。

因此实践中的分工是：翻译、摘要、语音识别等有明确参考的任务可用束搜索并配长度惩罚；对话、写作、代码补全等开放式任务用随机采样（温度 + top-p），需要多样性时增加采样次数。这一结论来自对解码目标与任务目标不一致的分析，而不是实现缺陷。

### 6 随机采样与温度

温度采样先缩放 logits 再 softmax：

$$ p_i^{(\tau)}=\frac{\exp(z_i/\tau)}{\sum_{j}\exp(z_j/\tau)}. $$

$\tau=1$ 时为原分布，$\tau<1$ 使分布更尖锐，$\tau>1$ 使其更平坦。三个极限与性质如下。

**保序性**：$z_i>z_j$ 时 $z_i/\tau>z_j/\tau$（$\tau>0$），故 softmax 后 $p_i^{(\tau)}>p_j^{(\tau)}$，argmax 不随 $\tau$ 改变。

**$\tau\to0$**：设 $m=\max_i z_i$，$i^{*}$ 为唯一取得最大值的下标。对 $i\neq i^{*}$，

$$ \frac{p_i^{(\tau)}}{p_{i^{*}}^{(\tau)}}=\exp\!\left(\frac{z_i-z_{i^{*}}}{\tau}\right)\xrightarrow[\tau\to0]{}0, $$

故 $p^{(\tau)}$ 收敛到集中在 $i^{*}$ 的 one-hot 分布，与贪心一致。若最大值由 $k$ 个 token 并列取得，则这些 token 之间比值为 1，极限是并列集合上的均匀分布而非 one-hot；这是 $\tau\to0$ 与"取 argmax"在浮点并列时结果不同的原因。

**$\tau\to\infty$**：$z_i/\tau\to0$，故 $p_i^{(\tau)}\to1/V$，即词表上的均匀分布。

**熵的单调性**：记 $\beta=1/\tau$，$Z(\beta)=\sum_i e^{\beta z_i}$，则 $H(\beta)=\log Z-\beta\,\mathbb{E}_{p}[z]$，且

$$ \frac{\mathrm{d}H}{\mathrm{d}\beta}=-\beta\,\mathrm{Var}_{p}[z]\le0, $$

故 $H$ 随 $\beta$ 递减、随 $\tau$ 递增，端点 $H(0^{+})=0$（并列时为 $\log k$）、$H(\infty)=\log V$。

温度与"对概率取幂"等价：

$$ \mathrm{softmax}(\mathbf{z}/\tau)_i=\frac{e^{z_i/\tau}}{\sum_j e^{z_j/\tau}}=\frac{(e^{z_i})^{1/\tau}}{\sum_j(e^{z_j})^{1/\tau}}=\frac{p_i^{1/\tau}}{\sum_j p_j^{1/\tau}}. $$

因此"logits 除以 $\tau$"与"概率开 $1/\tau$ 次方后归一化"是同一变换。对概率直接乘以或除以 $\tau$ 则不是概率分布（和不为 1），不能用于采样。

数值示例：$\mathbf{z}=(2.5,1.5,1.0,0.5,0.0,-0.5,-1.0,-2.0)$，$V=8$，$\log V=2.0794$。

| $\tau$ | $p_0$ | $p_1$ | $p_2$ | 熵 $H$ |
|---|---|---|---|---|
| 0.25 | 0.9793 | 0.0179 | 0.0024 | 0.1104 |
| 0.5 | 0.8239 | 0.1115 | 0.0410 | 0.6463 |
| 1.0 | 0.5264 | 0.1937 | 0.1175 | 1.4226 |
| 2.0 | 0.3091 | 0.1875 | 0.1460 | 1.8725 |
| 4.0 | 0.2074 | 0.1615 | 0.1425 | 2.0241 |

$\tau=0.25$ 时最大概率占 0.9793，采样结果近似贪心；$\tau=4$ 时熵为 2.0241，已接近均匀分布的 2.0794，八个候选几乎等概率。$p_2$ 从 0.0024 升到 0.1425：升温使最大概率单调下降、最小概率单调上升，二者在 $\tau\to\infty$ 时同趋于 $1/V=0.125$，$p_2$ 在中间某处达到最大值后再回落。

表中从 $\tau=0.25$ 到 $4.0$ 的变化说明温度不是"随机性开关"而是"分布形状参数"：它同时改变所有 token 的相对权重，且改变幅度依赖 logit 差值。

温度只作用在 softmax 之前。若先 softmax 得到概率，再对概率乘以或除以 $\tau$，结果不再是归一化分布；即使重新归一化，得到的分布也与 $\mathrm{softmax}(\mathbf{z}/\tau)$ 不同，因为线性缩放与幂运算不等价。若对 logits 加常数再除以 $\tau$，结果不变（softmax 对平移不变），但先除以 $\tau$ 再加常数会改变结果。

### 7 top-k 采样

top-k 保留概率最大的 $k$ 个 token，其余置为 $-\infty$，再在保留集上重新归一化：

$$ S_k=\{i: \operatorname{rank}(p_i)\le k\},\qquad \pi_i=\frac{p_i\,\mathbf{1}[i\in S_k]}{\sum_{j\in S_k}p_j}. $$

$k=V$ 时退化为原分布，$k=1$ 时退化为贪心。实现用 `argpartition` 在 $O(V)$ 时间内找出前 $k$ 大，不必全排序；并列时 `argpartition` 的选择依赖实现，结果可能不同，需要确定性时应对 $(z_i,-i)$ 排序。

top-k 的缺陷是 $k$ 为绝对数量，与分布形状无关。同一 $k=5$ 在尖峰分布下几乎没有影响，在平坦分布下会截掉可观的概率质量：上例中 $\tau=2$ 时前 5 个 token 的原始概率质量只有 0.8448，截掉的 15.5% 被重新分配；$\tau=0.25$ 时前 5 个的质量为 1.0000，但其中第 3 至第 5 个 token 的概率都小于 0.003，实际起作用的只有前两个。前者损失多样性对应的有效候选，后者引入几乎不可能的候选。

### 8 top-p（核采样）

top-p 按累积概率确定候选集合。将概率降序排列 $p_{(1)}\ge p_{(2)}\ge\cdots$，取最小的 $m$ 使

$$ \sum_{i=1}^{m}p_{(i)}\ge\rho,\qquad S_\rho=\{i: \operatorname{rank}(p_i)\le m\}, $$

集合 $S_\rho$ 称为**核**（nucleus），采样时只在该集合上重新归一化。$\rho\to1$ 时 $S_\rho\to\mathcal{V}$，退化为原分布；$\rho$ 很小时 $m=1$，退化为 top-1。由于 $m$ 由累积概率决定，$S_\rho$ 的大小随分布形状自适应：分布尖锐时核小，分布平坦时核大。

实现的关键是正确保留"跨越阈值"的那个 token。按降序计算累积和 $c_i=\sum_{j\le i}p_{(j)}$，删除条件为

$$ c_i-p_{(i)}>\rho, $$

即"在当前 token 之前的前缀已经达到阈值"。若写成 $c_i>\rho$，则会误删第一个使累积和超过 $\rho$ 的 token，使实际保留质量严格小于 $\rho$：在 $\rho=0.9$、第四个 token 的累积和 $c_4=0.9088$ 时，错误实现只保留 3 个 token。

上例四个阈值与 top-k 的保留结果对照：

| 策略 | 保留数 | 保留下标 | 原始质量 | 重归一化后的概率 |
|---|---|---|---|---|
| top-k $k=3$ | 3 | 0,1,2 | 0.8376 | 0.6285, 0.2312, 0.1402 |
| top-p $\rho=0.5$ | 1 | 0 | 0.5264 | 1.0000 |
| top-p $\rho=0.7201$ | 2 | 0,1 | 0.7201 | 0.7311, 0.2689 |
| top-p $\rho=0.9$ | 4 | 0,1,2,3 | 0.9088 | 0.5793, 0.2131, 0.1293, 0.0784 |
| top-p $\rho=0.95$ | 5 | 0,1,2,3,4 | 0.9520 | 0.5530, 0.2034, 0.1234, 0.0748, 0.0454 |

$\rho=0.7201$ 一行是边界情形：$c_2=0.7201$ 恰好等于阈值，按 $\ge$ 的定义保留 2 个；这正是实现中容易差一个 token 的位置。$\rho=0.5$ 一行说明 top-p 在尖峰分布下的行为与贪心接近，但仍有 0.4736 的原始质量被丢弃后重新分配。

top-k 与 top-p 可以叠加，顺序影响结果：先 top-k 再 top-p 时，top-p 在已截断的分布上重新计算累积概率，可能保留更少；先 top-p 再 top-k 时，$k$ 可能小于核大小而再次截断。叠加后必须重新归一化。不同框架的应用顺序不同（常见顺序为重复惩罚、温度、top-k、top-p），复现他人结果时需要同时记录顺序。

温度与 top-p 的交互值得单独说明：温度不改变排序，因此不改变 top-k 的集合；但温度改变概率值，因此改变 top-p 的核大小。上例中 $\rho=0.9$ 在 $\tau=0.25$ 时核为 1 个 token（原始质量 0.9793），在 $\tau=2$ 时为 6 个 token（质量 0.9137）。所以"温度 0.7 + top-p 0.9"不能理解为两个独立参数，调高温度会同时放宽核。

### 9 重复惩罚与 presence/frequency penalty

三类惩罚都直接修改 logits。**重复惩罚**（repetition penalty，由 CTRL 引入）对已出现在前缀中的 token 做分段缩放：

$$ z_i\leftarrow \begin{cases} z_i/\gamma, & z_i>0\\ z_i\cdot\gamma, & z_i\le0 \end{cases}\qquad \gamma>1. $$

该变换在 $z=0$ 处连续且分段单调，但对正负 logit 的作用方向相反：正值被压小，负值被压得更负。它不是按概率惩罚，而是按 logit 尺度惩罚，因此对高置信 token 效果弱（$z=10$、$\gamma=1.2$ 仍为 8.33，依旧远高于其他 token），对低置信 token 效果强。另外，它只区分"出现过"与"未出现"，不区分出现次数。

**presence penalty** 与 **frequency penalty** 是线性惩罚：

$$ z_i\leftarrow z_i-\alpha_p\,\mathbf{1}[c_i>0],\qquad z_i\leftarrow z_i-\alpha_f\,c_i, $$

其中 $c_i$ 为 token $i$ 在前缀中的出现次数。presence 只要该 token 出现过就扣一个固定量，与出现次数无关；frequency 按出现次数线性扣。二者的量纲是 logit，与概率不是线性关系：扣 1.5 个 logit 在概率 0.5 附近改变有限，在概率 0.01 附近可使该 token 几乎不可能。

三类惩罚的共同风险是压制必要的重复。代码中的缩进、括号、变量名，数学表达中的运算符，诗歌中的叠句，都属于应当重复的内容；惩罚过强会迫使模型改写本应重复的片段，产生语法错误或语义漂移。另一个副作用是：惩罚后的分布不再等于模型分布，生成文本在该策略下的对数概率不再能作为质量指标。

### 10 典型参数组合

下表是常见任务的起点配置，不是最优配置；实际取值需在目标任务上验证。

| 任务 | 温度 | top-p | top-k | 说明 |
|---|---|---|---|---|
| 代码补全、结构化输出 | 0–0.2 | 0.95 | 关闭 | 需要确定性与语法正确，温度接近 0 |
| 事实问答、抽取 | 0–0.3 | 0.9 | 关闭 | 降低采样引入的事实漂移 |
| 通用对话 | 0.7 | 0.9 | 关闭 | 多样性与一致性折中 |
| 创意写作 | 0.9–1.1 | 0.95 | 关闭 | 需要词汇多样性 |
| 翻译、摘要 | 0（贪心）或束搜索 | — | — | 有参考文本，束宽 4–5 加长度惩罚 |
| 自洽性投票 | 0.7 | 0.9 | 关闭 | 采样多条路径后按答案投票 |

需要强调两点。第一，许多 API 把 `temperature=0` 实现为"直接取 argmax"的特殊分支，而不是真的除以 0；自行实现时若写成 `z / tau`，$\tau=0$ 会产生除零或 `inf`，必须先判断。第二，top-k 与 top-p 同时开启时，二者的相对顺序与是否重归一化会改变分布，配置应写明。

### 11 随机性与可复现

采样需要从 categorical 分布抽一个下标。两种等价实现：逆累积分布（抽 $u\sim U(0,1)$，取最小 $i$ 使 $\sum_{j\le i}p_j\ge u$）与 Gumbel-max：

$$ \hat{i}=\arg\max_{i}\left(\log p_i+g_i\right),\qquad g_i\overset{\text{iid}}{\sim}\mathrm{Gumbel}(0,1). $$

Gumbel-max 的合法性来自直接计算。Gumbel 分布的 CDF 为 $F(x)=e^{-e^{-x}}$、密度为 $f(x)=e^{-x}e^{-e^{-x}}$，于是

$$ \begin{aligned} \Pr(\hat{i}=i)&=\int_{-\infty}^{\infty}f(x)\prod_{j\neq i}F\!\left(x+\log p_i-\log p_j\right)\mathrm{d}x\\ &=\int_{-\infty}^{\infty}e^{-x}\exp\!\left(-e^{-x}\sum_{j}\frac{p_j}{p_i}\right)\mathrm{d}x=\int_{-\infty}^{\infty}e^{-x}e^{-e^{-x}/p_i}\,\mathrm{d}x=p_i. \end{aligned} $$

Gumbel-max 的价值在于可以对整个 batch 并行加噪再一次 argmax，不必逐条做逆 CDF；代价是需要 $V$ 个独立随机数而不是 1 个。

可复现性需要同时固定四件事：随机数种子；随机数的消耗顺序（batch 组成、并发请求、是否对每条序列独立开 generator）；实现与库版本（softmax、排序、`argpartition` 的平局处理可能变化）；硬件与算子（GPU 上归约与原子加的顺序不确定，同一 seed 在同一卡上也可能不同）。PyTorch 中可设 `torch.use_deterministic_algorithms(True)` 并固定 `CUBLAS_WORKSPACE_CONFIG`，但这会降低速度且并非所有算子都支持。

实践含义：本地实验固定 seed 可以复现；线上服务不应承诺逐字复现，需要审计时记录 seed、模型版本、解码参数、batch 组成与硬件。温度与 top-p 相同的两次调用结果不同，是随机采样的定义性质，不是故障。

## 关键直觉

> [!tip] 解码策略对每步条件分布做两件事：温度改变分布形状而保持支撑集（所有 token 仍可能被抽到，只是权重按 $p^{1/\tau}$ 重新分配）；top-k 与 top-p 改变支撑集而保留集合内的相对权重（截断后重归一化）。贪心与束搜索不改变分布，只改变选择规则：前者取每步众数，后者用每步保留 $b$ 条候选的方式近似求序列众数。任何策略的实际采样分布 $\pi_t$ 与模型分布 $p_t$ 的差异，就是该策略引入的偏差，偏差的大小可以用 $\mathrm{KL}(\pi_t\,\|\,p_t)$ 或保留质量来度量。

这一表述与严格定义的关系是：定义给出的是 $p_\theta(x_{1:T})$ 与解码规则的形式，上述分解说明不同规则分别在"形状"与"支撑集"两个维度上作用，因此温度与 top-p 的组合效果不能独立分析。

## 例子与代码

以下代码使用 NumPy 2.x，Python 3.10 以上版本可直接运行。所有输出为实际运行结果。

### 例 1：温度对分布的影响

```python
import numpy as np

def softmax(z, tau=1.0):
    z = np.asarray(z, dtype=np.float64) / tau   # 温度作用在 softmax 之前
    z -= z.max()                                # 减去最大值，防止 exp 溢出，不改变结果
    e = np.exp(z)
    return e / e.sum()

def entropy(p):
    p = p[p > 0]                                # 0 log 0 约定为 0
    return float(-(p * np.log(p)).sum())

logits = np.array([2.5, 1.5, 1.0, 0.5, 0.0, -0.5, -1.0, -2.0])
print("tau     p0      p1      p2      H")
for tau in (0.25, 0.5, 1.0, 2.0, 4.0):
    p = softmax(logits, tau)
    print(f"{tau:<5} {p[0]:.4f}  {p[1]:.4f}  {p[2]:.4f}  {entropy(p):.4f}")

p1 = softmax(logits)
for tau in (0.5, 2.0):
    a = softmax(logits, tau)
    b = p1 ** (1.0 / tau)
    print(tau, np.allclose(a, b / b.sum()))
```

```text
tau     p0      p1      p2      H
0.25  0.9793  0.0179  0.0024  0.1104
0.5   0.8239  0.1115  0.0410  0.6463
1.0   0.5264  0.1937  0.1175  1.4226
2.0   0.3091  0.1875  0.1460  1.8725
4.0   0.2074  0.1615  0.1425  2.0241
0.5 True
2.0 True
```

`softmax` 中的减法利用 softmax 的平移不变性，把最大指数控制在 0，避免 $e^{z}$ 上溢；去掉这一步在 $\tau=0.25$ 时仍不会溢出（$2.5/0.25=10$），但若 logits 量级为 100、温度为 0.1，$e^{1000}$ 会直接溢出为 `inf`，结果为 `nan`。最后两行验证第 6 节的等价关系：`p1 ** (1/tau)` 再归一化与 `softmax(logits / tau)` 在浮点误差内相同。

### 例 2：top-k 与 top-p 的候选集合

本例接上例，复用其中的 `logits` 与 `softmax`。

```python
def top_k(z, k):
    z = np.asarray(z, dtype=np.float64)
    k = min(max(k, 1), z.size)                  # 边界保护：k 不得为 0 或超过词表
    keep = np.argpartition(-z, k - 1)[:k]       # O(V) 取前 k 大，未排序
    out = np.full_like(z, -np.inf)
    out[keep] = z[keep]
    return out

def top_p(z, rho):
    z = np.asarray(z, dtype=np.float64)
    order = np.argsort(-z)                      # 概率降序等价于 logits 降序
    probs = softmax(z[order])
    cum = np.cumsum(probs)
    drop = (cum - probs) > rho                  # 当前 token 之前的前缀已达阈值才删除
    zs = np.where(drop, -np.inf, z[order])
    out = np.empty_like(z)
    out[order] = zs                             # 还原为原始下标顺序
    return out

prob = softmax(logits)
print("p      ", np.round(prob, 4))
print("cumsum ", np.round(np.cumsum(prob), 4))
for name, z in [("top_k=3", top_k(logits, 3)), ("top_p=0.5", top_p(logits, 0.5)),
                ("top_p=0.9", top_p(logits, 0.9)), ("top_p=0.95", top_p(logits, 0.95))]:
    keep = np.isfinite(z)
    print(f"{name:<10} keep={keep.sum()} idx={np.flatnonzero(keep)} "
          f"mass={prob[keep].sum():.4f} probs={np.round(softmax(z), 4)[keep]}")
```

```text
p       [0.5264 0.1937 0.1175 0.0712 0.0432 0.0262 0.0159 0.0058]
cumsum  [0.5264 0.7201 0.8376 0.9088 0.952  0.9783 0.9942 1.    ]
top_k=3    keep=3 idx=[0 1 2] mass=0.8376 probs=[0.6285 0.2312 0.1402]
top_p=0.5  keep=1 idx=[0] mass=0.5264 probs=[1.]
top_p=0.9  keep=4 idx=[0 1 2 3] mass=0.9088 probs=[0.5793 0.2131 0.1293 0.0784]
top_p=0.95 keep=5 idx=[0 1 2 3 4] mass=0.9520 probs=[0.553  0.2034 0.1234 0.0748 0.0454]
```

`top_k` 用 `argpartition` 而非全排序，因为采样只需要集合与重归一化，不需要集合内顺序；`out` 保持原始下标，后续与词表对齐时不需要再映射。`top_p` 中 `probs[keep].sum()` 是保留的原始质量，`softmax(z)[keep]` 是重归一化后的实际采样概率，两者不同：前者说明截掉了多少概率，后者才是采样用的分布。

若把 `drop` 写成 `cum > rho`，$\rho=0.71$ 时会删掉下标 1（$c_2=0.7201>0.71$），只保留 1 个 token、质量 0.5264，远低于阈值；$\rho=0.9$ 时同一错误实现保留 3 个、质量 0.8376。这就是第 8 节所述差一个 token 的具体位置。

### 例 3：贪心与束搜索

```python
VOCAB = ["a", "b", "c"]
P1 = np.array([0.50, 0.35, 0.15])                        # 第一步分布
P2 = np.array([
    [0.40, 0.30, 0.30],                                  # p(x2 | x1 = a)
    [0.10, 0.85, 0.05],                                  # p(x2 | x1 = b)
    [0.20, 0.20, 0.60],                                  # p(x2 | x1 = c)
])

def beams(k, alpha=0.0, depth=2):
    live = [("", 0.0)]                                   # (序列, 对数概率和)
    for _ in range(depth):
        cand = []
        for seq, lp in live:
            dist = P1 if not seq else P2[VOCAB.index(seq[-1])]
            for j, pj in enumerate(dist):
                if pj > 0:
                    cand.append((seq + VOCAB[j], lp + np.log(pj)))
        cand.sort(key=lambda item: -(item[1] / max(len(item[0]), 1) ** alpha))
        live = cand[:k]                                  # 只保留前 k 条
    return live

bg = max(((VOCAB[i] + VOCAB[j], P1[i] * P2[i][j]) for i in range(3) for j in range(3)),
         key=lambda item: item[1])
gi = int(np.argmax(P1))                                   # 第一步取最优
gj = int(np.argmax(P2[gi]))                               # 第二步在该条件下取最优
print("global argmax:", bg[0], round(float(bg[1]), 4))
print("greedy       :", VOCAB[gi] + VOCAB[gj], round(float(P1[gi] * P2[gi][gj]), 4))
for k in (1, 2, 3):
    print(f"beam k={k}     :", [(s, round(float(np.exp(lp)), 4)) for s, lp in beams(k)])
```

```text
global argmax: bb 0.2975
greedy       : aa 0.2
beam k=1     : [('aa', 0.2)]
beam k=2     : [('bb', 0.2975), ('aa', 0.2)]
beam k=3     : [('bb', 0.2975), ('aa', 0.2), ('ab', 0.15)]
```

`beam k=1` 与贪心结果相同，验证束搜索在 $b=1$ 时退化为贪心。$b=2$ 时束保留了第一步的次优 token `b`（概率 0.35），第二步扩展到 `bb`（0.35×0.85），从而找到全局最优。若把 `alpha` 设为 1，两条候选的排序按平均对数概率进行，本例中两条长度相同，排序不变；长度不同时才会改变排序。`max(len(seq),1)` 防止空序列除零，这是长度归一化实现的常见疏漏。

### 例 4：完整解码循环

```python
from collections import Counter

TOK = ["<bos>", "a", "b", "c", "."]
L = np.array([                                        # 玩具 bigram 模型的 logits 表
    [-9.0, 3.0, 2.0, 1.0, -2.0],                      # 由 <bos> 出发
    [-9.0, -1.0, 3.0, 0.5, -1.5],                     # 由 a 出发
    [-9.0, 3.0, -1.0, 0.5, -1.5],                     # 由 b 出发
    [-9.0, 2.0, 2.0, -1.0, -1.0],                     # 由 c 出发
    [-9.0, -2.0, -2.0, -2.0, 2.0],                    # 由 . 出发
])

def generate(seed=0, mode="greedy", tau=1.0, k=0, rho=1.0, gamma=1.0, freq=0.0, steps=12):
    rng = np.random.default_rng(seed)
    seq = [0]                                         # 以 <bos> 开头
    lps = []
    for _ in range(steps):
        z = L[seq[-1]].astype(np.float64).copy()
        z[0] = -np.inf                                # 禁止生成 <bos>
        if gamma != 1.0:
            for t in set(seq[1:]):
                z[t] = z[t] / gamma if z[t] > 0 else z[t] * gamma
        if freq != 0.0:
            for t, c in Counter(seq[1:]).items():
                z[t] -= freq * c
        if k:
            z = top_k(z, k)
        if rho < 1.0:
            z = top_p(z, rho)
        probs = softmax(z, tau)                       # 先过滤再算温度分布
        i = int(np.argmax(z)) if mode == "greedy" else int(rng.choice(z.size, p=probs))
        lps.append(float(np.log(probs[i])))
        seq.append(i)
    return " ".join(TOK[t] for t in seq[1:]), float(np.mean(lps))

for kw in (dict(mode="greedy"), dict(mode="sample"), dict(mode="sample", tau=0.5),
           dict(mode="sample", tau=1.5), dict(mode="sample", k=3), dict(mode="sample", rho=0.8),
           dict(mode="greedy", gamma=2.0), dict(mode="greedy", freq=1.5)):
    text, mlp = generate(seed=0, **kw)
    print(f"{str(kw):<38} {text:<26} mean_logp={mlp:.4f}")
```

```text
{'mode': 'greedy'}                     a b a b a b a b a b a b    mean_logp=-0.1312
{'mode': 'sample'}                     a b a b a b a b a c b a    mean_logp=-0.3926
{'mode': 'sample', 'tau': 0.5}         a b a b a b a b a b a b    mean_logp=-0.0185
{'mode': 'sample', 'tau': 1.5}         b a a a b c b a b c b a    mean_logp=-1.1655
{'mode': 'sample', 'k': 3}             a b a a b b a b a c b a    mean_logp=-1.0485
{'mode': 'sample', 'rho': 0.8}         a b a b a b a b a b a b    mean_logp=-0.0261
{'mode': 'greedy', 'gamma': 2.0}       a b a b a b a b a b a b    mean_logp=-0.3507
{'mode': 'greedy', 'freq': 1.5}        a b a b c a b c . . . .    mean_logp=-0.3970
```

逐行解读。贪心在 token `a` 与 token `b` 之间往返，12 步没有产生句号，这是第 3 节所述退化循环：由 `a` 出发时 `b` 的 logit 为 3.0、句号为 $-1.5$，差值 4.5，贪心永远选 `b`。温度 0.5 的采样同样落入循环（概率更集中，随机性不足以跳出去）；温度 1.5 打散了循环但出现 `a a a` 这样的局部重复；top-k=3 与 top-p=0.8 都改变了轨迹，但都在 12 步内没有收敛到句号，因为模型本身的句号概率低。

重复惩罚 $\gamma=2.0$ 一行仍为 `a b a b ...`：由 `b` 出发时 `a` 的 logit 3.0 除以 2 得 1.5，仍高于句号的 $-1.5$，惩罚不足以改变 argmax。frequency penalty 1.5 一行在 `a`、`b` 各出现两次后把它们各扣 3.0，$c$ 的 0.5 成为最大，循环被打破，输出进入 `c` 并最终产生句号。两者效果的差异说明第 9 节的两点：缩放式惩罚依赖 logit 尺度，线性惩罚直接作用于竞争关系；同一个任务上后者的可控性更强。

`mean_logp` 是该步实际采样分布下所选 token 的对数概率均值，只在不同策略使用**同一** $\tau$ 与同一过滤集时可比。温度 0.5 的 $-0.0185$ 高于贪心的 $-0.1312$，原因是温度压低熵、抬高了最大概率，并不表示质量更好。把它当作质量指标是常见误用。

### 例 5：种子与可复现

```python
print("same seed:", generate(seed=0)[0] == generate(seed=0)[0])
print("seed 1   :", generate(seed=1, mode="sample")[0])
g1 = np.random.default_rng(7)
g2 = np.random.default_rng(7)
print([int(g1.integers(0, 10)) for _ in range(6)])
print([int(g2.integers(0, 10)) for _ in range(6)])
```

```text
same seed: True
seed 1   : a c a c a b a b a b a b
[9, 6, 6, 8, 5, 7]
[9, 6, 6, 8, 5, 7]
```

`generate` 内部每次调用都新建 `default_rng(seed)`，因此相同 seed 得到相同序列；若把 `rng` 提到函数外共享，第二次调用会接着消耗随机数，结果不同。两个 `default_rng(7)` 给出完全相同的序列，说明 NumPy 的 PCG64 在相同平台上可复现；跨版本或跨平台不保证。

需要复现他人的采样结果时，仅记录 seed 不够：还需记录 batch 大小与组成（第 $i$ 条序列消耗的随机数区间依赖前面的序列）、是否对每条序列独立开 generator、以及是否用了确定性算子。在 GPU 上即使这些全部固定，同一结果也不总能保证，原因是归约顺序与原子加的顺序不确定。

## 易错点

> [!warning] 以下六条均可在实现或核算中直接检验。
> 1. 温度作用位置错误：对 softmax 之后的概率乘以或除以 $\tau$ 得到的不再是概率分布（和不为 1）；正确做法是缩放 logits，或等价地对概率取 $1/\tau$ 次方后归一化。先 softmax 再对概率乘 $\tau$、最后重新归一化，得到的分布与 `softmax(z/tau)` 不同，因为幂运算与线性缩放不等价。
> 2. top-p 忘记排序：直接在原始下标上做 `cumsum`，累积和依赖词表顺序，核集合与阈值无关；必须先按概率降序排序、计算累积和，再把掩码映射回原下标。
> 3. top-p 阈值差一个 token：用 `cum > rho` 会删掉第一个使累积和超过阈值的 token，使保留质量小于 $\rho$；正确条件是 `cum - p > rho`。可用第 8 节 $\rho=0.7201$ 的表核对，正确实现保留 2 个。
> 4. 束搜索中重复候选：同一父节点扩展出的前 $b$ 名若全部来自同一父节点，束会退化为贪心加长；应在全部 $b\times V$ 个扩展上统一排序。此外束中的候选不去重时，多个 token 序列可能解码为相同字符串，最终输出出现重复片段。
> 5. 束搜索比较未完成与已完成候选时不做长度归一化：对数概率随长度单调下降，直接比较会偏好刚生成结束符的短序列；长度惩罚必须在进入 `done` 集合时即生效，而不是只在最终比较时使用。
> 6. 温度设为 0 触发除零，或把 `temperature=0` 与 `top_k=1` 当作完全等价：前者应先判断并走 argmax 分支，后者仍走 softmax 与采样流程，在数值下溢或并列时结果可能不同。另一个相关错误是把 `mean_logp` 或输出困惑度当作质量指标跨策略比较，而它们随温度与过滤集系统性变化。

## 关联笔记

- 前置 [[Transformer架构详解]]：本篇的 logits 由解码器最后一层的输出投影产生；层数、$d_{\text{model}}$ 与词表大小决定每步前向的计算量 $2N$，而其中的因果掩码保证位置 $t$ 不看到未来，这是训练可并行、推理必须串行的结构原因。
- 后续 [[KV缓存]]：本篇第 2 节给出的 $O(T^{3})$ 与 $O(T^{2})$ 之差，是 KV 缓存存在的理由；缓存的显存公式按层数、KV 头数与序列长度计算。
- 后续 [[GPT系列架构]]：GPT-1/2/3 的零样本与少样本表现必须在固定解码策略下比较，上下文学习的效果对温度与 top-p 敏感。
- 对照 [[BERT与双向编码模型]]：BERT 的训练目标不构成合法的链式分解，因此不能直接用于本篇描述的自回归生成流程。
- 后续 [[从零实现小型GPT指南]]：阶段项目要求实现 greedy、温度、top-k、top-p 四种解码并报告同一权重下的输出差异。

## 达标检测

- [ ] 写出链式分解并说明它为何不依赖独立性假设；给出逐位采样所得序列服从联合分布的一步归纳证明。
- [ ] 对第 3 节的两步反例，手算九条序列的概率，指出贪心结果与全局最优的差距，并说明束宽为 2 时是否能找到最优。
- [ ] 推导 $\tau\to0$ 时 $p^{(\tau)}$ 收敛到 one-hot 的条件，说明并列最大值时极限为何是并列集上的均匀分布。
- [ ] 证明 $\mathrm{softmax}(\mathbf{z}/\tau)_i=p_i^{1/\tau}/\sum_j p_j^{1/\tau}$，并说明"对概率乘 $\tau$"为何不构成分布。
- [ ] 对给定 logits，手算 $\rho=0.9$ 时的核集合与保留质量，并与 `cum > rho` 的错误实现比较，指出差几个 token。
- [ ] 用不超过 40 行实现 greedy、温度、top-k、top-p 四种解码，在同一组 logits 上打印各自的选择分布，核对本篇表格中的数值。
- [ ] 解释为什么束搜索在开放式生成上会退化，并给出一个用固定 seed 复现采样结果的完整条件清单。

## 参考来源

- d2l.ai《动手学深度学习》文本生成（Text Generation）一节 —— 对应本篇第 3、4、5 节的贪心、束搜索与随机采样实现，以及前缀与采样循环的写法。
- Holtzman et al., "The Curious Case of Neural Text Degeneration", arXiv:1904.09751, 2019 —— 对应第 5 节束搜索在开放式生成上的退化分析，以及第 8 节核采样的提出动机。
- Brown et al., "Language Models are Few-Shot Learners", arXiv:2005.14165, 2020 —— 对应第 2 节的推理成本核算与第 10 节中采样配置对任务表现的影响。
- Radford et al., "Language Models are Unsupervised Multitask Learners", 2019 —— 对应第 1 节的条件分解与第 10 节中零样本生成的解码设置。
- Raschka, *Build a Large Language Model (From Scratch)*, 2024, 第 5 章 —— 对应第 6 节温度与 top-k 的实现细节，以及 `softmax` 的数值稳定写法。
- Hugging Face Transformers 文档，Generation strategies 与 logits processor 部分 —— 对应第 9 节的重复惩罚、presence/frequency penalty 接口与第 10 节的参数组合。
