罗罗编程学习记录
本页内容 展开查看

06.2 阶段 1:LLM 基础与输出控制

所属:全栈开发面试题库 / 学习路径 / 06 AI Agent

本页目录

一、阶段定位

阶段 0 你已经能把一个请求发出去、拿到回答。本阶段解决"怎么让回答稳定、可预期、成本可控"的问题。核心不是"模型有多聪明",而是三件事:模型按 token 计费,所以你必须能数 token;采样参数决定输出的随机性与长度;上下文窗口有硬上限,超长必须截断或摘要。

为什么这是阶段 1:从这一阶段开始,你做的每个决定都会反映到账单和响应质量上。不理解 token,就无法估算成本;不理解采样参数,就无法复现一次"好回答";不理解上下文窗口,长输入直接 400。这些都是后面 Prompt 工程、RAG、Agent 的前置——RAG 要把检索结果塞进上下文,Agent 要把历史消息塞进去,窗口管理是它们共同的地基。

与前后阶段的衔接:往上接 阶段 0,那时你只看到 usage 里的数字,本阶段要知道这些数字怎么来的、怎么预估;往下接 阶段 2 Prompt 工程与结构化输出,那时你会学习怎么约束输出格式,但前提是你已经能控制温度和长度。跳过本阶段直接写 Prompt,常见的后果是:每次输出都不一样却不知道调哪个参数、长文档一塞就报错、月底收到账单吓一跳。

本阶段的卡点(判断依据):

  • 把模型当数据库:现象是追问模型训练数据截止时间之后的事,模型仍一本正经编造。判断标准:你能否说清"知识截止日期"这个概念,并知道该用检索(阶段 4)而不是追问来获取实时信息。
  • 不区分输入与输出 token 计价:现象是估算成本时把输入输出混为一个价。判断标准:你能否说出输入 token 和输出 token 单价通常差 3–5 倍,并据此理解"为什么要控制输出长度"。
  • 上下文超长直接报错不做截断:现象是把整篇文档塞进去得到 context_length_exceeded,就放弃了。判断标准:你能否给出三种以上超长处理策略(截断、摘要、分块检索)。

二、阶段目标与投入

能力目标(可验证的行为) 验证方式
能估算一段文本的 token 数,并解释中英文差异 用 tokenizer 把一句中文和一句英文分别数 token,说出比例
能解释 temperature/top_p/max_tokens/stop 各自的作用与推荐区间 同一问题在不同 temperature 下各生成 5 条,能描述差异
能对超长输入设计截断或摘要策略 给定一段超过窗口的文本,写出处理后的 messages 构造逻辑
能按输入/输出 token 估算单次调用成本 给出价格表,算出一次 1000 输入 + 500 输出的调用费用
能按任务选模型,说明为什么 列一张"任务—模型—理由"对照表
能说清模型能力边界(代码、数学、长文、实时知识) 对一个超出能力的任务,能指出该用工具或检索而非模型硬答

建议学时:

  • 全职(每天 4–6 小时):1.5 周,约 40 小时。其中 token 与上下文 12 小时、采样参数实验 10 小时、成本与选型 10 小时、能力边界与复盘 8 小时。
  • 在职(每天 2 小时、周末补 4 小时):3–4 周,约 45 小时。采样参数务必做对比实验,不要只看文字说明。

学时分配:token 与分词 15%、上下文窗口与截断 20%、采样参数 25%、Transformer 直觉 10%、成本与缓存 15%、能力边界与选型 15%。采样参数是实验性最强的部分,时间要给够。

三、先修自检

先修项 合格标准 不合格时回到
一次完整请求 能发 chat completions 并打印 usage 06.1 阶段 0
JSON 结构 能口述 choices[0].message.content 路径 06.1 阶段 0
环境变量 Key 从环境变量读取,不硬编码 06.1 阶段 0
算术 能做单价 × token 量的乘法与单位换算 直接补算术即可

经验判断:如果你之前用过聊天界面和模型对话,最容易犯的错是"凭感觉调 temperature"——认为 temperature 越高越聪明。本阶段要用实验证明它只是在控制随机性,不提升质量。

四、知识地图

