Skip to content

LLM 多轮对话 ​

输入如何构造 → 回答如何生成 → 下一个 Token 如何选择 → 推理如何执行 → 长度、随机性与成本

一、从对话输入到生成回答:整体流程 ​

一次语言模型调用,可以理解为:把本次需要的指令和对话内容转换成 Token 序列,再让模型根据这个序列逐步生成新的 Token,最后转换成文本。

1.1 输入:系统指令、多轮历史与当前用户消息 ​

大模型的推理接口是无状态的(stateless):每次调用都是一次独立的计算,模型不会自动“记得”上一轮聊过什么。因此,多轮历史必须由调用方(应用程序或服务端会话机制)显式地拼进本次请求中。

模型接收的输入由三部分组成,首先,它们被拼接成一个完整的消息列表:

输入部分作用举例
系统指令(System Prompt)设定模型的角色、回答方式和总体要求数学助教、用中文解释
多轮历史(Conversation History)之前所有轮次的对话,包括用户的提问和模型的回复已经讨论过最大似然估计
当前用户消息(Current User Message)本轮用户最新说的话比较最大似然估计与最大后验估计
python
messages = [
    {"role": "system",    "content": "你是一名数学助教,请用中文解释概念。"},
    {"role": "user",      "content": "什么是最大似然估计?"},
    {"role": "assistant", "content": "最大似然估计是选择使观测数据出现的似然最大的参数……"},
    {"role": "user",      "content": "那它与最大后验估计有什么区别?"}
]

对于通常的文本模型调用,模型不会自动读取此前所有聊天内容。 应用需要把相关历史放入本次上下文,或者由服务端的会话机制将其组织进去。

记:第 t 轮的用户输入记为 ut ,助手回复记为 at ,则本轮输入整体为 ct:

ct=(St,Ht,ut),Ht=(u1,a1,⋯,ut−1,at−1)

其中 St 是系统指令,Ht 是多轮历史信息。本次任务就是根据 (c_t) 生成助手回答 (a_t):

at∼πθ(⋅|ct)=πθ(⋅|St,Ht,ut)

1.2 一次回答的完整流程 ​

第 t 轮回答的完整过程可以写成:

ct=(St,Ht,ut)→模板与分词xt→反复预测与选择yt→转换为文本at.

第一步:使用 Chat Template 组织对话格式,如 1.1所示

第二步:使用 Tokenizer 转换为整数序列

分词器将格式化后的内容转换为 Token ID。记第 t 轮的模型输入为:

ct=(St,Ht,ut)⏟应用层:结构化对话⟶xt=(xt,1,…,xt,nt)⏟模型层:Token 序列xt=Tokenizer(Template(ct))=(xt,1,xt,2,…,xt,nt),

第三步:自回归生成 :从下一 Token 的概率分布 + 解码策略

xt→yt 是一次完整的 Decoder-Only 架构的推理过程:

xt→EmbeddingH(0)→L 个 Decoder blocksH(L)→NormZ→Wvocablogits(下一个token的概率分布)logits→解码策略yt

整个生成过程在逻辑上表现为:

xt⟶yt,1,(xt,yt,1)⟶yt,2,(xt,yt,1,yt,2)⟶yt,3, ⋮(xt,yt,1,…,yt,Lt−1)⟶yt,Lt.

第四步:将生成的 Token 序列转换为回答文本

生成结束后,我们得到的是一串 Token ID:

yt=(yt,1,yt,2,…,yt,Lt).

分词器将它们解码为文本,并根据规则处理不需要展示的特殊标记:

at=TextDecode(yt).

1.3 进入下一轮对话 ​

第 t 轮回答的完整过程可以写成:

ct=(St,Ht,ut)→模板与分词xt→反复预测与选择yt→转换为文本at.

从执行顺序来看:

  1. 应用组织系统指令、历史消息和当前用户消息。
  2. 使用 Chat Template 和 Tokenizer 构造输入 Token 序列。
  3. 模型计算下一 Token 的分布。
  4. 解码策略选出一个 Token,将其追加到生成序列。
  5. 若未满足停止条件,则继续预测下一个 Token。
  6. 将生成的 Token 转换为文本,得到本轮助手回复。

回答结束后,应用将本轮的用户消息和助手回复加入历史:

Ht+1=Ht⊕(ut,at),

