从 BERT 到大模型:让模型从“会接龙”到“会回答

人工智能学习笔记 · 第五篇

从 BERT 到大模型:让模型从"会接龙"到"会回答"

这一篇把前面学过的 Transformer、Attention、语言模型训练串了起来。以前我知道 BERT、GPT 都是基于 Transformer 的模型,但它们为什么一个擅长理解、一个擅长生成?一个只会预测下一个 token 的模型,又是怎么变成能和人对话的助手的?

这次我把整条路线串起来:生成循环 → Attention Mask → 三种架构范式 → 大模型能力 → SFT → API 调用。


01 语言模型如何生成文本?

1.1 语言模型:给定前文,预测下一个 token

语言模型做的核心工作是:根据已经出现的 token,预测下一个 token 的概率分布。

P(wt∣w1,...,wt−1) P(w_t \mid w_1,\ldots,w_{t-1}) P(wt∣w1,...,wt−1)

例如,输入"今天天气",模型可能给出下面的候选分布:

候选 token 概率
真 0.45
不 0.25
很 0.15
有 0.10
还 0.05

模型并不是直接"写出一句话",而是给词表中的候选 token 打分,输出 logits,再由外部的选词策略决定选哪个。

这和拼音输入法给出候选词有点像:模型给出概率分布,系统再从中选择一个候选。

1.2 生成是一个循环

文本生成不是一次前向传播就完成的,而是重复执行下面的步骤:

  1. 把当前文本输入模型。
  2. 模型计算下一个 token 的概率。
  3. 根据选词策略选出一个 token。
  4. 把新 token 拼回原文本。
  5. 再次输入模型,继续预测。

例如:

今天天气 → 预测"真" → 今天天气真 → 再预测下一个 token。

不断重复,直到生成 EOS(结束标记)或者达到 max_new_tokens 的限制。

每一步模型都会输出一个 vocab_size 维的向量。比如词表有约 15 万个 token,就相当于每一步都要给这 15 万个候选打分。

这里要区分两件事:模型负责打分,生成循环和解码策略负责选词、决定何时停止。

1.3 选词策略:确定性解码与随机采样

模型给出概率分布后,接下来要解决的问题是:到底选哪个 token?

确定性解码

  • Greedy(贪心) :每一步都选择概率最大的 token,也就是 argmax。结果比较稳定、可复现,但容易出现重复。
  • Beam Search(束搜索):同时保留 k 条候选路径,根据累积概率选择结果。它相对稳妥,但计算开销也会随候选路径增加。

这类方法适合代码、数学、翻译等相对有标准答案的任务。

随机采样

  • Temperature(温度):通过调整 logits 改变概率分布的尖锐程度。

pi=softmax⁡(logits⁡iT) p_i=\operatorname{softmax}\left(\frac{\operatorname{logits}_i}{T}\right) pi=softmax(Tlogitsi)

  • 温度降低,分布更尖锐,高概率 token 更容易被选中。

  • 温度升高,分布更发散,生成结果更有多样性。

  • Top-K:只保留概率最高的 K 个候选,再从中采样。

  • Top-P:按照累积概率截断候选集合,候选数量会根据分布自动变化。

这里给出的参数参考:

任务 Temperature
代码 / 数学 0.1
事实问答 0.3
对话 0.7
创意 1.0

top_p 通常固定为 0.9,可以先固定 top_p,再调整温度。

记住:这些参数改变的是"怎么选词",不是模型本身。确定性和多样性之间需要做工程权衡。


02 BERT 为什么不适合直接生成?

2.1 BERT 不适合生成的三个原因

BERT 的预训练目标和生成任务并不匹配,主要有三个原因。

第一,预训练目标不匹配。

BERT 使用 MLM(Masked Language Modeling),也就是完形填空:给出双向上下文,让模型预测被遮住的位置。

而文本生成是续写:给定前文,预测下一个 token。

一个是在上下文中填空,一个是根据过去继续向后写,训练信号不同。

第二,注意力是双向的。

BERT 的每个位置都可以看到序列中的其他位置,包括它后面的 token。