模块 知识点 掌握程度 对应题库章节
Token 与分词 subword 分词、中英文 token 比、tokenizer 调用 能讲清原理 10.1 LLM 基础
上下文窗口 窗口大小、输入+输出共享窗口、截断策略 能讲清原理 10.1 LLM 基础
采样参数 temperature、top_p、max_tokens、stop、seed 会用 10.1 LLM 基础
Transformer 直觉 注意力、自回归、上下文越长越慢越贵 了解 10.1 LLM 基础
成本结构 输入/输出分别计价、prompt 缓存、批量折扣 会用 10.1 LLM 基础
能力边界与选型 知识截止、多模态、代码/数学边界、模型分级 能讲清原理 10.1 LLM 基础

进度管理建议:采样参数一定要做"同问题多温度"对比实验,把观察写进笔记。《知识点全清单》给全量条目,本页聚焦重点;术语查《术语表》。

五、分模块精讲

5.1 Token 与分词

为什么需要它:模型不直接读"字",也不读"词",而是读 subword token。计费、上下文窗口、截断都按 token 算。不知道 token 怎么数,就既控不住成本也控不住长度。

核心机制:

  • 分词(tokenization)把文本切成 subword 单元:常见词整块成一个 token,罕见词拆成片段。例如 "unbelievable" 可能切成 un + believ + able 三个 token。
  • 英文大约 1 token ≈ 4 个字符 ≈ 0.75 个单词;中文一个汉字通常约 1–2 个 token(不同 tokenizer 差异大),所以中文相同字数比英文更"费 token"。
  • 每次请求的 usage.prompt_tokens 是输入侧所有 messages(system + 全部历史)合并后的 token 数;completion_tokens 是模型生成的 token 数。
  • 不同模型的 tokenizer 不同,token 数不能跨模型直接搬,但量级可估。
  • 推荐用官方 tokenizer 或 tiktoken(OpenAI 系)精确数,不要用字符数除以 4 硬估。

最小可运行示例:

pip install tiktoken
# count_tokens.py:精确数 token 并对比中英文
import tiktoken

# 选对应模型的编码;gpt-4o 系用 o200k_base
enc = tiktoken.get_encoding("o200k_base")

text_en = "Tokenization splits text into subword units."
text_zh = "分词把文本切成子词单元,这是计费的基本单位。"

for name, t in [("英文", text_en), ("中文", text_zh)]:
    ids = enc.encode(t)
    print(f"{name}: 字符数={len(t)} token数={len(ids)}")
    print("  切片:", [enc.decode([i]) for i in ids])
# 典型输出(量级):
# 英文: 字符数=47 token数=9
# 中文: 字符数=26 token数=18

常见坑:

现象 原因 修法
中文 token 数远超预期 汉字在 subword 下常多字一切 用 tokenizer 精确数,不要按字符估
多轮对话后 prompt_tokens 暴涨 历史 messages 每条都重复计入 做历史压缩或摘要(阶段 5)
用错 tokenizer 估出的数和 usage 对不上 不同模型编码不同 用模型对应编码,或直接看返回的 usage

面试考法:问"为什么中文比英文费 token"。要点:英文 subword 把常见词整块编码,平均一个 token 承载约 0.75 个词;中文 tokenizer 对汉字常按 1–2 token 切,相同信息量中文 token 数更高。追问常问"多轮对话为什么成本随轮次线性增长",答到"每轮都把全部历史重新送进输入侧,prompt_tokens 随消息条数增长"。

5.2 上下文窗口与截断策略

为什么需要它:每个模型都有上下文窗口上限(如 128k tokens),且输入与输出共享这个窗口——输入 100k 时输出只能再有 28k。超长输入直接 400。生产中必须主动管理窗口,不能等报错。

核心机制:

  • 窗口 = 最大输入 token + 最大输出 token 之和。max_tokens(输出预留)必须小于窗口减去 prompt_tokens。
  • 超长处理策略按成本从低到高:
    1. 截断:从历史消息的最早轮次删起(保留 system 和最近 N 轮),适合对话。
    2. 摘要压缩:把旧历史用模型总结成一段,再放回上下文。
    3. 检索式记忆:不把全部历史塞进去,只检索相关片段(阶段 4/5)。
  • 截断时保留 system 提示词和最近轮次,删除中间旧轮次;不要删 system,否则行为设定丢失。
  • max_tokens 设太大浪费配额,设太小回答被 length 截断;按任务预估输出长度设置。