其中 ⊕ 表示按顺序追加。

当下一轮用户消息 ut+1 到来时,新的输入为:

ct+1=(St+1,Ht+1,ut+1).

这样,上一轮生成的输出,就成为了下一轮输入的一部分。因此,改变一个回复会改变后续对话分布。


二. 对话如何进入模型:Chat Template 与多轮历史 ​

上一节把本轮对话输入记为:

ct=(St,Ht,ut),

其中 St 是系统指令,Ht 是历史对话,ut 是当前用户消息。

这一节要进一步解释:这些带有角色和轮次的信息,如何被编码进一个连续的 Token 序列,以及模型如何知道应该从哪里开始回复。

2.1 消息列表与角色 ​

在应用层,一段对话通常表示为一个有序消息列表。每条消息包含两个基本字段:

python
{
    "role": "消息角色",
    "content": "消息正文"
}

其中,role 表示消息的来源与用途,content 表示具体内容。

  • 这是常见的文本对话格式;具体模型支持哪些角色、如何排列,需要遵循其模板约定。

  • 对常见的 Decoder-only 对话模型,这些角色通常通过输入序列中的标记来表示。


2.2 Chat Template:将结构化消息转换为序列 ​

Chat Template 是一套序列化规则,规定如何把消息列表转换成模型使用的对话格式。

它通常需要处理:

  • 每条消息如何开始、如何结束;
  • 角色名放在哪里;
  • 角色与正文之间如何分隔;
  • 是否添加序列起始标记;
  • 如何表示“接下来开始生成助手回复”。

在 Hugging Face 中,模板通常可以通过 tokenizer.chat_template 查看,其实现使用 Jinja 模板语言。学习使用模型时,先理解模板的输入和输出即可,无需立即学习 Jinja 语法。Hugging Face 模板编写说明

以 Qwen2.5 的普通文本对话格式为例:

前面的消息列表,在添加助手生成前缀后,会形成:

tex
<|im_start|>system
你是一名数学助教,请用中文解释概念。<|im_end|>
<|im_start|>user
什么是最大似然估计?<|im_end|>
<|im_start|>assistant
最大似然估计通过最大化观测数据的似然来估计参数。<|im_end|>
<|im_start|>user
那它与最大后验估计有什么区别?<|im_end|>
<|im_start|>assistant

对话模型在训练过程中接触了特定格式的数据,并学习了这些标记与后续内容之间的关系。

例如,经过训练后,模型会倾向于在 <|im_start|>assistant 后面生成助手回答,在用户消息中理解用户的问题。

若随意替换角色标记、改变消息边界或遗漏必要标记,就改变了模型实际接收的序列。即使正文相同,输入也不再相同:

Tok(T1(M))≠Tok(T2(M)),

其中 M 是同一个消息列表,T1,T2 是不同模板。


2.3 多轮历史的拼接 ​

记第 t 轮的消息列表为:

Mt=[(system,St),(user,u1),(assistant,a1),…,(user,ut)].

Chat Template 按列表顺序组织这些消息,然后分词得到:

xt=Tok(T(Mt)).

对于普通多轮问答,可以把格式化后的输入理解为:

系统消息⊕ 第 1 轮用户消息与助手回复⊕ ⋯⊕ 当前用户消息⊕ 助手生成前缀,

其中 ⊕ 表示按顺序拼接。消息结束标记负责标识边界,并不会自动将前后两轮的注意力隔开。


2.4 Assistant 生成前缀 ​

Assistant 生成有两种不同的任务:开启一条新回复和续写上一条未完成的回复。

第一种:开始一条新的助手回复

如果当前最后一条消息是用户问题:

<|im_start|>user
那它与最大后验估计有什么区别?<|im_end|>

对于这里使用的 Qwen2.5 模板,我们希望在其后加上:

<|im_start|>assistant

这段内容称为 Assistant 生成前缀。它将模型的续写位置放在助手消息正文的开头。

在 Hugging Face 中:

formatted = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)

add_generation_prompt=True 的含义是让模板添加相应的生成前缀。

第二种:继续一条已经开始的助手回复

有时,生成过程可能因为以下原因中途停止:

  • 达到 max_tokens 限制;
  • 触及上下文窗口上限;
  • 流式输出时客户端断开重连;
  • 模型自己生成了截断的句子。