但生成第 t 个 token 时,不应该提前看到 t+1 及之后的内容,否则就相当于提前看到了答案。

第三,输出长度由输入决定。

BERT 预测的位置数量由输入中 [MASK] 的数量决定。真正的生成则需要模型逐步决定生成多长,以及什么时候输出 EOS 停止。

因此,要让模型适合生成,需要调整训练目标、注意力可见范围和生成方式。

2.2 改造 BERT:核心是三处变化

材料强调,改造时不需要改变 Transformer 的主体结构,主要调整三件事:

改造位置 原来的方式 生成需要的方式
训练目标 MLM 完形填空 Next-token prediction
Attention Mask 双向全可见 下三角因果 Mask
使用方式 一次前向预测 逐 token 生成循环

不变的部分包括层数、隐藏维度、注意力头数和模型参数。

因此,这里最重要的理解是:模型从理解任务转向生成任务,关键变化不是换掉整个 Transformer,而是改变它能看到什么、训练它预测什么,以及如何使用它。

2.3 Attention Mask 加在哪里?

注意力计算可以写成:

$$

\operatorname{Attention}(Q,K,V)

\operatorname{softmax}\left(

\frac{QK^T}{\sqrt{d}}+M

\right)V

$$

其中,Mask 矩阵 M 加在 softmax 之前。

计算过程可以拆成四步:

  1. 计算相似度 :scores = Q @ K.T / sqrt(d)。
  2. 屏蔽不可见位置:把不允许关注的位置加上负无穷。
  3. Softmax 归一化:负无穷经过 softmax 后对应的权重变成 0。
  4. 加权聚合:用注意力权重对 V 做加权求和。

对应的代码:

python 复制代码
scores = Q @ K.T / math.sqrt(d)       # 计算打分
scores.masked_fill_(mask == 0, -inf)  # 屏蔽不可见位置
w = torch.softmax(scores, dim=-1)     # 转换为注意力权重
out = w @ V                           # 加权求和

Mask 并不是给模型增加新的能力,而是在注意力计算中规定:每个位置有权看到哪些位置。

2.4 L×L 矩阵:谁能看见谁?

Mask 可以理解为一张 L×L 的可见性表格:

  • mask[i][j] = 1:第 i 个 token 可以看到第 j 个 token。
  • mask[i][j] = 0:第 i 个 token 看不到第 j 个 token,对应注意力分数会被屏蔽。

常见模式如下。

全可见 Mask(双向)

所有位置都可以看到所有位置,代表模型是 BERT、RoBERTa,主要用于分类、NER、信息抽取等理解任务。

下三角 Mask(因果)

每个位置只能看到自己和之前的位置,不能看到未来位置。代表模型是 GPT、Llama、Qwen,主要用于对话、续写和代码生成。

前缀双向 + 后缀因果 Mask

前缀部分可以双向互相查看;后缀部分只能看到前缀和自己。代表模型包括 GLM、ChatGLM 的 Prefix LM 变体,适用于以输入前缀为条件的生成任务。

所以,三种可见性模式可以概括为:

Mask 模式 可见规则 代表模型 主要用途
全可见 所有位置互相可见 BERT / RoBERTa 理解
下三角 只能看自己和过去 GPT / Llama / Qwen 生成
前缀双向 + 后缀因果 前缀互看,后缀看前缀和自己 GLM / ChatGLM 变体 条件生成

同一个 Transformer,改变 Mask 的可见性规则,就可以适配不同任务。

2.5 自回归训练:一次前向,监督所有位置

自回归训练的目标是:让序列中每个位置都预测下一个 token。

例如,输入序列是:

text 复制代码
输入 x:深 度 学 习
标签 y:度 学 习 <eos>

标签相对输入向后错开一位(shift by one)。

由于因果 Mask 保证第 i 个位置只能看到前 i 个 token,因此每个位置的输出都可以用于预测下一个 token。

一条长度为 L 的序列,就能提供 L 个位置的预测训练信号,而不是只提供一个样本。

示例代码:

python 复制代码
logits = model(x)  # (B, L, V)

loss = F.cross_entropy(
    logits.view(-1, V),
    y.view(-1)
)

这里把所有位置的预测结果一起计算 loss。

对比 BERT 的 MLM,这里需要注意:MLM 只有约 15% 的位置有监督信号,而因果语言模型会利用序列中的每个位置进行 next-token 预测。

训练时可以一次读入整条序列,并行计算所有位置;推理生成时没有后续标签,只能逐个 token 生成。

2.6 KV Cache:避免重复计算历史部分

自回归生成时,每次只增加一个 token。如果每一步都重新计算整个历史序列,会重复计算已经处理过的部分。

KV Cache 的作用就是缓存之前 token 的 Key 和 Value。

  • 没有 Cache :Q 的形状为 (t, emb),QKᵀ 的形状为 (t, t),每一步都要重新计算整段。
  • 有 Cache :新 token 的 Q 形状为 (1, emb),QKᵀ 的形状为 (1, t);历史 K/V 直接从缓存读取。

缓存也有代价,需要占用显存。这里给出的缓存规模表达式为:

2×层数×KV头数×dhead×长度×batch 2 \times \text{层数} \times \text{KV头数} \times d_{\text{head}} \times \text{长度} \times \text{batch} 2×层数×KV头数×dhead×长度×batch

可以把它理解为:历史部分不必反复计算,但需要把历史 K/V 保存起来。


03 三种架构范式:Encoder-only、Decoder-only、Encoder-Decoder

Transformer 并不只有一种使用方式。根据 Encoder、Decoder、Mask 和 Cross-Attention 的组合,可以分成三种常见范式。

3.1 Encoder-only

  • 结构:Encoder × L。
  • Mask:全可见、双向注意力。
  • 训练目标:MLM 完形填空。
  • 代表模型:BERT、RoBERTa。
  • 擅长任务:文本分类、命名实体识别(NER)、检索。
  • 短板:不擅长直接进行自回归生成。

它更适合把输入文本编码成表示,再用于理解和判断。

3.2 Decoder-only

  • 结构:Decoder × L。
  • Mask:下三角因果 Mask。
  • 训练目标:Next-token prediction。
  • 代表模型:GPT、Llama、Qwen。
  • 擅长任务:对话、续写、代码生成。
  • 短板:单向理解能力相对较弱。

它通过不断预测下一个 token,完成文本生成。

3.3 Encoder-Decoder

  • 结构:Encoder + Decoder,并使用 Cross-Attention。
  • Mask:Encoder 双向编码,Decoder 因果解码。
  • 训练目标:Span 去噪 / Seq2Seq。
  • 代表模型:T5、BART、Whisper。
  • 擅长任务:翻译、摘要、自动语音识别(ASR)。
  • 短板:结构更复杂,成本更高。

它适合输入和输出之间存在明确转换关系的任务。

3.4 如何选择架构?

我理解的选型思路是:先看任务希望模型输出什么,再看数据和部署条件。

任务需求 更适合的范式
输出标签、分数或实体 Encoder-only + 微调
输入与输出需要严格转换 Encoder-Decoder
任意文本输入,生成任意文本 Decoder-only

材料还强调,通用助手这一方向更倾向于 Decoder-only,原因包括:

  • 每个 token 都能提供训练信号,训练信号密度高。
  • 一个 next-token 目标可以统一多种任务。
  • 随着模型规模增加,ICL 能力会出现。
  • 工程上可以使用一套统一的推理流程。

但这不意味着其他范式没有价值。翻译、ASR、向量检索和低延迟分类等任务,Encoder-Decoder 或 Encoder-only 仍可能更合适。

实际落地时,还需要考虑数据条件:

  • 没有数据:先调用 API。
  • 有私有数据:考虑 LoRA。
  • 对低延迟和自部署有要求:考虑本地部署。

04 大模型的规模与能力

4.1 ChatGPT 时刻:从专用工具到通用接口