最小可运行示例:

# trim_messages.py:按 token 预算截断历史
import tiktoken

enc = tiktoken.get_encoding("o200k_base")
MAX_INPUT_TOKENS = 100_000   # 留出输出空间

def count(msg: dict) -> int:
    return len(enc.encode(msg["content"]))

def trim(messages: list[dict]) -> list[dict]:
    # system 永远保留,其余从最旧的 user/assistant 删起
    system = [m for m in messages if m["role"] == "system"]
    rest = [m for m in messages if m["role"] != "system"]
    budget = MAX_INPUT_TOKENS - sum(count(m) for m in system)
    kept = []
    # 从最新一条往前加,直到预算用完
    for m in reversed(rest):
        if budget - count(m) < 0:
            break
        kept.append(m)
        budget -= count(m)
    return system + list(reversed(kept))

# 模拟 10 轮对话后截断
msgs = [{"role": "system", "content": "你是助手"}]
for i in range(10):
    msgs.append({"role": "user", "content": f"第{i}个问题" * 50})
    msgs.append({"role": "assistant", "content": f"第{i}个回答" * 50})
trimmed = trim(msgs)
print(f"截断前 {len(msgs)} 条 -> 截断后 {len(trimmed)} 条")

常见坑:

现象 原因 修法
context_length_exceeded 但单次输入很短 历史 messages 累积超窗 按上面的 trim 截断旧历史
截断后模型"忘了"早期要求 删了 system 提示词 system 永远保留在第一条
回答被 length 截断 max_tokens 太小 按任务预估输出长度调大

面试考法:问"上下文窗口里输入和输出是什么关系,为什么输入太长会影响输出"。要点:共享窗口,输入占满后输出空间被挤掉;生产中要给输出预留 max_tokens。追问常问"长对话怎么不丢早期信息又不超窗",答到"摘要压缩 + 检索式记忆,而不是无脑截断"。

5.3 采样参数:temperature、top_p、max_tokens、stop

为什么需要它:同样的输入,模型每次输出不同,是因为生成过程是概率采样。要让输出稳定、可复现、不跑偏,就必须懂这些参数。这是"输出控制"的核心。

核心机制:

  • temperature(温度):控制概率分布的平滑度。0 = 贪心(取概率最高的 token,最稳定);越高越发散、越有创意但也越容易出错。问答/抽取/结构化任务建议 0–0.3;文案/创意 0.7–1.0;>1.0 很少用。
  • top_p(核采样):只从累计概率达到 p 的最小 token 集合里采样。0.1 表示只在最可能的前 10% 里选。与 temperature 一般只调一个,不要同时大改。
  • max_tokens:模型单次最多生成多少 token,是硬上限。
  • stop:停止序列,遇到该字符串就停止生成,不消耗后续 token。常用于控制输出格式边界。
  • seed:固定随机种子,相同 seed + 相同参数可复现输出(不保证所有模型都严格支持)。

最小可运行示例:

# sample_experiment.py:同一问题不同温度对比
import httpx
from config import BASE_URL, API_KEY, MODEL, auth_header

def ask(temp: float, n: int = 3) -> list[str]:
    out = []
    for _ in range(n):
        r = httpx.post(
            f"{BASE_URL}/chat/completions",
            headers=auth_header(),
            json={
                "model": MODEL,
                "messages": [{"role": "user", "content": "用一句话解释什么是缓存。"}],
                "temperature": temp,
                "max_tokens": 80,
                "stop": ["\n"],
            },
            timeout=30.0,
        )
        out.append(r.json()["choices"][0]["message"]["content"])
    return out

for t in [0.0, 0.3, 1.0]:
    print(f"--- temperature={t} ---")
    for s in ask(t):
        print(" ", s)
# 观察:temperature=0 三次输出几乎一致;1.0 三次说法各异

常见坑:

现象 原因 修法
结构化抽取任务输出格式飘 temperature 太高 降到 0–0.2,并用 JSON Schema(阶段 2)
同一请求两次结果不同 没固定 temperature 也没设 seed 稳定任务设 temperature=0
temperature 与 top_p 同时调反而失控 两个采样叠加 一般只调 temperature,top_p 保持默认 1.0
stop 没生效 停止序列写错或被分词拆开 用真实会出现的完整子串,注意 token 边界

面试考法:必问"temperature 和 top_p 有什么区别,为什么一般只调一个"。要点:temperature 缩放整个概率分布,top_p 限定候选集合大小;两者都在控制采样随机性,叠加会互相干扰,通常只调 temperature。追问常问"什么时候设 temperature=0",答到"抽取、分类、结构化输出、需要可复现的评测"。

5.4 Transformer 与注意力的直觉

为什么需要它:不需要手推公式,但要理解两件事——为什么上下文越长推理越慢越贵,以及为什么模型是"逐 token 自回归生成"而不是一次吐出答案。这决定了后面所有性能优化的方向。

核心机制:

  • Transformer 用注意力机制让每个 token 能"看到"上下文中其他 token,并计算关联权重。生成第 N 个 token 时,模型要重新处理前 N 个 token 的关系(有 KV cache 优化,但长度增长仍带来成本)。
  • 生成是自回归的:一个 token 一个 token 地吐,每吐一个都要把已生成的内容再"看"一遍。所以输出越长,延迟越高——这就是为什么流式重要(阶段 0)。
  • 模型没有数据库查询能力,它的"知识"来自训练时读入的文本,有一个训练截止日期(knowledge cutoff),之后的事不知道。
  • 注意力的计算量随序列长度近似平方增长,所以超长上下文不仅贵,延迟也显著上升。

最小可运行示例:

# timing.py:直观感受输入长度对延迟的影响
import time
import httpx
from config import BASE_URL, API_KEY, MODEL, auth_header

for prefix_len in [100, 2000, 8000]:
    long_text = "数据。" * prefix_len
    t0 = time.time()
    r = httpx.post(
        f"{BASE_URL}/chat/completions",
        headers=auth_header(),
        json={
            "model": MODEL,
            "messages": [
                {"role": "system", "content": long_text + " 然后只回复:好的"},
                {"role": "user", "content": "开始"},
            ],
            "max_tokens": 5,
            "temperature": 0,
        },
        timeout=60.0,
    )
    dt = time.time() - t0
    usage = r.json()["usage"]
    print(f"输入约 {usage['prompt_tokens']} tokens -> 耗时 {dt:.2f}s, usage={usage}")
# 观察:prompt_tokens 越大,即使输出只有 5 token,首响应也越慢

常见坑:

现象 原因 修法
问"昨天的新闻"模型编答案 模型知识有截止日期 用检索(RAG,阶段 4)接实时数据,不要追问
长输入下延迟暴涨 注意力随长度增长 + 自回归 缩短输入、用检索、做摘要
以为模型"一次想完整句" 实际逐 token 生成 理解自回归,长输出必然慢

面试考法:问"为什么上下文越长越贵越慢"。要点:注意力计算量随序列长度近似平方增长,且生成是自回归逐 token 进行;所以生产中要控制送入上下文的内容量,用检索而非全量塞入。追问常问"模型的知识从哪来,能问最新信息吗",答到"来自训练文本有截止日期,实时信息靠检索或工具,不能靠模型记忆"。

5.5 成本结构:输入/输出计价与缓存

为什么需要它:账单是 AI 应用最容易失控的部分。输入 token 和输出 token 单价通常差 3–5 倍,而很多人只按"一次调用多少钱"粗估,结果月底超支。

核心机制:

  • 计费按 token:输入(prompt_tokens)与输出(completion_tokens)分别计价,输出通常更贵。
  • 典型价格结构(每百万 token):输入约 $0.15–$2.5,输出约 $0.6–$10,小模型便宜、旗舰模型贵。
  • prompt 缓存(prompt caching):重复的前缀输入会被缓存,命中部分按折扣价计费(常见 5 折甚至更低)。所以把稳定的 system 提示词、长文档放在 messages 开头,可命中缓存。
  • 批量(batch)调用:非实时任务可走批量接口,通常再打 5 折。
  • 成本公式:费用 = prompt_tokens/1e6 × 输入单价 + completion_tokens/1e6 × 输出单价。