此时历史里已经存在一条“写到一半”的助手消息。如果新建一条助手消息继续写,格式会错乱,我们希望助手接着从前面的助手消息恢复。

可以先在消息列表末尾放入一个未完成的助手回复:

tex
truncated = response.choices[0].message.content   # 这段是现成的、确定的
partial_messages = messages + [{"role": "assistant", "content": truncated}]

然后使用:

tex
formatted = tokenizer.apply_chat_template(
    partial_messages,
    tokenize=False,
    add_generation_prompt=False,
    continue_final_message=True
)

这里不再添加新的助手消息头,而是让模型从已有正文后面继续。

2.5 模型的“记忆”来自哪里 ​

信息或状态主要存放在哪里作用
模型参数中的知识模型权重提供训练中学到的语言规律与知识
对话历史应用或服务端记录此前的消息,供后续构造上下文
KV Cache推理运行时复用已处理前缀的计算结果

应用保存的历史,不一定全部进入本次输入。

随着轮次增加,完整历史:

Ht=(u1,a1,…,ut−1,at−1)

会越来越长。应用可以通过某种历史管理规则 G,构造本轮实际使用的历史:

H~t=G(Ht,ut).

此时,本轮实际生成依赖的是:

πθ(at∣St,H~t,ut).

常见的组织方式包括:

方法如何处理历史主要影响
保留完整历史使用此前所有消息信息保留较完整,但输入不断增长
保留最近若干轮删除较早的消息输入较短,但可能丢失早期约定
摘要旧历史将早期消息压缩为摘要,保留近期原文节省空间,但摘要可能遗漏细节
选择相关历史根据当前问题选出相关片段能保留远处的相关信息,但依赖选择是否准确

2.6 用 Hugging Face 查看实际输入 ​

python
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(
    "Qwen/Qwen2.5-7B-Instruct"
)

# 1. 查看模板组织后的文本
formatted = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)

print(formatted)

# 2. 直接得到模型输入的 Token ID 和注意力掩码
inputs = tokenizer.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
    return_tensors="pt"
)

print(inputs["input_ids"].shape)
print(inputs["input_ids"][0, :20])

对于这里的单条对话,input_ids 的形状是:

(1,nt),

其中 1 是批次大小,nt 是正文、角色信息、边界标记和生成前缀共同占用的 Token 数量。


三、 自回归生成、停止条件与上下文窗口 ​

3.1 自回归生成的概率建模 ​

在第 t 轮回复中,每生成一个新 Token,都以原始输入和此前已经生成的 Token 为条件:

xt⟶yt,1,(xt,yt,1^)⟶yt,2,(xt,y^t,1,y^t,2)⟶yt,3, ⋮(xt,y^t,1,…,y^t,Lt−1)⟶yt,Lt.

概率形式:

pθ(yt,1:Lt∣xt)=∏i=1Ltpθ(yt,i∣xt,yt,<i)

在生成过程中,回答长度也是一个重要变量。若要描述“模型生成这些内容,然后结束”,还需要包含结束标记的概率。

正文有 Lt 个 Token,随后生成结束 Token e,则:

pθ(yt,1:Lt,e∣xt)=[∏i=1Ltpθ(yt,i∣xt,yt,<i)]pθ(e∣xt,y1:Lt).

因此,模型不一定提前决定整段回答要有多长,而是在逐步生成时,也不断给结束 Token 分配概率。


3.2 从 Logits 到下一 Token 分布 ​

整个循环可以写成:

当前前缀→Logits→候选分布→解码策略选择 Token→更新前缀

这里的“更新前缀”描述逻辑上的上下文增长;实际计算可以利用 KV Cache,不必每一步都完整重算历史。

  • 解码策略(见笔记 Transformer 4.2)。
  • 新生成的 Token 如何影响后续分布:
    • 训练时:使用训练样本提供的真实前缀
    • 生成时:使用模型此前实际选出的前缀 ⟶ Exposure Bias(暴露偏差)

3.3 生成的停止条件 ​

生成不是无限持续的,而是在满足固定条件时结束。不同的结束方式带来的效果不完全相同。、

  • 生成结束 token:先前设置好结束 token,模型可以在词表中为结束 Token 分配概率,并在某一步选择它

  • 达到最大生成 token 数

  • 命中停止字符串:可以指定某个字符串作为停止条件。例如 <END>,当生成的文本中出现这个字符串时,停止输出。

  • 外部中断:用户取消、请求超时或服务端主动终止

