LLM/Prompt 基础：把模型当成一个会算账的组件

1.1自注意力与 KV cache（为什么 LLM 又慢又贵）

自注意力让每个 token 关注序列里所有 token，代价是计算与显存随长度二次增长。

一次注意力的机制是确定的四步：每个 token 由三组向量表示——Query、Key、Value（QKV）。用当前 token 的 Q 与序列中所有 token 的 K 做点积，得到相关性分数；除以 √d_k 缩放（防止点积过大把 softmax 推到梯度近零的饱和区）；过 softmax 归一化成权重；再用这组权重对所有 V 加权求和，得到这个 token 融合了全局上下文的新表示。

关键在“所有 token”这三个字：序列里有 n 个 token，每个都要和另外 n 个算分，于是是 n × n 次交互——计算与显存都是 O(n²)。这就是上下文越长越贵、越慢的根因，也是后面 RAG 存在的第一个理由。

多头注意力（Multi-Head Attention）把 QKV 投影到多个子空间并行算，让不同的头学习不同的关系（一个头管句法、一个头管指代等），再拼接。它不改变 O(n²) 的量级，但显著增强表达力。

KV cache：把二次降成线性的工程手段

推理时 LLM 自回归地一个 token 一个 token 生成。生成第 t 个 token 时，注意力需要前面所有 token 的 K 和 V。朴素做法每生成一个就把整段历史的 K/V 重算一遍——累计下来是 O(n²) 的重复计算。KV cache 把已生成 token 的 K/V 缓存下来，每一步只为新 token 计算 K/V、复用缓存，于是每步的注意力计算从“二次”降到“对总长线性”。

为什么主流是 Decoder-only

GPT、Claude 这类 decoder-only 模型用因果掩码（每个 token 只能看到自己左边）做自回归生成，天然契合 KV cache 复用——已生成的部分 K/V 永不改变，缓存一次用到底。T5 这类 encoder-decoder 的编码器是双向的（每个 token 看全序列），适合翻译、摘要这类 seq2seq 任务，但双向编码难以廉价复用 KV cache，且 scaling 与统一接口不如 decoder-only 简洁。这是 decoder-only 成为通用大模型主流的工程原因之一。

1.2采样参数：temperature / top-p / top-k / penalty

采样参数控制“从模型给出的概率分布里怎么挑下一个 token”，决定输出的确定性与多样性。

temperature：在 softmax 前对 logits 做缩放。T→0 退化为贪心（最确定、近似可复现）；T=1 用原始分布（OpenAI 默认 1.0）；T>1 把分布拉平、低概率 token 更易被选中（更随机）。事实问答、代码、结构化抽取设 0–0.3；头脑风暴、文案设 0.7–1.2。

top-p（核采样，nucleus sampling）：按概率从高到低累加，取累积概率 ≥ p 的最小 token 集合再在其中采样。它是自适应的——分布陡峭时候选集小，分布平坦时候选集大。top-k：固定只保留概率最高的 k 个 token。两者都在“砍掉长尾垃圾 token”，但 top-p 随分布伸缩、top-k 是死数量。

frequency_penalty（-2..2）：随 token 已出现次数线性增大惩罚，越说越压、抑制重复。presence_penalty：只要 token 出现过就施加一次性惩罚，推动模型转向新话题。前者治“复读”，后者治“话题不发散”。

1.3上下文窗口与 “Lost in the Middle”

上下文窗口是模型一次能处理的最大 token 数；即便窗口够大，中间的信息也容易被忽略。

主流窗口在快速变大（截至 2026-06：GPT-5.5 约 256K–1M、Claude 4.x（Opus 4.8 / Sonnet 4.6）200K–1M、Gemini 3.x Pro 1M 起、最大档已到数 M 级）。型号与窗口每隔几个月就翻新，面试记框架、别背数字——因为窗口再大，三件事都没变：注意力的 O(n²) 成本让长上下文又贵又慢；模型的内部知识仍会过期、不可控；以及——位置偏差。