材料以 ChatGPT 的发布作为一个重要节点:

  • 2022 年 11 月 30 日:ChatGPT 公开发布。
  • 发布后 5 天,用户数量突破百万。
  • 2023 年 1 月:约 2 个月达到 1 亿月活。
  • 2023 年 3 月 14 日:GPT-4 发布。

这一变化不仅是模型规模变大,还体现在使用方式上:

  1. 一个模型可以尝试完成多种任务,不再是一种模型只负责一种任务。
  2. 自然语言成为人与模型交互的接口。
  3. 用户可以尝试零样本任务,不一定需要针对每个新任务重新训练模型。

这让模型从传统的专用工具,逐渐变成一种通用接口。

4.2 Scaling Law:规模与效果之间的规律

Scaling Law 描述了模型规模、数据规模或计算量与训练损失之间的关系。

这里给出的形式为:

L(X)=(XcX)α L(X)=\left(\frac{X_c}{X}\right)^\alpha L(X)=(XXc)α

这里的 X 可以代表:

  • N:参数量。
  • D:数据量。
  • C:计算量。

它们与 loss 之间呈现幂律关系。规模增加时,loss 会按照相对稳定的规律下降,因此可以根据预算预测训练效果。

另外还提到 Chinchilla(2022):参数量与训练数据量需要同比例增长。

需要注意,公式中的有效拟合指数会受到数据复杂度、优化器和训练协议等条件影响;这些条件改变时,指数也可能变化。

模型规模参考:

模型 年份 参数规模 训练数据
GPT-1 2018 117M 书籍语料
GPT-2 2019 1.5B 40GB 网页
GPT-3 2020 175B 300B tokens
GPT-4 2023 约 1T 多模态语料

另外还提到,Llama-3 使用了 15T tokens;而 Qwen3-0.6B 已经可以在笔记本上运行。

这里想表达的不只是模型越来越大,也包括单位能力的使用成本在下降。

Scaling Law 让模型训练从单纯"试出来",逐渐变成可以结合预算进行规划的工程问题。

4.3 涌现能力:有些能力会在规模增长后明显出现

材料把一些能力描述为具有规模阈值的"涌现"现象:

能力 材料中的规模参考 表现
In-Context Learning 约 100B 把示例放进 prompt 就能完成任务
Chain-of-Thought 大于 100B 可以展开推理过程
多步数学推理 约 100B GSM8K 表现出现明显提升
稳定指令遵循 约 100B + 对齐 仅靠规模还不够,需要后训练

材料也提醒:涌现看起来是否呈现明显的台阶,与评测指标有关;换成连续指标时,提升可能更像平滑增长。

所以不能把"涌现"简单理解成模型在某个参数规模之前完全不会、之后突然什么都会。更重要的工程结论是:模型规模和后训练会影响能力表现。

4.4 ICL:不更新参数,用示例切换任务

ICL(In-Context Learning,上下文学习)指的是:不修改模型权重,只通过 prompt 中的任务描述和示例,让模型尝试完成新任务。

可以分为三种形式:

  • Zero-shot:只描述任务,不提供示例。
  • One-shot:提供一个示例。
  • Few-shot:提供少量示例,这里给出的范围是 2~8 个。

例如:

text 复制代码
Zero-shot:
把下面这句翻译成英文:海獭

One-shot:
海獭 → sea otter
奶酪 →

Few-shot:
2 + 3 = 5
4 × 5 = 20
7 - 2 =

ICL 的重要意义:

  • 不需要为每个新任务准备训练数据并更新权重。
  • 切换任务时,通常只需要修改 prompt。
  • 一个模型可以尝试承担翻译、问答、摘要、代码等多种任务。

材料列出三种解释假说:

  1. 元学习:预训练过程中见过大量不同任务。
  2. 隐式梯度:注意力机制可能在前向计算中模拟微调过程。
  3. 格式识别:示例主要帮助模型识别任务格式。

这里要记住:ICL 不等于真的更新了模型参数,它是在上下文中利用示例完成任务。

4.5 CoT:让模型展开推理过程

CoT(Chain-of-Thought,思维链)是通过提示模型分步骤处理问题,让中间步骤显式呈现出来。