最小可运行示例:

# estimate_cost.py:按 usage 估算单次费用
# 假设价格(每百万 token,自行替换成实际厂商价)
PRICE_IN = 0.15    # 美元 / 百万输入 token
PRICE_OUT = 0.60    # 美元 / 百万输出 token

def cost_usd(prompt_tokens: int, completion_tokens: int) -> float:
    return prompt_tokens / 1e6 * PRICE_IN + completion_tokens / 1e6 * PRICE_OUT

# 一次 1000 输入 + 200 输出的调用
c = cost_usd(1000, 200)
print(f"单次费用约 ${c:.5f}")
# 日均 1 万次调用的月成本
print(f"日 1 万次月成本约 ${c * 10000 * 30:.0f}")

常见坑:

现象 原因 修法
账单远超预期 长历史导致 prompt_tokens 累积 截断历史;利用 prompt 缓存放稳定前缀
只按输出价估成本 输入也计费且量大 输入输出分开算,多轮对话输入是大头
每次都用旗舰模型 简单任务也走大模型 模型分级:简单任务走小模型(阶段 6)

面试考法:问"为什么输出 token 比输入贵"。要点:输出是自回归逐 token 生成,每生成一个都要做前向推理;输入是一次性并行处理(prefill),计算模式不同。追问常问"怎么降本",答到"缩短输入、用小模型处理简单任务、利用 prompt 缓存、非实时走批量、控制 max_tokens"。

5.6 模型能力边界与选型

为什么需要它:不是所有任务都该用同一个模型。选错模型要么质量不够要么成本爆炸。选型的核心是"任务需要什么能力,就选什么级别的模型"。

核心机制:

  • 模型分级:旗舰(强但贵)、标准(平衡)、轻量(便宜快)。分类、抽取、改写走轻量;复杂推理、代码、长文走旗舰。
  • 能力边界:代码生成、多语言、长上下文、数学推理各有强弱;多模态模型支持图片/音频输入,但纯文本任务不必选多模态。
  • 选型三问:数据能否出域(合规要求)?任务是问答还是执行?出问题谁能定位(可观测性)?
  • 同一个模型在不同上下文窗口下价格可能不同(长窗口档更贵),按实际长度选档。

最小可运行示例:

# model_router.py:按任务复杂度选模型
# 简单任务(分类/抽取)走小模型;复杂推理走旗舰
def pick_model(task: str) -> str:
    SIMPLE = ["分类", "抽取", "摘要短文本", "改写"]
    if any(k in task for k in SIMPLE):
        return "gpt-4o-mini"   # 便宜快
    return "gpt-4o"            # 旗舰,强但贵

# 用法:同一段代码,不同任务走不同模型
for task in ["抽取订单号", "设计一套分布式锁方案"]:
    print(f"{task} -> {pick_model(task)}")

常见坑:

现象 原因 修法
简单分类任务输出不稳定 用了旗舰模型但 temperature 高 换小模型 + temperature=0,更稳更便宜
长文任务频繁报错 选了短窗口档位 确认模型的长窗口档,或先摘要
问实时信息模型编答案 选模型解决不了知识时效 用检索/工具,不靠模型记忆

面试考法:问"怎么给一个企业客服助手选模型"。要点:先看数据合规要求能否出域;高频简单意图分类走小模型,复杂工单走旗舰;实时政策知识用 RAG 接最新文档而不是靠模型记忆;成本上用模型分级与缓存。

六、分层练习

6.1 复现型

练习 要求 验收标准 预计耗时
数 token 用 tiktoken 数一句中文和英文 能说出中文 token 密度更高 1 小时
温度对比 同一问题在 temperature 0/0.3/1.0 各跑 3 次 描述三档输出稳定性差异 1.5 小时
上下文延迟实验 从 100 到 8000 token 输入测延迟 观察到输入越长首响应越慢 1.5 小时
成本估算 按价格表算一次调用和月成本 给出输入输出分别计价的算式 1 小时
截断历史 实现 5.2 的 trim 函数 截断后 system 保留、总 token 不超窗 2 小时

6.2 改造型