Lost in the Middle：研究发现，当关键信息放在长上下文的开头或结尾时，被正确利用的概率高（约 85–95%）；放在中部时明显下探（约 76–82%）。召回率随位置呈 U 形。（具体数值为示意，趋势来自 Liu et al. 的 U 形结论，并非某一篇论文的实测值。）这意味着“把 50 个文档一股脑塞进 200K 窗口”并不能保证模型用到中间那几个关键段落。

所以“窗口够大了为什么还要 RAG”有四个并立的答案：① O(n²) 让长上下文的延迟与费用线性甚至超线性上涨；② Lost in the Middle 让“塞进去”不等于“用得上”；③ 模型权重里的知识会过期、私有数据根本不在其中；④ 把整库塞进窗口既不可控也不可审计。RAG 是用检索把“最相关的一小撮”放进窗口，既省钱又规避位置偏差。

1.4幻觉：成因与缓解

幻觉是模型生成了流畅但与输入或事实不符的内容——它在“编”，而且自己不知道在编。

分两类：内在幻觉（intrinsic）——输出与给定输入自相矛盾（如总结时改写了原文事实）；外在幻觉（extrinsic）——输出与客观事实不符，但输入里没有可对照的依据（如编造一条不存在的 API、一个假的引用）。

成因有三层。第一，训练目标：下一 token 预测优化的是“流畅、像人话”，不是“真实”——一句通顺的假话和一句通顺的真话，在语言建模损失上没有本质区别。第二，评测机制：OpenAI 2025 年的分析指出，主流评测在“蒙一个答案”和“老实说不知道”之间奖励前者——蒙对了得分、弃权得零分，于是模型被训得倾向于自信地猜而非承认无知。第三，数据：训练语料的覆盖缺口、歧义、以及模型校准（confidence 与正确率不匹配）问题。

1.5结构化输出（JSON mode / 约束解码）

结构化输出让模型稳定吐出可被程序解析的格式（通常是符合 schema 的 JSON）。

从弱到强四个层次：① few-shot 示例——给几个输入输出样例诱导格式，最弱、靠概率；② JSON mode——约束模型输出合法 JSON，但不保证符合你的具体 schema；③ strict schema（如 OpenAI strict: true 的 Structured Outputs）——保证字段、类型、必填都符合给定 JSON Schema；④ 约束解码（constrained decoding）——底层在每一步采样时就屏蔽掉会破坏 schema 的 token，从 token 级强制合法。

# 演示用：OpenAI Structured Outputs（strict schema，非事后校验）
from openai import OpenAI
client = OpenAI()

schema = {
    "type": "object",
    "properties": {
        "party_a": {"type": "string"},
        "amount":  {"type": "number"},
        "sign_date": {"type": "string"},
    },
    "required": ["party_a", "amount", "sign_date"],
    "additionalProperties": False,   # 不允许多吐字段
}

resp = client.chat.completions.create(
    model="gpt-5.5",
    temperature=0,                   # 抽取任务 → 最确定
    messages=[{"role": "user", "content": contract_text}],
    response_format={
        "type": "json_schema",
        "json_schema": {"name": "contract", "schema": schema, "strict": True},
    },
)
# strict=True 下 schema 由约束解码保证；仍建议对业务语义做一层校验

1.6Function Calling：工具调用的地基

Function Calling 让模型产出“要调用哪个函数、传什么参数”的结构化意图——但模型从不执行。

真实机制是四步循环，关键在于职责分离：模型负责“决定调什么、传什么参数”，你的 runtime 负责“真正执行 + 把结果回填”。模型自己从不触碰数据库或网络。

# 演示用：四步循环的骨架（OpenAI 风格）
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "查询某城市当前天气",  # 描述写清楚，模型靠它判断该不该调
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

messages = [{"role": "user", "content": "北京现在天气怎么样？"}]