材料中的例子:

text 复制代码
食堂有 23 个苹果,用了 20 个,
又买了 6 个,还剩几个?

如果直接回答,可能得到错误结果;如果先拆分步骤:

text 复制代码
23 - 20 = 3
3 + 6 = 9
答案:9

Zero-shot CoT 的做法是在问题末尾加一句:

Let's think step by step

不提供示例,也让模型尝试展开推理链。

这里给出的 PaLM 540B 在 GSM8K 上的准确率对比:

提示方式 准确率
标准 prompt 18%
Zero-shot CoT 40%
Few-shot CoT 57%

材料总结 CoT 可能有效的原因:

  • 把复杂问题拆成简单子问题。
  • 中间步骤可见,便于检查和纠错。
  • 符合逐 token 生成的形式。

但小模型使用 CoT 反而可能表现更差,CoT 的效果具有规模依赖性。

另外还提到,今天的 o1 / R1 把"写过程"训练进了模型内部;其训练方式涉及强化学习,本节没有展开。

4.6 大模型突破了什么,又带来了什么代价?

传统 NLP 面临的三类限制:

传统限制 大模型带来的变化
一个模型绑定一个任务 一个模型可以通过 prompt 尝试多个任务
依赖标注数据 可以通过 ICL 尝试零样本或少样本任务
换一种表达就容易退化 可以通过自然语言描述任务

大模型的优势包括通用性、可编程性和零样本泛化。

但代价也很明确:

  • 训练和推理成本。
  • 响应延迟。
  • 幻觉与不可控。
  • 版权问题和能耗。

还有一个关键前提:预训练得到的模型首先是一个会接龙的模型,并不天然就是一个会按用户意图回答问题的助手。


05 SFT:让续写模型变成问答助手

5.1 Base Model 为什么不一定会回答问题?

只有预训练的 Base Model,学习目标是根据前文预测下一个 token。

例如输入:

text 复制代码
什么是人工智能?

模型可能继续输出:

text 复制代码
什么是机器学习?
什么是深度学习?
什么是神经网络?
......

它不是完全没有完成任务,而是在按照训练目标续写文本。

原因是训练语料中,"问题"后面经常跟着更多问题,例如 FAQ 标题、目录或题目列表。

所以,预训练教会模型语言和知识,但没有直接教会它如何作为助手服务用户。

5.2 Base Model 与 Chat Model

同样输入:

text 复制代码
用一句话解释 Transformer 的核心

Base Model 可能继续提出相关问题;经过 SFT 的 Chat Model 则更可能直接组织答案、理解用户意图,并在回答结束后生成结束标记。

两者可以使用相同的架构和参数规模。区别在于中间增加了一个监督微调阶段。

5.3 SFT 做什么:改数据,不改结构

SFT(Supervised Fine-Tuning,监督微调)使用指令和回答组成的数据,让模型学习如何按照指令回答。

训练数据通常采用对话模板,例如:

text 复制代码
<|user|>
什么是人工智能?
<|assistant|>
人工智能是让机器模拟人类智能的一系列技术......
<|end|>

角色标记帮助模型区分谁在说话,以及一段回答在哪里结束。

这里给出的数据规模是几万到几十万条指令---回答数据,可以由人工编写或筛选得到。

SFT 的几个关键点:

  • 改变的是训练数据、loss 的计算范围和对话模板。
  • Transformer 结构不需要增加新的层。
  • 训练目标仍然是 next-token prediction。
  • 它主要教模型"应该怎样回答",而不是凭几万条数据灌入大量新知识。

SFT 的重点不是重新教模型所有知识,而是让模型学会使用已有知识回答用户。

5.4 Loss Mask:只学习回答部分

SFT 训练时,并不是输入序列中的每个 token 都参与 loss。

材料中的做法是:用户 prompt 部分的标签设为 -100,回答部分保留真实 token ID。

例如:

text 复制代码
输入:
<|user|> 什么 是 AI ?
<|assistant|> AI 是 智能 <|end|>

labels:
-100 -100 -100 -100
AI   是   智能 <|end|>