区分结束 token 与 停止字符串:

  • 结束 token:采样层,事先规定 <EOS> 的 token id,若 softmax 里给 EOS 分配概率并采样到它,生成结束

  • 停止字符串:文本层,detokenize 之后的字符串出现了停止文本,生成结束。stop string 是"推理引擎在文本层面强制截断"


3.4 上下文窗口与长度预算 ​

上下文窗口描述模型一次推理中能够支持的上下文长度范围,通常以 Token 数衡量。

对于常见的 Decoder-only 模型,在生成过程中,序列由三部分组成:

(ut,Ht,St)⏟输入(长度n)yt,1,⋯,yt,Lt⏟已生成输出

随着生成继续,上下文长度会增长:

n,n+1,n+2,…

在常见的总长度预算约定下,若可用上下文上限为 W,则规划输入和输出时需要满足:

n+T≤W
概念限制的对象
上下文窗口 W输入与生成内容占用的总序列空间
最大新增 Token 数 M本次最多生成多少个新 Token
实际输出长度 T本次最终生成了多少 Token

这也解释了多轮历史与输出长度之间的关系:

历史越长⇒输入 Token 越多⇒可预留的输出空间越少.

输入过长时,需要在生成前组织上下文。

若服务还规定独立的最大输出上限 O,则可分配的生成预算通常需要满足:

M≤min(W−n, O)

四、解码策略:如何选择下一个 Token ​

策略核心思想稳定性优点缺点
贪心解码每步选概率最高的确定性速度快,成本低易陷入局部最优,文本重复
束搜索保留 k 个最优路径确定性生成质量通常更高成本高,文本可能模板化
随机采样按概率分布随机选随机性多样性好,更自然可能生成不通顺的文本
温度调节调节概率分布的“尖锐”程度随机性灵活控制随机性需与其他采样方法结合使用
Top-k 采样在概率最高的 k 个中采样随机性兼顾质量与多样性k 值固定,不够灵活
核采样在累计概率达 p 的集合中采样随机性动态调整候选集,效果好计算量略高于 Top-k

五、推理的两个阶段:Prefill、Decode ​

对于常见的 Decoder-only Transformer,一次回答的推理过程通常分为两个阶段:

  • Prefill:一次处理已有的输入上下文,建立缓存,并得到第一个输出 Token 的分布。
  • Decode:利用缓存,每次处理一个新 Token,继续预测后续 Token。

KV Cache 连接了这两个阶段:它保存各层已经计算过的 Key 和 Value,使后续生成可以复用历史计算。

下面讨论常规自回归推理,暂不涉及推测解码等一次处理多个候选 Token 的方法。


5.1 KV Cache ​

我们来回顾一下 KV Cache。以某一层的 Decoder Masked Self-Attention 为例:

首先,投影得到:

Q=YWQ∈Rdk,K=YWK∈Rdk,V=YWV∈Rdv.

计算注意力输出,先忽略除以 dk 和 Softmax:

QKT+Mcausal=(q0q1q2⋮qn)(k0Tk1Tk2T⋯knT)+(0−∞−∞⋯−∞00−∞⋯−∞000⋯−∞⋮⋮⋮⋮⋮000⋯0)=(q0k0T−∞−∞⋯−∞q1k0Tq1k1T−∞⋯−∞q2k0Tq2k1Tq2k2T⋯−∞⋯⋯⋯⋯⋯qnk0Tqnk1Tqnk2T⋯qnknT)

故:

(QKT+Mcausal)V=(q0k0T−∞−∞⋯−∞q1k0Tq1k1T−∞⋯−∞q2k0Tq2k1Tq2k2T⋯−∞⋯⋯⋯⋯⋯qnk0Tqnk1Tqnk2T⋯qnknT)(v0v1v2⋮vn)

观察上式可看出,当我们推理到第 t 个词的时候,计算对应的自注意力输出时,只需要:

qt,K0:t,V0:t,

其中

K0:t=[k0k1⋮kt]∈R(t+1)×dk,V0:t=[v0v1⋮vt]∈R(t+1)×dv

计算推理第 t 个词时 Query 的注意力输出:

at=softmax(qtK0:tTdk)V0:t∈R1×dv