while True:
    resp = client.chat.completions.create(
        model="gpt-4o", messages=messages, tools=tools,
    )
    msg = resp.choices[0].message
    if not msg.tool_calls:           # 模型不再要工具 → 这是最终答案
        print(msg.content)
        break
    messages.append(msg)             # 记下模型的调用意图
    for call in msg.tool_calls:      # 可能并行多个 tool_call
        args = json.loads(call.function.arguments)
        result = dispatch(call.function.name, args)   # 你的 runtime 真正执行
        messages.append({            # 结果作为 tool message 回填
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })
    # 回到循环顶：把结果喂回，模型据此决定继续调工具还是给最终答案

这段循环就是 Agent 的雏形：单轮是“一次工具调用”，多轮叠加 + 让模型自己决定下一步，就成了 ReAct 式的“推理-行动-观察”循环。第 3 章会在它上面加规划、反思、记忆。

1.7微调：LoRA / SFT / DPO 与什么时候用它

微调是用领域数据继续训练模型、改变模型本身的行为与风格；它改的是“能力/语气”，不是“实时知识”。

按“更新多少权重”分三档。全参微调更新模型的全部权重，效果上限最高，但要存一整份梯度与优化器状态，显存与成本最高，几十亿参数往上单卡就吃不下。PEFT / LoRA冻结主干权重不动，只在权重旁注入一对低秩矩阵 A·B（秩 r 远小于原维度）并只训练它们，可训练参数量降到全参的零点几个百分点，显存大幅下降，且训练产物只是一个小适配器——同一主干可热插拔多个 LoRA，按任务切换。低秩为什么够用：微调要打的“补丁” ΔW 经验上是低内在秩的——适配一个新任务真正需要改变的方向，远少于权重矩阵的维度，所以用一对秩 r 的小矩阵 A·B 就能近似覆盖绝大部分 ΔW，而不必动整块权重。这正是 LoRA 不掉太多效果的根因，也解释了 r 的取舍：r 太小连这点低秩结构都装不下、欠拟合；r 取 8–16 多数任务就够；再大只是趋近全参、徒增开销与过拟合风险。QLoRA在 LoRA 之上把冻结的主干量化到 4-bit 再训练适配器，进一步压低显存，让单卡微调较大模型变得可行。

按“训练目标”分两层。第一层 SFT（监督微调）：喂“输入 → 理想输出”的成对数据，让模型模仿示范答案，把格式与能力学进去。第二层偏好对齐，目标是让模型懂“同一个问题，哪个回答更好”：RLHF走 PPO 强化学习、需要先训一个独立的奖励模型再用它打分调策略，链路长、调参敏感；DPO（直接偏好优化）直接拿“更优/更差”的偏好对当训练信号、省掉独立奖励模型，更简单也更稳定，近年常用。常见配方是先 SFT 打底、再用 DPO 做偏好对齐。

何时 RAG、何时微调、何时 prompt——三者不是互斥而是分工，对比见 02 章 §2.1。

1.8推理模型与 test-time compute

推理模型在给出答案前，先自己生成一长串“思考”token，用推理时的额外算力换准确率——这是 2025–2026 最大的范式变化。

代表模型（截至 2026-06）：OpenAI o3 / o3-pro、Claude 扩展思考（extended thinking）、Gemini Deep Think、开源的 DeepSeek R1（用 RL 直接训出推理能力、权重与论文公开）。它们共同的机制是 test-time scaling：给模型越多“思考预算”（推理 token），难题准确率越高——把原来只在训练时堆的算力，搬到了推理时。

但这条曲线不是单调上升。研究发现“想太多”反而掉分（overthinking）：超过某个点后，模型会推翻本来正确的答案、在简单题上空耗。所以思考不是越多越好，存在一个任务相关的最优思考量。

能力的代价很直接：思考 token 单独计费、照常烧钱，o 系列单价约为“快”模型（Haiku 档）的 10×，延迟也从亚秒级涨到数秒甚至更久。