对应代码:

python 复制代码
# prompt 部分不参与 loss
labels = [-100] * len(prompt) + \
         input_ids[len(prompt):]

loss = F.cross_entropy(
    logits,
    labels,
    ignore_index=-100
)

ignore_index=-100 是 PyTorch 的约定:这些位置会被忽略,不参与 loss 计算。

为什么要这样做?

因为 SFT 想让模型学习"如何回答",而不是让它把用户的问题也当成需要学习生成的目标。

材料对比了训练信号密度:

  • 预训练:序列中 100% 的位置都可以提供监督信号。
  • SFT:只有回答部分参与 loss,材料估计约占 50%。

5.5 SFT 改变了什么?

没有改变的部分:

  • Transformer 架构不变。
  • 参数量不变。
  • Attention Mask 仍然是下三角因果 Mask。
  • 训练目标仍然是 next-token prediction。
  • 推理仍然是逐 token 自回归生成。

发生改变的部分:

  • 输出分布:看到指令后更倾向于生成回答。
  • 对话协议:学习 <|user|> 和 <|assistant|> 的轮换。
  • 停止行为:学习在合适位置生成 <|end|>。
  • 表达风格:更容易组织成结构化、分点的回答。

可以这样记:

预训练提供知识,SFT 教会模型回答的形式。

5.6 预训练、SFT 与对齐:三个阶段

材料把模型训练过程概括为三个阶段:

阶段 数据与目标 主要结果
预训练 大规模无标注语料,next-token prediction 语言能力与世界知识
SFT 指令---回答数据,next-token + Label Mask 按指令回答、组织表达、学会停止
对齐 人类偏好数据与反馈信号 让回答更符合人类偏好、更加安全

其中,对齐阶段涉及 RLHF、DPO、GRPO,本节没有展开。

材料强调,预训练数据规模远大于 SFT 数据规模,但模型的回答形式和偏好会受到后两个阶段影响。

5.7 SFT 工程实践中的四个问题

1. 数据质量大于数据数量

几百条高质量标注数据,可能比几万条噪声数据更有价值。格式不一致也可能把模型带偏。

2. 多样性覆盖

训练数据需要覆盖不同任务类型、长度和语气。覆盖不足时,模型可能只会按照某一种格式回答,换一种问法就表现不稳定。

3. 灾难性遗忘

SFT 时间过长,可能导致模型丢失部分预训练能力。这里给出的应对思路包括使用较小学习率、减少 epoch,以及混入通用数据。

4. 参数高效微调:LoRA

LoRA 只训练一小部分参数,这里给出的比例约为 0.3%~1%,就可能改变模型行为。

材料还安排了后续使用 Qwen3-0.6B 进行 LoRA 实践。

这里最容易记错的一点是:SFT 主要是调行为,不是替代预训练来灌入大量知识。


06 LLM API:把模型接入自己的程序

模型训练好之后,还需要通过接口让程序能够调用它。

6.1 三条落地路径

路径 优势 代价与限制
闭源 API 零运维,注册后即可调用 按 token 付费,数据出域,模型不可修改
开源权重自部署 可私有化、量化和修改 需要 GPU 与运维,能力取决于模型选型
自己微调 更贴合业务任务 需要标注数据和训练资源,能力上限受基座模型限制

材料的建议是:先把 API 路径跑通,再逐步考虑自部署和微调。

6.2 OpenAI 兼容接口:三个关键参数

很多平台提供 OpenAI 兼容接口。调用时需要关注三样东西:

  • base_url:服务地址。
  • api_key:身份凭证。
  • model:模型名称,决定调用哪个模型。

示例:

python 复制代码
from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.deepseek.com/v1",
    api_key=os.environ["DEEPSEEK_API_KEY"]
)

Key 应放在环境变量中,不要直接写在代码里。

当不同平台都提供兼容接口时,通常只需要修改服务地址和模型相关配置,就可以复用大部分 SDK 调用代码。

6.3 Messages:模型本身不保存对话记忆

一次请求通常通过 messages 数组传递对话历史,并按时间顺序排列。