所以,在推理第 t 个词时,如果已经提前缓存了 K0:t−1,V0:t−1,这一步只需要计算新位置的 qt,kt,vt

然后追加:

K0:t=Concat(K0:t−1,kt),V0:t=Concat(V0:t−1,vt).

接着计算

qt⏟1×dkK0:tT⏟dk×(t+1)V0:tT⏟dk×(t+1)⇒注意力输出⏟1×dv,

每一步推理时,把 kt 和 vt 缓存起来,这就是 KV Cache

使用缓存究竟省掉了什么?

假设当前已有 N 个 Token,需要继续预测下一个 Token:

计算内容无缓存的朴素实现使用 KV Cache
历史位置的各层表示对整个前缀重新计算通过已有 KV 避免重算
历史位置的 K、V 投影重算复用
新位置的表示与 Q、K、V计算仍然需要计算
新 Query 对历史 KV 的注意力计算仍然需要计算
各层前馈网络对整个前缀计算只处理新位置

KV Cache 消除了大量历史位置的重复计算,但没有消除新 Token 对历史的注意力计算。


5.2 Prefill:处理输入上下文 ​

假设本次输入已经经过对话模板和分词,得到:

x=(x1,x2,…,xn).

输入包含系统指令、实际保留的历史、当前用户消息以及必要的格式标记。

在生成开始前,这 n 个 Token 全部已知。因此,模型可以一次接收整个输入,并在每一层中并行计算多个位置的表示。

以第 l 层的单个注意力头为例,设经过 Embedding ,该层输入为:

H(l)∈Rn×d.

计算:

Q(l)=H(l−1)WQ(l),K(l)=H(l−1)WK(l),V(l)=H(l−1)WV(l)Q(l),K(l)∈Rn×dk,V(l)∈Rn×dvO(l)=softmax(Q(l)K(l)⊤dk+M)V(l),Mij={0,j≤i,−∞,j>i.

经过 LN,残差连接和 FFN:

O(l)→LN,残差连接,FFNH(l)

特别地,最后一层注意力输出:

O(L)∈Rn×d→取最后一行On,:(L)∈R1×d→Linear + Softmaxz1∈R1×Vy1←解码策略选择Select(z1)

Prefill 完成后,会得到两类重要结果:

  • 第一类:各层输入 Token 的 KV Cache

对于第 ℓ 层,保存:

Kcache(ℓ)=K1:n(ℓ),Vcache(ℓ)=V1:n(ℓ).

每一层都有自己的缓存,因为不同层的输入表示和投影参数不同。

  • 第二类:第一个预测输出的 token idy1

5.3 Decode:逐步生成后续内容 ​

预测出 y1 后,为了预测 y2,需要把 y1 送入模型

这一次,历史输入 x1:n 已经有缓存。因此,各层只需要为 y1 计算新的 Query、Key 和 Value,并让新 Query 访问历史 KV。

首先,经过 Embedding 层:

h1(0)=Embedding(y1)∈R1×d

设进入第 l 层 Decoder Block 的新 token 表示为 h1(l),

计算:

q1(l)=h1(l)WQ(l),k1(l)=h1(l)WK(l),v1(l)=h1(l)WV(l).

然后将新的 Key 和 Value 追加到缓存:

K(x,y1)=[Kcache(l)k1(l)]∈R(n+1)×dk,V(x,y1)=[Vcache(l)v1(l)]∈R(n+1)×dv

这一层对应的新 token 的注意力输出为:

o1(l)=softmax(q1(l)K(x,y1)⊤dk)V(x,y1)∈R1×dv

经过所有层后,得到预测 y2 的 Logits,并选出 y2。随后继续:

y1 送入模型⟶y2,y2 送入模型⟶y3,⋯
阶段本次实际送入模型前向计算结束后的缓存根据本次结果选出
Prefillx1,…,xnx1:n 的 KVy1
第 1 次 Decodey1x1:n,y1 的 KVy2
第 2 次 Decodey2x1:n,y1:2 的 KVy3
第 T−1 次 DecodeyT−1x1:n,y1:T−1 的 KVyT

若第 T 个输出 Token 触发停止,则常规情况下共执行:

1 次 Prefill+(T−1) 次 Decode

KV Cache 的增长与显存开销 见 Transformer.md 中章节 《4.3.4 KV Cache 节省了多少计算?》