练习 要求 验收标准 预计耗时
给长对话加自动截断 给定无截断的多轮脚本,接入 trim 第 20 轮不再报 context_length_exceeded 2 小时
把高 temperature 任务改为 0 给定一个抽取脚本,降温度并加 seed 10 次运行输出格式一致 1 小时
加成本日志 每次调用后打印 prompt/completion token 与费用 日志含分项 token 与美元数 1.5 小时
利用 prompt 缓存 把长 system 前缀放 messages 开头 连续两次调用第二次命中缓存 2 小时
模型分级路由 按任务简单/复杂选不同模型 简单任务不命中旗舰模型 1.5 小时

6.3 设计型

练习 要求 验收标准 预计耗时
模型选型对照表 列 5 类任务—推荐模型—理由—预估单次成本 每类都有理由和成本算式 3 小时
长文档输入策略 一份 200k 字文档要问答,设计方案 说明截断/摘要/检索如何取舍 4 小时
成本看板设计 统计日调用量、token 分布、缓存命中率 给出可落地的指标定义与告警阈值 4 小时

七、排障表

现象 可能原因 排查步骤 解决办法
context_length_exceeded 输入+输出超窗口 打印 usage.prompt_tokens 与窗口上限 截断历史、摘要、或缩小 max_tokens
回答被 length 截断 max_tokens 太小 看 finish_reason 是否为 length 调大 max_tokens 或精简任务
同一请求两次输出不同 temperature 未固定 检查 temperature 与 seed 稳定任务设 temperature=0
中文 token 数远超预期 用字符数估算 用 tiktoken 精确数 按 tokenizer 结果做预算
长输入延迟暴涨 注意力随长度增长 对比不同输入长度的耗时 缩短输入、用检索、做摘要
账单超预期 多轮历史累积 + 输出贵 看 usage 分项 token 截断历史、模型分级、prompt 缓存
模型编造最新信息 超出知识截止日期 确认问题是否涉及时效 接 RAG/工具,不要靠模型记忆
stop 序列不生效 序列被分词拆开 用真实子串测试 换成模型实际输出的连续片段

八、出口条件

全部勾选后再进入 阶段 2 Prompt 工程与结构化输出。

  • [ ] 能用 tokenizer 精确数中英文 token,并解释中文 token 密度更高
  • [ ] 能口述上下文窗口中输入与输出共享,超长必须截断或摘要
  • [ ] 能在实验中展示 temperature 0/0.3/1.0 的输出稳定性差异
  • [ ] 能按输入/输出 token 分别计价估算单次与月度成本
  • [ ] 能实现一个按 token 预算截断历史、保留 system 的函数
  • [ ] 能对一个超出能力的任务指出该用工具/检索而非模型硬答
  • [ ] 排障表中随机抽三个现象能在 5 分钟内给出定位思路

自测题(先自己想,再看要点):

  1. 为什么中文相同字数比英文更费 token?
    • 要点:英文 subword 把常见词整块编码,约 1 token ≈ 0.75 词;中文一个汉字常切成 1–2 token,相同信息量 token 数更高。
  2. 上下文窗口里,输入 100k、窗口 128k 时输出还能有多少?为什么?
    • 要点:共享窗口,输出只剩约 28k;max_tokens 必须从剩余额度里预留。
  3. temperature 和 top_p 有什么区别?为什么一般只调一个?
    • 要点:temperature 缩放整个分布,top_p 限定候选集合;两者都在控采样随机性,叠加会互相干扰,通常只调 temperature。
  4. 为什么输出 token 比输入 token 贵?
    • 要点:输出是自回归逐 token 生成,每步都要前向推理;输入是一次性并行 prefill。
  5. 多轮对话成本为什么随轮次线性增长?怎么压?
    • 要点:每轮都把全部历史计入 prompt_tokens;用截断、摘要、检索式记忆压缩历史。
  6. 模型知识有截止日期,遇到实时问题怎么办?
    • 要点:不靠模型记忆,用 RAG 接最新文档或工具查实时数据。
  7. prompt 缓存为什么能省钱?怎么让稳定前缀命中缓存?
    • 要点:重复前缀被缓存按折扣计费;把稳定的 system 提示词和长文档放在 messages 开头,保持前缀不变。