python 复制代码
messages = [
    {
        "role": "system",
        "content": "你是耐心的助教"
    },
    {
        "role": "user",
        "content": "什么是 SFT?"
    },
    {
        "role": "assistant",
        "content": "SFT 是......"
    },
    {
        "role": "user",
        "content": "那它和预训练有什么区别?"
    }
]

三个角色分别负责:

  • system:身份、规则和输出格式。
  • user:当前问题、材料和指令。
  • assistant:历史回答,需要一起传回去,才能让模型接着之前的对话回答。

上下文窗口包含历史消息、新问题和预留输出空间。超出窗口后,需要截断或摘要。

因此,多轮对话并不是模型自动记住了所有内容,而是程序把历史消息持续追加到 messages 数组中,再传给模型。

历史越长,每次请求需要处理的输入 token 越多,成本也会增加。

6.4 非流式调用:等全部生成完成再返回

非流式调用会等待模型生成完整结果后再返回。

python 复制代码
resp = client.chat.completions.create(
    model="deepseek-flash",
    messages=[
        {"role": "system", "content": "你是助手"},
        {"role": "user", "content": "解释一下 ICL"}
    ],
    temperature=0.7,
    max_tokens=512
)

print(resp.choices[0].message.content)

返回结果中常用的信息包括:

  • choices[0].message.content:生成的正文。
  • usage.prompt_tokens:输入 token 数量。
  • usage.completion_tokens:输出 token 数量。

非流式调用适合批处理、需要拿到完整结果再解析或入库,以及对首字延迟不敏感的任务。

6.5 流式调用:边生成边返回

流式调用可以在模型生成过程中,逐段把内容返回给程序。

相对于非流式调用,主要变化是设置 stream=True,并循环读取返回的 chunk。

python 复制代码
stream = client.chat.completions.create(
    model=MODEL,
    messages=msgs,
    stream=True
)

for chunk in stream:
    d = chunk.choices[0].delta
    if d.content:
        print(d.content, end="", flush=True)

HTTP 层常见的形式是 SSE(Server-Sent Events)事件流。每个 data: 后面带有一个 JSON 数据,最后通过 [DONE] 表示结束。

流式与非流式的区别:

方式 返回方式 常见场景
非流式 全部生成完成后一次返回 批处理、后台任务
流式 生成一段就返回一段 对话界面、实时生成

流式不会改变模型本身,也不会改变价格,主要改变的是用户什么时候能看到第一个字。

6.6 参数、计费与上下文

常见的 API 参数:

参数 作用
temperature 控制生成多样性
top_p 核采样
max_tokens 限制输出长度
stop 遇到指定字符串时停止
stream 是否使用流式返回

费用可以粗略表示为:

费用≈输入 tokens×输入单价+输出 tokens×输出单价 \text{费用} \approx \text{输入 tokens}\times\text{输入单价} + \text{输出 tokens}\times\text{输出单价} 费用≈输入 tokens×输入单价+输出 tokens×输出单价

输出通常比输入更贵,思考 token 也会计入输出用量;命中前缀缓存时,输入成本可能降低。

三个省钱办法:

  1. 合理收紧 max_tokens。
  2. 批量任务使用 Batch。
  3. 开发阶段优先使用小模型。

另一个容易忽略的点:写清楚 system prompt 中的角色、格式、例子和边界,通常比反复调整 temperature 更有效。

6.7 生产环境中的故障处理

API 在真实项目中可能遇到不同故障:

故障 可能原因 处理方式
429 限流 请求过于密集 重试与退避
连接超时 服务不可用或响应过慢 断路器快速失败
网络抖动 偶发网络错误 适当重试
401 Key 失效 欠费、泄漏或过期 切换备用服务并告警

材料介绍了三层防护:

第一层:重试 + 退避

遇到限流或超时,可以采用指数退避,例如等待时间逐渐增加:

1s → 2s → 4s

第二层:断路器

当连续失败达到阈值时,断路器进入 OPEN 状态,后续请求快速失败,不再一直等待超时。

第三层:多 Provider + 主动探针

准备主、备 Provider。主服务出现持续故障时切换到备用服务;后台定时探测故障服务,确认恢复后再切回。

断路器的状态变化:

text 复制代码
CLOSED → OPEN → HALF_OPEN → CLOSED

材料中的 llm_failover 示例项目使用 FastAPI 和两个 Provider,每个 Provider 都有自己的断路器。它通过真实请求失败更新状态,也会定时探测处于 OPEN 状态的 Provider。

这里的核心矛盾是:单次失败不应该立刻切换,因为它可能只是短暂抖动;但持续失败时又必须快速切换,不能让用户一直等待。

6.8 Thinking 与 reasoning_content

材料还介绍了接口中的思考开关。

关闭 thinking 时,返回内容主要是 content;开启 thinking 时,返回结构中还可能出现 reasoning_content。

python 复制代码
# 开启思考
"thinking": {"type": "enabled"}

# 关闭思考
"thinking": {"type": "disabled"}

工程上需要注意:

  • 思考模式可能增加 token 消耗和响应延迟。
  • 简单任务可以显式关闭;需要分步推理时再开启。
  • reasoning_content 不要和 content 混在一起存储,否则可能污染后续上下文。

07 全篇回顾:从 BERT 到可以上线的大模型

把这一篇串起来,我现在能更清楚地理解一个大模型从基础语言模型走向对话助手的过程:

text 复制代码
BERT
双向理解
    ↓ 改变 Attention Mask
Causal LM
自回归生成
    ↓ 大规模 next-token 预训练
Base Model
拥有语言能力与知识
    ↓ SFT + Loss Mask
Chat Model
学会按指令回答
    ↓ 采样策略 + API
应用程序
接入模型并上线

这条路线中,最重要的变化可以归纳为:

  1. BERT 与 GPT 的差别:注意力可见范围和训练目标不同。
  2. 生成的本质:模型预测下一个 token,外部循环负责不断拼接和生成。
  3. 三种架构范式:Encoder-only、Decoder-only、Encoder-Decoder 各有适用任务。
  4. 大模型能力:Scaling Law 描述规模与效果的关系,ICL 和 CoT 展示了规模带来的新能力。
  5. 预训练与 SFT:预训练提供语言能力和知识,SFT 让模型学会按照指令回答。
  6. API 工程:通过 messages、流式返回、参数控制、计费和故障转移,把模型接入真实程序。

最后,我想记住这一篇贯穿始终的主线:

同一个 Transformer,从理解走向生成,再走向对话助手和实际应用,关键变化集中在 Attention Mask、训练数据、Loss 的计算位置,以及生成和调用方式上。

相关推荐
TomEval27 分钟前
【测AI】第26篇:线上模型监控与告警体系 — 测试不是终点
人工智能·python·功能测试·ai
ZhengEnCi1 小时前
AI 总模仿代码库里的过时写法怎么办:先清坏样例,再用类型与测试让 AI 无法犯错
人工智能·ai编程
一只爱撸猫的程序猿1 小时前
五周、两个开源仓库、九次拦截之后:AI 时代程序员缺的到底是什么
人工智能·后端·开源
GitCode官方2 小时前
开源鸿蒙跨平台直播|AI 时代,用 cj-tauri 开发鸿蒙 PC 应用
人工智能·华为·harmonyos·atomgit
老金带你玩AI2 小时前
GPT-6.2更强更便宜了,为什么还有人骂?
人工智能
CyrusYiVPP3 小时前
实测 uv 0.13.7:同一套包,pip 装 94 秒,它只用 19 秒
人工智能·python
泯泷3 小时前
OpenClaw 退潮背后,是 AI 圈“技术自嗨”的终结
人工智能·chatgpt·llm
罗西的思考3 小时前
【轻量化复刻大模型 / KIMI K3】Muon 优化器及 训练系统
人工智能·算法·机器学习
屿华AI3 小时前
AUTOSAR 实战-诊断工具 | 用 Claude Code 开发诊断测试工具:AI 协作开发实践
人工智能·测试工具