这一篇处理模型之外的系统层问题，包括上下文工程、Harness Engineering、检索增强生成（RAG）与智能体。前一篇讲的是模型本体及其训练和推理，这一篇转向“模型如何被放进真实系统里工作”：上下文如何组织，工具与知识库如何接入，验证闭环如何建立，以及多步推理与多智能体协作如何落地。

提示词工程（Prompt Engineering）最早强调的是“怎么写一句更有效的话”，关注点集中在措辞、顺序、示例和限制条件。随着大模型应用从单轮问答扩展到智能体（AI Agent）、RAG、多工具调用与长会话系统，工程重点逐渐转向上下文工程（Context Engineering）：真正决定效果的，不再只是某一句提示词本身，而是系统提示、用户输入、示例、检索结果、对话历史、工具返回、结构化状态与输出约束如何被整体组织成一次模型调用。

因此，上下文工程可以看作比提示词工程更大的外层概念。提示词仍然重要，但它只是上下文中的一个组件；在生产系统里，更关键的问题通常是“哪些信息应该进入上下文、以什么顺序进入、保留多久、如何压缩、何时替换、如何约束输出”。这一变化反映的不是术语时尚，而是应用形态已经从“写一句 prompt”演进为“设计一套输入装配系统”。

上下文学习（In-context Learning）指模型在不更新参数的前提下，仅凭当前输入中的任务说明、示例与约束完成新任务。它依赖的是上下文中的条件信息，而不是额外微调。

零样本（Zero-shot）是在不给示例的情况下，直接通过任务描述让模型完成目标。例如“判断以下影评是正面还是负面，只输出标签”。它的优点是成本低、迁移快；缺点是任务边界一旦含糊，模型更容易自由发挥。

少样本（Few-shot）是在提示词中附带少量示例，让模型在当前上下文里归纳输入输出模式。它特别适合标签定义不够直观、格式要求严格或任务带有领域习惯的场景。示例的价值不只是“给答案”，更是显式定义任务边界、异常情况与输出风格。

一个可维护的提示词通常由若干功能块组合而成，而不是一段散乱文本。把这些块拆开，能够显著提高复用性、可调试性与一致性。

角色定位（Role）定义模型在本次任务中的身份与职责边界，例如“你是严谨的法律信息抽取器”或“你是面向儿童解释科学概念的讲解者”。它的作用是设定默认行为策略，而不是替代具体任务指令。

指令（Instruction）直接说明模型要完成什么任务，是提示词中最核心的控制块。好的指令应当明确目标、操作步骤、禁止事项与完成标准，避免把多个含糊目标混在同一层表达里。

上下文（Context）提供完成任务所需的背景信息，例如产品文档、会话历史、用户约束、检索片段或前一步工具返回。它回答的是“模型基于什么信息工作”，而不是“模型该怎么工作”。

输出格式（Output Format）规定结果应该长什么样，例如纯文本、项目符号、JSON、表格或固定字段。格式要求越明确，后续系统越容易解析、验证与链接到其它模块。

受众（Audience）决定解释深度、术语密度与默认背景知识。例如 ELI5（Explain Like I'm 5）指面向完全没有背景知识的读者，需要更浅白的表达；面向资深工程师时，则应保留专业术语、边界条件与实现细节。

语气（Tone）控制表达风格，例如正式、简洁、鼓励式、审慎式或客服式。它影响的是话语风格和风险表达方式，但不应改变事实本身或任务判断标准。

数据（Data）指与任务本身直接相关的材料，例如待分类文本、待总结文档、用户表单、日志片段、表格记录或检索回来的证据。很多提示词失败，根源在于真正决定任务结果的数据并没有进入上下文。

系统提示（System Prompt）是整个上下文的最高层行为约束，通常用于定义角色、原则、边界和长期稳定规则。它应该稳定、简短且高信号，承载通用策略，而不适合塞入频繁变化的任务细节。

多数大模型 API 是无状态（Stateless）的：模型在一次调用中只“看到”你发送的输入（Prompt），不会自动记住上一次调用的对话内容。因此对话应用通常需要把对话历史（Conversation History）连同当前用户输入一起发给模型。

这会带来两个直接后果：

• token 占用会随着历史增长而上升（直到触达上下文窗口上限）。
• 并非“发得越多越好”：冗余历史会稀释注意力、提高成本，并可能引入过时或冲突信息。

工程上常见的记忆（Memory）分层是：

• 短期记忆（Short-term Memory）：保留最近 N 轮原文对话，确保局部连贯。
• 工作记忆（Working Memory）：把对话状态压缩成结构化摘要，例如用户偏好、已确认事实与当前任务约束。
• 长期记忆（Long-term Memory）：把历史片段写入外部存储（向量库/数据库），需要时检索回填。

工具调用上下文（Tool Context）指模型在调用搜索、数据库、代码执行器或业务 API 后得到的中间结果。它的关键不只是“把结果贴回模型”，而是把工具返回整理成模型真正可用的状态：保留必要字段、去掉噪声、标明来源与时间，并避免把原始日志整段塞进上下文。

渐进式披露（Progressive Disclosure）强调：不要在一开始把所有文档、规则、工具说明和历史对话一次性塞进上下文，而应只注入当前步骤真正需要的那一层信息。模型先看到最小可行上下文，只有当任务推进到下一层时，才继续展开更具体的约束、领域知识或执行细节。

这样做的原因不只是节省 token，更是为了保持推理质量。多组工程实践都观察到，上下文利用率一旦超过大约 40%，模型就可能从“聚焦求解”进入“信息过载”状态，开始出现幻觉、循环、格式错误或低质量实现。渐进式披露的目标，就是让 Agent 长时间停留在这个甜蜜区，而不是被无关材料拖进噪声区。

Token 预算（Token Budget）是把上下文窗口（Context Window）当作一种稀缺资源来管理：一次请求的输入 token 与输出 token 都要计入模型的最大长度限制，并直接影响延迟与成本。

经验做法是把 prompt 切成可控的几块：系统提示尽量短且稳定；对话历史只保留近期原文；把长期信息通过检索（Retrieval）按需注入。

压缩与摘要（Compression & Summarization）的核心，是把信息从逐字转录（Transcript）变成可被模型继续使用的状态（State），而不是单纯把文本“变短”。常见策略：

• 滚动摘要（Rolling Summary）：每轮对话后更新一段固定长度的当前状态。
• 层级摘要（Hierarchical Summarization）：长文先分块总结，再总结摘要。
• 结构化记忆（Structured Memory）：用 JSON 或表格保存关键字段（偏好、约束、已决策项），避免自然语言摘要漂移。

摘要要可验证：优先保留可操作事实（约束、数值、名称、决策），少写主观评价。

当最新一次对话依赖很久以前的信息时，更可靠的方法是检索增强：把历史切成片段并建立索引（向量索引、关键词索引、主题标签），在每次请求前先检索与当前问题最相关的片段，再把这些片段注入上下文。无限追加历史通常会带来更高噪声和更差上下文利用率。

在当前智能体开发里，最主流的组合通常是：滑动窗口 + 滚动摘要 + 向量检索（RAG）。早期的外部记忆网络（Memory Networks / Neural Turing Machine）更多是研究范式，工程落地上更常见的是向量数据库与检索管线。

JSON Schema 约束把“输出应该长什么样”前置为机器可验证的结构定义，例如字段名、字段类型、必填项、枚举值与嵌套关系。它的价值在于把格式控制从“模型尽量照做”提升到“系统可以检查对不对”，从而显著降低后处理复杂度。

函数调用（Function Calling）把模型输出从自由文本转成“选择哪个工具、填写哪些参数”的结构化决策。它的工作方式是让模型先生成一个可被程序消费的调用意图，再由外部系统负责权限校验、真实执行与结果回填。

这里讨论的高级提示词策略，指的是仅通过提示词设计改变模型求解过程，而不借助额外框架、搜索控制器或推理编排器。它们本质上仍属于上下文工程：通过改变输入结构，让模型在一次或少数几次调用中显式展开中间推理步骤。

思维链（Chain-of-Thought, CoT）的核心做法是：在提示词中明确要求模型先分步分析，再给出最终答案。例如，可以把任务写成“先列出关键事实，再逐步推理，最后只输出结论”。若任务本身较复杂，也可以在 few-shot 示例里直接展示“问题 ➡ 分步推理 ➡ 最终答案”的格式，让模型在上下文中模仿这种求解模式。

在纯提示词使用方式下，CoT 的关键在于把推理过程结构化地写进输出要求，而不是迷信某一句固定咒语。例如，可以把输出格式限定为“步骤 1 / 步骤 2 / 结论”，或要求模型先检查条件、再排除候选、最后汇总结论。这样做通常有利于多步算术、条件判断、规则推导与长链依赖任务；但对简单任务、严格结构化输出任务或成本敏感场景，强行要求展开思维链反而会增加 token 开销与噪声。

思维树（Tree of Thoughts, ToT）可以看作思维链的分支化版本：提示词不只要求模型给出一条线性推理路径，而是要求它先生成多个候选思路，再比较这些思路，最后选择更优的一条继续展开。在不借助框架的前提下，这种策略仍可以通过提示词实现，例如要求模型“先给出三个可能方案，分别说明优缺点，再选择最合理的方案给出最终答案”。

纯提示词版 ToT 的本质，是把“分支生成 + 分支比较 + 继续展开”都压进一次或少数几次模型调用里。它适合开放式规划、方案比较、复杂写作提纲和策略搜索这类任务，因为这类任务往往不存在唯一直接路径。代价同样明显：提示词更长，输出更长，模型也更容易在分支之间漂移。因此，ToT 更适合高价值、需要比较多个候选方案的任务，而不适合作为所有请求的默认模式。

Harness Engineering（驾驭工程）研究的是：当模型推理与生成能力已经足够强时，决定 Agent 能否稳定完成复杂任务的，往往是模型外围的整套工作系统。Harness 指模型之外的所有代码、配置与执行逻辑——工具接口、状态管理、上下文装配、架构约束、验证机制、回滚策略与持续清理，全部属于这一层。裸模型只能接收输入、输出文本；只有当 Harness 为它提供状态、工具、约束和反馈回路后，它才能成为一个持续干活的 Agent。

目前 Harness Engineering 落地最广、讨论最充分的场景仍然是 Coding Agent，因此本章中的很多方法首先来自代码生成、调试、验证、跨会话交接和多 Agent 编排的工程实践。但它并不局限于写代码。凡是 Agent 需要长期持有状态、调用外部工具、在约束下执行任务、接受反馈并持续纠偏的场景，都可以应用同样的方法论，例如研究 Agent、数据分析 Agent、运维自动化 Agent、业务流程 Agent 以及多模态交互系统。随着 Agent 从“生成回答”走向“持续执行任务”，Harness Engineering 也会从 Coding Agent 的经验集合，扩展为更一般的 Agent 系统工程。

下文将沿着“为什么 Agent 会失效 ➡ 如何搭建控制面 ➡ 如何长期治理系统 ➡ 工程师角色如何变化”这条主线展开。

Prompt Engineering（提示词工程）、Context Engineering（上下文工程）与 Harness Engineering 构成了层层外扩的系统模型：前者决定如何表达任务，中间层决定模型能看到什么，最外层决定整个系统如何执行、纠偏与长期维持质量。

提示词工程回答的是“如何把任务说清楚”。它关注指令措辞、角色设定、Few-shot 示例、输出格式和推理引导，目标是在单次调用里把任务表达得足够明确，让模型更容易走向期望行为。

上下文工程回答的是“模型应该看到什么”。它关注记忆注入、检索回填、窗口压缩、状态摘要和工具返回整理，目标是控制输入信息的相关性与密度，使模型在有限上下文里获得完成当前任务所需的关键材料。

Harness Engineering 回答的是“模型在什么系统里工作”。它处理的不再只是输入文本，而是工具接口、状态持久化、架构边界、验证回路、错误恢复、执行顺序与持续清理。到了这一层，关注点已经从“如何让模型回答得更好”转向“如何让 Agent 在真实系统中稳定完成工作”。

Harness 并不等同于某一句系统提示，也不等同于某个框架的名称。框架（Framework）、运行时（Runtime）和工具链都可以参与实现 Harness，但 Harness 这个词强调的是模型外围整套工作系统，而不是其中任何一个单独组件。

从系统设计视角，一个可用的 harness 通常由五类承重件组成：上下文管理（Context Management）、工具编排（Tool Orchestration）、安全护栏（Safety Guardrails）、反馈回路（Feedback Loops）与可读性/可观测性（Legibility / Observability）。前两者解决“Agent 知道什么、能做什么”，中间两者解决“何时纠偏、如何避免越界”，最后一类解决“系统当前到底发生了什么”。

上下文管理决定 Agent 在每一步究竟能看到什么信息。它的目标是把系统提示、短期记忆、长期知识、工具返回和任务状态按层组织，让模型始终工作在信息足够但不过载的区间，而不是简单堆砌更多材料。

工具编排决定 Agent 能做什么，以及如何把动作接回推理链路。搜索、数据库、代码执行器、浏览器自动化和业务 API 只有在权限、输入输出格式、调用顺序与结果回填都被设计清楚后，才会从“外挂能力”变成稳定的执行系统。

安全护栏负责限制 Agent 的越界空间。它包括写权限边界、架构约束、审批节点、沙箱、敏感操作限制与结构化状态约束，作用是把“模型可能做错事”转化为“系统不允许它在关键位置随意犯错”。

反馈回路负责告诉 Agent 当前结果究竟对不对。测试、lint、evaluator、Sprint Contract、健康检查和人工验收都属于这一层。没有反馈回路，Agent 只能凭语言流畅性误判成功；有了反馈回路，系统才能把错误重新送回执行链路中修复。

可读性与可观测性负责让 Agent 看见系统真实状态。UI、日志、指标、追踪、截图、DOM 快照和运行时事件，都是 Agent 判断“系统发生了什么”的依据。若系统对 Agent 不可见，很多问题即使存在，也只能靠盲目试错去碰。

Harness 的成熟度，本质上就是这五类控制面被工程化到什么程度。后文的各个部分，基本都可以看作对这五类支柱的展开：先看 Agent 为什么会系统性失效，再分别讨论上下文、编排、知识、约束、可读性、验证与熵控制如何把这些失效压回系统边界之内。

长运行 Agent（Long-Running Agent）必须跨多个上下文窗口持续工作，每个新会话在启动时对前一会话发生的事情没有任何记忆。即使使用最强的前沿模型，如果只给一个高级别的提示词，Agent 也无法稳定构建出生产质量的复杂系统。实践观察到四类典型失效：

• 过早宣告完成（Premature Victory Declaration）：在项目进行到一定阶段后，Agent 环视已完成的工作，宣告整个项目已经完成，忽略仍未实现的功能。
• 脏状态遗留（Dirty State Handoff）：会话结束时遗留未修复的 bug 或未记录的进度，下一个会话必须先花大量 token 恢复工作环境，而不是推进新功能。
• 伪完成标记（False Completion）：Agent 完成代码改动并运行单元测试或 curl 命令后，在没有进行端到端验证的情况下把功能标记为已完成，而该功能实际上并不能正常工作。
• 上下文焦虑（Context Anxiety）：部分模型在上下文窗口填充到一定程度后，会主动收尾、提前结束任务——即便任务尚未完成，这种过早的"善后行为"会导致中途截断的工作状态。

这四类失效都不能靠"换一个更好的模型"自动解决。它们是系统性问题，需要 Harness 层面的工程设计来对抗。

Harness 是通过失败持续生长的控制层。一个重要的工程判断是：当 Agent 在某类任务上反复失败时，应先把失败当作 Harness 缺口的定位信号。失败可能意味着工具接口缺失、文档不可达、架构边界不清、状态交接不足，或验收标准仍停留在模糊自然语言层面。

因此，Harness Engineering 的关键动作是把失败外化成新的系统组件：增加脚本、补充文档、收紧 lint 规则、拆出更明确的 Contract、补上 evaluator 或可观测性接入。每次失败若都能回写为新的约束与支撑物，Agent 系统就会逐步从“靠经验驱动”演化为“靠机制驱动”。

上下文焦虑（Context Anxiety）是指模型在感知到上下文窗口即将耗尽时，主动把任务包装成"已完成"状态——即便还有大量工作未做。Anthropic 在 Claude Sonnet 4.5 上观察到这一现象尤为明显。

应对上下文耗尽有两种互相对立的策略：

对于 Sonnet 4.5，仅靠 Compaction 不足以支撑长任务，Context Reset 成为 Harness 设计的必要组件。随着 Opus 4.6 的推出，其长上下文检索能力显著提升、上下文焦虑基本消除，Context Reset 可以从 Harness 中移除——这正是 Harness 组件应随模型能力动态调整的典型示例。

一个很有价值的经验规律是：上下文窗口并不是“越满越好”。多组实践都观察到，随着无关文档、工具说明和历史对话不断堆积，Agent 的推理质量会先升后降。工程上可以把这理解为上下文利用率的“甜蜜区间”：模型需要足够信息才能稳定工作，但一旦被冗余材料淹没，就会出现幻觉、循环、格式错误或低质量实现。Harness 的任务不是把更多 token 塞进去，而是让 Agent 在任意时刻只看到当前步骤真正需要的信息。

长运行 Agent 在会话之间传递状态，不能依赖模型的内部记忆，必须依靠外化的持久化制品（Persistent Artifacts）。实践中形成了一套固定的状态传递套件：

• 进度文件（Progress File）：纯文本日志，记录每个会话完成了什么、遇到了什么问题、下一步是什么。每个会话开始时读取，结束时更新。
• 功能列表文件（Feature List）：结构化的功能需求清单，初始全部标记为未完成，Agent 逐项实现并通过测试后方可标记通过。使用 JSON 而非 Markdown——实验发现模型不当覆写或修改 JSON 文件的概率远低于 Markdown 文件。
• 启动脚本（init.sh）：由初始化代理预先写好的环境恢复入口，负责安装依赖、启动必要服务并打印访问入口。后续 fresh session 不再重新猜测项目如何运行，而是把它作为标准恢复脚本，在需要时检查并调用。
• Git 历史：每个会话以描述性的 commit message 结束。Git 历史既是进度时间线，也是恢复机制——Agent 可以通过

  git revert

  从错误改动中恢复。

这套设计借鉴的是人类软件工程师的轮班交接实践：进度文件对应交班笔记，git commit 对应有记录的工作移交，init.sh 对应标准化的环境搭建步骤，功能列表对应待办看板。

当单个 Agent 已经能够跨会话持续推进后，下一个问题就不再是“如何记住过去”，而是“如何把复杂任务拆给更合适的执行者”。这正是多 Agent 架构出现的背景。

让单个 Agent 对自己的输出进行评估会产生自评偏差（Self-Evaluation Bias）：即使输出质量明显一般，模型也倾向于给出积极评价。这一问题在主观任务上尤为突出，在可验证任务上同样存在。

一个有效的应对结构来自生成对抗网络（Generative Adversarial Network, GAN）的启发：将生成者和评估者分离成两个独立 Agent。

[Generator Agent] ←── feedback ──[Evaluator Agent]
        │                                 │
        └──────── output artifact ────────┘

关键发现：调教一个独立的评估者使其保持怀疑态度，远比让生成者对自己的输出保持批判性更为可行。评估者仍然是 LLM，仍然有宽容倾向，但针对评估者进行专项提示调优的效果可以稳定收敛，而自评调优往往无效。

在 Generator–Evaluator 基础上增加一个 Planner Agent，构成完整的三 Agent 架构：

Agent 之间的通信完全基于文件：一个 Agent 写文件，另一个读文件并响应。这种方式简单、可追溯、不依赖框架内部状态。

对于需要跨多个上下文窗口持续工作的场景，一种实用模式是将第一次会话与后续会话用不同的提示驱动：

• 初始化 Agent（Initializer Agent）：仅在第一个会话运行，负责构建整套脚手架：根据项目规格生成 init.sh、功能列表 JSON、初始 git commit 和进度文件，把“项目如何启动、功能如何追踪、状态如何恢复”一次性外化成可执行制品。
• 编码 Agent（Coding Agent）：从第二个会话起运行，先读取进度文件、功能列表和最近的 git 历史，再按需调用 init.sh 恢复环境，每次只实现一个功能，并以"干净状态（Clean State）"结束会话。

两个"Agent"在技术上是同一套系统提示和工具集，区别仅在于初始用户提示不同——这是一种提示策略，而非架构分离。

这种设计的关键，在于把“如何把项目跑起来”从高 token 成本的推断问题，转成低成本、可重复、可审计的脚本执行问题，而不是简单多一个 shell 脚本。后续每个 fresh session 的标准启动序列因此可以稳定下来：先用

pwd

git log

init.sh

Sprint Contract 是 Generator 与 Evaluator 在任何代码被写下之前，对"这一阶段完成的标准"达成共识的协议制品：Generator 提出将要构建什么以及如何验证成功，Evaluator 审查并确认，双方迭代直到达成一致。其目的是弥合高层用户故事与可测试实现之间的鸿沟，防止模糊需求在实现阶段演变为争议。

任务拆分解决了“谁来做”，但还没有解决“知识从哪里来、如何保持最新”。一旦 Agent 工作跨越多个会话、多个角色和多个代码域，知识组织方式本身就会成为 Harness 的一部分。

“给 Agent 地图而非手册”讨论的是知识入口（Knowledge Entry Point）的设计原则：在大型、持续演化的代码库中，Agent 需要的是一套能够把它稳定引导到正确信息源的导航结构，而不是一份试图囊括所有细节的单体说明书。知识库工程的关键目标是让上下文可定位、可更新、可裁剪，而不是一次性塞满。

因此，这里的首要挑战是"如何让 Agent 在需要时找到正确信息"。"一个巨型 AGENTS.md 文件"的方案会失败，原因是多方面的：

• 上下文是稀缺资源。一个巨大的指令文件会挤占任务本身、代码和相关文档的空间，导致 Agent 要么遗漏关键约束，要么对错误的目标进行优化。
• 过多的指导等于没有指导。当所有内容都被标记为"重要"时，Agent 会退化成局部模式匹配，而不是有目的地导航。
• 单体文档会迅速腐烂。人类停止维护，Agent 无法分辨哪些规则仍然有效，文件变成一个充满过期规则的吸引力陷阱。

有效的替代方案是：AGENTS.md 充当目录（Table of Contents），而非百科全书。一份约 100 行的精简 AGENTS.md 作为上下文的入口，通过指针将 Agent 引导至结构化 docs/ 目录中的具体知识源。

AGENTS.md 还有一个更重要的角色：它不应是一次写完后长期冻结的静态文档，而应是失败驱动的活反馈循环。每当 Agent 因为命令使用错误、目录理解偏差、架构约束遗漏或工具接入方式不清而出错，最直接的修复方式往往就是把这类经验回写进 AGENTS.md 或其指向文档。这样，文档不再只是说明书，而是把历史失败压缩成未来会话可直接继承的系统记忆。

AGENTS.md            ← 约100行，地图角色
ARCHITECTURE.md
docs/
├── design-docs/
│   ├── index.md
│   └── core-beliefs.md
├── exec-plans/
│   ├── active/
│   └── completed/
├── generated/
│   └── db-schema.md
├── product-specs/
│   └── index.md
├── references/
│   ├── design-system-reference-llms.txt
│   └── ...
├── DESIGN.md
├── FRONTEND.md
├── PLANS.md
└── QUALITY_SCORE.md

这种结构实现了渐进披露（Progressive Disclosure）：Agent 从一个小而稳定的入口开始，被引导到它需要的具体知识，而不是在启动时被所有信息淹没。

当团队反复构建相似类型的系统时，Harness 不应只停留在单项目经验，而应上升为组织级的服务模板（Service Template）或黄金路径（Golden Path）。现实中的软件形态并不是无限多样的，常见项目通常集中在少数几类技术拓扑：前端应用、后端服务、数据流水线、内部工具。若能把每类拓扑常用的目录结构、启动脚本、验证流水线、可观测性接入、架构约束和 Agent 指令打包成模板，新项目就不必从零设计 Harness。

这类模板的价值不只是“脚手架复用”，更在于组织把高频工程判断沉淀成标准化控制面。团队成员在真实项目中学到的约束、回滚经验和验证方法，可以持续回流到模板；模板更新后，又会反过来提升后续所有项目的默认质量。Harness 一旦进入这个阶段，便不再只是某个工程师的个人技巧，而是组织级生产力资产。

从 Agent 的视角来看，任何它在运行时无法在上下文中访问的知识，实际上不存在。存在于 Google Docs、Slack 线程或人脑中的决策，对 Agent 来说与从未发生过没有区别。唯一对 Agent 有效的知识是代码库中版本化的制品：代码、Markdown、Schema、可执行计划。

这一约束倒逼团队把越来越多的上下文推入代码库：对齐团队架构决策的 Slack 讨论、产品原则、工程规范，都需要以 Agent 可读的形式在仓库中存在。这不仅是文档实践，更是系统设计约束。

知识库的有效性需要机械化强制执行，而不能依靠人工自律。专用的 linter 和 CI 任务验证知识库是否最新、交叉引用是否完整、结构是否正确。一个周期性运行的"文档园丁 Agent（doc-gardening agent）"扫描文档与实际代码行为之间的偏差，发现过期或不一致的内容后自动开启修复 Pull Request。

知识工程解决的是“找得到信息”，架构约束工程解决的是“即使知道该做什么，也不能随意乱做”。两者结合，Agent 才既有方向感，也有边界感。

Agent 在具有严格边界和可预测结构的环境中工作效果最好。在全 Agent 生成的代码库中，这一原则需要在工程层面提前落地：等到有数百名工程师时再引入架构规则，通常已经太晚了——而在 Agent 驱动的代码库中，混乱会以比人类团队快得多的速度蔓延。

一种行之有效的结构是分层领域架构（Layered Domain Architecture）：每个业务域被划分为固定的层集合，依赖方向被严格验证，仅允许有限的跨层边。例如，在一个业务域内部，代码只能沿固定顺序向前依赖（Types → Config → Repo → Service → Runtime → UI）；跨切面关注点（认证、连接器、遥测、特性标志）通过单一显式接口进入。其他所有依赖方向都被机械地禁止。

架构规则通过定制 linter 和结构测试强制执行，而不是依赖文档和代码审查中的人工判断。关键实践：

• linter 的错误信息被设计成直接包含修复指令，从而将约束违反转化为 Agent 可消费的上下文。
• 在对人类团队而言显得迂腐的细粒度规则，对 Agent 来说是乘数效应：一旦编码，立即在所有代码上生效，无需逐一审查。
• 约束划定边界，边界内部的实现方式允许 Agent 自由选择——这类似于大型平台工程组织的管理模式：集中强制边界，局部授权自治。

这套约束还包括"品味不变量（Taste Invariants）"：结构化日志、Schema 与类型命名规范、文件大小限制、平台特定的可靠性要求。这些规则用静态分析强制执行，将人类工程师的审美判断固化成可机器检查的规则。

对 Agent 可以修改的内容施加精确的写权限，是防止状态腐蚀的重要手段。典型模式：功能列表文件中，Agent 只允许修改

passes

此外，在数据边界处解析数据形状（而不是 YOLO 式地推断数据结构），使用类型化 SDK 或 Schema 验证库，是保持 Agent 可以安全推理的代码库形态的基础约束。

边界清晰之后，系统仍然需要对 Agent “可见”。否则即使约束被写得很严，Agent 也只能在黑箱里试错，无法高效定位运行时问题。

Agent 可读性（Agent Legibility）指的是：系统的 UI、日志、状态和指标对 Agent 来说是否足够可见、可解析、可操作，从而使模型能够直接观察应用行为、复现问题并验证修复结果。它关注的是系统是否为推理提供了足够清晰的外部反馈面。

随着代码吞吐量提升，人工 QA 容量会成为瓶颈。此时，关键路径不再是增加人力，而是让应用自身的 UI、日志和指标对 Agent 直接可读，使 Agent 能够自主复现 bug、验证修复并对应用行为进行推理。

使应用对 Agent 可读的关键手段：

• 每个 git worktree 独立启动一个应用实例：Agent 可以针对自己的变更启动隔离的应用版本，互不干扰。
• Chrome DevTools Protocol（CDP）接入：将 CDP 接入 Agent 运行时，并封装操作 DOM 快照、截图和页面导航的技能，使 Agent 能够驱动浏览器、复现 bug 并验证修复，而不依赖人工截图传递。
• Playwright/Puppeteer MCP：在多 Agent 架构中，评估 Agent 使用浏览器自动化工具实际操作运行中的应用，而不是静态分析代码。这使得"应用看起来工作"与"应用实际可用"之间的差距得以被发现。需注意：浏览器原生弹窗（alert modal）对这类工具不可见，这是已知盲区。

将完整的可观测性栈暴露给 Agent，使其可以查询日志、指标和追踪数据，是将模糊性能目标转化为 Agent 可执行任务的关键。每个 worktree 配备临时的本地可观测性栈（完成后自动销毁），Agent 可通过 LogQL 查询日志、PromQL 查询指标、TraceQL 查询链路追踪。

有了这种接入能力，"确保服务启动在 800ms 以内完成"或"这四条关键用户路径中没有 span 超过两秒"这类提示就变得可执行——Agent 可以直接查询数据、定位问题根源并实施修复，而不需要人工解读日志然后描述问题。

不过，看得见系统状态还不等于能正确判断任务是否完成。可读性回答的是“发生了什么”，验证闭环回答的是“这样是否算成功”。

对于没有二元正确性检验的任务（如界面设计、用户体验），需要将主观判断转化为具体的、可评分的标准，才能构建有效的验证闭环。一套已验证有效的前端设计评分框架包含四个维度：

重要发现：评估者提示中的措辞本身（如"最好的设计是博物馆级别的"）会直接影响生成器的输出风格——不仅仅在评估反馈阶段生效，在第一次生成时就已经开始引导模型远离通用默认值。评估者需通过 Few-shot 示例加详细评分解析进行校准，以保持判断一致性并减少分数漂移。

单元测试和 curl 命令验证的是代码片段，而不是用户体验。端到端测试的原则是：像人类用户一样测试——通过浏览器自动化工具实际操作运行中的应用，才能发现"代码逻辑看似正确但功能整体不可用"的问题。

实施健康检查门控（Health-Check Gate）：在每个会话开始时，Agent 必须先运行基础端到端功能测试，确认应用处于正常工作状态，再开始实现新功能。如果发现应用处于损坏状态，应先修复，否则新功能会在损坏的基础上叠加，问题会更难追溯。

干净状态（Clean State）的定义：每个会话结束时，代码库应处于可合并到主分支的状态——无重大 bug，代码有序且有文档，后续开发者（或 Agent）可以直接开始新功能，而无需先清理遗留的乱局。

Harness 案例里常见一个容易被忽略的盲点：系统也许已经很好地约束了内部质量，却未必充分验证了外部行为是否真的符合产品意图。目录结构、架构 lint、单元测试、Clean State 和持续回收都很重要，但这些机制首先保证的是内部一致性，而不是最终功能一定可用。

因此，成熟的 Harness 必须把功能验证（Functionality Verification）视为独立承重件，而不是默认附属物。真正可靠的系统需要对“用户是否真的能完成任务”建立单独的验证回路，例如任务级验收标准、浏览器自动化、独立评估 Agent、人工 spot check，或基于运行时信号的行为检查。能持续写代码只是起点；能持续验证行为，才是 Harness 真正闭环的标志。

即使单次任务已经具备了约束、可读性和验证，长期运行后的系统仍会累积漂移。Harness 因此不仅要管每一轮执行是否正确，还要管整个代码库是否在时间尺度上持续失真。

Agent 会复制代码库中已存在的模式——即使这些模式并不理想。随着时间推移，全 Agent 生成的代码库会发生不可避免的漂移：重复工具函数扩散、文档与代码行为不同步、架构规则被逐渐侵蚀。早期的应对方式是每周花费 20% 的团队时间手动清理，但这完全不可扩展。

有效的替代方案是将"黄金原则（Golden Principles）"直接编码进代码库，并建立周期性的自动化垃圾回收流程：

• 在代码库中明确记录有主见的、机械可检查的原则（如：优先使用共享工具包而非手写 helper；必须在边界处解析数据形状，不得基于猜测的结构构建逻辑）。
• 周期性运行后台 Agent 任务，扫描原则违反、更新质量评分、开启针对性重构 Pull Request。
• 大多数这类 PR 可以在一分钟内完成审查并自动合并。

技术债务与高息贷款相似：持续小额偿还几乎总是优于积累后集中清算。人类工程师的品味判断被捕获一次，随后在每一行代码上持续强制执行——这是 Agent 驱动开发模式下特有的杠杆效应。

但这些组件本身并不是一成不变的。任何垃圾回收策略、验证门控或多 Agent 编排，背后都隐含着对当前模型能力的判断；一旦模型变化，Harness 的承重结构也需要重新评估。

Harness 中的每一个组件都编码了一个假设：模型目前无法独立完成这件事，所以需要这层脚手架。这些假设有两个失效原因：

• 假设从一开始就是错的——模型其实能做到，但工程师没有测试验证就加了脚手架。
• 假设因模型能力提升而过时——昨天需要 Sprint 分解的任务，今天的模型可以持续完成而不失去连贯性。

因此，评估哪些 Harness 组件是真正的承重结构（Load-Bearing Components）——每当新模型发布时，剥除不再有效的部分，添加利用新能力的新部分——是 Harness 工程师持续的工作职责。

一个典型的演化轨迹：Claude Sonnet 4.5 需要 Context Reset + Sprint 分解 + 完整三 Agent 架构；Opus 4.5 在三 Agent 架构下表现更好，Sprint 结构依然必要；Opus 4.6 消除了上下文焦虑，Generator 可以持续运行超过两小时而无需 Sprint 分解，Evaluator 从"始终必要"变为"在任务超出模型原生能力时才有价值"。这套 Harness 对于 Sonnet 4.5 来说恰到好处，对于 Opus 4.6 来说则是过度设计。

一个重要的元原则：随着模型能力提升，有趣的 Harness 组合空间不会缩小，而是移动。工程师的工作不是等待模型强大到不需要 Harness，而是持续找到下一个新颖的组合。

一旦系统的主要难点从“写出代码”转移到“设计并维护这套控制面”，工程师的职责也会随之改变。

在 Harness Engineering 语境下，工程师的工作重心发生了系统性上移。原本直接产出代码的工作，转变为设计 Agent 工作的环境、指定意图与验收标准、构建使 Agent 能可靠工作的反馈闭环，以及将人类判断和品味持续编码进系统。

核心原则可以概括为一句话：Humans steer, agents execute。这意味着人类在更高的抽象层次上工作：确定优先级、将用户反馈转化为验收标准、验证结果。当 Agent 遇到障碍时，工程师更应追问"缺少什么能力？如何让这个需求变得对 Agent 可理解且可强制执行？"

随着代码吞吐量的提升，许多传统工程规范变得适得其反。PR 在高吞吐系统中应该是短命的；测试 flakiness 有时更适合通过后续补丁修复而非阻塞合并；纠错的成本极低，等待的成本极高。这与低吞吐人工团队的工作假设完全相反。

不过，这些方法目前验证得最充分的，仍然主要是绿地项目或受控实验环境。一旦进入历史包袱深重的老系统，Harness 的建设顺序与成本结构都会发生变化。

当前公开的成功 Harness 案例大多发生在绿地项目、受控实验或可以从零搭脚手架的环境中。真正更难的问题，是如何把 Harness Engineering 引入一个已经运行多年、缺少架构边界、测试质量不稳定、文档残缺且历史包袱沉重的棕地代码库。这里最大的风险不是 Agent 不会写代码，而是现有系统本身已经缺乏足够清晰的控制面，Agent 一旦接手，只会更快复制并放大原有混乱。

因此，棕地改造不能照搬绿地模板，通常需要渐进式引入：先补最关键的边界约束，再建立最小可用的知识入口、验证门控和可观测性接入，最后才考虑多 Agent 编排或更高自治级别。换言之，Harness 在棕地场景里的首要任务不是提升速度，而是先把代码库变成一个对 Agent 可理解、可约束、可验证的环境。

OpenAI Codex 内部实验（2026 年 2 月）：三名工程师在约五个月内，通过零人工手写代码的流程，构建了一个拥有内部日常用户和外部 alpha 测试用户的内部 beta 产品。代码库规模约一百万行，覆盖应用逻辑、测试、CI 配置、文档、可观测性和内部工具。约 1500 个 PR 被合并，平均吞吐为每名工程师每天 3.5 个 PR，且随团队扩张吞吐还在提升。核心投入集中在：精简的 AGENTS.md 目录结构、分层领域架构 + 机械化 linter、应用 + 可观测性对 Agent 的完整可读性、黄金原则与周期性垃圾回收 Agent。

Anthropic 复古游戏编辑器对比实验（2026 年）：使用 Claude Opus 4.5，对同一个 prompt "构建一个 2D 复古游戏制作工具"进行两种模式的比较。单 Agent 单次运行：20 分钟，花费 9 美元，结果是布局浪费空间、核心玩法无法运行。完整三 Agent Harness（Planner + Generator + Evaluator，含 Sprint Contract）：6 小时，花费 200 美元，结果是 Planner 将一句 prompt 扩展为横跨 10 个 Sprint 的 16 项功能规格，游戏核心机制正常运行，并额外实现了精灵动画、AI 辅助关卡设计等超出原始 prompt 的功能。成本约为单次运行的 22 倍，但输出质量远超。

Anthropic 浏览器 DAW 实验（2026 年）：使用 Claude Opus 4.6（已移除 Sprint 分解），通过 prompt "构建一个基于 Web Audio API 的全功能浏览器 DAW"，三轮构建 + QA 循环总计 3 小时 50 分钟，花费 124.70 美元。最终产物包含可用的编排视图、混音台和传输控制；内置 AI Agent 可通过自然语言提示设置节拍/调性、演奏旋律、建立鼓轨、调节混音和添加混响，完成一段完整的短曲创作。

检索增强生成（Retrieval-Augmented Generation, RAG）把“外部知识”通过检索在推理时注入到上下文里：先检索，再生成。它解决的不是模型能力问题，而是信息可得性与可控性问题：把知识放在可更新的外部存储里，而不是指望模型参数记住一切。

真正落地到生产后，RAG 很快会从“模型 + 向量库”的玩具结构，变成一套完整的知识处理系统。一个更接近现实的抽象是：知识源接入、文档获取、分块、增强、索引、召回、融合、重排、上下文回拼、生成。其中任何一步做得粗糙，最终回答质量都会明显退化。

从工程视角看，RAG 的核心是把知识库建成一个可持续演化的外部记忆系统，而不是简单把文本切块后丢进向量数据库。这里通常至少会区分三层对象：知识库（Base）负责来源配置、召回策略与索引策略；文档（Document）负责内容文件、语言、状态与分块配置；块（Chunk）负责可检索的最小语义单元及其摘要、问题、向量、命中统计等元数据。再往上，很多系统还会加一个目录（Catalog）层，把知识按业务树、产品线、权限域或租户边界组织起来。这种分层的意义在于：RAG 检索的不是“一个文本文件夹”，而是一个带治理、带生命周期、带配置继承的知识对象系统。

一个成熟的知识库系统通常会显式区分知识源（Source）与检索目标（Target）。知识源回答“内容从哪里来”，例如上传文件、网页抓取、代码仓库、目录扫描；检索目标回答“内容最终由谁提供召回能力”，可以是系统自建索引，也可以是外部知识平台。这样设计的好处是把“接入来源”与“服务出口”解耦：同一套文档采集和治理流程，可以接到不同的检索后端，而不用把采集逻辑和向量库实现绑死。

另一个关键决策是把知识处理做成异步流水线，而不是同步上传即就绪。现实中的知识库往往需要经历扫描、下载、解析、分块、摘要生成、问题生成、向量化、索引构建等多个阶段。把这些阶段拆开，一方面是因为它们耗时、依赖不同资源且失败模式不同；另一方面是为了支持恢复、重试、并发控制与增量更新。于是，生产 RAG 往往天然带有一个状态机：知识库有自己的状态，文档有自己的状态，块也有自己的状态。这个状态机的作用是把长链路处理过程显式化，使每个阶段都能被观察、重跑和局部修复。

教程中的“上传文档 ➡ embedding ➡ 检索 ➡ 回答”只覆盖了最小闭环。真实系统里的知识库会持续新增、修改、下线、重建索引，并不断调整切分方式和召回参数。因此，RAG 更接近“搜索系统 + 知识处理中台 + 生成模型”的组合，而不是一次性的离线脚本。

分块（Chunking）决定了“检索的最小单位”。块太大：召回相关信息但携带大量噪声；块太小：召回片段零散，缺上下文导致生成不稳。分块应与文档结构、问题类型、上下文窗口预算一起设计。

固定大小分块（Fixed-size Chunking）按 token/字符数切片，简单稳定，适合结构较弱的纯文本与大规模离线构建。常配合重叠窗口（Overlap）避免跨边界信息断裂。

语义分块（Semantic Chunking）用段落/标题/语义边界切分，目标是让一个 chunk 自洽（Self-contained）。它通常更适合技术文档与带层级结构的内容，但需要更复杂的解析与规则。

递归分块（Recursive Chunking）先按大结构切（章节/标题），再对子块继续切（段落/句子/固定大小），兼顾结构与长度约束，是很多工程实现的折中方案。

生产系统里的分块通常远比这三类更细。除了固定大小、递归和语义切分，还会按 Markdown、HTML、PDF、代码、表格、JSON、LaTeX、句子、段落、滑动窗口等内容类型选择不同 chunker。这背后的设计判断非常重要：分块不是一个通用算法参数，而是内容理解策略的一部分。代码和 API 文档更适合按语法结构或标题层级切；表格和 PDF 更需要保留版面边界；Markdown/HTML 则需要保留层次结构，甚至形成父子 chunk 树。

这类设计会直接改变召回质量。若把所有内容都按固定长度切块，标题、层级、页面边界、代码块和表格结构都会被抹平；若系统保存 chunk 的父子关系、边界分隔符、正文起止位置、重叠前后文与结构元数据，那么检索命中的就不再只是孤立片段，而是文档结构中的一个明确位置。此时的 RAG 更接近结构化文档检索。

Agentic Chunking 进一步把 LLM 引入切分阶段，由模型判断哪些内容应属于同一语义单元。它在复杂文档上可能带来更强的语义完整性，但代价同样明显：构建成本高、可重复性差、调试难度大，提示词质量会直接影响索引结果。因此它更适合作为高价值内容的增强型切分，而不适合作为默认的全量基础设施。

向量数据库（Vector Database）存储每个 chunk 的向量表示（Embedding Vector）及其元数据（Metadata），支持近似最近邻（Approximate Nearest Neighbor, ANN）检索。向量并不“包含全文”，它是语义相似度的索引键；检索结果仍然需要回源拿到原文片段。

工程上需要区分“向量索引（Vector Index）”与“向量数据库（Vector Database）”：前者强调 ANN 检索算法与数据结构；后者强调持久化、增量更新、元数据过滤（Metadata Filtering）、分片/副本与多租户（Multi-tenancy）等系统能力。

生产知识库通常会同时维护多个索引平面：chunk 正文索引、chunk 摘要索引、chunk 问题索引，必要时还有文档摘要索引。它们对应的是不同的检索语义：正文索引擅长直接召回原文；摘要索引更适合长文压缩后的主题级匹配；问题索引则把 chunk 改写成更贴近用户查询的可检索意图。因此，生产 RAG 的索引设计本质上是“同一内容的多种检索视图”。

双后端架构也是常见现实。高质量知识库常把 Milvus/Qdrant 一类向量系统与 Elasticsearch/OpenSearch 一类全文检索系统并行使用：前者负责稠密向量、稀疏向量与 ANN 检索，后者负责 BM25、字段过滤和业务搜索。这种组合对应的是信号分工：向量擅长语义匹配，词项系统擅长精确关键词与过滤。真正的难点随之转移到一致性和融合上：索引命名要对齐，更新要同步，删除要清理，跨系统分数不能直接比较。

向量检索组件通常有三种部署形态：向量索引库（如 FAISS/ScaNN）偏“库”；向量数据库（如 Milvus/Qdrant/Weaviate）偏“服务”；全文检索引擎（如 Elasticsearch/OpenSearch）则以 BM25 为核心并逐步补齐向量检索能力。许多生产系统采用“双引擎”组合：向量库负责高性能 ANN，全文检索负责复杂过滤与关键词召回，最终在融合/重排阶段统一排序。

ANN 索引（ANN Index）在“速度、召回率（Recall）与内存”之间权衡。检索侧常见痛点是“向量相似度可算，但业务过滤很难做快”：元数据过滤会破坏 ANN 的近邻结构，使得系统需要在“先过滤再向量检索”和“先向量检索再过滤”之间做策略选择。

在生产知识库里，过滤通常不是可选项，而是第一等公民。目录树（Catalog Tree）、启用状态、文档类型、租户边界、语言、内容类型、业务域前缀，都可能成为过滤条件。也正因为如此，许多系统会把 catalog 前缀过滤、enabled 标志、source_type/source_id 等字段同时写入 Milvus 和 ES，两边都能先做过滤再做召回。否则，召回质量再高，也可能把“本不该返回的内容”混进上下文。

稠密检索（Dense Retrieval）用向量相似度（如余弦相似度或内积）做 top-k 召回，擅长语义匹配与同义改写，但可能漏掉精确关键词（如错误码、版本号）。

它还有一个常被低估的前提：embedding 模型的训练分布必须与目标领域足够接近。若把主要基于互联网通用语料训练出来的嵌入模型，直接拿去检索法律、医疗、专利或企业内部术语密集的文本，向量空间中的“相似”往往就不再等于业务上的“相关”，召回质量会明显下降。此时更稳妥的做法通常是引入领域微调 embedding、混合检索，或让 sparse / full-text 路径共同兜底。

全文检索（Lexical Retrieval）以 BM25 等词项匹配为核心，擅长精确匹配与关键词召回。它对拼写、专有名词、数字更敏感，但对语义改写不够鲁棒。

稀疏检索（Sparse Retrieval）用“稀疏向量”表示文本：向量维度对应词项（或子词），权重表示该词项对匹配的贡献。与 BM25 相比，稀疏检索的权重来自模型学习而非纯统计；与稠密检索相比，它保留了词项级可解释性与对罕见词/数字的敏感性。

典型路线包括 SPLADE（Sparse Lexical and Expansion Model）：通过学习得到“词项扩展（Lexical Expansion）”，让语义相关但不共词的文本仍能在词项空间相遇。工程上，稀疏检索常作为混合检索的一路召回信号，而不是单独替代 BM25。

混合检索（Hybrid Retrieval）把稠密检索与全文检索结合：先分别召回，再融合排序（如加权、去重、学习排序）。这是目前最稳健的通用策略之一。

在更完整的知识库系统里，混合检索不只是“dense + BM25”两路，而可能是 chunk / summary / question 三类检索目标与 dense / sparse / fulltext 三类检索路径的组合矩阵。换句话说，生产 RAG 召回的是多个“信号通道”，而不是单一相似度函数。它的优势是覆盖面更强：原文命中、主题命中、问句改写命中可以互补；但代价也很直接：路径暴涨、分数更不可比、日志更难读、回归测试更复杂。

这类系统往往还会按知识库能力做“有效方法裁剪”。例如，用户请求 fullhybrid，但某个知识库只建了 dense 和 sparse 索引，那么实际就只能退化成 hybrid；某个库没有开启 question recall，就不该在该路径上浪费资源。这个细节反映出一个成熟的 RAG 判断：检索策略不是全局写死的，而是知识库级配置与请求级策略共同决定的。

混合检索的难点不在“多路召回”，而在“分数不可比（Incomparable Scores）”：BM25 分数、余弦相似度/内积分数、稀疏向量分数往往不在同一尺度，不能直接相加。常见融合策略：

• 归一化后加权：对各路分数做 min-max / z-score 等归一化，再做加权求和或加权乘积。
• 基于排序的融合：不依赖原始分数尺度，例如 RRF（Reciprocal Rank Fusion）：\(\mathrm{score}(d)=\sum_{s}\frac{1}{k+\mathrm{rank}_s(d)}\)。
• 学习排序（Learning to Rank）：把各路分数与特征（BM25、embedding sim、字段匹配、长度等）作为特征，训练一个排序模型做融合。

生产系统通常更偏爱基于排序的融合，而不是直接拼原始分数。这是因为 ES 的 \(_score\)、Milvus 稠密距离、Milvus 稀疏 BM25 分数往往来自完全不同的评分体系。RRF 或加权 RRF 的价值就在于鲁棒：它不要求各后端分数可比，只要求各路径给出相对顺序。若再往上追求精度，则会在粗召回后接一个模型重排器，对融合后的候选做统一判断。

相关性阈值（Relevance Threshold）决定的是：召回结果里哪些片段值得继续送给模型，哪些片段应该被直接丢弃。很多 RAG 系统的问题并不是“完全没召回到东西”，而是把大量边缘相关、低置信度甚至明显错误的片段一并塞进上下文，结果让生成阶段被噪声牵着走。

因此，top-k 本身通常不够；工程上还需要结合相似度阈值、分数差值阈值或最小证据数量规则共同判断。阈值设得过低，会把噪声片段混进上下文；阈值设得过高，又可能让系统在真实有答案时错误地进入“未检索到结果”分支。成熟系统往往会把阈值当作知识库级和请求级都可调的参数，并配合离线标注集或在线反馈持续校准。

查询改写（Query Rewriting）解决的问题是：用户真正表达的检索意图，经常并不等于用户字面上输入的那句话。尤其当用户提问冗长、上下文依赖强、代词很多、问题里混有解释性语句而不是检索关键词时，直接拿原问题去召回，往往不如先把问题改写成更适合检索的形式。

查询改写的核心是把问题重新组织成更适合索引命中的检索表达，例如补全省略主语、显式写出实体名、拆开复合问题、提取关键词、或把对话上下文中的隐含约束展开成可检索文本。

多查询 RAG（Multi-Query RAG）会先把一个原始问题改写成多个语义相近但表述不同的检索查询，再分别召回并合并结果。它的动机很直接：单一路径的 query 很容易受措辞影响，而多个改写版本可以覆盖不同的关键词、别名、问题角度与表达方式，从而提高召回覆盖率。

多跳 RAG（Multi-hop RAG）适合那些答案依赖多段证据链的查询。它通常不会指望一次检索就拿到最终答案，而是先检索第一跳证据，再根据第一跳结果生成下一跳 query，继续检索后续证据。于是，检索过程本身就变成了一条“检索 ➡ 读证据 ➡ 改写下一问 ➡ 再检索”的链式推理流程。

智能体 RAG（Agentic RAG）则把查询改写提升为一个可反复决策的过程：模型不只改写一次 query，而是根据当前召回质量、证据缺口、工具反馈与上下文状态，决定是否继续搜索、换一种问法、切换知识库、触发重排，或干脆停止检索进入回答阶段。它的重点已经不只是“改写 query”，而是让检索成为 Agent 控制流的一部分。

重排序（Reranking）在“召回”（Recall）之后提升“相关性排序”（Precision@k）：用更强但更慢的模型对候选片段重新打分。

成熟 RAG 系统里的 rerank 还常分成两层。第一层是每个知识库内部的局部重排：对该库自己的候选做加权、RRF 或模型精排。第二层是多知识库结果合并后的全局重排：当查询同时打到多个知识库时，再在总候选集合上做一次统一排序。这样做的动机很现实：单库内部的分数可比较，并不代表跨库结果也天然可比较；若不做第二层，全局 top-k 往往会被某个打分体系更“激进”的知识库垄断。

Cross-Encoder Reranker 把 query 与候选 chunk 拼接后输入同一个编码器，用注意力做细粒度匹配，相关性通常更高，但计算更慢，适合对 top-k（例如 50→10）做精排。

典型输入形式是

[CLS] query [SEP] doc [SEP]

打分通常取 \([\mathrm{CLS}]\) 位置的最终隐向量 \(h_{\mathrm{CLS}}\) 过一个线性层得到相关性分数（或二分类 logits）。与双编码器（Bi-Encoder / Dual Encoder）相比，cross-encoder 更准但无法离线预计算候选向量，因此在线成本更高。

LLM Reranker 用大模型直接判断相关性或做对比选择，能融合更复杂的语义与任务约束，但成本更高且需要防止“自信乱判”。工程上常用它做少量候选的最终筛选。

生成式重排序（Generative Reranking）把“相关性打分”转写为生成任务：把 query 与 doc 拼接输入解码器（Decoder-only）或编码器-解码器（Encoder–Decoder），让模型生成一个标签 token（例如

Yes/No

常见的点式打分形式是二分类 log-odds：令 \(y\in\{0,1\}\) 表示是否相关，则

相比传统 BERT 类 cross-encoder，生成式 reranker 往往更擅长处理长文本匹配、复杂约束与隐含推理；工程上常用“轻量级 LLM + 领域数据微调”来获得显著增益。

列表式重排序（Listwise Reranking）把多个候选 doc 一次性送入模型，在同一个上下文窗口中共同建模“相对顺序”，而不是对每个（query, doc）独立跑一次 forward。直觉上，它让候选之间在 self-attention 中“同台竞争”，从而提升排序一致性，并降低多次推理带来的总开销。

实现上常见做法是：把候选 doc 按截断长度拼接成一个 list，要求模型输出每个 doc 的分数或名次；也有实现会在末尾使用一个专门的“汇聚 token”对每个 doc 读取表示。Listwise 方法的工程约束更强：候选数、每段 doc 的截断长度与模型上下文窗口会直接决定可吞吐的 top-k。

精排训练的难点是“区分相似但不相关”：需要硬负样本（Hard Negatives）来逼迫模型学习细粒度差异。硬负样本通常来自第一阶段召回：对同一 query，取检索 top-k 中不相关的候选作为 negatives（也可混入 BM25 negatives、in-batch negatives、或对抗式 negatives）。

蒸馏（Knowledge Distillation）把一个强但慢的教师模型（Teacher）产生的打分/偏好，转移给一个更快的学生模型（Student）。在重排序里，蒸馏最常见的目标不是“压缩参数”，而是把 LLM 级别的相关性判断能力下放到可规模化的 reranker，使线上能承载更大的 top-k、更高的 QPS 或更低的 P99。

RAG 检索阶段的最终产物并不一定只是“命中的那一小段 chunk”。很多高质量系统会把返回内容模式做成显式策略：只返回命中块正文、返回去掉 overlap 的核心正文、返回命中块加邻近上下文、或按文档中的位置范围把相关块递归拼回更完整的片段。这样做的原因是：模型生成真正需要的是足够完整且边界清晰的证据上下文，而不是孤立句子。

这里的关键判断是：检索命中的是索引单元，但喂给模型的应是生成单元。索引单元倾向短小、便于召回；生成单元则要兼顾上下文完整性、token 预算和可引用性。若两者完全绑定，系统通常会在召回精度与生成可读性之间来回拉扯。

第一，RAG 的上限不只由 embedding 模型决定，而是由“分块质量、索引视图、融合策略、回拼策略、状态治理”共同决定。把注意力只放在换一个更强 embedding 上，通常抓不住主矛盾。

第二，知识库应当被理解为带状态机的外部知识资产，而不是静态文件集合。只有显式区分 base、document、chunk，并让它们有自己的生命周期，系统才可能支持增量更新、失败恢复、重建和审计。

第三，生产 RAG 常常天然走向双后端和多路径召回。这个方向的收益是更稳健的覆盖率，代价是系统复杂度、索引一致性成本和观测难度都会明显上升。因此它适合高价值知识库，不一定适合所有团队的第一版系统。

第四，把摘要和问题也视作可检索对象，是一个非常务实的设计。它等于承认“原文表述”与“用户提问方式”经常不一致，于是用知识增强知识本身的可检索性。但它也会带来额外索引、额外 embedding 成本与额外一致性问题，因此只有在召回质量确实成为瓶颈时，这种多视图索引才值得引入。

第五，外部知识平台同步并不等于“复制一份数据就结束”。一旦系统允许一部分知识由外部平台托管、另一部分知识由内部系统自建索引，那么“谁是事实源、谁负责更新、谁负责删除、谁负责召回”就必须在架构上说清楚。否则最容易出现的不是召回不到，而是召回出重复、过期或跨系统不一致的内容。

生成与融合（Generation & Fusion）的关键在于：把检索到的证据（Evidence）以可控格式注入 prompt，并要求模型“基于证据回答”。常见做法包括：

• Stuffing：把 top-k 片段直接拼接进上下文（最简单，最易超预算）。
• Map-Reduce：先对各片段分别提炼要点，再汇总生成最终答案（更稳，成本更高）。
• Refine：先用少量证据生成初稿，再逐片段增量修订（适合长证据链）。

检索增强生成（RAG）解决的是“模型缺少外部知识”的问题；智能体（Agent）解决的是“模型如何在真实环境中持续完成任务”的问题。一个真正可用的 Agent 不再是单次 prompt 的包装，而是一个带有状态（State）、工具（Tools）、记忆（Memory）与控制流（Control Flow）的运行时系统。它能够观察环境、决定下一步动作、调用外部能力、根据反馈修正策略，并在多轮交互中维持任务连续性。

从工程视角看，Agent 的本质是“以大模型为决策核心的软件系统”。模型负责理解、推理与生成；外层系统负责注入上下文、执行动作、保存状态、施加约束，并把环境反馈重新送回模型。只有这几层协同起来，模型才会从一次性回答器变成可持续工作的执行体。

计划-执行（Plan-Execute）是智能体最常见的控制流之一：先把“用户目标”分解为一组可操作步骤（计划），再逐步调用工具/模型完成这些步骤（执行），并把中间结果写回状态（State）。当环境反馈与计划假设不一致时，触发再计划（Replan）。工程上，它的价值是把一次长输出变成可观测（Observable）、可重试（Retryable）、可中断（Interruptible）的多步过程。

感知-推理-行动（Perception-Reasoning-Action）循环是 Agent 的基本闭环。感知阶段读取环境状态，例如用户输入、网页 DOM、数据库返回值、日志、文件内容或工具回执；推理阶段根据当前目标、约束和历史状态决定下一步策略；行动阶段把决策落实为具体操作，例如搜索、调用 API、写文件、点击界面或向下游智能体发消息；随后再读取新反馈，进入下一轮循环。这个闭环的关键不在“会不会思考”，而在“每一轮是否拿到了正确观测、是否执行了正确动作、是否把结果正确写回状态”。

因此，Agent 设计首先是状态机（State Machine）设计。很多失败并不是模型推理能力不足，而是观测不完整、动作不可验证、状态写回混乱，导致下一轮推理建立在错误世界模型之上。一个好的 Agent runtime 会显式记录当前目标、最近动作、动作结果、异常信息与下一步计划，从而让每一轮循环都建立在稳定状态上。

工具使用（Tool Use）让语言模型突破“只会生成文本”的边界，把外部系统接成自己的感官与执行器。工具既可以是只读型能力，例如搜索、数据库查询、文件读取；也可以是动作型能力，例如发送请求、执行 shell、操作浏览器、写入代码仓库。模型本身不直接执行这些动作，而是输出结构化调用意图，再由外层系统负责真正执行、捕获结果并返回。

工程上，Tool Use 的难点不在“把工具接上”，而在“把工具定义清楚”。一个好的工具接口需要明确输入 schema、输出 schema、权限边界、失败语义和重试策略。工具定义越模糊，模型越容易产生参数幻觉（Argument Hallucination）、错误调用和无效循环；工具定义越稳定，模型越容易学会把工具当作程序原语来组合。

记忆系统（Memory System）负责解决跨步骤与跨会话连续性问题。没有记忆的模型每次调用都像“重新开机”；有记忆的 Agent 才能累积上下文、复用历史决策、根据过去错误调整行为。记忆并不等同于“把更多 token 塞进上下文窗口”，而是要把不同时间尺度、不同重要性的状态放进不同存储层，再按需检索。

短期记忆（Short-term Memory）通常由上下文窗口（Context Window）承载，保存当前任务最活跃的信息：系统指令、最近几轮对话、正在执行的计划、刚拿到的工具结果、当前工作草稿等。它的优势是读取成本低、和当前推理绑定最紧；它的限制也同样明显：容量昂贵、注意力会稀释、信息越多不代表效果越好。

因此，短期记忆的核心工作是“裁剪”。优秀的 Agent 会把原始轨迹压缩成摘要（Summary）、状态（State）和待办项（Next Actions），只保留当前决策真正需要的变量。短期记忆承担的是工作记忆（Working Memory）的职责：它服务当前这一轮推理，而不是承担长期知识库的角色。

长期记忆（Long-term Memory）存放在上下文窗口之外，常见载体包括向量数据库、关系数据库、对象存储、文档库、日志系统、代码仓库、任务看板与事件流。它保存的是“现在不必全部加载，但未来可能需要回忆”的信息，例如用户偏好、历史案例、项目规范、过去失败总结、已验证的事实与中间产物。

长期记忆要解决三个问题：写什么、怎么检索、何时遗忘。写入过多会让存储退化为噪声池；只做向量相似度检索又容易漏掉结构化约束与时间关系。成熟做法通常会把结构化状态、全文检索、向量召回与人工定义的索引结合起来，让 Agent 既能“语义回忆”，也能“精确定位”。

目前主流 Agent 设计常借用认知科学中的三类记忆划分：情景记忆（Episodic Memory）、语义记忆（Semantic Memory）与程序记忆（Procedural Memory）。这三类记忆对应的是“发生过什么”“知道什么”“怎么做”。把它们混在一个存储里，检索和写入策略很快就会失控；分层建模则更容易设计稳定的读写规则。

其中，程序记忆对工程系统尤其关键。很多所谓“Agent 经验”最终都会沉淀成程序记忆，例如某个 API 的调用顺序、某类错误的排查流程、某个项目的提交流程。Harness Engineering 本质上就是把这些隐性经验逐步外化成可持续复用的程序记忆。

推理（Reasoning）解决的是“当前这一步怎么想”；规划（Planning）解决的是“整个任务怎么走”。现代 Agent 往往同时需要二者：局部步骤要有足够的推理精度，长期任务要有阶段化计划与中途重规划能力。近两年的研究基本沿着四条路线收敛：交错式思考与行动、反思式自我修正、显式规划后求解，以及基于搜索的多路径探索。

ReAct（Reason + Act）是当前 Agent 范式最有影响力的起点之一。它把“思考轨迹”和“动作轨迹”交错起来：模型先给出一小步 reasoning，再发起 action，读取 observation 后继续下一步 reasoning。与只做链式思维（Chain-of-Thought）的做法相比，ReAct 的优势在于每一步都能接触外部环境，因此能在事实不确定、需要探索、需要工具辅助的任务上持续修正路径。

ReAct 的核心价值，在于让推理过程与环境反馈形成闭环，而不是单纯让模型“想得更多”。它也有明显代价：若没有停机条件、步数上限和工具约束，轨迹很容易冗长、循环或过度调用工具。因此，ReAct 更像 Agent 控制流的原型范式，生产系统通常会在其外层再加计划、验证、预算控制与错误恢复机制。

Reflection（自我反思）把“错误”变成下一轮决策的输入。其基本思想是：一次执行失败后，不只返回原始错误信号，还额外生成一段高信息密度的经验总结，说明失败原因、已验证无效的路径、下一次应当修改的策略。这样，模型获得的不是一个抽象的 reward，而是一段可以直接进入上下文的文字化梯度。

从研究谱系看，Reflexion 将这种思路系统化为 verbal reinforcement learning：把环境反馈转写成文本反思，并存入 episodic memory，供后续回合检索。工程上，这类方法通常以“执行后 Critic”“失败总结卡片”“经验回放摘要”等形式落地。它最适合高代价试错任务，例如代码修复、网页操作、长任务代理；前提是系统能可靠地区分“失败是策略问题”还是“失败只是偶然噪声”。

Plan-and-Solve 的思想很直接：先显式列出求解计划，再根据计划执行。它针对的是零样本链式思维常见的 missing-step 问题，即模型直接开始求解时容易跳步骤、漏约束或在中途漂移。把“先规划、后执行”做成两个阶段后，模型的注意力会先聚焦在任务分解，再聚焦在逐步完成，从而显著降低长任务中的结构性遗漏。

这一思路在工程系统里几乎已经成为默认模式。很多 Coding Agent、Research Agent 与 Workflow Agent 都把 planner 和 executor 拆成不同阶段，甚至拆成不同角色。原因很简单：计划是一种低成本、高杠杆的中间产物。它既能让人类在写代码前审查方向，也能让系统在执行中持续对照“当前动作是否仍服务于原始目标”。

MCTS（Monte Carlo Tree Search，蒙特卡洛树搜索）把 Agent 的决策过程从“单路径生成”升级为“多路径探索”。系统不再只让模型给出一个下一步动作，而是展开多个候选分支，对不同轨迹进行模拟、评估和回传分值，再把计算预算集中到更有希望的分支上。对于需要长程依赖、路径选择、试探性探索的任务，这种显式搜索比单次贪心生成更稳健。

Language Agent Tree Search（LATS）是这一路线的代表性工作，它把 MCTS 与语言模型结合，让模型同时承担候选动作生成、状态评估和自我反思等角色。代价同样明确：搜索带来更高 token 成本、更复杂的状态管理和更重的工程编排。因此，MCTS 更适合高价值、高不确定性任务，例如复杂推理、博弈式决策、困难编程与网页任务，而不是每个简单问答都默认启用的通用套路。

如果说推理模块决定“应该做什么”，那么工具层决定“究竟能做到什么”。当前主流 Agent 平台基本收敛出几类高频动作接口：结构化函数调用、受控代码执行、Web 检索、图形界面操作，以及把外部工具和资源标准化接入的协议层。它们共同构成了 Agent 的执行面。

Function Calling（函数调用）是最基础、最通用的 Tool Use 形式。模型输出的不再是自然语言描述，而是一个满足 schema 的调用请求，例如函数名、参数对象、调用意图；应用侧接收到请求后真正执行代码，并把结果作为 tool result 返回。这样，模型负责“决定调用什么”，应用负责“保证执行正确”。

Function Calling 的真正意义是把自由文本接口收窄为结构化程序接口。只要参数 schema 足够清晰，模型就能稳定学会把外部系统当成可组合原语。这也是今天大部分 Agent 框架的底层抽象：上层看起来是“智能体会用工具”，底层通常仍是“模型在做结构化函数选择与参数填充”。

Code Interpreter（代码解释器）让模型在受控沙箱中执行代码，从而把“语言推理”转换为“可验证计算”。它特别适合数据清洗、表格处理、统计分析、绘图、文件转换、轻量脚本自动化与需要精确数值结果的任务。与纯文本推理相比，Code Interpreter 的优势在于中间状态可执行、可复现、可检查。

这类能力本质上是把 Python 或其他运行时变成模型的外部工作台。模型负责提出程序，沙箱负责执行，系统再把 stdout、文件产物、异常栈和图像反馈给模型。只要隔离、资源限制和文件边界设置得当，Code Interpreter 往往是让 Agent “从会解释变成会计算”的最直接跃迁。

Web 搜索（Web Search）解决的是模型知识静态化问题。基础模型参数中固化的是训练时刻之前的分布，而 Agent 经常需要回答最新价格、最新政策、最新产品文档、最新论文或当前网页状态。把搜索能力接入后，模型可以先检索，再基于来源生成回答，并在必要时附带引用。

工程上，Web 搜索不是“把搜索结果贴给模型”这么简单。系统还需要处理查询重写、来源筛选、去重、可信度排序、片段抽取与多源融合。对于需要最新信息的任务，搜索应当被视为一等能力，而不是可有可无的外挂；否则 Agent 的错误会表现为“推理看起来正确，但事实已经过时”。

Computer Use（计算机使用）让 Agent 直接在图形界面层面操作软件与网页，例如看截图、定位元素、移动鼠标、键入内容、滚动页面与读取屏幕变化。它的价值在于：当目标系统没有现成 API，或者真正业务流程本来就发生在浏览器/桌面界面中时，Agent 仍然可以像人类操作员一样完成任务。

这类能力也是最脆弱的一类动作接口。界面结构变化、网络延迟、弹窗遮挡、验证码、权限确认和安全风险都会放大失败概率。因此，Computer Use 应被视为“最后一层兼容性接口”：没有 API 时才使用，并始终运行在隔离环境中，为高风险动作保留人工确认与回滚机制。

MCP（Model Context Protocol，模型上下文协议）试图把“给模型接工具与上下文”这件事标准化。它定义了一套客户端-服务端协议，让宿主应用可以连接多个 MCP server，并以统一方式暴露工具（Tools）、资源（Resources）与提示模板（Prompts）。这样，模型不必为每个外部系统重新学习私有接线方式，应用也不必为每种模型重复造一套集成层。

在工程语义上，MCP 解决的是“工具可移植性”和“上下文供给标准化”。一个搜索 server、一个数据库 server、一个设计文档 server，只要遵循同一协议，就能被不同 Agent host 复用。当前生态已经把 MCP 从“工具协议”扩展成“上下文协议”：除了调用动作，也强调让模型按需读取结构化资源，而不是把所有材料一次性塞进 prompt。

截至 2026 年 3 月，MCP 官方稳定协议版本为 2025-11-25，2026 路线图正在推进会话扩展（session handling）、Server Cards、Registry 与 agent-to-agent 协作能力。对应用开发者而言，更重要的不是版本号本身，而是它标志着一件事：Agent 运行时正在从各家私有 Tool API，逐步走向可协商、可复用、可观测的开放接口层。

多智能体系统（Multi-agent System）指的是：把一个复杂任务分解给多个具有不同职责或不同上下文边界的 agent，由它们通过委派、协作、验证和状态传递共同完成目标。它关注的核心是如何把规划、执行、审查和并行探索写成一个可控的协作结构。

是否拆成多个 agent，取决于任务是否存在天然的角色分工、上下文隔离需求、并行空间与独立验证价值。很多简单任务用一个强单体 agent 加好工具即可；只有当单一上下文开始拥塞、单角色难以兼顾规划与执行、或多个分支可以并行推进时，多智能体系统才真正体现优势。

角色分工（Role Decomposition）指的是：在多智能体系统中，为不同 agent 分配稳定且边界清晰的职责，使每个 agent 只处理自己最应该承担的那一类决策与操作。它的作用是把复杂任务拆成多个可管理的视角与责任域，降低单一上下文同时兼顾规划、执行和审查的负担。

最常见的基本三角是 Planner、Executor 与 Critic：Planner 负责分解目标，Executor 负责实际操作，Critic 负责验证与挑错。这个结构的本质是在系统内部显式制造不同视角，避免同一个上下文同时承担规划、执行与审查，最终让错误在更早阶段暴露出来。

Planner 负责把模糊目标转成结构化任务图，例如目标拆解、依赖关系、优先级、完成标准与失败回退条件。一个好的 Planner 不直接沉迷于实现细节，而是尽快产出可被执行层消费的中间表示，例如任务列表、阶段计划、验收清单或执行 DAG。这样，后续 agent 的上下文会更短、更稳定。

Executor 负责把计划变成具体动作：调用 API、写代码、运行测试、检索资料、修改文件、操作界面。它通常需要最严格的权限控制，因为真正改变外部世界的是执行层，而不是规划层。把 Executor 的工具范围、写入范围和预算边界限定清楚，往往比继续优化模型 prompt 更能提升整体可靠性。

Critic 负责验证“结果是否正确”。它可以检查事实一致性、运行测试、比对输出格式、审查架构约束、回放浏览器流程，或要求执行层补充证据。Critic 的价值在于给系统引入独立的否决权：没有独立验证的多智能体系统，本质上仍然只是把同一种错误复制了几遍。

角色定义清楚之后，下一步是决定这些角色如何协作。常见模式主要有顺序执行、并行执行与层级委派。三者区别不在名称，而在状态如何传递、谁拥有控制权、失败后如何收敛，以及系统是否允许多个 agent 同时写入同一世界状态。

顺序执行（Sequential Execution）是最稳的模式：上一步完成并产出明确结果后，下一步才开始。它最适合依赖链强、可验证点清晰的流程，例如“先规划，再实现，再审查，再修复”。优点是状态简单、问题定位容易；缺点是吞吐量受限，前一环的错误会整体阻塞后续流程。

并行执行（Parallel Execution）用于把独立子任务同时推进，例如多个资料检索、多个候选方案探索、多个代码模块并行实现。它能显著提高吞吐，但前提是任务切分足够干净，或者系统拥有足够好的合并策略。并行化的真正难点在于如何避免它们争抢同一上下文、重复劳动或互相覆盖结果。

层级委派（Hierarchical Delegation）由一个上层 supervisor 或 manager 统一掌控目标和全局状态，再把子任务委派给不同 specialist。它适合长任务和复杂流程，因为全局控制权集中在上层，局部上下文压力则下沉到子 agent。代价是 supervisor 很容易成为瓶颈，因此需要明确委派粒度、回收机制与升级路径，避免系统退化成“一个总管在不停转述消息”。

Agent Framework 解决的是“如何把模型能力组织成长期可运行的软件系统”。主流框架的差异主要体现在三个层面：控制流表达方式、状态管理方式，以及多智能体协作的原生支持程度。选型时最重要的是它是否契合你的系统拓扑：你需要图式工作流、事件驱动编排、还是平台托管的工具执行与追踪能力。

LangChain 偏组件化抽象，LangGraph 偏图式控制流。前者适合把模型、检索器、工具、记忆等模块快速拼接起来；后者适合把复杂 Agent 流程显式建模为图（Graph），把循环、分支、检查点和人机介入点写成状态转移。对于生产系统，LangGraph 的意义尤其明显：它让“Agent 不是一段 prompt，而是一个状态机”这件事可以被直接编码。

在多智能体方面，LangGraph 当前更强调基于工具调用（tool-calling）的 supervisor 模式，而不是把所有 agent 都包装成自由对话体。原因很实际：当协作关系被写成显式图结构后，上下文边界、路由条件和失败恢复都会更好控制。

AutoGen 的长处在于把多智能体协作建模为显式消息系统。不同 agent 可以作为独立节点收发消息、触发工具、交换中间状态，因此很适合研究“团队式智能体”以及需要复杂路由的实验性系统。新版 AutoGen 也更强调事件驱动（Event-driven）与可扩展运行时，而不只是几个人工角色互相聊天。

它的代价也非常明确：自由度越高，系统边界越需要开发者自己画清楚。权限、可观测性、记忆持久化与异常恢复如果没有在框架外补齐，多智能体对话很容易演化成难以调试的消息洪流。

CrewAI 把多智能体系统表达为“角色（Role）+ 任务（Task）+ 工具（Tool）”的业务编排语言，适合把组织分工直接映射到系统设计中。它的上手成本较低，尤其适合内容生成、运营流程、分析流水线这类天然按岗位拆分的任务。

这类框架的优势是表达直观，代价是底层控制流往往被隐藏得更深。只要任务依赖、重试策略、共享状态和权限边界开始复杂化，就需要确认框架是否允许你把隐含运行时重新显式化。

从当前官方工具栈看，OpenAI 已经把 Responses API 作为构建 agent-like application 的统一接口，并以 Agents SDK 提供更轻量的编排、handoff、guardrail 与 tracing 能力。这一路线的核心价值是把常见基础设施平台化：函数调用、Web 搜索、Computer Use、Code Interpreter、Tracing 与多智能体 handoff 都可以沿着同一套接口组织。

托管式能力的优点是默认路径短、集成成本低、官方工具之间协同更顺滑；缺点是当业务开始需要深度定制的状态机、自定义持久化策略或异构执行环境时，应用仍然需要在 SDK 之上补一层自己的 runtime。换句话说，托管平台减少的是“起步成本”，而不是彻底消灭 Agent 工程本身。

OpenClaw 更适合理解为本地优先的 Agent Gateway 与运行时基础设施，而不是单纯的 prompt 编排库。它的核心不是“怎样写一条 Agent workflow”，而是“怎样把一个长期在线的 Agent 安全地接到 Discord、Slack、Telegram、WhatsApp、iMessage 这类渠道上，并用统一 Gateway 管理会话、路由、插件、节点设备和工具能力”。

这一路线的长处在于入口治理和系统完整性。若需求是“我需要一个可长期运行、跨多个聊天入口、会话持续存在、支持插件和设备节点的个人或团队助手”，OpenClaw 的抽象更贴近真实系统边界。它的重心不是研究型多智能体消息编排，而是把渠道、会话、路由、插件和运行时做成一个统一控制平面。

Hermes Agent 则更像学习型 Agent Runtime。它不是简单包装单一模型 API 的聊天壳，而是试图把长期记忆（Memory）、技能（Skills）、子 Agent 委派（Delegation）、工具调用、批处理、浏览器自动化、语音模式和消息网关放进一个统一自治运行时里。其最鲜明的卖点，是官方强调的 built-in learning loop：Agent 会把经验沉淀成可复用技能，并跨会话持续积累。

因此，Hermes 更适合那类“希望 Agent 长期运行、逐步形成操作习惯、沉淀程序性知识并持续复用”的场景。它的重点不是先把多渠道入口打通，而是让 Agent 在运行中越来越像一个有历史、有技能库、有工作记忆的长期执行体。

OpenClaw 与 Hermes 对比：

这两者并不是简单替代关系。一个偏“入口与治理”，一个偏“执行与成长”。如果系统目标是搭建长期在线、多入口、可治理的助手平台，OpenClaw 更贴近问题本身；如果目标是让 Agent 在长期运行中积累技能、形成风格、复用经验，Hermes 的抽象更自然。现实工程里，两类能力往往最终会逐步靠拢，但在当前阶段，它们仍代表了两条不同的主线。

The post 人工智能理论知识 - 智能体 appeared first on 绿色记忆.

这一篇聚焦现代大模型主线，内容从 Transformer 架构出发，延伸到语言模型、多模态模型、预训练与微调，以及推理阶段优化。前一篇已经建立了神经网络与训练机制，这一篇继续回答现代基础模型是如何堆叠出来、如何适配任务、又如何在部署侧提升吞吐、延迟与显存效率；最后一篇将转入上下文工程、RAG 与 Agent 系统。

Transformer 是现代大模型最核心的统一架构。它最初被提出用于序列到序列（Sequence-to-Sequence）任务，但很快演化成大语言模型（Large Language Model, LLM）、视觉 Transformer、多模态模型以及各类基础模型（Foundation Model）的共同骨架。它之所以重要，不只是因为“效果好”，更因为它提供了一种高度模块化、可并行扩展、易于堆叠放大的建模方式：输入被表示成一串 token，对这些 token 的关系建模主要依赖注意力（Attention），而每一层又通过前馈网络（Feed-Forward Network, FFN / MLP）继续做非线性变换与特征重组。

从工程角度看，Transformer 的成功来自三件事的结合：第一，注意力机制让模型能直接建模长距离依赖，而不必像循环网络那样逐步传递状态；第二，层与层之间结构统一，非常适合在 GPU / TPU 上做大规模并行训练；第三，模型规模可以沿着层数、隐藏维度、注意力头数、词表大小与训练数据量持续扩展，于是它天然适合作为“可放大”的通用架构。

因此，理解 Transformer 不应只停留在“注意力公式怎么写”，还要把它看成一条完整的信息处理流水线：token 如何变成向量，向量如何在注意力里彼此通信，MLP 如何重组和放大模式，残差流（Residual Stream）如何把各层计算串接起来，最后这些中间表示又如何被任务头（Task Head）读出，变成分类结果、生成 token 或其他下游输出。

Transformer 的“基本计算单元”是一个 Transformer block：把注意力子层（Attention Sublayer）与前馈子层（FFN Sublayer）串联起来，并在每个子层外包一层残差连接（Residual Connection）与归一化（Normalization）。注意力子层的输出不是最终预测，而是作为中间表示继续送入 FFN 与下一层 Transformer block，逐层构建更抽象的特征。

典型层结构（概念上）可以写成：

这条式子描述的是一个 Transformer block 内部最核心的两步。这里 \(H\) 表示进入当前层的隐藏状态矩阵（Hidden States），形状通常是 \(L\;\times d_{\text{model}}\)： \(L\) 是序列长度， \(d_{\text{model}}\) 是每个 token 的隐藏维度。 \(\mathrm{Attention}(H)\) 表示注意力子层对整段序列做一次“彼此通信”后的结果：每个 token 会结合其他位置的信息，得到新的上下文化表示。

第一步 \(H'=\mathrm{Add\&Norm}(H,\ \mathrm{Attention}(H))\) 中，Add 表示残差相加：把原输入 \(H\) 与注意力输出相加；Norm 表示再做归一化（通常是 LayerNorm）。残差的作用是保留原始信息并让梯度更容易穿过深层网络，归一化的作用是让数值尺度更稳定。经过这一步后，得到的 \(H'\) 可以理解为“已经完成一次上下文交互”的中间表示。

第二步 \(H^{\text{next}}=\mathrm{Add\&Norm}(H',\ \mathrm{FFN}(H'))\) 则把 \(H'\) 送入前馈网络（Feed-Forward Network, FFN）。FFN 不负责 token 之间的信息交换，而是对每个位置的向量分别做非线性变换与特征重组。它更像是在每个 token 内部重新编码：放大有用模式、抑制无关模式，并把低层线索组合成更抽象的表示。再经过一次“残差相加 + 归一化”后，输出 \(H^{\text{next}}\)，作为下一层 Transformer block 的输入。

因此，这个公式的阅读顺序可以概括为：先让 token 之间通过注意力交换信息，再让每个 token 自己通过 FFN 重组特征。多层堆叠之后，模型就会沿着这条路径逐层把原始输入变成越来越适合任务头读取的高层表示。

这里还需要区分 Pre-LN（Pre-LayerNorm）与 Post-LN（Post-LayerNorm）。它们的区别在于 LayerNorm 放在子层计算之前，还是放在残差相加之后。

若是 Post-LN，概念上更接近前面那条写法：先做子层计算，再与输入做残差相加，最后归一化。例如注意力子层可写成 \(H'=\mathrm{LN}(H+\mathrm{Attention}(H))\)。若是 Pre-LN，则顺序改成“先归一化，再做子层计算，再走残差”：注意力子层更接近 \(H'=H+\mathrm{Attention}(\mathrm{LN}(H))\)，FFN 子层同理。

两者表达的功能主线相同：信息都要经过注意力与 FFN，再靠残差流向后传递。差异主要体现在训练动力学（Training Dynamics）上。Post-LN 更贴近原始 Transformer 论文的写法，直观上像“每次子层更新完，再把结果规范一下”；Pre-LN 则让梯度更容易沿残差路径稳定传播，因此在很深的大模型里更常见。工程实现会在 Pre-LN / Post-LN 之间选择，这会影响训练稳定性、学习率可用范围以及深层可训练性，但不会改变我们对 block 主流程的理解：注意力负责跨 token 交互，FFN 负责单 token 特征重组，残差负责让信息与梯度顺畅穿层流动。

Transformer 这个名字源自 “Attention Is All You Need” 论文：模型不再依赖循环结构来处理序列，而是通过注意力把序列表示不断变换（Transform）为更适合预测的表征。

Transformer 的参数（Parameters）不是单一矩阵，而是一组可学习张量的集合，主要包括嵌入（Embedding）、注意力投影（Attention Projections）、前馈网络（FFN）以及归一化的缩放/平移参数等。

不同 Transformer 变体在维度设置上差异很大。下面列的是几类典型公开模型的常见配置，既包括中等尺寸的主流模型，也包括 2025 到 2026 年仍处前沿位置的开源大模型。它们的共同点在于：即使是“中等尺寸”的主流模型，隐藏维度、层数、头数和 FFN 宽度也已经足够大；而到了开源前沿模型阶段，参数扩展往往不再只靠加深层数，而是同时叠加更宽的隐藏维度、更大的 FFN、MoE（Mixture of Experts）和更激进的注意力/KV 设计，因此模型内部表示天然是高维、分布式且跨层叠加的。

这张表也说明了一个很重要的趋势。到 2026 年，开源前沿模型已经不再沿着“单纯加深层数”这一条路线演化，而是出现了明显分化：Qwen3-235B-A22B 把层数推到 94 层，同时保持相对克制的隐藏维度，并通过 128 个专家、每 token 激活 8 个专家来放大总容量；DeepSeek-V3 系列则维持 61 层，但把隐藏维度提升到 7168，并叠加 DeepSeekMoE 与 MLA（Multi-head Latent Attention）来同时优化容量与推理成本。也就是说，前沿模型的“强”并不只表现为更深，而更多表现为深度、宽度、专家稀疏性与注意力工程的联合扩展。

对闭源顶级模型的层数，外界通常拿不到可靠公开配置，因此只能做工程上的区间推断。若它们仍以 Transformer block 为主体，那么从公开开源前沿模型的尺度看，显式层数大概率仍落在数十层到一百多层这一带，而不是简单增长到几百层甚至上千层；更常见的扩展手段，是增大隐藏维度、放大 FFN、引入 MoE、延长上下文、增加训练 token，或在同等层数下叠加稀疏注意力、递归计算与工具链调用。因此，对 GPT、Claude、Gemini 这类闭源顶级模型，更稳妥的判断不是“它们一定有多少层”，而是“它们很可能已经处在百层级上下、并辅以更复杂的宽度与稀疏化设计”。

Transformer 的不可解释性（Lack of Interpretability）不是由某一个参数“导致”，而是由整体机制共同产生：表示是分布式（Distributed）且高维的，多层叠加的非线性变换把因果链条变长；注意力权重可视化能提供线索，但它不是完整解释。

大模型中的知识通常以分布式表示（Distributed Representation）的形式分散在大量参数里，而不是由某一个感知机单独存储一条事实。单个单元更像一个局部特征探测器（Feature Detector）：它只对某种模式敏感；许多单元级联后，网络才能把低层简单模式组合成高层抽象概念。模型规模越大、层数越深、参数越多，可被编码的模式组合也越丰富，这正是大模型具备强表达能力与“知识容量”的原因之一。

对于 Transformer 这样的模型，知识并不是以“一层一个概念、一神经元一事实”的方式整齐排布，而更像是沿着残差流（Residual Stream）在多层之间不断被提取、重组、放大和读出。注意力层更擅长在上下文中定位相关信息、建立 token 之间的依赖；MLP 层则更像参数化的模式变换器或记忆单元，会把某些已经被触发的模式映射成更强的语义方向，再写回主表示中。

从经验上看，这种知识分布有一些常见规律。较低层往往更接近词形、局部模式与浅层统计相关性；中间层更容易出现实体属性、关系模式和事实联想的组合；较高层则更接近任务相关读出，也就是更接近“最后怎样把内部表示变成具体输出”的阶段，例如下一 token 预测、答案选择或标签判别。但这更像统计趋势，而不是严格分工：同一类知识往往会跨多个层段冗余存在，并通过许多参数共同表达。

因此，更准确的理解不是“第几层存了什么知识”，而是“不同层在知识处理流水线里承担了什么功能”。有的层更偏检索线索，有的层更偏关系组合，有的层更偏把结果变成可供输出头使用的表示。单个 MLP 模块有时可以表现出类似键值记忆（Key-Value Memory）的行为，但真正稳定的知识通常仍然是跨层、跨参数、跨方向分布的。也正因为这种分布式编码，大模型既能表现出较强的知识容量，也会显得难以直接解释和精确定位。

编码器-解码器（Encoder–Decoder）结构对应经典 Seq2Seq：编码器先对输入序列做双向自注意力（Bidirectional Self-Attention）编码，即编码器里的每个 token 都可以直接看到源序列中的其他 token，不使用因果掩码（Causal Mask），因此更擅长形成充分的上下文化输入表示；随后解码器在自回归生成（Autoregressive Generation）时，一边做因果自注意力（Causal Self-Attention），只看已经生成的前缀，一边通过交叉注意力（Cross-Attention）读取编码器输出。于是，编码器负责把“输入内容本身”编码清楚，解码器负责在“已生成前缀 + 编码器语义表示”条件下逐步生成输出。典型用于机器翻译、摘要、问答等“输入到输出”的条件生成任务（Conditional Generation），代表模型如 T5、BART。

仅编码器（Encoder-only）结构使用双向自注意力（Bidirectional Self-Attention）：位置 \(i\) 可以看见所有位置（不做因果屏蔽）。它更擅长做“理解与表示”（Representation Learning），常见预训练目标是掩码语言建模（Masked Language Modeling, MLM）：把输入里部分 token 替换为 \([\mathrm{MASK}]\)，训练模型根据上下文预测被遮住的 token。代表模型如 BERT、RoBERTa；ELECTRA 则用“替换检测（Replaced Token Detection）”作为预训练任务，但架构仍是 Encoder-only。

注意“掩码（Mask）”在这里指的是 MLM 的 token masking，不是自回归解码里的因果 attention mask。

仅解码器（Decoder-only）结构使用因果自注意力（Causal Self-Attention）：位置 \(i\) 只能看见 \(j\le i\) 的历史 token，通过三角形掩码避免“偷看未来”。它天然对应自回归语言建模（Causal Language Modeling, CLM）：最大化 \(\prod_t p(x_t|x_{<t})\)。代表模型如 GPT 系列、LLaMA、Qwen。

这里的“掩码（Mask）”指的是 attention 里的因果屏蔽，与 MLM 的 \([\mathrm{MASK}]\) token 概念不同。

对生成式 Transformer，尤其是 Decoder-only 模型以及 Encoder–Decoder 中的解码器侧，推理过程通常可分成两个阶段：预填充（Prefill）与解码（Decode）。Prefill 先把整段已知提示词（Prompt）一次性送入模型，计算每一层的隐藏状态，并把各层的 Key / Value 写入 KV Cache；Decode 则在此基础上逐步生成新 token，每一步只新增一个位置，再与历史缓存做注意力计算。

Prefill 阶段虽然仍然使用因果掩码（Causal Mask），但因为整段 prompt 在进入模型时已经全部已知，所以输入处理过程中所有 token 仍可并行处理：同一层里的 Query / Key / Value 投影、矩阵乘法以及 masked attention 都可以一次性并行完成。因果掩码只负责限制“当前位置不能看未来位置”，并不会把已知 prompt 重新变回按时间步串行处理。

生成阶段则通常是串行的。因为每一个新输出 token 都要作为前缀的一部分，参与下一个 token 的预测，所以 token 与 token 之间存在真实的自回归依赖，不能像 Prefill 那样沿序列长度整段并行展开。此时系统仍然可以利用 batch 并行、head 并行、张量并行、专家并行和内核并行，但在“生成顺序”这一维上通常必须逐步推进。这也是为什么长 prompt 场景下常说系统先经历一次计算密集（Compute-bound）的 Prefill，而进入连续生成后，瓶颈又经常转向 KV Cache 读取、显存带宽与调度开销主导的 Decode。

这个两阶段视角非常重要，因为后续很多工程优化都直接对应其中一个阶段：FlashAttention 对长序列 Prefill 的收益通常最显著；KV Cache、GQA / MQA、Paged Attention、Prompt Caching 与 Speculative Decoding 等，则更多是在优化 Decode 或同时兼顾两者。理解了 Prefill 与 Decode 的分工，再看 Transformer 推理优化时，许多“为什么这里快、那里慢”的现象就会变得自然。

Decoder-only 成为主流之后，架构创新集中在“稳定性、KV Cache 成本与训练效率”三个轴：归一化/激活影响深层训练稳定性；注意力侧的 KV 结构决定长上下文推理成本；FFN 稠密/稀疏（MoE）与训练目标改造影响单位算力的有效学习信号。

Transformer 并不直接处理原始字符串。文本进入模型之前，必须先经过一条输入处理流水线：文本规范化、切分为 token、映射为 token id，再查表转成向量表示。只有完成这一步，后续的注意力、FFN 和位置编码才有可计算的离散输入。输入处理决定了模型“看见世界的最小单位”是什么，因此它不仅影响参数规模与推理效率，也会影响稀有词覆盖、跨语言能力、长度利用率以及生成结果的边界质量。

Tokenization 的核心任务是把连续文本切分成模型可处理的离散符号序列。这个离散化过程看似只是“切词”，实际上定义了词表（Vocabulary）、序列长度、未知词处理方式以及字符到语义表示的映射粒度。若切得过粗，词表会过大、稀有词泛化差；若切得过细，序列会变长、计算成本升高。因此，现代语言模型通常采用子词分词（Subword Tokenization）：用有限词表在“整词”和“字符”之间取得平衡。

分词并不只是训练前的一道预处理工序，它深度参与了模型能力边界的形成。相同一句文本，换一种 tokenizer，模型看到的 token 序列长度、常见片段分布、数字和符号的切分方式都会变化，进而影响上下文利用率、训练效率、长文本成本、代码与多语言表现，甚至影响困惑度（Perplexity）等指标的可比性。也正因为如此，跨模型比较时，若 tokenizer 不同，很多“每 token 指标”都不能直接横向解读。

此外，现代 tokenizer 通常不只负责“切分”，还负责一组配套约定：例如保留哪些特殊 token（Special Tokens），如何处理大小写、空格、换行、标点、表情与 Unicode 字符，以及遇到词表里没有的片段时如何回退。像

[UNK]

[UNK]

从风格上看，分词大致可以分为四类。第一类是整词分词（Word-level Tokenization）：把单词当作基本单位，优点是语义直观，缺点是词表会迅速膨胀，且对未登录词（Out-of-Vocabulary, OOV）非常敏感。第二类是字符分词（Character-level Tokenization）：把每个字符都当作 token，几乎没有 OOV 问题，但序列会显著变长，模型需要自己学习更多组合关系。第三类是子词分词（Subword Tokenization）：用常见片段构成词表，让高频词保持完整、低频词拆成片段，这是现代 NLP 最主流的折中路线。第四类是字节分词（Byte-level Tokenization）：直接在字节层处理输入，覆盖能力最强，跨语言和特殊符号最稳，但序列通常更长，对模型容量和训练配方要求更高。

因此，不同分词风格的本质取舍是：词表越大，单个 token 的语义通常越完整，但 OOV 与稀疏性越严重；词表越小，覆盖越稳，但序列越长、建模负担越重。现代大模型之所以大量采用 BPE、WordPiece、SentencePiece 或 byte-level BPE，本质上都是在这条权衡曲线上寻找更合适的工程平衡点。

BPE（Byte Pair Encoding）从字符（或字节）开始，通过统计合并高频相邻符号对（Pair Merge）逐步构建子词（Subword）词表。它的核心收益是用有限词表覆盖开放词汇：常见词被合并成整体，罕见词被拆成更小片段，减少 \([\mathrm{UNK}]\)。

BPE 的直觉可以概括为“把最常一起出现的片段逐步固化成一个 token”。例如，若训练语料里

t

h

th

th

e

the

从工程谱系上看，GPT 家族总体属于 BPE 路线的延伸：早期 GPT / GPT-2 风格 tokenizer 采用 byte-level BPE，把文本先映射到字节层，再做 BPE 合并；这种设计能更稳地覆盖任意 Unicode 文本、空格和特殊符号。对 OpenAI 当前模型生态而言，官方开发工具链中程序化分词通常使用 tiktoken；它对应的是面向具体模型的 encoding 体系，但核心思想仍然是 BPE 家族的子词压缩与高覆盖率路线。对开发者来说，更重要的实践结论是：GPT 并不是“按词”切分，而是按 BPE 家族 tokenizer 切成子词或字节片段；同一个自然语言单词，可能被切成一个 token，也可能被切成多个 token，取决于它在词表中的合并状态。

WordPiece 与 BPE 同属子词分词（Subword Tokenization），但合并准则更偏向最大化语言模型似然（Likelihood）。BERT 系列常用 WordPiece，因此会看到以

##

play

##ing

SentencePiece 是一种分词器（Tokenizer）训练与推理框架（常见算法包括 BPE 与 Unigram LM）。它可以直接在原始文本上训练（不依赖空格分词），因此在多语言与无空格语言（如中文、日文）上更常用；LLaMA 等模型的 tokenizer 通常基于 SentencePiece。

Token Embedding 的核心是一个可训练的嵌入表（Embedding Table，也常被称为嵌入矩阵（Embedding Matrix））：

其中 \(V\) 是词表大小（Vocabulary Size），每一行对应一个 token 的向量表示。给定输入 token id 序列 \((t_1,\dots,t_L)\)，查表得到输入嵌入序列（Embedding Output）：

一些材料会把 \(E\)（参数表）和 \(X\)（某次输入的嵌入结果）都叫“嵌入矩阵”，容易混淆。区分的一个简单方式是：E 是全词表参数，X 是当前输入的嵌入输出。

在语言模型里，这张输入嵌入表常与输出处理中的语言模型头（LM Head）共享参数，即权重共享（Weight Tying）。这里先记住这一点即可；它的具体计算方式与工程含义放在后面的“输出处理”中展开。

位置编码（Positional Encoding）解决一个根本问题：注意力机制本身对输入顺序是置换不变（Permutation-Invariant）的，如果不显式注入位置信息，模型无法区分“AB”和“BA”。因此需要把“位置”以某种方式编码进每个 token 的表示。

绝对位置编码（Absolute Positional Encoding）最常见的做法之一是学习一个位置嵌入表（Position Embedding Table）：

\(L_{\max}\) 是模型支持的最大位置索引数量（Maximum Position Index）。对长度为 \(L\) 的输入序列，取 \(P_{0:L}\)（或 \(P_{1:L}\)，取决于实现）得到当前序列的位置嵌入矩阵 \(P_{\text{seq}}\in\mathbb{R}^{L\;\times d_{\text{model}}}\)。

Transformer 通常用逐元素相加把 token 嵌入与位置嵌入融合：

这里 \(H^{(0)}\) 仍然是 \(d_{\text{model}}\) 维向量序列，不是“位置标量”。位置是否用一个标量并不重要；重要的是这种表示能让后续的线性层与注意力计算利用位置关系。高维位置向量提供了更丰富的可学习空间。

“相加会不会把信息混在一起、无法区分？”这个直觉常见，但对表示学习而言关键不是可逆性，而是可用性：模型不需要从 \(H^{(0)}\) 精确还原 \(X\) 与 \(P_{\text{seq}}\)，只需要用它们的组合完成预测。并且在高维空间里，模型可以把“语义”和“位置”分配到近似正交（Approximately Orthogonal）的方向，使得线性变换能有效解耦。

一个二维玩具例子：令 token 向量 \(x=(1,0)\)，位置向量 \(p=(0,0.1)\)，则 \(h=x+p=(1,0.1)\)。如果模型的某个线性读出只看第二维（例如乘以 \((0,10)\)），就能强烈感知位置而几乎不受语义影响。真实模型在上千维空间里有更大的自由度（Degree of Freedom, DOF）。

把位置“拼接”（Concatenation）到额外维度也能工作，但它会改变隐藏维度，影响后续层形状与参数规模；而加法保持 \(d_{\text{model}}\) 不变，是一种参数与工程都更稳定的设计选择。

另一类绝对位置编码是正弦位置编码（Sinusoidal Positional Encoding），它不引入可学习参数，而是用不同频率的正弦/余弦把位置 \(\text{pos}\) 映射为向量（原始 Transformer 的设计）：

为什么要成对使用 \(\sin\) 与 \(\cos\)（而不是全用 \(\sin\)）？因为对同一频率而言，\((\sin\phi,\cos\phi)\) 组成一个二维正交基（Orthogonal Basis），位置平移 \(\phi\mapsto \phi+\Delta\) 等价于二维平面上的旋转（Rotation）：

这让“相对位移”变成一个固定的线性变换，从而更容易被后续线性层和点积注意力利用；如果只用 \(\sin\)，相位信息会丢失，平移不再能用线性变换稳定表达。

若只取一个最小的 4 维例子，即 \(d_{\text{model}}=4\)，那么位置编码就会具体化成：

这时每个位置都不再是“一个编号”，而是一个 4 维向量。前两维变化很快，负责较短尺度的位置区分；后两维变化很慢，负责较长尺度的位置区分。例如 \(\text{pos}=0\) 时编码是 \([0,1,0,1]\)；\(\text{pos}=1\) 时约为 \([0.84,0.54,0.01,1.00]\)；\(\text{pos}=2\) 时约为 \([0.91,-0.42,0.02,1.00]\)。因此，不同位置会同时在多种频率刻度上留下痕迹，而不是只靠一个单调递增的数字区分。

上图把这个 4 维例子拆成三种读法。左侧热力图直接列出位置 \(0\sim 7\) 在四个维度上的编码值；右上角把前两维 \((\sin(\text{pos}),\cos(\text{pos}))\) 直接当成二维平面坐标，因此可以把它理解成：位置每增加一点，平面上的点就沿圆周往前走一步；右下角则把快频对与慢频对分开画出。图里第 3、4 维之所以先前看起来几乎是平的，不是因为它们不变，而是因为在标准公式里它们对应更低频率：在 \(\text{pos}=0\sim 12\) 这样很短的区间上， \(\sin(\text{pos}/100)\) 只从 0 变化到约 0.12， \(\cos(\text{pos}/100)\) 只从 1 下降到约 0.99，必须单独放大才容易看见变化。

模型利用这套编码的方式，可以直接理解成“拿多把不同刻度的尺子同时量位置关系”。同一对 token 的距离，在高频维度上会表现成较快的相位差，在低频维度上会表现成较慢的相位差；于是模型看到的就不是一个孤立的位置编号，而是一组跨多个尺度同时变化的模式。对于很近的 token，高频维度会给出很敏感的区分；对于距离更远的 token，低频维度仍然能保留稳定变化，不会太快绕回去。注意力层随后并不是逐维人工判读这些数值，而是在训练中学会：某些相位差组合通常意味着“相邻修饰”“短程依赖”，另一些更慢变化的组合更像“跨句呼应”或“长程对应”。这里并不存在一个必须被显式恢复出来的“角度标量”或“距离标量”。只要位置变化能够稳定地改变表示与点积结果，后续线性层和注意力头就可以把这种差异当作可利用特征。正弦位置编码的作用正是在于把位置关系改写成一组可被模型利用的周期信号，让模型自己在不同频率上学会读出距离与相对顺序。

相对位置编码（Relative Positional Encoding）不直接编码“绝对索引”，而是让注意力更显式地依赖 token 之间的相对距离 \(i-j\)。典型做法是在注意力打分里加入相对位置偏置（Relative Position Bias）：

这条式子描述的是：位置 \(i\) 的 query 去看位置 \(j\) 的 key 时，未归一化注意力权重会受到两部分共同决定。第一部分 \(\frac{q_i k_j^\top}{\sqrt{d_k}}\) 是标准内容相关性打分：其中 \(q_i\) 是第 \(i\) 个位置的查询向量（Query Vector），\(k_j\) 是第 \(j\) 个位置的键向量（Key Vector），二者点积 \(q_i k_j^\top\) 衡量“位置 \(i\) 当前想找的信息，与位置 \(j\) 持有的信息是否匹配”；\(d_k\) 是 key/query 的维度，除以 \(\sqrt{d_k}\) 是为了控制数值尺度，避免维度增大后 softmax 过早饱和。

第二部分 \(b_{i-j}\) 是只由相对距离决定的偏置项（Bias Term）。若 \(i-j=1\)，表示当前 token 正在看它左边紧邻的位置；若 \(i-j=10\)，表示它正在看更远的上文。这个偏置可以通过查表得到：给每一种相对距离，或给若干距离分桶（bucket）后的区间，各分配一个可学习标量；也可以由一个小网络根据 \(i-j\) 生成。它的作用是把“距离本身是否重要”直接加进打分，而不必完全依赖内容向量自己去隐式学出这种规律。

式子左边的 \(\alpha_{ij}\) 表示位置 \(i\) 对位置 \(j\) 的注意力权重；这里写成 \(\propto\) 而不是等号，是因为右边还只是指数化前的未归一化权重。真正的注意力概率还要在固定 \(i\) 后，对所有 \(j\) 一起做 softmax 归一化：

因此，相对位置编码的含义可以概括为：注意力不只比较“内容是否匹配”，还显式比较“这个位置离我有多远”。很多语言现象更依赖相对距离而不是绝对序号，例如局部搭配、邻近修饰、长程指代和句法依赖，因此把 \(i-j\) 直接写进打分，往往比单纯依赖绝对位置索引更贴近任务结构。

RoPE（Rotary Position Embedding）把位置信息以“旋转”的方式注入到 \(Q\)/\(K\) 中。若按实数矩阵来写，就是把向量的每两维视为一个二维平面，再用角度与位置成正比的旋转矩阵作用在这两维上。对第 \(i\) 个二维分量，令 \(\theta_{m,i}\) 表示位置 \(m\) 在该（每两维一个）频段上的旋转角，则

实现上，RoPE 不是“只把当前 query 旋转一下”，而是对每个位置的 \(Q\) 和 \(K\) 都各自按该位置做旋转；随后不同位置之间再做点积匹配。这样一来，位置 \(m\) 的 \(Q_m\) 和位置 \(n\) 的 \(K_n\) 在相遇时，二者各自携带的位置相位就会共同决定匹配结果。通常只有 \(Q\)/\(K\) 参与这种旋转， \(V\) 不旋转，因为位置信息的关键作用点在“如何计算注意力权重”，而不是在“被加权汇总的内容值”本身。

上述矩阵式在实现上是正确的，但从理解角度看仍然偏“机械”。更直接的方式是用复数视角（Complex Perspective）：把每两维 \((x_{2i},x_{2i+1})\) 看成一个复数

于是 RoPE 的位置注入就可以写成一个极其紧凑的式子：

这里 \(m\) 是位置索引， \(\theta_i\) 是第 \(i\) 个频段的基础角速度， \(e^{\mathrm{i} m \theta_i}\) 表示“在复平面上旋转 \(m\theta_i\) 角”。这时 RoPE 的直觉就变得很清楚：同一个向量本身不变，变化的是它在不同位置上附带的相位（phase）。位置越靠后，相位就继续往前转。

这种写法的关键价值在于：相对位置会自然地从乘法里浮现出来。若位置 \(m\) 的 query 与位置 \(n\) 的 key 都经过旋转，则它们的匹配项可写成

这里上划线表示复共轭（Complex Conjugate）。前文“二维向量的复数表示”已经给出同一条基本关系：二维点积可以写成复共轭乘积的实部，因此把二维块写成复数后，位置相位会直接进入匹配项。最重要的结果是指数项里只剩下 \((m-n)\theta_i\)：绝对位置 \(m\) 与 \(n\) 被自动折叠成了相对位移 \(m-n\)。因此，RoPE 并不是先写出绝对位置、再额外补一个相对位置项，而是通过“给每个位置乘一个相位因子”的方式，让相对位移直接出现在注意力匹配里。

若用一句更通俗的话概括，RoPE 做的事情是：给每个位置的 \(Q\)/\(K\) 都拧上一点角度；两个位置一做点积，位置差就会体现在匹配分数里。矩阵形式更像工程实现的展开式，复数形式更接近它的数学本质。模型并不需要在内部先还原出一个单独的“角度值”再决定如何注意；它只需要利用这种旋转所造成的分数差异与模式差异。只要某类相位关系稳定对应某类局部依赖、顺序关系或长程对应，训练过程就会把这些模式吸收到注意力头和后续层的参数里。也正因为这种“相对位移直接进入匹配”的结构，RoPE 在 Decoder-only 大模型中成为主流选择（例如 LLaMA 系列）。

RoPE 的旋转角随位置线性增长。若训练阶段最大长度为 \(L_{\text{train}}\)，推理时直接扩展到 \(L_{\text{test}}\gg L_{\text{train}}\)，部分频段会出现“过快旋转”：模型开始在比训练时更长得多的位置区间上继续累积相位，而这些大角度相位组合在训练中几乎没有见过。结果是远距离 token 之间的相对相位关系超出训练分布，注意力更容易退化为近邻偏好，长上下文检索与推理准确率下降。

典型评测是大海捞针（Needle in a Haystack）：在很长的上下文中埋入一条关键信息（needle），要求模型在指定问题下准确复述该信息。常见现象是针落在开头/结尾时表现更好，但针落在中间位置时准确率显著下降；这通常与位置编码外推、注意力实现细节与 KV Cache 行为共同相关。

工程上常见的 RoPE 外推改造包括：

• 位置插值（Position Interpolation, PI）：把推理位置按比例压缩回训练范围，相当于把 RoPE 角速度整体放慢。
• NTK-aware 缩放（NTK-aware Scaling）：按“有效核宽度”视角调整频率谱，缓和远距离相对位移失真。
• YaRN：对不同频段做分段/渐变缩放，尽量同时保住短程精度与长程外推。

以 PI 为例，一个常用写法等价于把 RoPE 的位置 \(\text{pos}\) 映射为 \(\text{pos}'=\text{pos}/s\)（\(s=L_{\text{test}}/L_{\text{train}}\)），从而把角度压回训练范围：

ALiBi（Attention with Linear Biases）直接在注意力 logits 上加一个与距离线性相关的偏置，而不改变表示维度，也不引入位置向量：

其中斜率 \(m\) 可按 head 设置。直觉上它鼓励模型更关注近邻 token，同时具备较好的长度外推（Length Extrapolation）行为。

注意力机制（Attention Mechanism）是序列模型中的动态信息选择机制。对于一个由多个 token 构成的输入序列，模型不会把所有上下文位置等量混合，而是会针对当前正在计算的位置，动态判断哪些位置更相关、相关程度有多大，以及这些位置的信息应当如何组合成新的表示。这个过程本质上是一个与输入内容相关的加权汇聚：当前位置先形成查询信号，再在上下文中寻找与之匹配的位置，最后把这些位置承载的信息按权重聚合回来。

这种设计改变了传统序列建模的信息传递路径。循环结构主要依赖状态沿时间步逐步传递，卷积结构主要依赖固定大小的局部感受野，而注意力机制允许任意两个位置直接建立联系，并且联系强度由内容决定而不是由距离预先写死。长距离依赖（Long-Range Dependency）因此可以被更直接地建模：一个 token 可以立刻读取很远处但与当前语义高度相关的信息，而不必等待信息穿过很长的递归链条或许多层局部卷积。

Transformer 将注意力机制置于核心位置。自注意力（Self-Attention）让同一序列内部的各个 token 相互读取；交叉注意力（Cross-Attention）让一个序列读取另一个序列的表示；因果注意力（Causal Attention）则通过掩码限制当前位置只能访问过去的信息，从而支撑自回归生成（Autoregressive Generation）。这些形式都遵循同一条主线：先计算相关性分数，再把分数归一化为权重，最后对承载内容的向量做加权求和。其最经典、最常见的数学形式就是缩放点积注意力（Scaled Dot-Product Attention）。

自注意力（Self-Attention）中，输入表示 \(X\) 通过三组参数投影为：

注意力输出为：

其中 \(W_Q,W_K,W_V\)（以及多头里的 \(W_O\)）都是模型参数（Parameters），训练的目标不是“生成这些矩阵”，而是在损失函数（Loss）下通过梯度下降（Gradient Descent）把它们优化到能完成任务的取值。

把公式按 token 展开更清楚。设当前只看一个注意力头，序列长度为 \(L\)。对第 \(i\) 个 token，模型先取出它的查询向量 \(q_i\in\mathbb{R}^{d_k}\)，再与序列中每个位置 \(j=1,\dots,L\) 的键向量 \(k_j\in\mathbb{R}^{d_k}\) 做点积，得到一个标量打分：

这里 \(d_k\) 表示每个头里 Key / Query 向量的维度，也就是 \(q_i\) 与 \(k_j\) 的长度。它之所以记作 \(d_k\)，是因为这个维度首先由 Key 空间定义；而 Query 必须与 Key 处在同样维度里，才能做点积匹配。因此 \(q_i\) 和 \(k_j\) 的长度通常相同。Value 向量的维度记作 \(d_v\)；实践中常见设置是 \(d_v=d_k\)，但这不是数学上的硬要求。

接着，对第 \(i\) 个 query 的整行打分做缩放和 softmax，得到一组对所有位置的注意力权重：

因此，对固定的 \(i\) 来说， \(\alpha_{i1},\dots,\alpha_{iL}\) 构成一个标量概率分布：它们都非负，且总和为 1。这个分布回答的是“第 \(i\) 个 token 应该从整段序列的哪些位置读取多少信息”。

输出 \(o_i\) 则是一个向量（Vector），由所有 Value 向量 \(v_j\in\mathbb{R}^{d_v}\) 按权重加权求和得到：

把这一步画成示意图会更直观：固定第 \(i\) 个 query 后，先得到一组对各位置 \(j\) 的注意力权重；再用这些权重去加权汇总对应的 Value 向量；右侧输出向量的每一维，都是左侧各个 Value 向量对应维度的加权和。

查询向量（Query）与键向量（Key）负责“匹配打分”；值向量（Value）承载被聚合的信息内容。把注意力看作“内容寻址（Content-based Addressing）”：先用 \(QK^\top\) 计算“应该看谁”，再用权重对 \(V\) 做加权求和得到“看到了什么”。

缩放因子 \(\sqrt{d_k}\) 的作用是控制数值尺度。由于 \(q_i\) 与 \(k_j\) 的点积是 \(d_k\) 个乘积项的求和，若各维分量方差相近，则点积分数的方差通常会随着 \(d_k\) 增长。维度一大， \(s_{ij}\) 的绝对值就更容易变大，softmax 会更快进入饱和区：某几个位置的权重接近 1，其余位置接近 0，梯度也会变小。除以 \(\sqrt{d_k}\) 后，分数尺度被拉回更稳定的范围，不同 head 维度设置下的 softmax 行为会更可控。

理论上可以让寻址与内容共用投影（例如令 \(V=K\) 或直接取 \(V=X\)），但实践中通常把 Q/K 与 V 分开，是为了让“打分空间”和“内容表示空间”解耦，提升表示能力与训练稳定性。

一个极简数值例子：若某个 Query 与 3 个 Key 的相似度（未缩放）为 \([2,1,0]\)，softmax 权重大约是 \([0.665,0.245,0.090]\)，输出就是把三个 Value 按这个比例加权求和。

Masked Attention（因果注意力 / Causal Attention）在自回归（Autoregressive）生成中使用：通过掩码（Mask）禁止位置 \(i\) 看到未来位置 \(j>i\)。实现上通常是在 softmax 前把被禁止位置的打分加上一个极小值（如 \(-\infty\)）。

若把未加掩码的打分矩阵记为 \(S=\frac{QK^\top}{\sqrt{d_k}}\in\mathbb{R}^{L\times L}\)，则因果掩码可写成一个上三角被屏蔽的矩阵 \(M\)。以 \(L=4\) 为例：

然后在 softmax 之前做逐元素相加：

这里主对角线及其左下区域为 0，表示当前位置及其历史位置允许被访问；右上区域为 \(-\infty\)，表示未来位置被强制屏蔽。softmax 之后，这些位置的权重会变成 0，因此第 \(i\) 行只能在 \(j\le i\) 的范围内分配概率。

从矩阵形状看，这就是一个保留下三角、屏蔽上三角的结构。它保证了解码器在位置 \(i\) 计算注意力时，只能读取已经出现的 token，而不能偷看未来 token。

注意力机制在训练阶段和推理阶段都会执行。区别在于：训练时通常一次性输入整段序列（Teacher Forcing）并使用因果掩码；推理时逐 token 解码，并结合 KV Cache 避免重复计算历史。

交叉注意力（Cross-Attention）让一个序列“去读另一个序列”。在 Encoder–Decoder Transformer 里：解码器当前状态提供 Query，编码器输出提供 Key/Value。若编码器输出为 \(H_{\text{src}}\in\mathbb{R}^{L_{\text{src}}\times d}\)，解码器输入为 \(H_{\text{tgt}}\in\mathbb{R}^{L_{\text{tgt}}\times d}\)，则

它与自注意力（Self-Attention）的区别仅在于 \(K,V\) 来自“别的序列”，因此能把“源序列信息”按需注入到“目标序列生成”中。

在交叉编码器（Cross-Encoder）语境里，很多实现并不显式写 cross-attention：它们把两段文本拼接成一个序列，用全连接自注意力直接建模跨序列交互；从效果上看等价于“允许任意 token 互相注意”。

Decoder-only 架构本身没有 cross-attention 子层；只有在做 Seq2Seq（有 encoder 输出）或显式引入外部记忆（Memory）时，才会在解码器里加入 cross-attention。

多头注意力（Multi-Head Attention）把注意力拆成 \(H\) 个头（Heads），每个头在不同的子空间里独立做一次注意力，然后在特征维度上拼接（Concatenation）并用输出矩阵混合：

若 \(d_{\text{model}}\) 固定，常见做法是每个头的维度 \(d_k=d_v=d_{\text{model}}/H\)，拼接后回到 \(d_{\text{model}}\)。多头的收益来自“并行关注不同关系”：有的头偏向局部邻域，有的头偏向长程依赖，有的头学到语法/实体指代等不同模式。

这种分工在标准训练里通常不是人工指定的，而是优化过程中的自发结果。每个头都拥有各自独立的 \(W_Q^{(h)},W_K^{(h)},W_V^{(h)}\) 参数，因此即使输入相同，它们也会把表示投影到不同子空间里，形成不同的匹配规则。随机初始化首先打破了头与头之间的对称性；随后，损失函数只约束“多头合起来的整体输出”是否有利于完成任务，而不要求每个头承担同一种功能。在这种条件下，若多个头完全重复，整体表示效率往往偏低；优化更容易把不同头推向不同关系模式，于是逐渐出现局部邻近、长程依赖、分隔符、指代、句法边界等不同偏好。

这种功能分化并不是严格保证。实际模型里常能观察到部分头高度相似，部分头贡献很小，甚至剪掉后性能几乎不变。若希望更强地控制不同头学习不同东西，就需要额外机制，例如对不同头加入多样性正则（Diversity Regularization）、局部窗口约束、特定监督信号，或在训练后做 head pruning / head specialization 分析。

从多头注意力再往下走一步，就会遇到一个非常重要的工程分叉：Query 头数与 Key/Value 头数是否必须一一对应。标准 MHA 默认每个 Query head 都有自己独立的 Key/Value head；而在长上下文大模型里，工程重点往往会进一步转向KV Cache 到底有多大、带宽到底有多贵。GQA 与 MQA 的区别，正是在回答这个问题。

GQA（Grouped Query Attention）用“更少的 KV 头”服务“更多的 Query 头”。它的核心做法是：多个 Query heads 共享同一组 Key/Value heads，从而显著降低 KV Cache 的显存与带宽压力。若仍记 Query 头数为 \(n_q\)，KV 头数为 \(n_{\text{kv}}\)，则 GQA 满足 \(1<n_{\text{kv}}\ll n_q\)。

对比标准多头注意力，GQA 的本质是把“每个 head 都独立维护一套 KV”改成“若干 Query head 结成一组，共享一套 KV”。注意力仍然按 head 计算，但 KV 表示不再完全一一对应，而是以组为单位共享。在长上下文推理中，它带来的收益往往比对算力的节省更关键：KV Cache 与内存带宽近似按 \(n_{\text{kv}}/n_q\) 比例下降。

这也是为什么很多现代大模型把 GQA 当作默认配置。它在表达能力与缓存成本之间提供了一个很实用的折中：比 MHA 便宜得多，但通常又比最极端的共享方案更稳。

MQA（Multi-Query Attention）可以看作 GQA 的极端情形，即 \(n_{\text{kv}}=1\)。这意味着全部 Query heads 共用同一套 Key / Value 表示。于是，KV Cache 被进一步压到最小，推理阶段的显存和带宽压力也达到最强压缩。

它的优点非常明确：在超长上下文和高并发解码场景下，MQA 往往是最省缓存的一类头部组织方式。缺点也同样明确：表示自由度下降得最厉害，不同 Query heads 看到的 Key/Value 空间过于相似，因此更容易带来质量损失。工程上通常会用更大的模型维度、更多 Query heads、或更强的 FFN 来补偿这种压缩。

因此，三者的关系可以概括成一条连续谱：MHA 表达最自由、成本最高；MQA 成本最低、共享最强；GQA 则处在两者之间，提供最常用的工程折中。进一步降低 KV Cache 成本的路线，还包括 Latent KV / MLA 一类潜空间压缩，以及 TurboQuant 一类面向内积保真的 KV 量化压缩。它们优化的仍然是长上下文推理里的 KV 存储与带宽，只是已经不再停留在“头数共享”这一层。

线性注意力（Linear Attention）是在注意力层内部改写计算顺序，使代价不再显式依赖完整的 \(L\times L\) 注意力矩阵。标准 softmax 注意力可写为：

其中 \(Q\in\mathbb{R}^{L\times d_k}\) 是整段序列的 query 矩阵， \(K\in\mathbb{R}^{L\times d_k}\) 是 key 矩阵， \(V\in\mathbb{R}^{L\times d_v}\) 是 value 矩阵； \(L\) 是序列长度， \(d_k\) 是 query / key 维度， \(d_v\) 是 value 维度。矩阵 \(QK^\top\in\mathbb{R}^{L\times L}\) 的第 \((i,j)\) 项就是 \(q_i^\top k_j\)，表示第 \(i\) 个位置对第 \(j\) 个位置的原始匹配分数。也就是说，标准注意力需要让每个 query 与每个 key 两两打分，因此时间与显存压力通常都是 \(\mathcal{O}(L^2)\) 级别。线性注意力的目标，就是把这种“先算完整两两相互作用，再做归一化”的流程，改写成“先把历史信息压缩成一组可累计统计量，再让每个 query 去读取这些统计量”。

标准注意力里，第 \(i\) 个位置的输出可以写成

这里 \(q_i\in\mathbb{R}^{d_k}\) 是第 \(i\) 个位置的 query 向量，表示“当前位置想找什么信息”； \(k_j\in\mathbb{R}^{d_k}\) 是第 \(j\) 个位置的 key 向量，表示“这个历史位置提供什么匹配线索”； \(v_j\in\mathbb{R}^{d_v}\) 是同一位置真正承载内容的 value 向量； \(\alpha_{ij}\) 是归一化后的注意力权重，表示第 \(i\) 个 query 最终给第 \(j\) 个位置分了多少注意力； \(o_i\) 则是当前位置输出。于是 softmax 注意力的本质很明确：先用 \(q_i\) 和所有 \(k_j\) 算相似度，再用这些权重去加权求和所有 \(v_j\)。

这里的 \(\phi\) 是特征映射（Feature Map）或核特征映射（Kernel Feature Map）。它把原本位于 \(\mathbb{R}^{d_k}\) 的 query / key 向量，映射到另一个通常更容易做内积分解的空间 \(\mathbb{R}^{m}\)：

其中 \(m\) 是映射后的特征维度。直观上， \(\phi\) 的作用是把原来的向量变成另一种表示，使得原本难以直接拆开的相似度，能够改写成内积形式。

若某种相似度函数 \(\kappa(q,k)\) 可以写成

其中 \(\kappa(q,k)\) 是 query 与 key 的相似度函数；右边写成 \(\phi(q)^\top \phi(k)\) 之后，相似度就被拆成了“只依赖 query 的一项”和“只依赖 key 的一项”的内积形式。这样一来，注意力里“query 与所有 key 的逐一比较”就能被拆成两部分：一部分只和 key/value 有关，另一部分只和当前 query 有关。对单个 query \(q_i\) 而言，若记

其中 \(S\in\mathbb{R}^{m\times d_v}\) 是把整段历史中“key 的特征表示”和“对应的 value 内容”绑定后累计起来得到的矩阵，可以理解为一份带内容的历史摘要； \(z\in\mathbb{R}^{m}\) 只累计 key 的特征表示，用来充当归一化分母。则输出可改写为

其中分子 \(\phi(q_i)^\top S\) 表示“当前 query 去读取带内容的历史摘要”，分母 \(\phi(q_i)^\top z\) 用来做归一化，防止输出尺度失控。这一步是线性化的核心。因为 \(S\) 与 \(z\) 可以沿着序列顺序递推累计，不需要先显式构造完整的 \(L\times L\) 打分矩阵。于是复杂度从“所有 token 两两交互”转成“每个 token 更新一次全局统计量并读取一次统计量”，在很多实现里就能接近 \(\mathcal{O}(L)\) 的序列复杂度。

为什么这里可以做近似，关键在于 softmax 注意力本身也可以被看成一种核化相似度。softmax 的未归一化权重本质上依赖 \(\exp(q^\top k/\sqrt{d_k})\)；如果能找到某个 \(\phi\)，使得

就能用可分解的内积结构近似原来的指数核。不同线性注意力方法对 \(\phi\) 的选择并不相同：有的方法用显式正特征映射，例如 \(\mathrm{ELU}(x)+1\) 之类的正值变换；有的方法用随机特征（Random Features）去逼近 softmax kernel；还有一些方法更进一步，直接放弃“精确逼近 softmax”，转而定义一种新的核化注意力族。于是“线性注意力”在数学上并不总是同一条公式，而是一大类可分解注意力路线。

“什么样的核函数能够做这件事”可以分成两类理解。第一类是可显式近似 softmax 的核。例如 Performer 使用 FAVOR+（Fast Attention Via Positive Orthogonal Random Features）路线，用随机特征把指数核 \(\exp(q^\top k)\) 近似成有限维内积 \(\phi(q)^\top\phi(k)\)。这里的 \(\phi\) 不再是一个随手指定的非线性，而是专门为逼近指数核构造出来的随机特征映射。

第二类是直接改用另一种正核。例如早期 Linear Transformer 一类方法常取 \(\phi(x)=\mathrm{ELU}(x)+1\) 或其他保持正值的映射。这样做的重点不在于把 softmax 严格逼近得多么精确，而在于构造一个满足非负性、可递推累计、数值上相对稳定的核化注意力形式。此时模型学到的已经不是“softmax 的近似实现”，而更接近“另一种可线性化的注意力定义”。

设序列里只有两个历史位置，当前位置的 query 为 \(q\)，历史 key / value 分别为 \((k_1,v_1)\) 与 \((k_2,v_2)\)。标准注意力会先显式算出两个分数：

再做 softmax：

最后输出

线性注意力则尝试把这一步改写成“先对历史做摘要，再让 \(q\) 读取摘要”。若有某个 \(\phi\) 使得 \(e^{q^\top k}\approx \phi(q)^\top\phi(k)\)，那么先预计算

然后输出近似为

这里的关键变化很明确：原公式需要先单独算 \(q\) 对 \(k_1\)、\(k_2\) 的两个打分；而线性化后的公式把历史两项先合成 \(S\) 与 \(z\)，后续任何新 query 都直接读取这个摘要即可。把“两项历史”换成“\(L\) 项历史”时，这种先摘要、后读取的结构才真正体现出线性复杂度优势。

从直觉上看，标准注意力像是“每个 query 都把整张历史表逐行翻一遍，再决定该关注谁”；线性注意力则像是“先把历史 key/value 在特征空间里压缩成一个可累计的摘要，再由每个 query 去读取这份摘要”。前者保留了最细粒度的两两比较，后者牺牲了一部分精细交互，换取长序列下更低的显存与更高的吞吐。

一个典型形式（省略实现细节）是：

线性注意力更适合“极长序列下的吞吐/显存”目标，但它往往需要在表示、数值稳定性与效果之间做取舍；在通用 LLM 上，主流路径仍然是“精确注意力 + 更好的内核 + 更强的位置/缓存工程”，线性注意力更多作为特定场景或混合架构的选项。

flash-linear-attention

fla

从运行阶段看，fla 的影响并不局限于训练。只要模型在推理时仍然调用同一套由 fla 实现的层或算子，推理阶段也会直接受益，因为推理本质上只是在执行前向传播（Forward Pass）。这意味着它通常会同时带来两类收益：第一，延迟下降，因为前向 kernel 更快；第二，显存占用下降，因为融合实现往往减少了中间张量写回与额外缓存。序列越长，这类收益通常越明显。

不过，fla 的收益并不是无条件出现。若模型本身根本没有使用 fla 支持的模块，而只是标准 Transformer 加普通 PyTorch attention，那么安装 fla 不会自动带来变化；若部署时已经把模型导出到另一套不支持相应 kernel 的执行引擎，例如某些 ONNX / 图编译推理链路，原本的加速路径也可能丢失；若运行环境是 CPU，或 GPU / Triton / CUDA 条件不满足，系统通常会回退到普通实现，此时收益会显著减弱甚至完全消失。

它与 FlashAttention 的关系也需要分清。两者都属于“前向路径加速会同时惠及训练与推理”的工程优化，但作用对象并不相同：FlashAttention 优化的是精确 softmax 注意力的实现，数学结果保持不变；fla 更常服务于线性注意力、递推或 SSM 风格模块的高效实现。因此，是否影响推理，关键不在于“训练还是推理”，而在于推理时走的是否仍是那条由 fla 支撑的前向计算路径。

标准密集自注意力（Dense Self-Attention）会让每个位置与所有可见位置计算打分，因此在长度 \(L\) 上通常带来 \(O(L^2)\) 级别的注意力矩阵与计算压力。稀疏注意力（Sparse Attention）的核心思路，就是预先限制“每个 token 允许看哪些位置”，只保留一部分连接，从而把长上下文建模的代价降下来。

稀疏注意力是一类注意力连接模式的总称。它可以是局部窗口（Local Window）、块状稀疏（Block Sparse）、跨步连接（Strided Pattern）、少量全局 token（Global Tokens），也可以是这些模式的组合。Longformer、BigBird 这类长序列模型，都属于这条路线的经典代表。它保留 softmax 注意力的基本定义，同时把原本“谁都能看谁”的全连接关系改成一个更受约束的稀疏图。

从 2026 年的工程现实看，稀疏注意力仍然重要，但它已经不是通用旗舰语言模型的默认路线。它更常出现在长文档理解、超长上下文、显存/带宽受限，或专门强调长序列效率的模型中；而很多主流通用基座仍然更常采用密集因果注意力，再叠加 GQA、KV Cache、FlashAttention、KV 压缩等优化。这是因为稀疏模式虽然更省，但也会直接限制单层里可建立的依赖范围，训练与实现复杂度通常更高。

滑动窗口注意力（Sliding Window Attention）是稀疏注意力里最常见、也最工程化的一种形式：位置 \(i\) 只看距离自己最近的一段窗口，例如前面 \(w\) 个 token。这样单层注意力的代价就从“与整段长度线性增长的每行宽度”，压缩成“与固定窗口宽度相关”的局部计算。

它的优点是非常直接：局部模式、邻近依赖和短程语义通常仍能被稳定捕捉，而长上下文成本显著下降。代价是，两个相距很远的位置无法在同一层里直接交互，只能依靠多层传播，或额外引入全局层、全局 token、周期性全注意力层等机制来弥补。因此很多实际架构会采用“局部层 + 少量全局层”的混合设计，而不是把所有层都做成纯局部窗口。

到 2026 年，滑动窗口注意力仍然被部分主流模型持续使用，尤其是在长上下文或高性价比路线中；例如 Mistral 一类模型会显式采用 Sliding Window Attention，Gemma 2/3 一类模型也会在 local / global hybrid 结构中交替使用局部注意力层。但它并不是所有主流模型的统一默认配置。更准确的说法是：通用“稀疏注意力”并非当代旗舰模型的普遍默认架构，而“滑动窗口注意力”则仍是今天主流工程实践里一条活跃的局部注意力路线。一旦局部窗口再与全局 token、周期性全注意力层或其他远程连接模式联合使用，它就进入了混合注意力的范畴。

混合注意力（Hybrid Attention）是一类设计思想：在同一个模型、同一层或同一组层里，同时组合两种或多种不同的注意力模式，让它们分别承担不同职责。可被混合的对象很多，例如局部窗口与全局连接、稠密与稀疏、未压缩与压缩表示、不同层采用不同注意力机制。它的核心目标始终一致：在不牺牲太多表达能力的前提下，同时兼顾局部细节、长程依赖和计算成本。

之所以需要“混合”，是因为单一注意力模式往往只能在一个方向上做到极致。纯密集注意力最通用，但长上下文成本太高；纯局部窗口注意力便宜，但单层看不到远处；纯压缩注意力能把上下文做得很长，但容易丢掉近邻精细结构。因此现代模型越来越多地采用“让不同注意力模式协作分工”的路线：局部部分负责细节保真，全局部分负责长距离背景，稀疏部分负责把计算集中在最重要的位置，压缩部分负责控制 KV Cache 和 FLOPs。

从实现方式看，混合注意力至少有三种常见形态。第一种是同层混合：在同一层里并行放入两条注意力分支，再把结果合并，例如局部窗口分支加全局分支。第二种是按层交替：不同层使用不同的注意力模式，例如一层偏局部，一层偏全局。第三种是主干 + 补充分支：主体注意力负责主要读写，同时再加一个窗口分支、全局 token 分支或压缩块分支补足缺失的信息路径。前面的滑动窗口路线，以及后文的 DeepSeek V4 `CSA / HCA`，都可以放在这条“混合注意力”主线上理解。

这里需要把两类经常被混在一起的优化明确分开。第一类是架构级注意力创新：它直接改写注意力层内部的参数化方式、KV 表示形式或 block 级计算路径，例如 MLA（Multi-head Latent Attention）以及 DeepSeek V4 的 CSA / HCA（Compressed Sparse Attention / Heavily Compressed Attention）。第二类是推理期运行时优化：它不改变模型训练时学到的注意力结构，而是在部署阶段降低显存、带宽或调度开销，例如 Paged Attention、Prompt Caching、KV 量化等。

这一区分很重要，因为 MLA、CSA、HCA 都属于主干网络内部的注意力设计。它们直接定义了模型在训练时看到的注意力几何结构：哪些历史信息会先被压缩，哪些块会被稀疏选中，局部窗口与压缩块如何共同参与注意力，Query 与压缩 KV 在什么空间里交互，这些都属于主干网络本身的前向计算路径。DeepSeek V4 也把 Hybrid Attention Architecture、mHC 和 Muon 并列为架构与优化升级，并明确说明该系列模型是在这些设计下完成超大规模预训练的。这说明 `CSA / HCA` 从一开始就是训练期与推理期共同生效的主干设计，而不是训练完以后再附加的后处理层。

更具体地说，MLA 把“每个 token 的 KV 应该以什么潜空间形式被缓存和恢复”写进了注意力层；CSA / HCA 则把“历史序列该怎样在序列轴上压缩、检索与混合”写进了注意力层。模型在预训练阶段就必须适应这种信息流，因此它们会同时影响表示学习、优化稳定性、长程依赖建模和最终推理成本。与之相对，KV 量化和 Paged Attention 更接近部署侧技术：即使它们也会显著影响可用上下文和吞吐，它们通常不要求模型从头按该结构重新预训练。

其中 DeepSeek V4 的 `CSA + HCA` 应被明确看作一种混合注意力机制。它把 CSA 这种“压缩后做稀疏重点检索”的模式，与 HCA 这种“重压缩后做全局粗读”的模式组合起来，并额外保留滑动窗口分支补足局部细节。因此它同时具备“局部 / 全局”“稀疏 / 稠密”“轻压缩 / 重压缩”三层混合特征。也正因为如此，把 `CSA / HCA` 只理解成 KV Cache 压缩技巧是不够的；更准确的定位是：它首先是一种混合注意力架构，其次才带来显著的缓存和 FLOPs 压缩收益。

因此，从文章结构看，DeepSeek 这一类注意力创新应当先在“注意力机制”这里出现，作为混合注意力的长上下文分支做总引；而后文“KV Cache 压缩”再展开它们为何能显著降低缓存和 FLOPs、各自内部具体有哪些组件。这样章节关系才准确：前者回答“这是不是注意力机制本身的创新”，后者回答“这种创新最终把成本压到了哪里”。

KV Cache（Key-Value Cache）是自回归（Autoregressive）解码的关键工程优化：生成到第 \(t\) 步时，历史 token 的 Key/Value 已经在前序计算中得到；缓存它们可以避免每一步都重算整段历史的 K/V。

形式上，单层注意力在序列长度为 \(L\) 时需要缓存：

其中 \(n_{\text{kv}}\) 是 KV 头数量（对标准多头注意力通常等于头数；对 GQA/MQA 通常更小），\(d_k\) 是每个 head 的维度。忽略实现细节（对齐、分块、paged layout）时，KV Cache 的显存规模近似线性增长：

这里前面的 2 来自同时缓存 K 与 V；\(B\) 是并发请求（batch）数；\(\text{bytes}\) 是每元素字节数（FP16/BF16 为 2）。因此 KV Cache 常成为长上下文与高并发推理的显存瓶颈。

KV Cache 的典型优化方向包括：

• 减少 \(n_{\text{kv}}\)，例如使用 GQA / MQA。
• 压缩 KV，例如 KV 量化、低秩表示、选择性缓存。
• 改进分配与复用，例如 Paged Attention、前缀缓存（Prompt Caching）。

FlashAttention 是一种对标准注意力（Standard Attention）的高性能精确实现：它不改变 \(\mathrm{softmax}(QK^\top/\sqrt{d_k})V\) 这个数学结果，而是通过分块（Tiling）、融合计算与在线 softmax，减少大规模中间矩阵在 HBM 与片上存储之间的来回搬运。因此，它首先是一种注意力算子实现优化，而不是新的模型结构。应用阶段上，训练与推理都可以使用 FlashAttention；在推理里，它最典型地加速的是预填充（Prefill）阶段，因为这时需要对整段输入做完整注意力计算，序列长、 \(QK^\top\) 代价高，FlashAttention 的收益最明显。到了逐 token 解码（Decode）阶段，单步 query 很短，瓶颈更常转向 KV Cache 读取、采样与调度，此时仍可使用面向解码优化的 Flash-Decoding / FlashAttention 变体，但收益模式已不同于预填充阶段。

从软件栈位置看，FlashAttention 可以放在内核级别（Kernel-level）/ 后端级别（Backend-level）来理解：上层框架仍然调用“注意力”这个算子，但底层并不一定走朴素的矩阵乘法 + softmax + 再乘 \(V\) 三步显式实现，而是改由高度融合的 GPU kernel 完成。是否真的启用 FlashAttention，取决于框架版本、后端实现、数据类型、head 维度、掩码形式以及硬件架构是否匹配。工程上常见支持平台是 NVIDIA 的 Ampere / Ada / Hopper，以及 AMD ROCm 生态中的部分高端 GPU；若硬件或后端条件不满足，框架通常会自动回退到 memory-efficient attention、cuDNN attention 或更普通的数学实现。

FlashAttention要解决的是标准注意力（Standard Attention）在长序列上的 中间张量 IO 成本 过高。标准缩放点积注意力（Scaled Dot-Product Attention）可写为：

其中：

• \(Q\in\mathbb{R}^{N\times d_k}\)：查询矩阵（Query Matrix），\(N\) 是序列长度， \(d_k\) 是每个 head 的查询/键维度。
• \(K\in\mathbb{R}^{N\times d_k}\)：键矩阵（Key Matrix），与 \(Q\) 做点积打分。
• \(V\in\mathbb{R}^{N\times d_v}\)：值矩阵（Value Matrix），\(d_v\) 是每个 head 的值维度。
• \(S\in\mathbb{R}^{N\times N}\)：注意力分数矩阵（Score Matrix），其中 \(S_{ij}\) 表示第 \(i\) 个 query 对第 \(j\) 个 key 的未归一化打分。
• \(P\in\mathbb{R}^{N\times N}\)：softmax 归一化后的注意力权重矩阵（Attention Probability Matrix）。
• \(O\in\mathbb{R}^{N\times d_v}\)：最终输出矩阵（Output Matrix）。

问题集中在 \(S\) 和很多实现中的 \(P\)：它们都是 \(N\times N\) 规模。序列一长，中间矩阵就会迅速膨胀。计算复杂度依然是 \(\mathcal{O}(N^2)\) 级别，但在 GPU 上更先撞上的往往不是算力上限，而是高带宽显存（High Bandwidth Memory, HBM）与片上共享内存 / SRAM（Static Random Access Memory, SRAM）之间的数据搬运成本。

传统实现通常经历三步：先算出整个 \(S=QK^\top\) 并写回显存；再把它读出来做 softmax，得到 \(P\) 并再次写回；最后再把 \(P\) 读出来与 \(V\) 相乘得到 \(O\)。这意味着真正拖慢速度的往往不是矩阵乘法本身，而是对 \(N^2\) 中间结果的反复显式物化（Materialization）与反复搬运。

一个直接类比是流水线工厂。普通注意力像“先把全部半成品都堆进仓库，再统一拿出来做下一道工序”；仓库本身就成了瓶颈。FlashAttention 则像“边加工边流转”的流水线：中间块只在车间里短暂停留，不建立巨大的中间仓库。

FlashAttention 的核心可以压缩成一句话：分块（Tiling）+ 在线 softmax（Online Softmax）+ 融合输出（Fused Output Accumulation）。

它并不改变注意力的数学目标，仍然精确计算同一个 \(\mathrm{softmax}(QK^\top/\sqrt{d_k})V\)；它改变的是计算顺序与中间结果的存储方式。具体来说，FlashAttention 不再把整个 \(N\times N\) 的注意力矩阵一次性算完并落到 HBM 中，而是把 \(Q,K,V\) 切成若干小块（tiles），每次只在 SRAM 中处理一小块分数、归一化和输出累加。

设查询块（query tile）为 \(Q_i\in\mathbb{R}^{B_q\times d_k}\)，键块和值块分别为 \(K_j\in\mathbb{R}^{B_k\times d_k}\) 与 \(V_j\in\mathbb{R}^{B_k\times d_v}\)。这里 \(B_q\) 和 \(B_k\) 是 tile 大小，远小于完整序列长度 \(N\)。FlashAttention 每次只把这样的局部块搬进 SRAM，在块内完成当前 query tile 对当前 key/value tile 的全部贡献计算。

对第 \(i\) 个 query 块和第 \(j\) 个 key/value 块，先计算块级分数矩阵：

其中：

• \(S_{ij}\)：当前块内的注意力打分矩阵。
• \(S_{ij}[r,c]\)：query 块中第 \(r\) 行与 key 块中第 \(c\) 行的打分。
• \(\sqrt{d_k}\)：缩放因子，用于抑制点积随维度增长而导致的 softmax 饱和。

难点在于 softmax 的分母依赖整行所有 key：对一个 query 而言，必须把它对所有位置的打分都考虑进去，才能完成归一化。FlashAttention 的关键突破是：不必先看到整行全部元素，再做 softmax；可以用在线算法维护“到目前为止的最大值、分母和分子累加量”，随着块不断读入而精确更新。

对当前 query 块 \(Q_i\)，FlashAttention 维护三个按行统计的状态：

• \(\mathbf{m}_i\)：每个 query 行到目前为止见过的最大分数（row-wise running max）。
• \(\boldsymbol{\ell}_i\)：每个 query 行当前的 softmax 分母累加量。
• \(R_i\)：每个 query 行对输出向量的未归一化加权和（unnormalized weighted sum）。

初始时可设：

当读入第 \(j\) 个块时，先求该块每一行的局部最大值：

这里 \(\mathrm{rowmax}(\cdot)\) 表示对矩阵每一行取最大值，因此输出是长度为 \(B_q\) 的向量。再把旧最大值和当前块最大值合并成新的全局参考点：

这里的 \(\max\) 是逐元素最大值（element-wise max），因为每个 query 行都维护自己的 softmax 参考值。

接着把当前块的指数项按新参考点重写：

其中：

• \(P_{ij}\in\mathbb{R}^{B_q\times B_k}\)：当前块中按新最大值平移后的指数权重。
• \(\mathbf{1}\in\mathbb{R}^{B_k}\)：全 1 向量，用于把 \(\mathbf{m}_i^{\mathrm{new}}\) 广播到块内每一列。
• \(\exp(\cdot)\)：逐元素指数函数。

然后更新分母累加量：

这里 \(\odot\) 表示逐元素乘法， \(\mathrm{rowsum}(P_{ij})\) 表示对 \(P_{ij}\) 每一行求和。这个式子的含义是：旧块已经累积的分母，先因为参考最大值改变而按 \(\exp(\mathbf{m}_i-\mathbf{m}_i^{\mathrm{new}})\) 重新缩放，再加上当前块的新贡献。

再更新输出分子的累加量：

其中：

• \(\mathrm{Diag}(\cdot)\)：把向量放到对角线上形成对角矩阵，用于按行缩放 \(R_i\)。
• \(P_{ij}V_j\in\mathbb{R}^{B_q\times d_v}\)：当前块对输出的新增贡献。

所有 \(K_j,V_j\) 块处理完之后，当前 query 块的最终输出为：

这里 \((\boldsymbol{\ell}_i)^{-1}\) 表示对向量每个元素取倒数，作用是把“未归一化加权和”除以 softmax 分母，从而得到真正的注意力输出。

FlashAttention 通过一种保持数值等价的累计方式精确计算 softmax。设某一行已经处理过的旧分数集合为 \(\mathcal{A}\)，其旧最大值为 \(m_{\mathrm{old}}\)，旧分母为：

新读入一块分数集合 \(\mathcal{B}\) 后，若新的全局最大值变成 \(m_{\mathrm{new}}\)，则旧部分相对于新参考点的分母贡献恰好变成：

这正是在线更新公式里那一项缩放因子的来源。分子累加量 \(R_i\) 也是同样的道理：旧部分先按新参考点缩放，再加上新块贡献。因此块级处理结束后得到的 \(O_i\) 与一次性对整行做 softmax 再乘 \(V\) 的结果完全一致。

FlashAttention 的速度优势主要来自 IO 模式优化，而不是渐近计算复杂度下降。它的核心收益主要来自四点：

• 减少 HBM 访问：不再反复把 \(S\) 与 \(P\) 这类 \(N^2\) 中间张量写回、读回。
• 提升 SRAM 复用：一个 tile 被搬进片上后，会在同一块内连续完成分数计算、归一化和输出累加。
• 算子融合（Kernel Fusion）：原本分散的 \(QK^\top\)、softmax、\(PV\) 被压成一条更短的数据通路。
• 数值稳定：在线 softmax 仍然使用减最大值（max trick），避免指数溢出，也避免了“先大矩阵 softmax 再回写”带来的额外数值压力。

因此，FlashAttention 的本质是减少无效搬运，而不是改变注意力本身的数学定义。从硬件视角看，它把一个明显受内存带宽制约的算子，改造成更能吃满矩阵乘法单元和 Tensor Core 的实现。

复杂度上需要严格区分“算了多少”和“存了多少”。FlashAttention 与普通注意力在算术复杂度上仍然同阶，因为每个 query 与每个 key 的交互并没有消失：

但中间激活的显存复杂度发生了根本变化。若只看注意力算子额外需要保留的中间结果，则：

这里的 \(\mathcal{O}(N)\) 指的是按行维护的 softmax 统计量与输出累加量；tile 临时块的大小由 \(B_q,B_k\) 控制，不随完整序列平方增长。工程直觉可以概括为：算力阶数没变，但仓库规模从平方级中间仓库变成了线性级流水线缓存。

for each query tile Q_i:
    m_i = -inf
    l_i = 0
    R_i = 0
    for each key/value tile (K_j, V_j):
        S_ij = Q_i K_j^T / sqrt(d_k)
        m_new = max(m_i, rowmax(S_ij))
        P_ij = exp(S_ij - m_new)
        l_i = exp(m_i - m_new) * l_i + rowsum(P_ij)
        R_i = diag(exp(m_i - m_new)) * R_i + P_ij * V_j
        m_i = m_new
    O_i = diag(1 / l_i) * R_i

这段伪代码对应的正是“边看块、边归一化、边输出”的流水线结构。与普通实现相比，最大的变化不是公式，而是调度顺序。

FlashAttention 的关键价值不仅在前向传播（Forward Pass），也在反向传播（Backward Pass）。训练时真正吃显存的不只是前向输出，还包括为了求梯度而保留的中间激活。如果 backward 仍然要求把完整的 \(S\) 或 \(P\) 存下来，那么前向省出来的显存会被反向阶段重新吃掉。因此，FlashAttention backward 的核心原则与前向一致：不保存 \(N\times N\) 注意力矩阵，而是在 backward 中按块重算（recompute）它们。

设前向定义为：

设损失函数为 \(\mathcal{L}\)，并记上游传回的输出梯度为：

这里：

• \(\mathcal{L}\)：整个模型的标量损失（scalar loss）。
• \(G\)：损失对注意力输出 \(O\) 的梯度，也就是 backward 进入注意力层时收到的上游信号。

普通 attention 的 backward 可以按链式法则拆成四步。先对 \(V\) 求梯度：

这个式子表示：某个 value 向量 \(v_j\) 对多少个 query 产生了贡献，就会按相应注意力权重 \(P_{ij}\) 把这些上游梯度累加回来。

再对概率矩阵 \(P\) 求梯度：

这里 \(\frac{\partial \mathcal{L}}{\partial P}\in\mathbb{R}^{N\times N}\) 的第 \((i,j)\) 项表示：若第 \(i\) 行第 \(j\) 列的注意力权重略有变化，会怎样影响损失。

关键一步是 softmax 的梯度。对第 \(i\) 行，记 \(p_i\) 为第 \(i\) 行概率向量， \(g_i^P\) 为 \(\frac{\partial \mathcal{L}}{\partial P}\) 的第 \(i\) 行，则：

其中：

• \(s_i\)：分数矩阵 \(S\) 的第 \(i\) 行。
• \(\odot\)：逐元素乘法。
• \(\delta_i\)：第 \(i\) 行 softmax Jacobian 压缩后的标量项，用来扣掉“整行归一化”带来的耦合影响。
• \(\mathbf{1}\in\mathbb{R}^{N}\)：全 1 向量。

把所有行拼起来，可写成矩阵形式：

这里 \(D\in\mathbb{R}^{N}\) 是逐行标量向量，第 \(i\) 个分量就是 \(\delta_i\)。最后再通过 \(S=QK^\top/\sqrt{d_k}\) 回传到 \(Q\) 与 \(K\)：

若直接照这些公式实现，最大问题是：看起来必须先拿到完整的 \(P\) 和 \(\frac{\partial \mathcal{L}}{\partial P}\)，而它们又都是 \(N\times N\)。FlashAttention backward 的突破在于，真正必须永久保存的量远比这少。

第一，前向阶段只需保存每一行的 log-sum-exp 统计量（Log-Sum-Exp Statistics），而不必保存整张 \(P\)。若前向某一行的最大值为 \(m_i\)，归一化因子为 \(\ell_i\)，则可存：

这里 \(L_i\) 是第 \(i\) 行 softmax 分母的对数。只要 backward 时重新算出某个块的分数 \(S_{ij}\)，就可以把该块的概率精确重建为：

这说明 backward 不需要读取前向保存下来的整张 \(P\)；它只需要 \(Q\)、\(K\)、行级统计量 \(L_i\)，就能按块把局部概率重新算出来。

第二，softmax backward 中的行级标量 \(\delta_i\) 也可以不通过整张 \(\frac{\partial \mathcal{L}}{\partial P}\) 显式求和，而是用一个更紧凑的等价式：

其中 \(g_i\) 是上游梯度矩阵 \(G\) 的第 \(i\) 行， \(o_i\) 是前向输出 \(O\) 的第 \(i\) 行。这个恒等式来自：

于是：

这一步非常关键，因为它说明 softmax backward 所需的行级校正项 \(\delta_i\)，可以直接由前向输出 \(O\) 和上游梯度 \(G\) 得到，而不需要显式展开整个 \(N\times N\) 概率矩阵。

因此，FlashAttention backward 的块级流程可以概括为：

1. 读取一个 query tile \(Q_i\)、对应输出 tile \(O_i\)、上游梯度 tile \(G_i\)，以及该 tile 的行级统计量 \(L_i\)。
2. 逐块读取 \(K_j,V_j\)，重算当前块分数 \(S_{ij}=Q_iK_j^\top/\sqrt{d_k}\)。
3. 由 \(L_i\) 重建当前块概率 \(P_{ij}=\exp(S_{ij}-L_i\mathbf{1}^\top)\)。
4. 用 \(G_iV_j^\top\) 得到当前块的 \(\frac{\partial \mathcal{L}}{\partial P_{ij}}\)，再结合 \(\delta_i=g_i^\top o_i\) 计算当前块的 \(\frac{\partial \mathcal{L}}{\partial S_{ij}}\)。
5. 把该块对 \(dQ_i\)、\(dK_j\)、\(dV_j\) 的贡献直接累加到输出梯度中。

写成块级公式，就是：

这里 \(dQ_i,dK_j,dV_j\) 分别表示当前块对 \(\frac{\partial \mathcal{L}}{\partial Q}\)、\(\frac{\partial \mathcal{L}}{\partial K}\)、\(\frac{\partial \mathcal{L}}{\partial V}\) 的局部累加贡献；符号 \(\mathrel{+}=\) 表示“把当前块的贡献继续累加到已有梯度里”，而不是一次性覆盖赋值。

这个设计的代价是：backward 需要重算部分前向中的块级分数和概率，因此算术量会比“全存中间矩阵”的朴素实现略多；但现代 GPU 上，额外矩阵乘法通常比反复读写 \(N^2\) HBM 张量便宜得多。于是 FlashAttention backward 的工程哲学可以概括为：用少量重算换大幅节省显存与 IO。

一个直观类比是：普通 backward 像把前向每一道工序的全部半成品都堆满仓库，等回头算梯度时再逐件取出来；FlashAttention backward 则更像保留每条流水线的关键账本和最终产物，真正需要某段中间细节时，再按原流程快速重演一小段。仓库变小了，流水线也更连贯。

FlashAttention v1 的核心贡献在于算法层：它首先把“注意力必须显式存下 \(N\times N\) 矩阵”这一默认前提打破，给出了一种精确、稳定、块级流式的注意力实现。v1 的关键词是 memory optimization：让注意力从“被中间矩阵拖慢”转向“更像一个流式矩阵核”。

在这个阶段，最重要的是先证明：不物化注意力矩阵，仍然可以精确完成前向与反向计算，并把显存墙显著后移。GPU 利用率优化反而是后续问题。它首先解决的是“能不能这样算”的问题。

FlashAttention v2 保留了 v1 的数学等价性与在线 softmax 思路，但把优化重点从“省内存”推进到“把 GPU 吃满”。它关注的是并行工作划分（Work Partitioning）：如何把 query 块、head 维度、batch 维度和线程块（Thread Block）组织得更均匀，让更多流式多处理器（Streaming Multiprocessor, SM）同时处于忙碌状态。

v1 的一个现实限制是：虽然显存访问已经大幅减少，但某些场景下并行粒度仍然偏粗，导致 GPU 占用率（Occupancy）不够高。v2 因此重写了 kernel 调度策略，让同一个大任务能够拆给更多线程块并行处理，同时尽量减少线程同步（Synchronization）带来的停顿。

从本质上看，v2 做的不是“新的注意力公式”，而是“同一公式在 GPU 上的更优任务分发”。如果说 v1 的问题是“别把中间矩阵落盘”，那么 v2 的问题就是“别让 GPU 的很多 SM 闲着”。

这也是 v2 在反向传播（Backward Pass）上价值很高的原因。前向只解决一半问题；训练吞吐还取决于 backward kernel 能否在不恢复 \(N^2\) 显存占用的前提下保持高并行度。v2 在这一点上比 v1 更成熟，因此更适合作为训练时的高性能默认实现。

FlashAttention v3 的重点进一步从并行层推进到硬件协同设计（Hardware Co-design），尤其针对 NVIDIA Hopper / H100 这类新一代 GPU。它不再只关心“块怎么切、线程怎么分”，而是进一步追问：数据加载、矩阵计算、结果写回能否形成异步流水线。

v3 的几个代表性关键词包括：

• 异步流水线（Asynchronous Pipeline）：加载下一块数据时，当前块已经在计算，从而重叠 load 与 compute。
• Warp 专职分工（Warp Specialization）：不同 warp 分别负责搬运、计算、写回，减少彼此等待。
• Tensor Core 深度利用：tile 尺寸与数据流更贴近 Tensor Core 最擅长的矩阵乘法路径。
• 更适合低精度数据类型：如 FP16、BF16，以及面向新硬件的 FP8 路径。

如果把 v1 看成“算法上不建大仓库”，把 v2 看成“让更多工人同时开工”，那么 v3 更像“把整座工厂变成不停顿的装配线”：搬运、计算、写回三条流水同时进行，尽量让每一级硬件资源都不空转。

因此，FlashAttention 的演进可以概括为三层推进：v1 解决“能否不存矩阵”、v2 解决“如何把 GPU 跑满”、v3 解决“如何贴着新硬件的数据通路跑”。三代版本的数学目标完全一致，差异主要体现在实现层面对 IO、并行性与硬件流水的挖掘深度。

状态空间模型（State Space Model, SSM）用“隐状态递推（State Recurrence）”建模序列：每步用一个小状态 \(s_t\) 累积历史信息，避免显式构造 \(L\times L\) 注意力矩阵。经典线性 SSM 的抽象形式是：

近年的 Mamba 等结构可理解为在此基础上引入输入依赖的选择性/门控机制（Selective / Input-dependent Dynamics），使得模型在保持线性复杂度的同时具备更强的表征能力。工程上，SSM 的优势通常体现在长序列吞吐与显存；代价是“按内容随机访问历史”的能力不如注意力直观，因此在需要强检索/对齐的任务上常见的是混合架构或与注意力模块组合使用。

Transformer 层里的前馈网络（Feed-Forward Network, FFN）本质上就是一个位置前馈（Position-wise）MLP：它对每个 token 的向量独立作用，不在序列维度做混合（序列维度的混合由注意力完成）。典型形式是两层线性变换加非线性：

这里为了贴近工程实现，把单个 token 表示写成行向量 \(x\in\mathbb{R}^{1\;\times d_{\text{model}}}\)。若中间宽度为 \(d_{\text{ff}}\)，则 \(W_1\in\mathbb{R}^{d_{\text{model}}\;\times d_{\text{ff}}}\)、\(W_2\in\mathbb{R}^{d_{\text{ff}}\;\times d_{\text{model}}}\)，因此这层先把 \(d_{\text{model}}\) 维表示升到更宽的 \(d_{\text{ff}}\) 维，再投回原宽度。很多教材把它叫“MLP 模块”，强调的是它在每层里与注意力并列构成 Transformer block 的两大子层。

“升维（Up-Projection）”指的是用线性投影把输入映射到更高维的特征空间。新维度不是补零得到的，也不是旧特征的简单复制。若

则第 \(j\) 个中间维度满足

这意味着：升出来的每一维都在重新组合输入特征。有些维度更像“检测某种局部模式”，有些维度更像“混合多种语义线索”，中间宽度越大，可供模型学习的组合方式就越多。随后，非线性函数 \(\sigma\)（常见如 GELU / ReLU）对这些组合结果做逐元素变换，把线性组合提升为非线性特征。

“降维（Down-Projection）”也不是简单删掉多余维度，而是再做一次线性组合：

因此，经典 FFN 的结构可以概括成：先在更宽的特征空间里生成大量候选特征，再把有用的那部分重新组合回模型主宽度。这就是“升维—非线性—降维”的真正含义。

很多现代大模型会用门控线性单元（Gated Linear Unit, GLU）的变体替代“Linear → 激活 → Linear”的经典 FFN，例如 SwiGLU（Swish-Gated Linear Unit）：把中间层拆成两路并行投影，再做逐元素门控：

若仍按行向量写法，则 \(W_1,W_3\in\mathbb{R}^{d_{\text{model}}\;\times d_{\text{ff}}}\)， \(W_2\in\mathbb{R}^{d_{\text{ff}}\;\times d_{\text{model}}}\)。这里 \(W_1\) 与 \(W_3\) 都是“升维投影”，但角色不同： \(xW_1\) 经过 \(\mathrm{SiLU}\) 后形成门控分支（gate branch），决定每个中间维度应当放大、通过还是抑制； \(xW_3\) 则形成内容分支（value / candidate branch），携带候选特征本身。两者做逐元素乘法 \(\odot\) 后，得到“被门控筛选过的中间表示”，最后再由 \(W_2\) 投回 \(d_{\text{model}}\)。

因此， \(W_3\) 不是额外多出来的“神秘矩阵”，而是门控 FFN 里的第二条并行升维支路。没有它，模型只有“激活后的门”，却没有“真正被门控制的候选内容”；有了它，FFN 才能表达“哪些特征值得通过、哪些特征应被压制”这一层选择机制。

这种“哪些维度打开、哪些维度抑制”的规则并不是人工写死的，而是通过训练从数据中学出来的。对第 \(j\) 个中间维度，门控值可以写成 \(g_j=\mathrm{SiLU}((xW_1)_j)\)，候选内容写成 \(c_j=(xW_3)_j\)，二者相乘后该维输出为 \(m_j=g_j c_j\)。若某类输入模式下，让这个维度更大能够降低最终损失，则反向传播会推动 \(W_1\) 和 \(W_3\) 把对应的 \(g_j\) 与 \(c_j\) 调到更有利的方向；若某个维度会带来噪声、干扰或错误特征，则梯度会推动该维在这类输入上变小，于是门控值逐渐靠近 0，内容即使存在也难以通过。

因此，门控学习到的不是一个离散的“开 / 关开关”，而是一组随输入变化的连续缩放系数。某些维度在数学推理样本上可能长期被放大，在闲聊样本上则被压弱；某些维度对代码括号、缩进、关键字组合更敏感，另一些维度则更偏向实体关系或长距离语义线索。门控 FFN 的本质，是让模型在更宽的中间空间里先生成大量候选特征，再由可学习的输入相关门控决定哪些特征应该被保留、哪些应被抑制。

门控（Gating）让 FFN 具备“按特征选择通过 / 抑制”的能力，在相近参数规模下常带来更好的效果与训练稳定性。与经典两层 FFN 相比，门控 FFN 并不是单纯“多一层”，而是把中间表示拆成“控制信号”和“候选内容”两路，再在中间宽空间里完成细粒度筛选。

从能力角度看，增大 \(d_{\text{ff}}\) 会增加中间表征的自由度（Degree of Freedom, DOF）与参数量，使模型能构造更丰富的非线性特征；但“维度更高”不等于“信息一定更多”，它提供的是可学习的表示空间与容量（Capacity），是否有效取决于数据与训练目标。

MoE（Mixture of Experts）把 FFN 子层替换成“多个专家网络（Experts）+ 路由器（Router/Gate）”：对每个 token，路由器只激活少数几个专家（Top-k），因此计算量近似不随专家总数线性增长，但参数容量可以大幅增加。

一种常见形式（概念表达）是：

其中 \(p_e(x)\) 是路由概率，专家通常就是不同参数的 FFN。与稠密 FFN 的区别在于：稠密 FFN 对每个 token 都执行同一套参数；MoE 则先由路由器决定“这个 token 该送去哪些专家”，再只计算被选中的少数几个专家。

专家的差异化（Specialization）来源于路由选择、梯度暴露和训练约束共同塑造的长期分工。随机初始化只负责打破完全对称；真正让专家“越学越不一样”的，是后续每个专家持续处理不同 token 子分布，并在这些子分布上反复累积参数更新。

这个过程通常由以下几类机制共同推动：

• 稀疏路由：每个 token 前向时通常只进入 top-k 个专家，因此反向传播时，也只有被选中的专家接收到该 token 的主要梯度。不同专家长期看到的训练样本分布因此不再相同，参数更新方向也随之分化。
• 路由—能力自增强：路由器先按当前表示给专家打分；某个专家一旦更常处理一类模式，就会在这类模式上进一步拟合得更好；下一轮遇到相似 token 时，路由器又更容易把它们送回这个专家。久而久之，专家会演化成代码型、数学型、长句法型或领域词汇型等不同处理器。
• 负载均衡损失：若完全放任训练，路由器容易把大量 token 都送往少数“热门专家”，其余专家几乎得不到梯度。负载均衡（Load Balancing）辅助损失会惩罚这种失衡，推动更多专家获得稳定训练信号，从而保留分工空间，而不是塌缩成少数几个超忙专家。
• 容量限制：工程实现常给每个专家设置每个 batch 最多接收多少 token 的上限。热门专家一旦满载，后续 token 就必须改道到其他专家。这相当于在训练期强行制造“分流”，避免所有高频模式都被同一专家垄断。
• 路由噪声与探索：训练早期常在路由分数上加入噪声（Noisy Gating / Jitter）或采用更平滑的选择策略，使模型不会过早把某些专家永久冷启动掉。它的作用类似探索机制：先让更多专家接触不同 token，后续再由训练结果把分工逐步固化。
• Top-k 竞争结构：当多个专家为同一 token 竞争有限的 top-k 名额时，路由器天然在做离散化分配。专家之间并不是同时都拿到完整梯度，而是在竞争中各自吸附不同区域的输入分布。这比稠密加权平均更容易形成明确边界。
• 专家参数独立：每个专家有自己独立的 FFN 权重，因此一旦早期路由稍有偏向，后续参数更新就会沿不同轨迹不断放大差异。若专家共享大部分参数，仅保留极少差异分支，则这种专门化能力会明显减弱。
• 数据分布本身的可分性：训练语料若天然包含代码、自然语言、表格、数学推导、多语种等明显子分布，专家更容易形成稳定分工；若数据分布高度均匀、模式差异很弱，则专家专门化也会更弱，更接近“多份相似 FFN”。

这些机制叠加后，MoE 中“每个专家学不同东西”就不再只是参数副本的偶然漂移，而是带有明确结构约束的分工过程。与多头注意力主要依赖独立参数的自发分化不同，MoE 额外利用显式路由、稀疏梯度、负载约束与容量分流来持续放大专家之间的功能差异。

MoE 结构本身不必然引入随机性。若路由使用确定性的 top-k，且推理使用确定性算子，则同一输入在同一权重下输出应是确定的。训练阶段常见的随机性主要来自 dropout、路由噪声（Noisy Gating）以及硬件/并行计算的非确定性；这些会影响训练轨迹，但不等价于“模型本质随机”。

层归一化（Layer Normalization, LayerNorm）在每个 token 的特征维度上做归一化（Normalization），与 BatchNorm 不同，它不依赖 batch 统计量，因此更适合变长序列与自回归推理。对向量 \(x\in\mathbb{R}^{d_{\text{model}}}\)：

其中 \(\gamma,\beta\) 是可学习的缩放与平移参数（Learnable Scale/Shift），\(\epsilon\) 是一个很小的正数，用于数值稳定性（Numerical Stability）。归一化本质上要除以标准差或均方根；若当前 token 的各维几乎相同，分母就可能非常接近 0，进而导致输出或梯度被异常放大，甚至出现 NaN / Inf。加入 \(\epsilon\) 相当于给分母设置一个下界。它通常很小，只在“方差或 RMS 过小”时介入；若 \(\epsilon\) 取值过大，则会把分母中的真实尺度差异压平，使归一化变弱，模型对幅值变化的敏感度下降。

当前主流的 Transformer 几乎都采用“token 内部归一化”，而不是跨 batch 的 BatchNorm：经典 Transformer、BERT、ViT 这一路架构以 LayerNorm 为主；许多更新的 Decoder-only 大模型则把每个残差块写成 Pre-Norm 结构，并进一步用 RMSNorm 取代标准 LayerNorm。

Pre-LN（Pre-LayerNorm）指先做归一化，再进入 Attention 或 MLP 子层，最后与残差分支相加；其典型形式可写为：

这种写法把归一化放进残差支路内部，有利于维持深层网络中的梯度流稳定。结合后文残差连接的分析来看，Pre-LN 的一个直接优势是：梯度更容易沿着 \(x\to x+\cdots\) 这条恒等主路向后传播，而不会在进入子层之前就先经历一次“相加后再归一化”的整体重标定。与之对应，Post-LN 会写成 \(y=\mathrm{LN}(x+\mathrm{Sublayer}(x))\)；它在早期 Transformer 中出现较多，但随着层数、上下文窗口和参数规模持续增大，Pre-LN 在大模型训练中更常见。

BatchNorm 很少出现在 Transformer 主干中的原因，是它要求当前表示依赖同一 batch 里其他样本的统计量。对于序列模型，这会带来几个直接问题：

• 变长序列和 padding 会污染 batch 统计。
• 训练与推理使用的统计规则不同，自回归逐 token 生成时尤其不自然。
• 大模型训练常依赖小 batch、梯度累积和跨设备切分，batch 统计噪声更大。

LayerNorm / RMSNorm 则完全避免了这些问题，因为每个 token 的归一化只依赖其自身特征。

RMSNorm（Root Mean Square Normalization）与 LayerNorm 的相同点是：都在每个 token 的特征维度上做归一化；不同点是 RMSNorm 不做去均值，只按均方根（RMS）缩放：

其中 \(\gamma\in\mathbb{R}^{d}\) 是可学习缩放参数（通常不需要 \(\beta\)），\(\epsilon\) 则是数值稳定项（Numerical Stability Term）。当 RMS 很小时，若没有 \(\epsilon\)，分母会过小，微小噪声也可能被异常放大；若 \(\epsilon\) 过大，又会把不同 token 之间本应存在的尺度差异压平，使归一化变弱。RMSNorm 省掉了均值计算，算子更简单，因此在许多 Decoder-only 大模型中被广泛采用（例如 LLaMA 系列）。

RMSNorm 之所以使用均方根，而不是直接对各维做算术平均，是因为这里要刻画的是向量整体有多大，而不是“各维带符号求平均后的中心位置”。若直接用 \(\frac{1}{d}\sum_i x_i\)，正负分量会彼此抵消：例如 \((10,-10)\) 的算术平均是 0，但这个向量的整体幅值显然并不小。均方根先平方再平均，保留了各维对整体能量的贡献，又与二范数只差一个 \(\sqrt d\) 的常数因子，因此很适合用来刻画表示的整体尺度。

这也是 RMSNorm 即使不做去均值，仍然常常有效的原因。对 Transformer 主干而言，更核心的问题通常不是“特征均值是否恰好为 0”，而是表示的整体尺度能否在深层网络中保持稳定。残差流里真正容易失控的，往往是表示向量的整体幅值在层与层之间持续放大或缩小，进而影响梯度传播、残差叠加与数值稳定。RMSNorm 保留了各维之间的相对方向与相对比例，只对整体大小做统一缩放，因此不会反复改写表示基线；对深层 Transformer 来说，这种“只管尺度、不强行去中心”的处理往往已经足够，而且算子更轻，更适合大规模训练与推理。也正因为如此，归一化与残差连接通常总是一起出现：前者负责稳定尺度，后者负责保留主通路。

残差连接（Residual Connection）把子层输出与输入做逐元素相加：

它不改变主表示的维度（Dimension）——前提是 \(x\) 与 \(\mathrm{Sublayer}(x)\) 形状相同。这个写法的核心价值，不是“把两份向量简单相加”，而是把深层网络的每一层改写成：在已有表示上追加一小步修正，而不是每层都彻底重写整份表示。

若没有残差，网络某一层必须直接学出从输入到输出的完整映射；有了残差后，子层只需学习增量项 \(\Delta(x)=\mathrm{Sublayer}(x)\)。当最优行为接近恒等映射时，学习“加多少修正”通常比学习“整层重新变换成什么样”更容易。这也是残差连接与恒等映射（Identity Mapping）关系紧密的原因：主通路默认保留原信息，子层负责在其上叠加必要变化。

从优化角度看，残差连接直接改变了梯度传播路径。若把一层的输入 \(x\) 看成 \(d\) 维向量，输出写成 \(y=x+f(x)\)，那么这里的求导就不再是标量对标量的导数，而是向量对向量的 Jacobian 矩阵。

先看最简单的恒等映射 \(g(x)=x\)。若 \(x=(x_1,\dots,x_d)^\top\)，则 \(g_i(x)=x_i\)。它的 Jacobian 第 \((i,j)\) 个元素是

因此，向量对自身的导数不是数字 1，而是恒等矩阵：

再对残差块 \(y=x+f(x)\) 求导，就得到

这里的 \(I\) 正对应那条“把输入原样传过去”的恒等分支。它并不表示整层没有维度之间的交互，而只表示：在这条直连路径上，每一维对自身的导数是 1、对其他维的导数是 0。真正的维度混合、特征重组与 token 间交互，仍然由 \(\frac{\partial f(x)}{\partial x}\) 负责。含义是：即使子层 \(f(x)\) 的局部 Jacobian 很小、很噪，或训练初期还没有学好，梯度仍然可以沿着这条恒等路径直接穿过该层，而不必完全依赖 \(\frac{\partial f(x)}{\partial x}\)。深层网络因此更不容易出现梯度迅速衰减，训练也更稳定。

从表示角度看，残差连接建立了一条贯穿全网的主通道，这正是前面多次出现的残差流（Residual Stream）。在 Transformer 中，注意力子层负责跨 token 交换信息，MLP / FFN 负责对单个 token 做非线性重组，而它们的输出都不是“另起炉灶”的新表示，而是写回这条主通道。于是每一层都更像是在同一块工作记忆上持续读写：有的层补充局部依赖，有的层补充长程关系，有的层强化事实模式或语法结构。

残差连接还有一个很重要的工程意义：它允许模型在“保留已有信息”和“注入新特征”之间取得平衡。若某层子层输出很弱，网络行为就更接近恒等传递；若某层确实学到了有价值的新模式， \(f(x)\) 就会沿某些表示方向显著写回主通道。后续层不需要把两部分精确拆开，只需要继续利用这个叠加后的结果即可，因为后续线性映射、注意力和归一化会在新的坐标方向上重新组织这些信息。

从反向传播（Backpropagation）的角度看，残差连接的价值同样直接。若没有残差，深层网络中的梯度必须连续穿过许多子层 Jacobian，相当于做多次矩阵连乘；当这些局部导数长期偏小，梯度就容易逐层衰减，出现梯度消失（Vanishing Gradient）；当它们长期偏大，又可能造成梯度爆炸（Exploding Gradient）。加入残差后，每一层的局部导数从 \(\frac{\partial f(x)}{\partial x}\) 变成了 \(I+\frac{\partial f(x)}{\partial x}\)，于是梯度不再只能依赖子层本身，而始终保留了一条沿恒等分支传播的主路径。可以把它概括成一句话：前向传播时保留原信息，反向传播时保留主梯度通路。这正是残差连接能显著缓解深层网络优化困难的根本原因。

这也是为什么残差连接几乎成为现代深网络的标准部件。对于非常深的模型，真正困难的并不是“单层表达能力不够”，而是层数增加后，前向信息更容易被后续变换不断改写，反向梯度也更容易在长链路中衰减或失稳。残差连接用一条恒等主路同时缓解了这两个问题：前向上保留原信息，反向上保留主梯度通路。因此，ResNet、Transformer、扩散模型乃至许多大型序列模型，都会把它作为主干结构的一部分。

标准残差连接默认只有一条主残差流：每层都在同一条表示通道上执行 \(x\mapsto x+f(x)\)。Hyper-Connections（HC）则把这条单通道残差流扩展成多通道残差流，使不同子流之间可以在层与层之间发生受控混合。若把第 \(l\) 层的多路残差状态记为 \(X_l\in\mathbb{R}^{n_{\text{hc}}\times d}\)，则 HC 可以抽象写成

这里 \(A_l\) 负责把多路残差流混合后送入子层 \(F_l\)， \(C_l\) 负责把子层输出写回多路残差流， \(B_l\) 则负责更新“残差主路本身如何在多路之间流动”。与标准残差相比，这相当于把单车道恒等高速路扩展成多车道互通系统：信息不再只能沿一条固定车道直行，而可以在若干并行残差流之间重新分配与汇合。

这类设计的收益是表达力增强。不同残差子流可以承担不同功能，有的更偏局部模式，有的更偏全局抽象，有的更像中间缓存或专家路由；层间的线性混合再把这些信息重新编排。但问题也随之出现：一旦 \(B_l\) 这类残差映射矩阵完全自由学习，原本标准残差中那条稳定的恒等主路就可能被破坏。于是多路残差虽然更灵活，却可能丢掉残差连接最宝贵的性质，即深层堆叠时对信号传播稳定性的保障。

DeepSeek 在这一点上引入了 mHC（Manifold-Constrained Hyper-Connections）。它的核心不是否定 Hyper-Connections，而是把其中最关键的残差映射 \(B_l\) 约束到一个具备稳定性的矩阵流形上。具体地，mHC 要求 \(B_l\) 位于双随机矩阵（Doubly Stochastic Matrix）构成的集合中：

这个约束意味着 \(B_l\) 的每一行和每一列都和为 1，而且所有元素非负。它不再允许残差主路做任意线性变换，而只能做一种“总量守恒的流间混合”。从矩阵角度看，这相当于要求残差信息在多条流之间重新分配时，既不能凭空放大，也不能通过正负抵消把主信号抹掉。

这类约束有三层直接好处。第一，双随机矩阵的谱范数满足 \(\|B_l\|_2\le 1\)，因此残差主路是非扩张的（Non-expansive），有助于抑制深层堆叠中的信号爆炸。第二，双随机矩阵在矩阵乘法下保持封闭；也就是说，多层残差主路连续相乘后，整体仍然保持同类结构，因此稳定性不会在深度方向上迅速丢失。第三，双随机矩阵构成所谓的 Birkhoff polytope，它等价于置换矩阵集合的凸包。这给出了非常清晰的几何解释：mHC 中的残差混合，本质上是在若干“重排残差子流”的方式之间做加权平均，而不是任意扭曲整条残差高速路。

若把标准残差看成只有一条车道，因此主路映射固定为 \(1\)；那么 mHC 的意义就是把系统扩展到多车道，但所有匝道与分流规则都必须满足“车流守恒、不会凭空放大、也不会相互抵消”的交通约束。这样一来，模型既获得了多路残差混合带来的表达力，又保住了恒等映射思想强调的稳定主路。这也是它与普通可学习残差混合最根本的区别。

在参数化与实现上，mHC 会先学习一个一般实矩阵，再通过类似 Sinkhorn-Knopp 的投影步骤把它拉回双随机矩阵流形，从而确保约束在训练过程中始终成立。DeepSeek V4 把这一路径用于大规模 Transformer 主干，实质上是在回答一个非常具体的问题：当模型层数、上下文长度和 MoE 结构都继续扩张时，残差连接如何在保留稳定性的前提下容纳更复杂的信息路由。mHC 给出的答案是：残差连接仍然是主干，但主干不必永远只有一条线；只要多路混合被限制在合适的几何约束内，残差主路依然可以稳定。

放回 DeepSeek V4 的整体结构里看，这种“多路残差混合”并不是只在层尾出现一次。图中的 Pre-Block Mixing、Residual Mixing 与 Post-Block Mixing，可以理解为 mHC 在 block 内不同位置的具体落地：进入注意力前先混一次，把多路残差流整理成当前子层更适合读取的输入；注意力后在残差主路上再混一次，决定新信息如何写回；进入 MoE 前再混一次，把表示重新组织成更适合专家路由与前馈扩展的形态。也就是说，mHC 并不只是给残差连接“加一个约束矩阵”，而是在每个 block 的读入、写回和子层衔接处共同维护多路残差流的稳定传播。

Transformer 主干（Backbone）本身的直接产物通常不是“类别”或“文字”，而是一组上下文化隐藏状态（Contextual Hidden States）。也就是说，在一次标准前向计算里，模型会先处理当前输入序列中的所有 token，把每个位置都编码成上下文化表示；若输入序列长度为 \(T\)，模型宽度为 \(d_{\text{model}}\)，经过最后一层后常得到：

其中 \(L\) 是 Transformer 层数，因此 \(H^{(L)}\) 表示“经过第 \(L\) 层之后得到的隐藏状态矩阵”； \(T\) 是当前序列的 token 数，所以这个矩阵一共有 \(T\) 行，每一行对应一个位置。若把第 \(t\) 个位置那一行单独记作 \(h_t^{(L)}\)，它表示的就是：第 \(t\) 个 token 在通过全部 \(L\) 层、吸收了上下文信息之后得到的最终向量表示。输出处理（Output Processing）的任务，就是把这组隐藏状态映射到具体任务所需的输出空间：可以是词表概率、类别分数、序列标签、起止位置分数，或回归数值。这里常说的读出（Readout），指的就是：主干网络先形成内部表示，再由最后的输出层把这种表示转换成任务空间里的可解释结果。更准确地说，Transformer 主干先产生整段序列的隐藏表示，再由具体任务的输出层决定如何读取这些表示：有的任务会逐位置读出，有的任务只取某个聚合位置；生成任务则在当前前缀对应的隐藏状态基础上，继续决定下一个 token 的输出。

最常见的输出处理是在线性读出（Linear Readout）层中，把 \(d_{\text{model}}\) 维隐藏状态投影到目标维度 \(d_{\text{out}}\)。若按 token 逐位置读出，可写成：

这里 \(H\in\mathbb{R}^{T\;\times d_{\text{model}}}\) 是最后一层隐藏状态； \(W_{\text{out}}\in\mathbb{R}^{d_{\text{model}}\;\times d_{\text{out}}}\) 是输出投影矩阵； \(b\in\mathbb{R}^{d_{\text{out}}}\) 是偏置； \(\mathbf{1}\in\mathbb{R}^{T}\) 是全 1 列向量，用来把同一个偏置加到每个位置； \(Z\in\mathbb{R}^{T\;\times d_{\text{out}}}\) 则是每个位置对应的输出分数。若任务是词表预测，则 \(d_{\text{out}}=V\)， \(V\) 是词表大小；若任务是 token 分类，则 \(d_{\text{out}}=C\)， \(C\) 是标签类别数。

并非所有任务都对每个 token 独立读出。序列分类常从整段序列中先取一个聚合表示，再做线性映射。例如 BERT 类模型常使用 \([\mathrm{CLS}]\) 位置的隐藏状态 \(h_{\mathrm{CLS}}\)，再输出：

其中 \(z\in\mathbb{R}^{C}\) 是整句的类别 logits。跨度抽取（Span Extraction）任务则常对每个位置分别给出“作为起点”和“作为终点”的分数；序列到序列任务中，解码器则对每个时间步读出一个词表分布。

在 Decoder-only 或 Encoder-Decoder 的生成端，输出处理通常还包含最后一次归一化层（如 LayerNorm 或 RMSNorm）以及语言模型头（Language Modeling Head, LM Head）。概念上可写成：

这里 \(\tilde H\in\mathbb{R}^{T\;\times d_{\text{model}}}\) 是最终归一化后的隐藏状态； \(W_{\mathrm{vocab}}\in\mathbb{R}^{d_{\text{model}}\;\times V}\) 是词表投影矩阵； \(Z\in\mathbb{R}^{T\;\times V}\) 是每个位置对整个词表的 logits。矩阵第 \(t\) 行 \(z_t\in\mathbb{R}^{V}\) 描述的是：当模型已经看到当前位置之前允许访问的上下文后，当前位置对每个候选 token 的偏好分数。

这里最后再做一次归一化，并不是多余的重复，而是把“主干内部的表示空间”整理成更适合词表读出的数值形态。Transformer 主干中的隐藏状态一路沿着残差流（Residual Stream）传播，虽然语义信息已经形成，但向量整体尺度仍可能随着层数、上下文和激活模式发生波动。若直接把 \(H^{(L)}\) 送入 \(W_{\mathrm{vocab}}\)，这些尺度变化会被直接放大到 logits 上，使 softmax 有时过尖、有时过平，输出分布与梯度都更难稳定。

最后一次归一化的作用，是在进入词表空间之前先把隐藏状态重新放回一个稳定坐标系里：一方面减弱“幅值忽大忽小”对 logits 的直接干扰，另一方面让 LM Head 更专注于“当前表示朝哪个语义方向更接近某个 token”，而不是过度依赖向量长度本身。换言之，主干网络负责把内容表示出来，最后的归一化负责把这种内容整理到一个尺度可控、便于读出的状态，再交给 \(W_{\mathrm{vocab}}\) 做最终投影。这也是许多现代 Decoder-only 大模型会在输出头前保留一层 LayerNorm 或 RMSNorm 的原因。

语言模型里常把输入嵌入表 \(E\in\mathbb{R}^{V\;\times d_{\text{model}}}\) 与输出头权重绑定为同一组参数。若不共享，输出头通常写成 \(W_{\mathrm{vocab}}\in\mathbb{R}^{d_{\text{model}}\;\times V}\)；若共享，则直接令

这不是把“两份数据塞进一个矩阵”，而是让同一个参数矩阵在前向计算的两个位置重复使用：输入阶段按 token id 取出 \(E\) 的某一行作为该 token 的嵌入；输出阶段则把隐藏状态 \(h\) 与所有 token 向量做点积，得到整张词表的 logits：

这里 \(z\in\mathbb{R}^{V}\)，第 \(i\) 个分量 \(z_i=h\cdot E_i+b_i\) 表示当前隐藏状态 \(h\) 与第 \(i\) 个 token 向量 \(E_i\) 的匹配分数。输入嵌入回答“这个 token 进来时长什么样”，输出头回答“当前语境最像词表里的哪个 token”；Weight Tying 让这两种词向量语义共用同一个坐标系。

这里共享的是参数。训练时，这张矩阵同时接收两类梯度：一类来自输入查表路径，更新当前 batch 真正出现过的 token 行；另一类来自输出 softmax 路径，推动隐藏状态与目标 token 更接近、与竞争 token 拉开。自动求导会把这两部分梯度加到同一份参数上，形成联合更新。因此它通常能减少参数量、增强输入与输出语义空间的一致性，并起到一定正则化（Regularization）作用。

只有在输入嵌入维度与输出读出维度一致时，这种共享才最直接。若模型在读出前额外引入了投影层，使输出维度不再等于 \(d_{\text{model}}\)，则需要先做维度变换，或不共享。Weight Tying 因而是常见做法，但不是所有架构都必须采用的硬规则。

输出处理的最后一步，是把 logits 变成任务可用的结果。训练时，很多损失函数会直接接收 logits，例如交叉熵损失（Cross-Entropy Loss）内部会把 softmax 与负对数似然（Negative Log-Likelihood）合并计算，以提高数值稳定性。推理时，则通常再做显式后处理：分类任务对 logits 做 softmax 或 sigmoid 得到概率；序列标注任务可在 logits 之上接 CRF 解码；生成任务则对词表 logits 做 softmax 后，再通过贪心搜索（Greedy Decoding）、束搜索（Beam Search）、Top-k 采样或 Top-p 采样等策略选择下一个 token。

以生成任务为例，若当前位置的词表 logits 为 \(z_t\in\mathbb{R}^{V}\)，则先得到条件分布：

这里 \(V\) 是词表大小， \(z_{t,i}\) 是第 \(t\) 个位置对第 \(i\) 个候选 token 的 logit， \(p(x_{t+1}=i\mid x_{\le t})\) 则是在当前前缀 \(x_{\le t}\) 下，下一个 token 取第 \(i\) 个词的概率。解码策略的区别，不在于 logits 或 softmax 公式不同，而在于：拿到这组概率之后，究竟用什么规则选出真正输出的 token。

贪心搜索（Greedy Decoding）是最直接的策略：每一步都选当前概率最大的那个 token。写成公式，就是

它的优点是速度快、实现简单、结果确定；缺点是过于短视。因为它每一步都只看“眼前概率最高”，而不考虑“当前稍差一点、但后续整体更优”的路径。于是贪心搜索很容易陷入局部最优：第一步看起来最稳的选择，不一定能导向整句概率最好的结果。

直觉上，它像每到路口都选眼前最宽的一条路，而不回头评估整条路线是否更通畅。因此贪心适合需要稳定、低延迟输出的场景，但在开放生成任务里往往较保守，也更容易重复。

束搜索（Beam Search）是在每一步同时保留多个高分候选前缀，而不是像贪心那样只保留 1 条路径。设束宽（Beam Width）为 \(B\)，则在第 \(t\) 步，算法会维护 \(B\) 条当前最优候选序列；每条序列再向外扩展多个 token，最后从所有扩展结果中重新筛出新的 \(B\) 条最高分路径继续前进。

若一条候选序列为 \(x_{1:T}\)，其常见打分方式是对数概率和：

因为概率连乘会非常小，所以实现里通常比较对数概率之和，而不是直接比较概率乘积。有时还会加长度惩罚（Length Penalty），避免模型系统性偏爱过短序列。

束搜索的优点是全局性比贪心更强，常用于机器翻译、摘要等更强调整体序列质量的任务；缺点是计算量更高，而且它本质上仍是“找高分路径”的搜索，不会主动引入随机性，因此输出可能仍然偏保守、偏模板化。

Top-k 采样（Top-k Sampling）先把概率最高的 \(k\) 个 token 保留下来，其余 token 概率全部截断为 0，然后在这 \(k\) 个候选里重新归一化并随机采样。设保留下来的候选集合为 \(\mathcal{K}_k\)，则采样分布可写成：

这里 \(p_i\) 是 softmax 后原始概率， \(\mathcal{K}_k\) 是当前概率最高的 \(k\) 个 token 集合。这样做的效果是：极小概率的长尾 token 不再参与抽样，从而降低胡言乱语或离谱跳转的风险；同时又保留了随机性，不会像贪心那样永远输出同一条路径。

Top-k 的关键超参数是 \(k\)。 \(k\) 太小，分布会重新变得接近贪心； \(k\) 太大，又会把很多低质量候选放回来。它本质上是在“稳定性”和“多样性”之间做硬截断式折中。

Top-p 采样（Top-p Sampling, Nucleus Sampling）不固定保留多少个 token，而是先按概率从高到低排序，再取最小的前缀集合 \(\mathcal{N}_p\)，使其累计概率至少达到阈值 \(p\)：

然后只在这个“概率核心区”里重新归一化并随机采样。与 Top-k 相比，Top-p 的保留集合大小是动态变化的：如果当前分布非常尖锐，可能只需要少数几个 token 就能覆盖 90% 或 95% 的概率质量；如果当前分布较平，保留下来的 token 数量就会自动增多。

这种自适应机制更贴合语言生成的实际状态：有些位置模型非常确定，例如固定短语或语法闭合，此时候选空间本来就应很小；有些位置模型不那么确定，例如开放内容展开，此时候选空间应更大。Top-p 因而通常比固定的 Top-k 更灵活，也是现代大模型推理中非常常见的采样策略。

温度（Temperature）常与上述采样策略配合使用。若把 logits \(z_{t,i}\) 除以温度 \(\tau\) 后再做 softmax，则有：

当 \(\tau<1\) 时，分布会变尖，模型更保守；当 \(\tau>1\) 时，分布会变平，采样更发散。于是，解码策略的工程取舍可以概括为：

• 贪心搜索：最快、最稳定，但最短视。
• 束搜索：更重视整句高分路径，但计算更贵、表达更保守。
• Top-k 采样：固定候选数，简单直接，易于控制长尾噪声。
• Top-p 采样：候选数自适应，通常更自然、更适合开放生成。

当温度设为 \(0\) 时，工程语境里通常就是把系统推向“只取当前最大概率 token”的极限，也就是接近贪心解码（Greedy Decoding）。若模型权重固定、算子实现固定、数值计算路径也完全固定，这种解码理论上应当是确定的；同一输入会得到同一输出。但在线推理系统里，结果仍可能出现轻微不一致，因为真实部署环境常包含非确定性来源（Non-determinism），例如并行归约时浮点加法顺序不同、不同硬件或 kernel 实现带来微小数值差异，以及服务端动态调度、缓存策略或批处理拼接方式改变了底层执行路径。

因此，\(\text{temperature}=0\) 只能说明“解码策略本身不再主动引入随机采样”，并不自动等于“整条推理链路绝对确定”。若业务确实需要强确定性，工程上通常还要同时满足几件事：禁用 Top-k、Top-p 等采样选项，固定随机种子（Seed）（若框架支持），并尽量启用确定性计算（Deterministic Kernels）或等价的确定性执行模式。换句话说，温度控制的是分布如何被取样，而强确定性还取决于数值计算路径是否也被锁死。

仅靠解码策略本身，往往还不足以避免模型进入重复、啰嗦或机械回环的状态。例如开放生成时，模型可能连续输出相同短语，或不断在几个近义表达之间打转。工程上因此常在 logits 层再加入一类后处理规则：对已经出现过的 token 施加惩罚，从而改变下一步的候选分布。

最常见的一类是重复惩罚（Repetition Penalty）。它的思想很直接：若某个 token 已经在当前上下文中出现过，就下调它再次被选中的倾向。实现细节在不同框架里略有差异，一种常见写法是对已出现 token 的 logit \(z_i\) 施加按符号分段的缩放：

这里 \(r\) 是重复惩罚系数。这样处理的目的，是在不破坏 logit 正负号语义的前提下，整体压低“已经出现过的 token 再次被选中”的优势。 \(r\) 越大，惩罚越强；过大则可能把正常重复也压掉，使输出变得生硬。

另一类常见控制项是 presence penalty（出现惩罚）与 frequency penalty（频次惩罚）。它们的共同目标是抑制重复，但力度来源不同：前者只关心“出现过没有”，后者关心“已经出现了多少次”。若原始 logit 为 \(z_i\)，token \(i\) 在当前已生成文本中的出现次数为 \(c_i\)，则一个常见抽象写法是：

这里 \(\lambda_{\mathrm{pres}}\) 是 presence penalty 系数， \(\mathbf{1}[c_i>0]\) 是指示函数：只要 token \(i\) 出现过至少一次，就减去一个固定惩罚； \(\lambda_{\mathrm{freq}}\) 是 frequency penalty 系数， \(c_i\) 越大，惩罚越强。因此：

• presence penalty 更像“出现过就提醒一次”，主要鼓励模型换新词、开新话题。
• frequency penalty 更像“出现越多罚越重”，主要抑制机械重复和啰嗦堆叠。

三者的作用位置都在 softmax 之前：先修改 logits，再重新归一化成概率。它们不是在训练阶段改变模型参数，而是在推理阶段临时改写候选分布。因此，它们更像输出控制器（Output Controller），而不是模型能力本身的一部分。

工程上，这些惩罚项通常与温度、Top-k、Top-p 一起调节。若目标是严谨、稳定、少跑偏的回答，常采用较低温度并只施加较轻的重复控制；若目标是创意写作或开放发散，则可能提高温度，同时保留较温和的 presence penalty，鼓励内容展开但避免原句循环。它们解决的不是“模型知不知道答案”，而是模型在已知概率分布下，最终说话风格如何被约束。

因此，Transformer 的“输出”需要分成两个层次理解。主干网络输出的是高维隐藏表示；真正面向任务的可解释结果，来自这些隐藏表示经过归一化、线性读出、概率映射与解码后的最终读出。输出处理连接了通用表示学习与具体任务目标，是 Transformer 从“会表示”走向“会预测、会生成、会决策”的最后一跳。

语言模型（Language Model）是对自然语言序列概率分布进行建模的模型。给定一段上下文，它学习并估计后续词元（token）或整个序列出现的概率，从而捕捉语言中的词法、语法、语义以及长程依赖结构。现代语言模型通常由参数化神经网络实现，其本质是把语言规律压缩进一个可计算的概率模型中。

从严格定义看，语言模型处理的对象是有顺序的 token 序列，而不是无序词集合。若把一句话写成 \(x_1,x_2,\dots,x_T\)，语言模型的核心任务就是为这段序列分配概率；等价地，它也可以被看成在每一步根据已有上下文估计下一个 token 的条件概率。

这一定义说明了为什么语言模型天然关心词序、上下文依赖与条件生成。无论后续采用 n-gram 统计模型还是 Transformer，本质上都在近似这类序列概率分布。

这里的分词（Tokenization）指的是：把原始文本切分成模型实际处理的 token 序列，并据此映射到词表（Vocabulary）中的离散 id。它服务于语言模型建模本身，决定模型看到的基本单位是什么。

这与全文检索（Full-text Retrieval）里的“分词”不是同一个概念。检索系统里的分词更强调索引构建、倒排表匹配与查询召回；语言模型里的 tokenization 更强调如何把文本编码成适合训练与推理的离散序列。一个 token 不一定等于自然语言里的“词”，它也可能是子词、单字、标点、空格片段，甚至字节。更具体的 tokenizer 类型与工程差异，见 Transformers 部分的

Tokenization

词袋模型（Bag of Words, BoW）本质上只做一件事：统计一段文本里各个词出现了多少次，或只记录它是否出现。它把文本表示成词表上的计数向量 \(\mathbf{c}\in\mathbb{R}^{|\mathcal{V}|}\)，其中每一维对应某个词的出现次数。除了这些词频统计之外，BoW 不保留任何顺序信息，也不建模句法结构、上下文依赖或条件概率。

因此，BoW 严格说并不是语言模型，而是一种早期文本表示方法。它常与朴素贝叶斯（Naive Bayes）、逻辑回归（Logistic Regression）或 TF-IDF 一起用于文本分类、检索和主题分析。它的重要性在于：它展示了“先把文本映射成向量，再交给下游模型处理”的经典思路；但由于它仅仅统计词是否出现以及出现次数，无法区分“我喜欢你”和“你喜欢我”这类序列差异，也不能承担现代语言模型那种条件生成任务。

词嵌入（Word Embedding）把每个词映射到一个低维稠密向量。与 BoW 的计数统计不同，词嵌入不再把每个词看成彼此独立的离散符号，而是让共现模式或语义相近的词在向量空间里彼此接近。Word2Vec、GloVe 和 FastText 都属于这一类方法。

经典词嵌入通常是静态的：同一个词在任何上下文里共享同一个向量。以

bank

open a bank account

sit on the river bank

句子嵌入（Sentence Embedding）进一步把整句或整段文本表示为一个向量。它关注的不再是单词层面的局部语义，而是整个输入的综合语义，常用于分类、检索、匹配与聚类。

历史上，基于循环神经网络（Recurrent Neural Network, RNN）的序列到序列模型（Sequence-to-Sequence, Seq2Seq）曾经采用“先编码成一个固定长度向量，再由解码器生成输出”的路径。Sutskever、Vinyals 和 Le 在 2014 年提出的 Seq2Seq 工作，就用深层 LSTM 把输入序列压缩为固定维度向量；这种单向量压缩在长句上容易形成信息瓶颈，而 RNN 本身的串行计算方式也限制了并行效率，并使长程依赖建模变得困难。Bahdanau、Cho 和 Bengio 在 2014 年提出的注意力机制（Attention Mechanism）开始缓解这一问题：解码器在每一步都能直接参考输入序列的不同位置，而不必把整句信息全部压缩进单一向量中。

真正的结构转折点来自 2017 年的 Attention Is All You Need。这篇论文提出了 Transformer 架构，用自注意力（Self-Attention）替代 RNN 的递归路径，使模型更擅长并行训练，也更有效地建模长距离依赖。当前主流句子嵌入方法，通常都建立在 Transformer 之上：无论是编码单句得到表示的 Encoder-only 模型，还是用于检索的双编码器（Bi-Encoder）结构，如 SBERT、E5、BGE 和 text-embedding 系列，都属于这一路线的延伸。

从表示形式看，无论词嵌入还是句子嵌入，本质上都属于稠密向量：用较低维的实值向量承载词、句子或文档的信息。向量的每一维不再直接对应某个具体词，而是由训练过程自动学习得到；因此，模型可以把共现模式、语义相似性以及部分上下文规律压缩进连续向量空间。

这也是后文嵌入模型（Embedding Model）、Word2Vec、Sentence-BERT 和 text-embedding 系列的共同基础。它们的差异在于：表示对象是词、句子还是文档，训练目标是预测上下文、对比学习还是任务特化微调；但核心思想一致，都是让语义结构在向量空间中变得可计算。

上述内容回答的是“文本如何被表示”。回到语言模型本身，还需要进一步区分模型究竟在学什么、输出什么、内部结构如何组织，以及它在工程系统中承担什么角色。

理解语言模型时，至少需要区分四个互相独立但彼此关联的维度：第一，模型在预训练时学的是什么；第二，模型最终主要输出什么；第三，模型内部的信息流结构如何组织；第四，模型在工程上是通用基座、指令对齐模型，还是任务特定模型。它们回答的是四个不同问题，因此一个模型完全可以同时拥有多重身份。例如，BERT 可以同时被描述为“掩码语言模型（Masked Language Model, MLM）+ 表示模型（Representation Model）+ Encoder-only 模型”；GPT / Qwen / LLaMA 则通常是“自回归语言模型（Autoregressive Language Model）+ 生成模型（Generative Model）+ Decoder-only 模型”。

按预训练目标分类，关注的是模型在大规模无标注文本上被要求完成什么自监督任务。这一维决定了模型最初学会的信息组织方式，但不直接等价于它最终能做什么任务。最经典的两类是掩码语言模型与自回归语言模型。

两者的差异首先体现在条件概率分解方式上。自回归语言模型直接建模整段文本的联合概率：

这里 \(x_t\) 是第 \(t\) 个 token， \(x_{<t}\) 表示它之前所有 token；模型在第 \(t\) 步输出的是“下一个 token 的词表分布”。掩码语言模型则不是按固定顺序展开整句，而是在输入中随机挑出若干位置 \(M\) 做遮蔽，训练目标可写成：

其中 \(M\) 是被遮住的位置集合， \(x_{\setminus M}\) 表示其余未遮住 token。它学到的是“给定上下文，如何恢复缺失信息”，而不是“如何一步步把整段文本续写出来”。因此，MLM 天然更偏表示学习；ARLM 天然更偏生成建模。

这一维并不只有两类。ELECTRA 的替换检测（Replaced Token Detection, RTD）不直接恢复 mask，而是判断 token 是否被替换；T5、BART 的去噪重建（Denoising Reconstruction）则通过破坏输入再让模型恢复原文。因此，“掩码 vs 自回归”是最核心的一条主线，但不是全部可能性。

按输出与用途分类，关注的是模型最终主要产出什么，以及这些产出在工程系统里被如何使用。这里最容易混淆的是“嵌入模型”和“表示模型”。两者都能产出向量，但优化目标和默认使用方式并不相同。

嵌入模型的关键特征是：它的向量空间本身就是最终产品。用户真正拿来用的是向量之间的距离、余弦相似度或最近邻结构。表示模型则更像通用特征提取器：它输出的隐藏状态通常还要再接一个任务头（Task Head）或额外池化层，才能变成分类分数、序列标签或其他任务结果。生成模型的最终输出则是一个条件词表分布，经过解码后形成文本或结构化序列。

同一底座模型有时可以被改造成不同用途。例如，BERT 原本是表示模型，但经过对比学习和专门池化后可以变成句向量嵌入模型；Decoder-only 大模型原本是生成模型，但也可以通过取隐藏状态做 embedding。不过从默认训练目标与最强项看，这三类仍然应当区分。

按架构分类，关注的是模型内部如何读取上下文，以及输入和输出是如何在网络中流动的。这一维对应的是结构设计，而不是预训练目标本身。

这一维与前两维经常联动，但不是一一对应。Encoder-only 模型常与 MLM 或 RTD 结合，Decoder-only 模型常与自回归目标结合，Encoder–Decoder 模型则常与去噪或条件生成目标结合；但它们分别回答的是“结构长什么样”和“训练时学什么”的两个不同问题。

在工程落地中，还需要区分模型处于哪种产品化形态。通用预训练基座（Base Model）强调语言知识与可迁移能力；指令对齐模型（Instruction-tuned Model）强调遵循人类指令、对话风格与格式约束；任务特定模型（Task-specific Model）则围绕某个明确监督目标继续微调，并常配合专门任务头工作。

把四个维度合在一起看，模型的定位会变得清晰得多：

• BERT：更接近 MLM + 表示模型 + Encoder-only + 常作为任务特定模型底座。
• SBERT 或 BGE：更接近 表示 / 对比学习 + 嵌入模型 + 常为双编码检索结构。
• GPT / Qwen / LLaMA：更接近 自回归 + 生成模型 + Decoder-only + 常见指令对齐形态。
• T5 / BART：更接近 去噪或 text-to-text 目标 + 生成模型 + Encoder–Decoder。

到 2026 年，表示型语言模型（Representation Model）的工程格局已经明显分成两条主线。第一条是以 Encoder-only 为核心的判别式表示模型，主要服务于分类、自然语言推断（Natural Language Inference, NLI）、命名实体识别（Named Entity Recognition, NER）、抽取式问答等理解任务；第二条是专门为句向量、检索、聚类和召回设计的嵌入模型。前者仍沿着 BERT 家族演化，后者则越来越多地直接采用 BGE、E5、Qwen3-Embedding、jina-embeddings 这类专门路线。因此，讨论“更好的表示模型”时，必须先区分目标到底是任务头微调，还是直接产出高质量向量表示。

BERT（Bidirectional Encoder Representations from Transformers）是典型的 Encoder-only 模型：用双向注意力做表示学习，预训练目标以掩码语言建模（Masked Language Modeling, MLM）为主。原始 BERT 还包含下一句预测（Next Sentence Prediction, NSP）任务：输入通常写成句段 A [SEP] 句段 B，模型需要根据最终的

[CLS]

[CLS]

但这里必须把两件事分开。

[CLS]

[CLS]

[CLS]

[CLS]

不过，

[CLS]

[CLS]

[CLS]

这也是它不能自然代替显式池化（Explicit Pooling）的根本原因。显式池化会把所有 token 的隐藏状态用平均、最大值或加权汇聚的方式整合成句向量，例如平均池化可写成

这里每个 token 的最终表示都会直接进入句向量构造过程；而

[CLS]

从几何上看，这个差异会进一步表现为表示各向异性（Anisotropy）：原始 BERT 的

[CLS]

[CLS]

BERT 以及其他表示型语言模型通常先在海量通用语料上做预训练，从而学到词法模式、句法结构、语义关系以及一定程度的世界知识。正因为这些知识不是为某一个具体任务单独学习出来的，它们非常适合作为通用特征提取器（General-purpose Feature Extractor）：在迁移学习框架下，只需接上分类头、序列标注头或匹配头，并在目标任务数据上继续微调，就可以把通用表示快速适配到具体自然语言处理任务。

BERT系列“是否支持中文”关键在词表与分词器（Tokenizer）。英文 BERT-base 的 WordPiece 词表主要覆盖英文子词；对中文文本可能会大量落到 \([\mathrm{UNK}]\) 或被切成极碎片段，效果通常不理想。要做中文任务更常用中文 BERT、mBERT（multilingual BERT）或以 SentencePiece 为主的多语模型。

RoBERTa（Robustly Optimized BERT Approach）延续 BERT 的 Encoder-only 架构，但通过更大规模数据与训练配方改进（例如更长训练、更大 batch、动态 masking、移除或弱化 NSP 等）显著提升表示质量。它的工程意义在于：在不改变基本架构的前提下，训练细节足以带来可观收益。

RoBERTa 证明了一个重要事实：Encoder-only 模型的性能上限，不完全取决于“是否换了新架构”，训练数据规模、batch 策略、masking 方式和目标设计本身就足以显著改变表示质量。

chinese-roberta-wwm-ext

从工程历史看，它是 2020 年前后到 2022 年中文 NLU 的事实标准之一：社区验证充分，微调范式成熟，适配文本分类、句对匹配、自然语言推断（Natural Language Inference, NLI）与命名实体识别（Named Entity Recognition, NER）都非常稳定。到 2026 年，这个模型的优势仍然清晰存在：中文语料预训练充分、生态成熟、部署经验丰富、对中小规模监督数据通常相当稳健。它特别适合作为中文闭集理解任务的经典强基线，用于给新模型或新训练策略提供可复现、低风险的比较参考。

它的局限也同样明确。架构主体仍然停留在 BERT-base 时代：上下文长度通常围绕 512 token，长文档处理能力有限；注意力与推理路径没有吸收长上下文时代的高效实现；分词与词表路线也仍属于较早一代中文 Encoder 设计。因此，若把它放到 2025-2026 年的主流表示模型谱系里，更准确的定位是成熟、稳定、中文友好的经典底座，而不是长上下文或现代高吞吐判别式编码器的前沿代表。

替代方案的选择应按目标分层。若目标仍是中文单语分类、NER、句对匹配，且优先级是稳定微调与成熟生态，那么继续使用

chinese-roberta-wwm-ext

围绕

chinese-roberta-wwm-ext

这一层的替换更像是在相近预算内调整预训练目标、词表与工程实现。收益通常来自更合适的中文训练配方或更现代的编码实现，而不是简单的“参数更多”。若现有系统已经有成熟的特征聚合层、样本构造策略或 MIL 结构，encoder 升级未必自动转化成同幅度任务收益。

若任务真正受限于表达容量而不是训练配方，扩大 encoder 往往比在多个 base 模型之间横向切换更容易带来可见提升。代价也非常直接：显存、延迟、吞吐和微调稳定性压力都会同步上升。因此 large 路线适合作为“资源换上限”的升级，而不是默认替代。

ELECTRA（Efficiently Learning an Encoder that Classifies Token Replacements Accurately）仍属于 Encoder-only 模型，但它不再让主模型只做“把被遮住的词猜出来”的掩码语言建模（Masked Language Modeling, MLM）。它先用一个较小的生成器替换部分 token，再让主模型判断每个位置上的 token 是原词还是替换词，这就是替换检测（Replaced Token Detection, RTD）。这种训练方式让模型几乎在每个 token 上都获得监督信号，因此在相近预训练预算下通常比纯 MLM 更高效。

DeBERTa（Decoding-enhanced BERT with Disentangled Attention）可以看作对 BERT / RoBERTa 的一次结构级强化。它仍然是典型的判别式 Encoder-only 语言模型，因此特别适合文本分类、自然语言推断（Natural Language Inference, NLI）、命名实体识别（Named Entity Recognition, NER）和情感分析等理解类任务；但它不满足于只靠“更大数据、更长训练”来变强，而是直接对注意力机制本身做了精细改造。

它最核心的突破是解耦注意力（Disentangled Attention）。在传统 BERT 中，词的内容信息与位置信息通常会较早融合；DeBERTa 则把“这个 token 是什么”和“这个 token 在哪里”分开处理。对位置 \(i\) 与 \(j\) 的注意力打分，可直观写成三部分：

其中 \(C_i\) 表示第 \(i\) 个位置的内容表示（Content Representation），\(P_{j|i}\) 和 \(P_{i|j}\) 表示相对位置表示（Relative Position Representation）。这个拆分的意义在于：模型不必把“词义”和“位置”混成一个整体再去匹配，而可以更精细地学习“哪个内容会关注什么位置关系”。对于短语修饰、依存关系和实体边界判定这类任务，这种改造往往更有利。

DeBERTa 的第二个关键设计是增强型掩码解码器（Enhanced Mask Decoder, EMD）。它的动机是：相对位置固然重要，但在掩码预测时，绝对位置有时也能提供额外信息。因此 DeBERTa 在接近输出端的位置再次显式注入绝对位置信息，让模型在做 MLM 预测时同时利用相对与绝对位置信号。这相当于在保持主体编码过程解耦的前提下，在最后的“读答案”阶段补上一层位置提醒。

从工程结果看，DeBERTa 长期是判别式 NLU 的强基线之一。它的重要性不只在于“分数更高”，还在于它说明了一个事实：Encoder-only 模型的上限不只是由数据和算力决定，内容表示、位置表示和解码方式本身的结构设计也会显著影响表示质量。后续的 DeBERTa-V3 又把替换检测（RTD）这类更高效的预训练目标引入进来，进一步改善了训练效率与效果，使其在很多精细理解任务里依然保持很强竞争力。

ModernBERT 代表的是 BERT 风格双向编码器在 2025 年之后的一次现代化重写。它仍然属于 Encoder-only，但不再停留在 2018 年 BERT 的上下文长度、注意力实现和推理路径上，而是把长上下文支持与现代高效实现直接纳入底座设计。其官方模型卡给出的关键信息包括：预训练规模达到 2T tokens，原生上下文长度扩展到 8192 token，并引入 RoPE、本地-全局交替注意力（Local-Global Alternating Attention）、unpadding 和 Flash Attention 等现代工程机制。

与原始 BERT 还有一个重要区别在于

[CLS]

[CLS]

这类改造的意义非常直接。传统 BERT 家族最舒服的输入长度通常仍停留在几百 token 到一两千 token 量级，而 ModernBERT 这一路则把长文档分类、长文本检索、代码检索和大段上下文理解一并纳入可用范围。于是，在英文或以英文 / 代码为主的判别式任务里，ModernBERT 往往比 DeBERTa-V3 更接近 2026 年的默认新基线；DeBERTa-V3 仍然是高质量经典强基线，但 ModernBERT 明显更符合当前对长上下文与吞吐效率的要求。

它的交替局部-全局注意力也进一步改变了人们对

[CLS]

[CLS]

[CLS]

多语表示模型的选型逻辑与英文单语场景并不完全相同。XLM-R（XLM-RoBERTa）仍然是经典多语 Encoder-only 基线之一：其预训练覆盖 100 种语言，核心价值是把多语文本映射到共享表示空间，再用于序列分类、序列标注和问答等下游任务。mDeBERTa-V3 则把 DeBERTa-V3 的结构与训练目标迁移到多语场景，在跨语言自然语言推断等零样本迁移任务上，相比 XLM-R-base 给出更强的官方基线结果。因此，若目标是稳定、成熟、适合任务头微调的多语编码器，XLM-R 与 mDeBERTa-V3 依然是 2026 年非常现实的主流选择。

更前沿的一支则沿着 ModernBERT 的方向继续推进。2025 年发布的 mmBERT 直接把 ModernBERT 的现代编码器路线扩展到大规模多语场景，官方介绍强调其训练覆盖 3T 以上 token 和 1800 多种语言，并把它定位为首个在性能和速度上同时明显超过 XLM-R 的新一代多语编码器。这说明多语表示学习也正在从“经典 XLM-R 世代”向“ModernBERT 世代”迁移，只是就生态成熟度与工程复用性而言，XLM-R / mDeBERTa-V3 仍然更稳，mmBERT 更像下一阶段的高端新底座。

因此，到 2026 年若任务是分类、序列标注、NLI 或抽取式问答，主流候选通常已经变成 DeBERTa-V3、ModernBERT，以及多语场景下的 XLM-R / mDeBERTa-V3。若任务明确是中文单语理解，

chinese-roberta-wwm-ext

GPT 系列是典型 Decoder-only：以 CLM（自回归 next-token）为主目标，把各种任务统一为“续写”。工程上其优势来自统一接口与强 in-context learning；代价是推理成本高（尤其长上下文与高并发场景）。

LLaMA 系列是开源 Decoder-only 基座的重要代表，强调稳定的训练配方与生态可用性（tokenizer、推理支持、微调社区）。它常作为“可控、可复现”的研究/工程基线，用于 SFT、LoRA、RAG 与本地部署。

Qwen 系列同属开源 Decoder-only 生态，中文与多语言能力通常更受关注；在工具调用、代码与多模态等方向也有较多衍生版本。工程上，它常被用作中文业务与多语言场景的基座候选。

Mistral 系列强调“更高性价比的推理与训练”：通过架构与工程优化在相近成本下获得更强的生成质量与吞吐表现，常见于高并发推理与轻量级部署场景。

DeepSeek 系列更强调训练与推理效率的极致：在注意力 KV 压缩、稀疏结构（MoE）与训练目标（如 Multi-Token Prediction）等方向探索更激进的工程取舍，目标是在同等算力预算下提升有效容量与上下文能力。

若从 block 级结构看，DeepSeek V4 的主干并不是“普通 Transformer 换一个注意力模块”这么简单，而是把三条路线绑在同一层里协同工作：CSA / HCA 负责注意力，mHC 负责多路残差混合，DeepSeekMoE 负责前馈容量扩展。一层的阅读顺序可以概括为：输入 token 先进入 embedding；随后经过 mHC 的 Pre-Block Mixing，把多路残差流混合后送入当前 block；注意力子层再按层使用 CSA 或 HCA；其输出经过 Residual Mixing 写回残差主路；接着通过 Post-Block Mixing 送入 DeepSeekMoE；MoE 输出再写回主干，进入下一层。换句话说，V4 的每个 Transformer block 内部实际上是“混合注意力 + 流形约束残差 + 稀疏 MoE”的三件套，而不是单一算子主导全层行为。

这也解释了 CSA 与 HCA “如何交替堆叠”这个问题。它们并不是游离在模型外部的长上下文外挂，而是 block 内部的注意力实现位。某一层装配的是 CSA，这一层就更偏向“压缩后召回重点块”；某一层装配的是 HCA，这一层就更偏向“极粗粒度地扫全局背景”。而同一层前后的 mHC mixing 与 DeepSeekMoE 保持不变，于是模型能够在同一主干框架里，让不同层承担不同的阅读粒度，同时继续依靠统一的残差主路和稀疏专家容量维持深层表达。

在训练端，DeepSeek V4 也不是只在最后接一个普通 LM Head。其顶层除标准语言模型损失外，还叠加了多 token 预测（Multi-Token Prediction, MTP）这一辅助监督信号。于是从整体上看，V4 的设计是四层联动的：注意力层解决百万上下文，mHC 解决深层稳定性，MoE 解决有效容量，MTP 解决训练信号密度。也正因为这几部分是一起设计的，DeepSeek V4 不能被简单归类成“只是 MLA 的延伸”或“只是更大的 MoE 模型”。

Word2Vec 用一个简单的自监督目标（Self-supervised Objective）学习词向量（Word Embeddings）：监督信号来自文本的共现上下文（Context），而不是人工标签。

它可以理解为学习两个嵌入表：输入词向量 \(V\in\mathbb{R}^{|{\cal V}|\times d}\) 与输出词向量 \(U\in\mathbb{R}^{|{\cal V}|\times d}\)（\(|{\cal V}|\) 为词表大小）。训练结束后，常用 \(V\)（或 \((V+U)/2\)）作为词向量。

Word2Vec 有两种经典训练方式：CBOW（Continuous Bag of Words）根据上下文预测中心词，Skip-gram 则根据中心词预测上下文。二者的预测方向相反，但都利用局部共现关系学习词向量。下面以 Skip-gram 为例说明它最核心的训练机制。

Word2Vec 的样本不是人工标注出来的，而是通过滑动窗口（Sliding Window）在语料上自动生成。设窗口半径为 \(m\)，当滑动窗口扫到位置 \(t\) 时，中心词 \(x_t\) 会与它左右 \(m\) 个位置内的上下文词组成正样本对；越靠近句首句尾，可用上下文自然会变少。对单个中心词，Skip-gram 的局部目标可写成：

这意味着：窗口每向前滑动一步，模型就把“中心词与邻近词共同出现”当作新的监督信号。CBOW 则反过来，把窗口内多个上下文词聚合起来预测中心词；但两者的训练样本都来自同一套滑动窗口机制。

在 Skip-gram 中，给定中心词（center word）\(w_c\)，预测窗口内的上下文词（context word）\(w_o\)。若用 full softmax：

如果保留这个完整 softmax，模型会被迫在整个词表上做归一化比较；真实上下文概率升高时，其他词的概率就必须相应下降。但如果改成更便宜的“只学习哪些词对是真的”而又只提供正样本，模型就会立刻出现投机空间：它完全可以把几乎所有词对都打成高分，因为目标里从来没有人告诉它哪些配对是假的。换句话说，只基于正样本训练一个二分类式共现目标，最容易学到的不是语义结构，而是“永远预测真”。

因此，实践里常用负采样（Negative Sampling）：对每个正样本对 \((w_c,w_o)\)，再随机采样 \(K\) 个噪声词 \(w_k\)，把 \((w_c,w_k)\) 当作负样本，并最大化

第一项要求真实共现词对的内积更大，第二项要求随机噪声词对的内积更小。这样模型学到的就不再是“所有词都彼此相似”，而是“哪些词在局部上下文里更可能共同出现”。这里的“模型参数”主要就是这些词向量；模型输入通常是 token id（或 one-hot）经查表得到的 \(v_{w_c}\)。

Word2Vec 的负样本通常也不需要过度精心设计。经典做法就是按词频分布的 \(0.75\) 次方做随机采样，让高频词仍然更常被抽到，但不会垄断全部负样本。它的核心目标不是构造“最难反例”，而是持续给模型提供足够多的噪声对照，让真实共现和随机拼接之间产生可学习的区分。后来的对比学习常会显式挖掘 hard negatives，但在经典 Word2Vec 里，简单而稳定的随机负采样通常已经足够有效。

GloVe（Global Vectors for Word Representation）用全局共现统计学习词向量：目标是让词向量的内积拟合共现概率（或其对数）。与 Word2Vec 相比，它更强调全局统计的一致性；但二者都属于“静态词向量”（Static Embedding），无法像 Transformer 那样根据上下文动态改变词义表示。

Sentence-BERT（SBERT）是文本嵌入（Text Embedding）中的经典双编码器（Bi-Encoder / Dual Encoder）范式。它与后面的 text-embedding 系列并不是两种不同任务；二者都把文本映射为向量，用于相似度计算、检索、聚类与召回。区别主要在于：SBERT 更像一条开源方法路线，而 text-embedding 系列更像近年的通用嵌入模型或 API 产品家族。

在 SBERT 之前，句子嵌入任务通常沿用交叉编码器（Cross-Encoder）+ BERT 的范式实现相似度建模：把两个句子同时输入 Transformer 网络，常见形式是将句子 A 与句子 B 拼接成单个序列，中间用分隔符隔开，然后在原始 BERT 顶部增加分类头或回归头，直接输出这一对句子的相似度分数。这种架构的优势在于两个句子的 token 可以在同一次自注意力计算中充分交互，因此非常擅长做细粒度匹配判断；但它输出的是“句对分数”，而不是两个可独立复用的句向量。

这会直接带来大规模计算问题。若要在一个包含 10000 个句子的集合中找出相似度最高的匹配对，交叉编码器原则上需要对几乎所有句对分别做一次联合编码，计算量约为 \(\frac{10000\times 9999}{2}=49{,}995{,}000\) 次前向比较。也就是说，问题规模从“编码 10000 个句子”膨胀成了“编码近五千万个句对”。由于每个候选句子都必须与其他句子重新拼接、重新过一遍 BERT，这类方法几乎无法承担大规模语义检索、聚类或召回的第一阶段计算。SBERT 的关键突破，正是在保留 BERT 语义建模能力的同时，把句子表示改造成可预先编码、可缓存、可直接做余弦相似度比较的独立向量。

因此，SBERT 的核心价值首先体现在计算结构的改变上：它把原本“对句对打分”的问题，改写成“分别编码句子，再比较向量距离”的问题。这样一来，候选句子可以预先编码并缓存，检索阶段只需要做向量相似度计算，而不必让每一对候选都重新经过一次完整的 BERT 联合编码。

它与 Cross-Encoder 的关键差异在于计算结构：

• 双编码器：两个输入分别编码，可离线预计算候选向量，适合大规模检索（ANN）。
• 交叉编码器（Cross-Encoder）：把两个输入拼接后一起编码，匹配更精细但无法离线索引，适合重排序（Reranking）。

在结构上，SBERT 的核心是孪生架构（Siamese Architecture）：两侧使用一模一样的编码器，参数完全共享，但分别接收一个句子作为输入。训练时，句子对会分别经过这两个共享权重的编码塔，各自得到固定维度的句向量，再基于余弦相似度、三元组损失（Triplet Loss）或对比损失（Contrastive Loss）优化距离关系。共享权重保证了两个句子被投射到同一个表示空间中，因此向量之间的距离才具有可比较性。

SBERT 的训练过程可以拆成两个步骤。第一步是把每个句子单独编码成向量。设句子 \(x=(t_1,\dots,t_n)\)，经过共享编码器后得到逐 token 的隐藏状态 \(H=[h_1,\dots,h_n]\)；随后用池化（Pooling）把它压缩成句向量 \(e(x)\in\mathbb{R}^d\)。经典实现最常用平均池化：

有些实现还会继续做 L2 归一化，得到 \(\hat e(x)=e(x)/\|e(x)\|_2\)，以便后续直接用余弦相似度比较方向。这里的关键点是：左右两侧并不是两套不同模型，而是同一组参数共享的编码器分别处理句子 A 和句子 B，最终得到 \(\hat e_a\) 与 \(\hat e_b\) 两个可独立复用的句向量。

训练语料的形状也必须与损失函数匹配。最常见的几类数据形式如下：

• 带连续分数的句对：形如 \((x_a,x_b,y)\)，其中 \(y\) 是 0 到 1、或 0 到 5 再归一化后的语义相似度分数。这类数据最适合 STS（Semantic Textual Similarity）任务，监督信号不是“是不是同类”，而是“到底有多像”。
• 二元正负句对：形如 \((x_a,x_b,y)\)，其中 \(y\in\{0,1\}\)。这里 \(y=1\) 表示复述句、同义问法、相关 query-document 或其它正样本对；\(y=0\) 表示语义无关、错误匹配或人工拒绝的负样本对。
• 检索式正配对：形如 \((q,p)\)，只显式给出 query 与其正确匹配的正样本，不单独列出负样本。训练时，通常把同一 batch 中其它 \(p_j\) 当作 \(q_i\) 的负例，这就是批内负样本（In-batch Negatives）的基本数据组织方式。
• 三元组：形如 \((a,p,n)\)，其中锚点 \(a\) 与正样本 \(p\) 应靠近，而与负样本 \(n\) 应拉开距离。这类数据天然适合排序与检索，因为它直接表达了“哪个比哪个更相关”。

因此，SBERT 训练并不要求数据必须带精确分数；它既可以吃连续相似度打分，也可以吃正负标签，甚至只需要 query-positive 配对或三元组。真正关键的是，训练样本必须能清楚告诉模型：哪些句子应该靠近，哪些句子应该远离，以及这种关系是绝对打分还是相对排序。

第二步是根据标注关系定义损失。若训练数据给的是连续相似度分数，例如 0 到 1 之间的语义相似度标签 \(y\)，最直接的做法是先计算两向量的余弦相似度

再让模型输出的相似度逼近人工标签，例如最简单的回归式目标可以写成

这时，相似句子的标签 \(y\) 更高，损失会推动两向量余弦相似度上升；不相似句子的标签更低，损失则推动相似度下降。原始 SBERT 在 STS（Semantic Textual Similarity）类任务上，常用的正是这种“句对回归到相似度分数”的训练方式。

若训练数据只有二元标签，即“相似”或“不相似”，则更常见的是对比式损失（Contrastive Loss）。设距离 \(d(\hat e_a,\hat e_b)\) 可以取欧氏距离，也可以取 \(1-\cos(\hat e_a,\hat e_b)\)，则典型形式为

其中 \(y=1\) 表示正样本对，损失会逼迫距离变小；\(y=0\) 表示负样本对，损失会要求两句至少相隔一个 margin \(m\)。这就把“相似句子拉近，不相似句子推远”写成了显式几何约束。

若任务更接近检索或召回，现代实践更常用批内负样本（In-batch Negatives）或多负样本排序损失（Multiple Negatives Ranking Loss）。设一个 batch 中第 \(i\) 个查询句子的正样本是 \(p_i\)，其余 \(p_j\) 都视为负例，则可写成

其中 \(\tau\) 是温度（Temperature）参数。这个目标并不需要显式为每个查询单独准备大量负样本，而是直接把同一 batch 里的其它正样本当作自己的负样本；于是优化方向很清楚：正确配对的句子相似度必须高于 batch 中所有错误配对。许多现代 embedding 模型，包括大量 SBERT 派生模型，都是沿着这条路线训练出来的。

另一类经典形式是三元组损失（Triplet Loss）。它不再只看一对句子，而是同时给出锚点 \(a\)、正样本 \(p\) 和负样本 \(n\)，要求锚点与正样本的距离小于锚点与负样本的距离，且至少留出一个 margin：

它表达的仍然是同一个原则：相似句子靠近，不相似句子远离；只是监督信号从“单对标签”变成了“相对排序关系”。

前文已经提到，原始 BERT 的

[CLS]

这里也需要区分 Sentence-BERT 与 sentence-transformers。前者更严格地指 2019 年提出的 SBERT 方法路线：在 BERT、RoBERTa 等编码器基础上，通过孪生网络（Siamese Network）/三元组网络（Triplet Network）或后续对比式训练，把原本不适合作为通用句向量的表示空间改造成更适合相似度计算的句向量空间。后者则主要指围绕这一路线发展出来的开源框架与模型生态，用于统一训练、评测、发布和调用各类句向量模型。因此，sentence-transformers 不是与 SBERT 并列的另一类基础模型，而更像 SBERT 方法在工程上的延伸与集合。

从工程角度看，SBERT 仍然有明确实用价值：它特别适合私有化部署、领域微调、本地低延迟语义检索，以及“双编码器召回 + Cross-Encoder 重排”的两阶段检索流水线。它不是被现代 embedding 模型淘汰，而是在开源可控、可微调、可离线部署这些约束下依然非常常用。

如果把 SBERT 看作“如何训练和使用句向量”的经典范式，那么 text-embedding 系列代表的就是近年的通用嵌入模型实现。BGE、E5、GTE、OpenAI 的 text-embedding、Cohere Embed 等，本质上都属于同一任务族：生成可用于相似度、检索、聚类、召回的向量表示。它们的主要差异不在“是否属于 embedding”，而在训练数据、模型规模、多语言能力、上下文长度、向量维度压缩策略，以及是开源模型还是托管 API 服务。

通用嵌入模型（General-purpose Embedding Model）的目标通常是“语义相似近、语义无关远”，因此天然适配检索与聚类。也可以把嵌入模型微调成“任务特化嵌入”（Task-specialized Embedding）：用监督标签构造正/负样本对（同类为正、异类为负），用对比学习目标把同类拉近、异类推远，然后用最近邻/类原型（Prototype）实现分类。

与“表示模型 + 分类头（Representation Model + Classifier Head）”相比，二者取舍通常是：

• 特化嵌入：推理时只算一次向量 + 相似度，便于大规模检索/多标签扩展；但输出是距离分数，概率校准与细粒度判别能力通常不如专门的分类头。
• 分类头微调：直接最小化分类损失，闭集分类效果与可解释的概率输出更强；但对大规模候选检索不友好，且不同任务往往需要不同 head。

T5（Text-to-Text Transfer Transformer）是典型 Encoder–Decoder：把所有任务统一为“文本到文本”的生成问题（text-to-text）。它既可用于摘要、翻译等生成任务，也可用于分类，此时模型直接生成类别名对应的 token 序列。

在预训练阶段，T5采用的是掩码式去噪目标（Denoising Objective），但它不是只遮住单个 token 再逐个恢复，而是会对连续的 token span 做遮掩（Span Corruption）。输入中的若干片段会被替换为哨兵标记（Sentinel Token），模型则在解码端按顺序生成这些被遮住的片段。这样的训练方式既保留了“根据上下文恢复缺失内容”的掩码语言建模思想，又让模型从一开始就以 Encoder–Decoder 的生成方式学习条件重建。

在后续适配阶段，T5 延续了统一的 text-to-text 框架：翻译、摘要、问答、分类等任务都写成文本输入到文本输出的形式。沿着这条路线继续发展后，研究者又引入了更大规模的多任务指令微调（Instruction Tuning）：把大量带自然语言任务描述的监督任务混合起来训练，迫使模型学习“读懂任务说明，再按说明生成答案”。FLAN-T5 就是这一路线的代表，即在 T5 底座之上经过 FLAN 指令微调得到的系列模型；它相比原始 T5 更强调零样本（Zero-shot）和少样本（Few-shot）泛化能力。

BART（Bidirectional and Auto-Regressive Transformers）同属 Encoder–Decoder，但预训练更强调去噪自编码（Denoising Autoencoding）：对输入做扰动（mask、shuffle、delete 等），让模型恢复原文。它在摘要、生成式改写与条件生成任务上常用作强基线。

任务特定语言模型（Task-specific Language Model）指在通用预训练模型基础上，围绕某个明确监督任务附加任务头（Task Head）并继续微调的模型。常见任务包括句段级分类、token 级序列标注、文本匹配、排序与信息抽取。这里“句段级”指分类对象是一段独立文本，可以是单句，也可以是能够整体输入模型的段落。工程上它并不是一类全新架构，而是“预训练主干 + 任务头 + 对应损失函数”的组合：同样是 BERT、DeBERTa、T5 或大语言模型（Large Language Model, LLM），接什么头、优化什么目标，决定了它最终服务什么任务。

对 BERT 类 Encoder-only 模型，多分类通常采用“句向量 + 线性分类头（Linear Classification Head）”的形式。设句子表示为 \(h\in\mathbb{R}^{d}\)，类别数为 \(K\)，则分类头输出 logits：

其中 \(h\) 是主干模型抽取出的整句语义表示，常取自

[CLS]

训练时通常直接把 logits \(z\) 输入交叉熵（Cross-Entropy）损失，softmax 与对数运算一般由损失函数内部完成，以获得更好的数值稳定性；推理时若需要概率分布、阈值决策或置信度排序，再显式做 softmax。实践中还常在分类头前加入 Dropout，以降低小样本场景下的过拟合风险。

命名实体识别（Named Entity Recognition, NER）等 token 级任务的输出结构不同。设序列长度为 \(T\)，第 \(t\) 个 token 的隐藏状态为 \(h_t\)，则每个位置的标签打分可写成：

此时分类头不再输出“整句一个类别”，而是为每个 token 输出一组 BIO / BIOES 标签 logits。若任务更强调标签转移的一致性，还可在 token 分类头后叠加条件随机场（Conditional Random Field, CRF），显式约束标签序列的合法转移。

因此，任务头的输出形式始终取决于任务本身：句子分类输出 \(\mathbb{R}^{K}\) 上的一组 logits，token 分类为每个位置输出一组 logits，匹配/排序任务常输出单个相关性分数，生成任务则在词表维度输出下一 token 的 logits。主干负责提供中间表示（Intermediate Representation），任务头负责把这种表示投影成可直接优化的任务空间。

到 2026 年，任务特定语言模型的工程选型已经稳定分化。对高并发、闭集标签、边界清晰且标注数据相对充足的文本分类与 NER，DeBERTa、ModernBERT 一类 Encoder-only 模型仍然具有极高性价比：延迟低、吞吐高、概率校准更稳、部署成本更可控。若任务明确是中文单语理解，

chinese-roberta-wwm-ext

在这类 LLM 任务里，LoRA 仍然是默认起点：它最适合指令跟随、风格迁移、格式约束、轻量领域适配等大多数常规需求。若显存是第一约束，QLoRA 往往是最自然的落点；若任务要求更接近全参数微调的表达力，例如深领域知识吸收、复杂推理、困难边界判别或更强的稳定性，则可优先考虑 DoRA 或 Q-DoRA。全参数微调仍然保留在少数高门槛场景：领域迁移极深、训练数据极大，或需要改动词表、上下文长度、位置编码等底层结构时，它仍然提供最高上限。

工业系统中也常采用混合路线：先用强 LLM 做数据清洗、弱标注、难例发现或标签体系归并，再把任务蒸馏到更轻的 Encoder-only 模型上线。这种做法利用了 LLM 的语义泛化能力，也保留了小模型在延迟、吞吐与稳定性上的优势。

推荐系统也经常以“任务特定模型”的方式落地，尤其是在召回（Recall）阶段。若每首歌曲都能通过歌词、标题、风格标签、歌手简介或多模态信息编码成一个向量 \(e_i\)，那么系统就可以把用户已经选择、收藏或反复播放的歌曲向量聚合成一个用户兴趣表示 \(u\)。一个最常见的做法是把若干已选歌曲的嵌入做平均或加权平均：

随后，对候选歌曲 \(s_j\) 计算它与用户兴趣向量的相似度，例如余弦相似度（Cosine Similarity）：

得分越高，说明该歌曲与用户已选择歌曲在嵌入空间里越接近，也就越可能在风格、主题、情绪或语义上相似。于是，如果用户最近连续选择了几首节奏轻快、独立流行、以失恋叙事为主题的歌曲，系统就会优先召回在向量空间中靠近这些歌曲的其它曲目，而不是只依赖“同歌手”或“同标签”的硬规则。

这类推荐的关键不是显式分类，而是把“用户喜欢什么”和“歌曲像什么”统一表示到同一嵌入空间，再用最近邻搜索完成相似歌曲推荐。工程上它通常对应双塔模型（Two-Tower Model）或文本/多模态嵌入模型：一侧编码用户历史，一侧编码候选歌曲，训练时用点击、收藏、完整播放等行为构造正样本，再配合负采样或对比学习把用户喜欢的歌曲拉近、不感兴趣的歌曲推远。这样得到的推荐结果，本质上是基于语义相关性而不是基于精确关键词匹配。

一条常见路线是把 BERT、RoBERTa、DeBERTa 这类表示模型（Representation Model）当作固定特征提取器（Feature Extractor）使用：先用预训练基座把输入文本编码成一个向量表示，再在其上训练一个轻量分类器，而不继续更新基座模型参数。这种做法的重点不是“让语言模型重新学习任务”，而是直接利用其已经学到的通用语义表示。

工程上，一个典型流程是：先冻结（Freeze）BERT 系列底座的全部参数，只保留前向编码功能；然后对每条输入文本提取句级表示 \(h\in\mathbb{R}^{d}\)，这个表示可以取自

[CLS]

这里 \(W\) 与 \(b\) 是新训练的分类器参数，而 BERT 底座参数保持不变。这样做的优点是训练成本低、显存压力小、过拟合风险更可控，也便于把同一个表示底座复用到多个小任务上。代价是分类边界完全依赖预训练表示的可分性：如果任务与通用语料差距较大，或标签语义非常细，冻结底座通常不如继续微调主干模型灵活。

与此相近的还有基于嵌入模型（Embedding Model）的分类。它的做法更直接：先用 SBERT、BGE、E5、GTE 或 text-embedding 一类嵌入模型，把整段文本映射成一个句向量 \(e(x)\in\mathbb{R}^{d}\)；然后直接在这个嵌入向量后面接一个分类器，例如逻辑回归、线性分类器或一个很小的 MLP，学习从嵌入空间到类别空间的映射。

若使用最简单的线性分类器，这条路线在形式上与前面的表示模型分类并没有本质区别，仍然可以写成

不同之处不在“后面接不接分类器”，而在于前面的底座向量是怎么来的：表示模型通常是为理解类任务设计的上下文化表示；嵌入模型则更强调在向量空间中保持语义距离结构，使相似文本彼此接近、不相似文本彼此远离。因此，基于嵌入模型的分类与基于表示模型的分类，主要区别在底座优化目标而不是分类头形式。表示模型更偏向判别式理解，输出表示通常更适合直接服务闭集分类、序列标注和细粒度 NLU；嵌入模型更偏向语义检索与相似度结构，优势在于跨任务复用、向量检索兼容性和“分类 + 召回”一体化。

工程上可以把两者概括成一句话：表示模型分类强调“先得到适合判别的表示，再做分类”；嵌入模型分类强调“先得到适合度量的向量，再在其上学习分类边界”。如果任务是标准闭集分类、标签边界清晰、追求最高分类精度，BERT 一类表示模型通常更自然；如果系统本身已经以 embedding 为中心，例如既要分类又要相似检索、聚类、召回或原型匹配，那么直接在嵌入模型后接分类器会更统一，也更容易复用同一套向量基础设施。

嵌入模型（Embedding Model）的另一条典型用途是文本聚类（Text Clustering）。代表性方法如 BERTopic：先用句向量模型把文档映射到嵌入空间，再做降维与聚类，最后从每个簇中抽取代表词或主题词。这里真正决定簇结构的并不只有嵌入模型；降维模型与聚类模型本身仍然是经典机器学习方法。

一个通用流程通常分成三步：

1. 使用嵌入模型将文档转换为向量表示，例如把每篇文档编码为 \(e(x_i)\in\mathbb{R}^{d}\)。
2. 使用降维模型把高维向量压缩到更适合聚类的低维空间。
3. 使用聚类模型在降维后的表示上得到簇标签，或进一步识别离群点。

降维阶段的典型选型是 PCA（Principal Component Analysis）或 UMAP（Uniform Manifold Approximation and Projection）。PCA 是线性方法，适合作为快速、稳定的基线；UMAP 更擅长保留非线性邻域关系与整体簇结构，因此在文本聚类里往往更常见。工程上常把 UMAP 先降到 5 到 10 维，作为后续聚类的默认起点；这个范围通常已经足以保留主要结构，同时明显降低噪声与计算成本。

UMAP 的一些常见设置也会直接影响聚类形状。

min_dist

cosine

聚类阶段则常见 K-means 或 HDBSCAN。K-means 适合簇数大致已知、簇形状相对规则的场景；HDBSCAN 更适合密度不均、簇形状复杂，或希望显式识别“不属于任何簇”的离群文档。BERTopic 之所以常见，正是因为它把“嵌入模型 + UMAP + HDBSCAN + 主题表示”这条工程链路封装成了一个相对稳定的默认方案。

基于嵌入模型的主题建模（Topic Modeling）与上一节的聚类路线一脉相承：先把文档映射为向量，再做降维与聚类；不同之处在于，这里还要继续回答“每个簇到底在谈什么”。因此，在聚类结果之上还需要增加一个主题提取（Topic Extraction）步骤，为每个簇生成一组能概括其内容的主题关键词。

这一步的典型做法是 c-TF-IDF（class-based TF-IDF）。它不是对单篇文档计算 TF-IDF，而是先把同一簇里的所有文档拼接成一个“类别文档”，再统计词在该簇中的相对频率，并结合它在其它簇中的区分度计算权重。于是，一个词若在当前簇中频繁出现、但在其它簇中并不常见，它的 c-TF-IDF 权重就会更高；反之，那些在所有簇里都常见的泛化词，其权重会被压低。这样提取出来的关键词，描述的是“这个簇相对于其它簇最有代表性的内容”，而不是“整个语料里最常见的词”。

从工程流程看，这条路线可以写成四步：先用嵌入模型得到文档向量，再用降维与聚类得到簇，随后用向量化器统计每个簇中的词项分布，最后用 c-TF-IDF 为每个簇生成主题词。BERTopic 的核心价值就在于，它把“嵌入模型 + UMAP + HDBSCAN + c-TF-IDF”串成了一个统一框架，因此既保留了 embedding 在语义空间中的表达能力，也保留了词袋统计在主题解释上的可读性。

不过，c-TF-IDF 产出的关键词顺序仍然主要依赖词频统计与类间区分度，语义相关性未必总是最优。于是 BERTopic 又提供了主题表示微调（Representation Tuning）机制：先用 c-TF-IDF 生成候选关键词，再对这些候选词做重新排序。这里最常见的表示模型之一是 KeyBERTInspired。它会先利用 c-TF-IDF 为每个主题挑出一组代表性文档，把这些代表文档聚合成该主题的语义表示，再用与文档编码相同的嵌入模型去计算“候选关键词与主题表示”的语义相似度，最后按相似度重排关键词顺序。在实践中，这种表示方式通常还能进一步压低停用词在最终主题表示中的占比，使主题词列表更干净。

因此，KeyBERTInspired 并不是重新做一遍聚类，也不是替代 c-TF-IDF；它更像是在 c-TF-IDF 给出的候选集之上增加一层语义重排序。这样做的结果通常是：靠前的主题词更连贯、停用词和噪声词更少，主题标签也更接近人类对“这个簇在讲什么”的直觉。对 BERTopic 而言，这一步属于主题表示优化，而不是主题发现本身。

即便经过上述处理，主题关键词之间仍可能存在明显冗余，例如多个高频近义词反复出现在同一主题里。此时还可以进一步使用最大边际相关性（Maximal Marginal Relevance, MMR）做关键词多样化：它在选择下一个关键词时，同时考虑“该词与主题表示有多相关”以及“该词与已经选中的关键词有多相似”，从而找到一组彼此具有差异性、但仍然和目标文档或主题表示保持相关的关键词。于是，MMR 的作用不是提升聚类质量，而是让最终主题表示更分散、更少重复，也更适合人工阅读与命名。

在此基础上，还可以再走一步：把已经得到的一组主题关键词交给生成模型（Generative Model），例如 FLAN-T5，让模型基于这些关键词生成一个更短、更自然的主题标签或一小段摘要式说明。这样做并不改变主题发现本身，而是把“关键词列表”进一步压缩成更适合展示给用户阅读的主题名称。

嵌入模型还可以直接用于零样本分类（Zero-shot Classification）。做法是不训练额外分类器，而是先把每个候选类别改写成自然语言标签描述，再把输入文本与这些标签描述同时编码到同一嵌入空间中，通过相似度完成类别判断。若影评任务只有“正面”和“负面”两类，就可以构造两个标签文本，例如“这是一条正面影评”和“这是一条负面影评”，然后分别计算影评向量与两个标签向量的余弦相似度：

其中 \(x\) 是待分类影评，\(t_k\) 是第 \(k\) 个类别对应的标签描述。若 \(\mathrm{score}_{\text{positive}}\) 高于 \(\mathrm{score}_{\text{negative}}\)，系统就把该影评判为正面评价。这个过程本质上是把分类问题改写为“文本与标签描述谁更接近”的相似度匹配问题。

这条路线的优点是部署快、几乎不需要任务专用标注数据，也不必重新训练分类头；只要标签语义写得足够清晰，就可以立刻在新任务上工作。它的代价同样直接：由于模型并未使用该任务的监督信号显式学习分类边界，零样本分类的准确率通常低于有标注数据时训练出的监督式分类器，尤其在标签定义细、类别边界接近、文本包含反讽或领域术语时更明显。

另一条更轻量的工程路线是基于生成模型（Generative Model）做分类，即直接调用大语言模型（Large Language Model, LLM），通过提示词工程（Prompt Engineering）把分类任务表述为指令，例如要求模型在读完一段文本后只输出“正面”或“负面”。这种做法本质上是把分类看作条件生成：模型先理解输入，再生成最符合提示约束的类别标签。这里的“生成模型”不只包括 Decoder-only LLM；像 T5 这样的 Encoder–Decoder 模型，虽然结构上属于编解码器，也同样可以在不给额外训练的情况下，直接通过输入提示词完成分类，因此在使用方式上也可以视作这一类路线。

它的优点是上手快、改标签体系方便、对少样本或零样本任务尤其灵活；局限是输出稳定性、延迟和成本通常不如专门训练的分类器，而且类别边界是否清晰、提示词是否严格，会明显影响结果一致性。因此，这条路线更适合作为快速原型、弱标注工具或低频复杂任务的分类接口，而不是高吞吐、强约束场景下的默认方案。

多模态模型（Multimodal Model）的主线，不是“把图像、文本、音频都接进来”这么简单，而是不同模态如何进入同一套表示、同一套推理链路、同一套训练目标。从技术演进看，这条路线大致经历了四步：先有稳定的单模态编码器，再有跨模态对齐模型，然后发展出“视觉编码器 + 大语言模型”的连接式系统，最后才逐步走向原生多模态（Native Multimodality）。

ViT（Vision Transformer）本身不是多模态模型，因为它只处理图像，不直接处理文本、语音或视频。它更准确的定位是视觉编码器（Visual Encoder）或视觉骨干网络（Backbone）：把原始像素转换成可供下游检索、分类或跨模态建模使用的视觉表示。

ViT 的关键做法是把图像切成固定大小的 patch，再把每个 patch 视作一个视觉 token。每个 patch 先被展平，再经线性投影映射到统一维度的向量空间，最后叠加位置编码送入 Transformer。这样，二维图像就被改写成了一维 token 序列，Transformer 可以像处理文本序列那样处理图像局部块之间的关系。

因此，ViT 的意义不在于“它已经实现了多模态”，而在于它为后续的多模态系统提供了一个稳定、强大的图像侧前端。无论是 CLIP、BLIP-2 还是 LLaVA，一类很常见的路径都是：先让 ViT 之类的视觉编码器把图像变成高层特征，再考虑如何与文本模型对齐或融合。

第一代真正有代表性的多模态突破，不是“直接生成一切”，而是先把模态对齐。CLIP（Contrastive Language-Image Pre-training）的核心做法是：图像编码器与文本编码器分别输出向量，再通过对比学习（Contrastive Learning）让匹配的图文对更接近、不匹配的图文对更远离。这样，图像与文本就被压到同一嵌入空间中。

这种路线的价值非常直接。只要图像和文本已经进入同一向量空间，就可以做图文检索、文本检索图片、图片检索文本，以及把类别标签写成自然语言描述来完成零样本分类（Zero-shot Classification）。OpenCLIP 则把这条路线做成了可复现、可扩展的开源基础设施，因此在研究和工程里都比原始 CLIP 更常作为起点。

对齐式多模态的贡献是打通跨模态语义空间。模型开始能够理解“这张图和这段文字在说同一件事”，而不再只是各自做各自的单模态任务。但它的能力边界也很清楚：对齐不等于复杂推理，更不等于自由生成。双编码器模型很擅长相似度匹配，却不天然擅长长链推理、细粒度问答和多轮对话。

因此，对齐式系统更像是在给多模态建模打地基。它先解决“不同模态能否进入同一个语义坐标系”这个问题，再把更复杂的生成与推理问题留给下一阶段的系统去解决。

在多模态系统的下一阶段，重点从“把图文对齐”转向“让大语言模型真正看见图像并围绕图像说话”。这就形成了视觉-语言模型（Vision-Language Model, VLM）的主流范式：视觉编码器负责看图，语言模型负责生成，中间再用一个连接器（Connector / Projector）把二者接起来。

BLIP-2 的方法论非常有代表性。它不从零联合训练整个多模态系统，而是尽量复用两边已经训练好的单模态模型：视觉侧使用预训练视觉编码器，语言侧使用预训练大语言模型（Large Language Model, LLM），中间只训练一个较轻量的桥接模块。这样做的目的，是在保留两侧成熟能力的前提下，用较小成本建立跨模态接口。

这个桥接模块在论文中的标准名称是 Q-Former（Querying Transformer）。它通过一组可学习的 query，从视觉编码器输出的图像特征中抽取最适合语言模型消费的信息，再把这些压缩后的视觉表示投影到 LLM 的输入空间。它本质上解决的是“图像特征如何变成语言模型能理解的前缀表示”这个接口问题。

LLaVA（Large Language and Vision Assistant）把这条路线进一步推向“视觉对话”与“视觉指令遵循”。它通常采用视觉编码器提取图像特征，再通过投影层把视觉特征接入语言模型，然后用视觉指令微调（Visual Instruction Tuning）训练模型按图像与文本指令联合回答问题。这样，模型不再只是做相似度匹配，而是可以围绕图像展开问答、描述、解释与推理。

这类系统已经比 CLIP 更接近通用助手，但从结构上看，它仍然属于连接式多模态：图像先由视觉模型单独处理，文本再由语言模型主导生成，融合主要发生在后期接口层，而不是从一开始就在统一主干里共同建模。

原生多模态（Native Multimodality）讨论的是多模态是否在模型内部形成统一的信息流。判断重点不在“支持几种输入”，而在输入表示、时间对齐、主干推理、输出链路和训练过程是否都尽量摆脱“先拆开、后拼接”的流水线。当前前沿系统已经把这个问题分成两条路线：一条偏理解与推理，例如 Gemini 与 Qwen Omni；另一条偏生成，例如 Seedance 这类原生音视频生成模型。

工程上，原生多模态通常不是一个非黑即白的标签，而是一组连续特征。系统越是在模型内部统一处理模态，越接近原生；越依赖外部桥接、先转文本再推理、先出文本再外接语音或视频模块，越接近连接式系统。

原生多模态的第一层难点，是把不同模态改写成模型能共同消费的内部对象。图像相对容易，因为静态图像只需要处理二维空间；音频和视频更难，因为它们天然带有时间轴。模型既要知道“看到了什么”，也要知道“什么时候发生”，还要知道多个模态之间是否同步。

因此，当前更先进的系统不只做“把图像变成 token”这一步，还会显式处理跨模态时间对齐。例如在实时音视频交互场景中，视频帧和音频片段必须在同一时间轴上组织，否则模型很难稳定理解口型、说话节奏、环境声音与画面事件之间的对应关系。原生多模态在这里解决的已经不是简单的图文对齐，而是跨模态时空对齐。

更进一步的区别出现在主干网络和输出端。连接式 VLM 往往已经能把图像看懂，但输出通常仍然以文本为中心；若要说话，就再接一个语音模块；若要生成视频，再接另一套生成器。原生多模态希望把这条链路收进同一系统，让“理解图像”“围绕图像推理”“输出文本”“输出语音”“生成视频”之间的中间状态尽量共享。

这一步对语音和视频尤其关键。文本生成更多是离散 token 的自回归；自然语音需要兼顾内容、音色、韵律和实时延迟；视频生成则同时要控制空间结构、时间连续性、镜头运动和角色一致性。也正因为如此，当前真正具有代表性的原生系统，往往在输出链路上引入更专门的设计，而不是把一切都压成单一路径。

从公开资料看，当前最值得拿来理解原生多模态的代表，大致分成三类：理解优先的长上下文 omni 模型、端到端语音交互模型，以及原生音视频联合生成模型。生成侧里，Seedance 2.0 代表了技术报告完整、控制能力非常强的闭源工业路线；HappyHorse 1.0 则代表了近期受到高度关注的开源路线。

Gemini 路线的代表意义，在于它把“原生”首先落在统一感知与统一推理上。Gemini 1.5 技术报告已经把它定义为高效的多模态 MoE 系统，强调可以在百万级上下文中处理长文档、音频和长视频；Gemini 2.5 则进一步把思维链式推理、长上下文和多模态理解合到同一代模型中。这条路线说明：原生多模态并不只等于“模型会出语音或会生成视频”，更重要的是不同模态能否在同一个长上下文里被一起检索、比较、归纳和推理。

Qwen2.5-Omni 和 Qwen3-Omni 展示了另一种更彻底的做法：系统不仅统一感知文本、图像、音频和视频，还直接生成实时语音响应。其关键难点不在“多接几种输入”，而在音视频时间对齐与输出干扰控制。Qwen2.5-Omni 采用交错组织的音视频序列与时间对齐位置编码 TMRoPE，再用 Thinker-Talker 把“负责推理的语言主干”和“负责流式说话的语音输出链路”拆开但端到端协同；Qwen3-Omni 则进一步把这一路线升级到 MoE，并围绕首包延迟和 codec 级语音生成做了更强的流式优化。

生成侧的原生多模态，目标已经不是“看图回答问题”，而是直接联合生成视频与音频。ByteDance 在 2026 年 2 月正式发布的 Seedance 2.0，把这一方向推进到更完整的工业化形态：统一的多模态音视频联合生成架构，同时支持文本、图像、音频和视频输入，并把参考、编辑、扩展、镜头控制与音视频同步放进同一系统。它解决的重点，是如何让复杂控制信号真正进入视频生成主干，而不是只靠提示词描述一个大概方向。

HappyHorse 1.0 则体现了另一条值得关注的路线：更强调开源可部署与统一 Transformer 架构。公开模型页把它描述为 15B 参数、统一自注意力 Transformer、联合生成视频与同步音频，并突出 1080p、7 语种 lip-sync 和较快推理。和 Seedance 2.0 相比，它当前公开的技术透明度明显更低，缺少完整论文级技术报告，但它的重要性在于：原生音视频生成已经不再只是少数闭源大厂的能力，开源路线也开始逼近前沿体验。

因此，这两类模型放在一起看，技术含义很清楚。Seedance 2.0 更像“高控制度、强参考编辑、面向专业生产工作流”的路线；HappyHorse 更像“统一架构、快速推理、可开源落地”的路线。它们共同说明，视频生成已经从单纯比较单帧画质，转向比较时序稳定性、音视频同步、镜头叙事、可控性与部署形态。

原生多模态的训练与部署成本明显高于连接式系统，原因并不神秘：它要处理的问题本来就更多。连接式 VLM 主要解决“视觉特征如何喂给 LLM”；原生系统还要额外处理时序同步、多模态采样率差异、输出链路异构、流式延迟、模态之间的训练平衡，以及更复杂的安全过滤。

这也是为什么连接式 VLM 仍然长期存在。它更容易复用成熟视觉编码器与 LLM，训练成本更低，部署链路更稳定。原生多模态代表的是能力上限更高的方向，而不是所有场景都必须立即切换到的唯一范式。

图像与视频生成模型可以看作多模态生成的一条重要分支：输入通常是文本、图像或更复杂的条件信号，输出是图像或视频。它们处理的不是“模型看懂了什么”，而是“模型如何把条件约束转成可感知内容”。因此，它们和视觉-语言问答系统同属多模态，但核心目标不同。

DALL-E 与 Imagen 都属于文本到图像（Text-to-Image, T2I）生成路线的代表。工程上更关心的是文本-图像对齐、提示词控制、风格一致性与安全过滤，而不是单一的像素级指标。它们的共同点是：都把文本条件作为生成控制信号，让图像生成过程服从语言约束。

Stable Diffusion 则代表开源扩散模型（Diffusion Model）路线。它通常在潜空间（Latent Space）中进行扩散与去噪，再把潜变量解码回图像。它的工程意义尤其大，因为这条路线不仅支持文本生成图像，还容易叠加 LoRA、ControlNet、风格微调与本地部署，因此形成了非常完整的开源工作流生态。

视频生成比图像生成多了一个真正困难的维度：时间。模型不只要把单帧画出来，还要保证人物身份、动作轨迹、镜头运动、物理连续性和叙事节奏在多帧之间保持稳定。因此，视频生成天然更接近原生多模态问题，因为它几乎总要同时处理空间、时间，进一步还可能处理语音、音乐和环境音。

这一方向的前沿已经从“无声文本生视频”继续推进到音视频联合生成。Seedance 2.0 已经把文本、图像、音频和视频都纳入同一个参考与编辑框架，并支持多段素材混合输入、多镜头音视频输出和更稳定的复杂动作场景；这意味着视频模型开始更像“可编排的生成引擎”，而不只是一次性吐出一段短片。HappyHorse 1.0 则把另一条路线推到台前：以统一 Transformer 和开源权重为卖点，把文本/图片到视频、同步音频和多语言 lip-sync 打包成更容易部署的开源系统。

这两条路线各有强调。前者更重多模态参考、编辑与专业创作控制，后者更重统一架构、开源可用性与推理效率。但它们都在说明同一件事：视频生成的比较标准已经从“画得像不像”升级成“是否能稳定控制时间、镜头、声音和角色一致性”。

语音也是多模态体系中的重要一支。它一方面可以单独形成语音识别（ASR）和语音合成（TTS）任务，另一方面也可以作为更大多模态系统中的输入或输出模态，与文本和视觉共同构成统一交互链路。

自动语音识别（Automatic Speech Recognition, ASR）把音频转成文本。Whisper 是这一方向的代表之一。它本身更接近“语音到文本”的专用模型，而不是完整的原生多模态基础模型；但它在工程上非常重要，因为许多语音助手和语音 Agent 系统的第一步，仍然是先把音频稳定转写为文本，再进入后续语言推理链路。

语音合成（Text-to-Speech, TTS）则反过来把文本转成音频波形。工程关注点通常包括音色一致性（Voice Consistency）、韵律（Prosody）、延迟控制与多说话人能力。对多模态系统而言，TTS 的意义不只是“朗读文本”，而是把文本侧推理结果重新投射到语音模态，使系统具备完整的语音交互闭环。

传统语音系统更像流水线：ASR 先把音频转写成文本，语言模型基于文本做推理，最后 TTS 再把文本回答合成为语音。原生多模态路线则倾向于减少这种层层转译，尽量让语音中的情绪、停顿、说话风格和实时交互信号直接进入统一推理链路。也正因为如此，语音逐步从“单独外接模块”变成原生多模态系统中的一等模态。

对生成式大语言模型（Large Language Model, LLM）而言，训练通常不是一步完成，而是一个逐层收紧目标的三阶段过程。第一阶段是预训练（Pretraining）：让模型“学会语言”，掌握通用世界知识、语言统计规律与基础生成能力。第二阶段是监督微调（Supervised Fine-Tuning, SFT）：让模型“学会按指令做事”，把通用生成能力收束到更明确的任务格式、回复风格和指令遵循能力上。第三阶段是偏好对齐（Preference Alignment）：让模型“生成得更好”，在多个候选答案中更稳定地偏向人类认为更有帮助、更安全、更相关的输出。

这三步也对应了三种不同的模型状态。只做完预训练的模型通常称为基础模型（Base Model）：它拥有语言能力，但并不天然理解“用户现在真正想要什么”。经过监督微调后，模型开始具备指令理解与任务对齐能力，这一步常被称为指令微调（Instruction Tuning）。再往后，通过偏好对齐把模型行为进一步向人类目标、价值约束和回答偏好靠拢，这一步才构成更完整的对齐（Alignment）过程。当前主流通用助手模型，基本都建立在这条“预训练 → SFT → 偏好对齐”的标准范式之上。

从工程视角看，微调的本质不是重新训练一个模型，而是在保留预训练通用能力的前提下，对模型进行二次开发。领域适配、风格约束、指令遵循、安全边界和用户体验优化，几乎都发生在预训练之后。也正因为如此，微调并不是可有可无的附加步骤，而是把“会说话的模型”变成“可用的产品模型”的关键环节。

模型训练并不是所有因素等权叠加的黑箱过程。不同决策对结果的影响层级并不相同：有些因素决定性能上限，有些因素决定能否稳定逼近这个上限，还有些因素更多只影响复现实验时的波动。把这些层级看清，比机械扩大超参数搜索空间更重要。

一个足够稳定的工程经验是：数据定义与数据质量决定上限，训练目标决定模型究竟被要求学什么，模型架构决定它擅长表达什么，超参数主要决定训练能否稳定地逼近该上限，随机种子则决定同一方案在局部范围内会波动多少。这五类因素都重要，但重要性的层级并不相同。

在大多数真实任务里，数据问题比超参数问题更早构成瓶颈。标注标准不一致、负样本定义含混、类别长尾覆盖不足、训练集与线上分布偏移、重复样本过多、低信息密度样本占比过高，这些问题会直接抬低性能天花板。此时即使继续精细搜索学习率、dropout 或 warmup 步数，得到的往往也只是对现有缺陷数据的更精致拟合。

因此，训练停滞时最先应排查的通常不是“还有没有更神秘的超参数组合”，而是以下四件事：监督信号是否可信，训练数据是否覆盖真实决策边界，验证集是否真的代表部署分布，以及坏例是否能被归纳成明确的数据缺口。若这些环节存在结构性问题，数据集工程（Dataset Engineering）通常比额外的超参数搜索更有价值。

不同模型家族里，各因素的影响力分布并不完全一样。传统机器学习模型更依赖显式特征与模型假设是否匹配；Transformer 一类现代深度模型则更依赖数据规模、训练目标与训练配方是否成熟。两者的优化重点不能混成一套。

对传统模型而言，常见主线是“先把特征、标签定义和模型假设对齐，再调超参数”；对 Transformer 而言，常见主线更接近“先把数据、目标和基座路线做对，再用一套成熟训练配方稳定落地”。因此，现代大模型工程里最常见的成功路径，并不是超参数盲搜，而是先建立可信基线，再围绕数据与目标做高价值迭代。

训练是否健康，不能只看“loss 最后降到了多少”。真正有经验的训练监控，关注的是曲线形态、不同指标之间是否彼此一致，以及这些指标是否在给出同一种信号。例如训练损失下降但验证损失持续恶化，说明问题往往不在“模型没学到”，而在泛化；学习率正常但梯度范数突然飙升，则更像数值稳定性问题。

loss

train_loss

val_loss

eval_loss

val_accuracy

eval_f1

val_auc

eval_bleu

token_accuracy

eval_token_acc

eval_mean_token_accuracy

lr

learning_rate

grad_norm

gradient_norm

param_norm

weight_norm

step_time

iter_time

time_per_step

samples_per_second

tokens_per_second

it/s

gpu_memory

memory_allocated

max_memory_reserved

loss_scale

overflow

nan_count

其中，grad_norm 常被误读成“某层梯度大小”或“loss 的导数值”。更准确地说，它是当前这一步所有可训练参数梯度拼成一个大向量后的 L2 范数，因此表示的是整体更新冲动的强弱。若训练初期较大、随后回落并稳定在适中区间，通常是健康现象；若突然从稳定区间跃升到极大值，则应优先排查异常 batch、学习率、混合精度溢出与梯度裁剪是否失效。

一条实用经验是：不要孤立解读单个监控项。训练健康与否，通常要联立观察“训练损失、验证损失、验证指标、学习率、梯度范数、吞吐和显存”这几条曲线。只有当这些信号彼此一致时，结论才可靠；若它们相互矛盾，真正的问题往往就藏在这种矛盾里。

一个极常见的问题是：如果训练集已经很大，例如有 200 万条样本，是否 1 个 epoch 就一定够了。答案是否定的。epoch 数从来不是脱离任务、模型容量、batch size 和学习率调度单独成立的“固定真理”。数据量很大时，重复看同一批数据的边际收益确实会下降；但这并不自动意味着“只看一遍就已经充分收敛”。真正该判断的，不是样本数本身，而是模型在当前 step 数、当前噪声水平和当前优化配方下，是否已经把这批数据中的稳定规律吸收进去。

从优化角度看，epoch 表示“把整个训练集完整扫过几遍”，而训练真正发生更新的基本单位是 step。若训练集大小为 \(N\)，全局 batch size 为 \(B\)，则每个 epoch 的更新步数近似为

这条式子解释了为什么“同样是 1 个 epoch”，训练强度可能完全不同。若 \(N=2{,}000{,}000\) 且 \(B=2{,}048\)，那么 1 个 epoch 约等于 977 步；若 \(B=128\)，则 1 个 epoch 已经接近 15625 步。前者可能连 warmup 和衰减都还没完全展开，后者却已经给了优化器大量迭代机会。因此，真正需要关注的是总更新步数是否足够、学习率曲线是否有足够空间完成收敛，而不是孤立地看 epoch 数字本身。

当数据量相对模型容量已经非常充足，或者任务本身建立在强预训练基座之上时，1 个 epoch 确实可能足够。最典型的例子是大语言模型预训练和大模型微调。预训练阶段若数据规模巨大，重复多次扫同一语料的收益会迅速递减，甚至更容易把模型推向记忆高频样本而不是继续扩大有效覆盖；微调阶段若基座已经很强，而 200 万样本又足够多，1 到 2 个 epoch 往往已经能把任务信号写进模型。

这种情形之所以成立，不是因为“大数据天然只需要 1 个 epoch”，而是因为模型在第一轮扫描中就已经见到了足够多的新模式，额外重复的边际知识增量开始下降。换一个表述，真正够用的不是“1 个 epoch”这个数字，而是“这 1 个 epoch 已经包含足够多有效、不同且信息密度高的更新”。

相反，即使样本数已经达到百万级，多 epoch 仍然可能有必要。第一种情形是模型容量很大、任务本身又不只是表面分类，而需要模型充分吸收细粒度规律；此时 1 个 epoch 可能只是让模型“看过”，还未真正“消化”。第二种情形是 batch size 很大，导致每个 epoch 的 step 数偏少，学习率调度甚至还没完全展开，训练就已经结束。第三种情形是数据噪声较大或任务边界本身较模糊，多几轮迭代有助于模型在不同 mini-batch 组合中逐步稳定参数，而不是过度受一次随机采样影响。

从优化器视角看，多 epoch 的价值不只是“重复看数据”，还包括让随机梯度下降在更多 mini-batch 路径上反复修正参数。一次 epoch 中，每个样本通常只参与一次梯度更新，但 SGD 的更新方向本身带噪声；多轮迭代使优化器有机会在不同 batch 组合下持续磨平这种噪声，更接近一个稳定解。

多跑 epoch 的好处是提高数据利用率，坏处则是重复过度后更容易过拟合。这里的过拟合并不一定表现为“训练损失不再下降”，更常见的是训练损失持续变好，而验证损失、验证指标或校准状态开始恶化。对去重不充分的数据，这个问题会更严重：重复样本本身已经降低了有效样本量，再叠加多 epoch，就会把模型进一步推向记忆。

因此，epoch 数的合理区间通常不是越大越好，而是存在一个任务相关的甜蜜点。预训练里这个甜蜜点往往很靠前，因为数据足够大、重复收益低；中小模型从头训练时甜蜜点通常更靠后，因为模型需要更多轮次才能把有限数据中的模式真正吃透；大模型微调和 SFT 则常介于二者之间。

所有经验法则最终都应回到验证集信号。若训练损失持续下降，而验证损失 \(\texttt{val\_loss}\) / \(\texttt{eval\_loss}\) 不再下降甚至开始上升，就说明继续增加 epoch 很可能只是在拟合训练集细节。相反，若训练到 1 个 epoch 时验证损失和验证指标仍在稳定改善，那么因为“样本很多”就强行提前停止，反而可能让模型欠收敛。

Epoch 1: train_loss=2.1  val_loss=2.3
Epoch 2: train_loss=1.8  val_loss=2.0
Epoch 3: train_loss=1.5  val_loss=1.9
Epoch 4: train_loss=1.2  val_loss=2.0

这类曲线就是最典型的判断依据。前 3 个 epoch 中，训练损失与验证损失同步下降，说明模型既在学习训练集，也在改善泛化；到第 4 个 epoch，虽然

train_loss

val_loss

上文已经系统列过训练监控项，这里只强调一个更容易被误用的原则：early stopping 的判断不能死板地绑定单一指标。停止准则必须跟任务目标、模型架构和损失函数对齐。对 BERT 一类 Encoder-only 模型的二分类任务，若最终部署关心的是固定阈值下的分类正确率、召回率或 F1，而不是输出概率本身是否校准，那么 checkpoint 选择往往应优先盯住

val_f1

val_acc

val_loss

val_loss

val_f1

这类曲线在二分类里并不少见。若损失函数采用二元交叉熵（Binary Cross-Entropy, BCE）或交叉熵（Cross-Entropy），那么

val_loss

val_f1

因此，在这类 BERT 二分类任务中，更合理的策略通常是：把 early stopping 的耐心值绑定在

val_f1

val_acc

val_loss

val_loss

在 CoT（Chain-of-Thought）生成任务里，这个问题会更明显。更常见的情况是

eval_loss

eval_loss

token_accuracy

eval_loss

eval_loss

token_accuracy

这类现象尤其容易误伤大模型或较晚才兑现能力的配置。若 9B 模型的绝对

eval_loss

patience=1

eval_loss

因此，还要把三个容易混淆的判断分开。欠拟合（Underfitting） 是现象层描述，表示训练集和验证集都做不好；欠容量（Undercapacity） 是成因层判断，表示模型或可训练适配器的表达能力确实不够，导致训练误差下不去；而停止准则误判 则是监控层问题，表示模型本来还在朝任务目标变好，却被不合适的指标提前停掉。

eval_loss

token_accuracy

patience

因此，更可靠的工程结论不是“200 万数据就跑 1 个 epoch”或“必须至少跑 3 个 epoch”，而是：先根据任务类型给出一个合理初值，再把停止准则绑定到真正代表任务成败的验证信号上。换句话说，epoch 只是外层计数单位，停止条件必须服务于任务目标，而不是机械服从某一条曲线。

超参数仍然重要，但它们最主要的作用通常是把一个合理方案从“训不动”推到“训得稳”，再从“训得稳”推到“训得更高效”，而不是凭空创造数据与目标之外的新能力。学习率、batch size、warmup、weight decay、dropout、梯度裁剪与调度策略都属于高杠杆参数，因为它们直接影响优化轨迹；但一旦进入成熟配方附近，继续做大规模穷举搜索，边际收益往往迅速下降。

这也是为什么工程上更强调经验调参（Empirical Baselines）。先从社区已验证的默认范围起步，再围绕少数真正高杠杆参数做小范围、可解释的搜索，通常比无约束网格搜索更高效，也更不容易把验证集偶然性误判成模型能力提升。若一个方案必须依赖极其苛刻的超参数才能成立，它通常也更难在新数据、新种子和新硬件上稳定复现。

随机种子不是主导因素，但也绝不是噪声到可以忽略的细节。初始化、数据打乱顺序、负样本采样、dropout 路径和混合精度下的数值非确定性，都会让两次训练出现差异。数据越少、任务越难、可训练参数越多，这种波动通常越明显。小样本微调、few-shot 提示学习、PEFT 与不平衡分类任务，都经常出现“只换一个 seed，指标就有明显起伏”的现象。

因此，实验纪律至少应包括三点：第一，重要结论不要基于单次运行下判断；第二，对关键方案记录 seed、数据切分、依赖版本和硬件环境；第三，若不同 seed 方差已经接近方案之间的提升幅度，就不应把这点差异解读为方法突破。工程上真正可信的改进，应当在多次运行、不同切分或更接近真实分布的验证下仍能站住。

若把训练优化压缩成一条实用顺序，通常是：先校正任务定义与评估指标，再修数据分布与标签质量，然后确定模型家族与训练目标，接着使用成熟经验配方建立基线，最后才对少数关键超参数做有节制的搜索。这个顺序并不保证一步到位，但它能最大限度避免把大量算力消耗在低回报环节上。

预训练首先是一条数据管线（Data Pipeline）。对大语言模型而言，模型最终学到什么、遗漏什么、偏向什么，首先取决于它看到了哪些语料，以及这些语料在进入训练前经历了怎样的筛选、清洗与混合。训练配方当然重要，但在大规模预训练里，数据分布本身往往比单个优化技巧更具决定性。

第一步通常是收集训练数据。来源往往包括公开网页、百科、书籍、论文、新闻、论坛、代码仓库、问答站点、对话语料以及经过授权的专有文本。不同来源的作用并不相同：网页和百科提供广覆盖的语言统计与世界知识，代码语料强化程序生成与形式化模式，论文和书籍提升长程结构与知识密度，对话数据则更贴近后续助手形态。预训练阶段谈“知识注入”，最底层的载体首先就是这些原始语料源。

第二步是数据清洗（Data Cleaning）。原始互联网语料通常充满模板页、导航栏、广告、乱码、截断文本、语言混杂、低信息密度页面和大规模重复内容，直接拿来训练只会把噪声写进模型。常见清洗动作包括：语言识别、文本抽取、HTML / Markdown 噪声剥离、异常字符过滤、长度过滤、文档质量评分、敏感内容过滤，以及近重复或完全重复文档去除。它的目的不是把数据“洗得越干净越好”，而是把明显无价值、重复或高风险的部分尽量挡在训练集之外。

第三步是数据去重与质量过滤。对现代大模型来说，重复数据并不只是浪费 token 预算，还会放大训练分布中的头部模式，使模型更容易过拟合少数高频模板、降低有效数据多样性，并污染后续评测。于是，工程上通常既要做文档级去重，也要做段落级、片段级甚至近似语义去重；同时配合质量分类器、启发式规则或小模型过滤，把低信息密度、机器生成垃圾、SEO 内容农场和错误密集文本压低占比。

第四步是数据配比（Data Mixture）。预训练通常不是把所有清洗后的数据简单拼接后均匀抽样，而是会显式控制不同来源、语言、领域和模态的采样比例。原因在于：不同语料的规模差异极大，若完全按原始数量采样，网页噪声和头部来源往往会淹没更高质量但规模更小的数据，例如书籍、论文和代码。数据配比的本质，是决定模型应该把多少训练预算分配给广覆盖、多少分配给高质量、多少分配给特定能力方向。

这种配比通常带来直接的能力权衡。代码比例升高，模型的程序生成和形式化推理往往更强，但自然语言对话风格未必同步变好；高质量书面语比例升高，模型的行文稳定性和知识密度往往改善，但口语互动和开放域覆盖可能下降；多语比例升高，则跨语言泛化更强，但单语极致性能未必最优。因此，数据配比并不是纯粹的数据工程细节，而是预训练目标函数之外最重要的能力分配器之一。

第五步才是把整理后的语料送入真正的训练阶段。也正因为前面已经做过收集、清洗、去重和配比，后面的“初期训练、中期训练、退火训练”才有明确的数据基础：初期通常强调大规模广覆盖混合，中后期再逐步提高高质量数据、特定能力语料或长上下文样本的权重。换句话说，阶段化训练并不是独立于数据工程存在的，它本身就是建立在先构造可控数据分布，再按阶段调整采样分布这一前提之上。

现代大语言模型的预训练，通常不是把同一种数据、同一种上下文长度和同一组优化超参数一路跑到结束，而更接近一种分阶段课程学习（Curriculum Training）。所谓“知识注入”，本质上也不是把某条事实单独写入参数，而是通过逐步调整数据分布、上下文长度、学习率和训练目标，让模型先建立通用语言统计骨架，再吸收更高质量、更长程或更专业的模式。

工程上常见的三段式可以概括为：

• 初期训练。这一阶段通常以海量、多样、相对较短的上下文为主，重点是尽快建立词法、句法、语义组合、事实共现与基础推理的统计骨架。之所以大量使用短上下文，是因为在标准注意力下，序列长度增加会显著抬高训练成本；在固定算力预算下，较短序列通常能换来更多 token 更新和更稳定的早期收敛。
• 中期训练（Mid-training）。当模型已经具备基本语言能力后，训练重点会从“广覆盖”逐步转向“高价值分布塑形”。这一阶段更常看到更严格过滤的高质量语料、代码、推理数据、专业领域语料，或逐步扩展的上下文长度。它的作用不是重学语言本身，而是把模型的能力重心推向更有用的区域，例如更强的代码能力、更稳的长程依赖、更贴近目标领域的表达分布。
• 退火训练（Annealing Phase）。这是预训练后段的精修阶段，通常伴随更小的学习率、更保守的更新幅度，以及更精选、更低噪声的数据混合。它的目标不是再靠大步更新去扩张知识覆盖面，而是收束参数、压低噪声影响、强化高质量模式，并把模型最终的能力形态稳定下来。很多现代配方会把更专业或更高质量的数据留到这一阶段，以获得更好的下游表现。

从“注入什么知识”的角度看，这三段关注的重点并不相同。初期训练主要注入广覆盖的语言统计、世界常识共现和通用结构先验；中期训练主要注入能力相关的分布偏好，例如代码、推理、长文档和领域语料；退火训练则更像把高价值知识和高质量行为模式做最后收束，使模型从“已经学会很多”走向“把重要能力学得更稳”。

长上下文能力也常在这一框架下被放到中后期处理。原因并不神秘：长上下文训练既昂贵，又更容易让优化目标与数据工程复杂化；如果在模型尚未建立稳定短程语言骨架时就大规模拉长序列，单位算力的有效学习信号往往并不划算。因此，很多训练配方会先用短上下文把基础能力打牢，再在中后段逐步扩展到更长上下文，或者单独追加一段上下文扩展训练。

因此，预训练阶段谈“知识注入”时，更准确的理解不是一次性灌入，而是按训练阶段逐步改变模型看到的分布与约束条件：先学会语言，再学会更有价值的语言分布，最后把这些能力收束成一个更稳定的基座模型。

自回归语言建模（Causal Language Modeling, CLM）把文本建模为从左到右的条件概率连乘：给定前缀 \(x_{<t}\) 预测下一个 token \(x_t\)。训练目标是最小化 next-token 交叉熵：

CLM 与 Decoder-only 架构天然匹配：因果 attention mask 保证模型只能看见历史 token，避免训练-推理不一致。绝大多数通用生成式大模型都以 CLM 为主目标。

多 token 预测（Multi-Token Prediction, MTP）是在 CLM 基础上的“监督信号加密”：除了预测 \(x_{t+1}\)，还额外让模型在同一隐藏状态上预测更远的未来 token（例如 \(x_{t+2}\)、\(x_{t+3}\)），从而在相同序列长度下产生更多训练信号。一个抽象写法是：

MTP 通常作为辅助损失（Auxiliary Loss）提升训练效率或长程规划能力；但推理阶段是否能“真正一次生成多个 token”取决于解码与验证策略，不能简单由训练目标推出。

掩码语言建模（Masked Language Modeling, MLM）随机遮住输入中的一部分 token（替换为 \([\mathrm{MASK}]\) 或其他扰动），训练模型用双向上下文预测被遮住位置的 token。它是 Encoder-only 表示模型（如 BERT 系列）的典型预训练目标：

其中 \(\mathcal{M}\) 是被 mask 的位置集合。MLM 的优势是能学到更强的双向表示，但它与生成式解码不天然一致，因此“理解类任务”更常用 MLM 预训练模型，“生成类任务”更常用 CLM。

对比学习预训练（Contrastive Pre-training）把“相似样本拉近、非相似样本推远”作为核心目标。它广泛用于句向量/图像-文本对齐等场景：例如 CLIP 用图像编码器与文本编码器产生表示，对匹配对最大化相似度；Sentence-BERT 等句向量模型也常用对比目标训练。

典型形式是 InfoNCE：对 batch 内正对（Positive Pair）与负对（Negative Pair）做 softmax，对每个 query 只奖励其匹配的 key：

其中 \(\tau\) 是温度（Temperature），\(\mathrm{sim}\) 常用余弦相似度或内积。

继续预训练（Continual Pre-training）位于“通用预训练”与“下游微调”之间。它不直接把模型改造成某个具体任务的分类器或助手，而是先用目标领域的大规模无标注语料，对已经完成通用预训练的模型再训练一段时间，让参数分布、词汇统计、上下文共现和知识重心向目标领域迁移。对 Encoder-only 模型，这一步通常仍以掩码语言建模（Masked Language Modeling, MLM）为主；对 Decoder-only 生成模型，则通常继续做自回归语言建模（Autoregressive Language Modeling）。

它的核心价值是先让底座学会“这个领域怎样说话”，再让它学会“这个任务怎样输出”。若直接拿通用模型去做医疗、法律、金融、代码仓库、企业内部知识库等垂直场景的监督微调，模型往往会同时面对两类落差：一类是领域词汇和表达方式本身就不熟，另一类是下游任务的标签或指令又要求它立即做出稳定判断。继续预训练先处理前一类问题，把底座拉近目标域分布，后续监督微调只需要处理任务映射，训练通常会更稳定，也更节省标注数据。

因此，继续预训练本质上是一种领域自适应预训练（Domain-Adaptive Pretraining, DAPT）。如果继续预训练的语料不仅来自某个大领域，而是更进一步贴近最终任务的输入分布，例如只使用某个具体产品线、某类工单、某种法律文书或某一学科论文语料，那么它也可以被视作任务自适应预训练（Task-Adaptive Pretraining, TAPT）。两者的区别不在训练算法，而在语料与最终应用的距离：DAPT 更强调“进入这个领域”，TAPT 更强调“贴近这个任务”。

领域适配能带来的收益通常体现在四个层面。第一，模型会更熟悉目标域词汇和短语共现，例如医学缩写、金融术语、企业内部专有名词、代码 API 与日志模式。第二，模型对目标域上下文的概率分布会重新校准，原本罕见的搭配在该领域里会变成高频结构。第三，后续监督微调需要学习的东西会减少，因为模型不必一边补语言常识、一边学任务映射。第四，在低标注数据场景下，继续预训练常常比一上来就重监督微调更稳，因为它先利用了最容易获得的大规模原始文本。

继续预训练最适合三类场景：

• 领域语料很多、标注很少。这是最经典的适用条件，因为继续预训练最能利用大规模无标注文本，而不要求先构造高成本监督数据。
• 目标文本分布与通用互联网语料差异极大。例如长文档、半结构化记录、专业术语密集文本、代码与自然语言混合语料；这类差异首先是语言分布差异，而不是标签定义差异。
• 模型需要吸收的变化更接近“知识与表达分布迁移”，而不是单纯“输出标签变了”或“格式要求变了”。后者通常更适合直接做监督微调或 PEFT。

从训练流程看，更合理的顺序通常是：先完成通用预训练，再做领域继续预训练，最后再进入监督微调、参数高效微调或偏好对齐。原因很简单：继续预训练改变的是基座对语言分布和知识结构的建模，而监督微调改变的是输出行为。先做基座适配，再做行为适配，优化目标更清晰，也更符合迁移学习的层次结构。

继续预训练的主要风险，是灾难性遗忘（Catastrophic Forgetting）。它指的是模型在吸收新分布时，原来在通用语料上学到的能力被明显冲掉：例如领域内术语理解变强了，但通用语言理解、跨领域泛化、常识问答、原始格式鲁棒性或多语言能力反而下降。这个问题并不是继续预训练独有的，但在“新语料分布很窄、训练步数又较长”时尤其容易出现。

其根本原因在于参数共享。神经网络并不会为“旧知识”和“新知识”自动分出两套互不干扰的存储区；当优化器持续在窄领域语料上更新同一组权重时，原先支持通用能力的参数方向会被新的梯度不断改写。如果新领域文本的语言风格、词频结构和任务偏置都高度集中，模型就会把有限参数容量优先分配给当前最常见的模式，从而牺牲原本更广的覆盖面。

灾难性遗忘最常见的外在表现包括：继续预训练阶段训练损失持续下降，但回到通用基准或旧任务验证集上时指标明显退化；模型在目标领域内更流畅，却在开放域输入上变得更僵硬、更偏模板化；对窄领域高频术语反应更强，但对跨域问题的泛化能力下降。这些现象都说明模型不是单纯“学到了更多”，而是在重新分配有限表示能力。

缓解灾难性遗忘有几条经典路线：

• 控制继续预训练强度。包括减少训练步数、降低学习率、使用更保守的 warmup 与衰减策略，避免模型在窄分布上过度漂移。
• 混合语料训练。在领域语料之外保留一定比例的通用语料，让模型在吸收新分布的同时持续回顾旧分布。
• 参数隔离。例如只对部分层做继续预训练，或采用 Adapter、LoRA 这类参数高效路径，把领域偏移写进新增参数，而不是完全重写主干。
• 保留旧能力验证。继续预训练不应只看领域损失，还应并行跟踪若干通用验证集，否则模型退化往往到很晚才会被发现。

因此，继续预训练并不是“领域语料越多、训练越久越好”。更准确的目标应当是：在尽量少破坏通用能力的前提下，把模型的统计重心向目标领域移动。它追求的不是把模型变成只会某个领域的专家，而是在通用底座之上增加一层更贴近目标分布的适配。工程上真正好的继续预训练，通常表现为领域内显著增益、领域外可控退化，甚至几乎无退化，而不是单纯把领域损失压到最低。

监督微调（Supervised Fine-Tuning, SFT）用“输入 ➡ 期望输出”的监督数据继续训练预训练模型，使其在特定分布上更符合目标行为。对自回归语言模型（Autoregressive LM）而言，SFT 仍然是 next-token 交叉熵：给定提示词 \(x\) 与目标回复 \(y\)，最小化

其中 \(\pi_\theta\) 表示由参数 \(\theta\) 决定的模型条件概率分布，也就是“在给定前缀条件下，模型对下一个 token 的预测分布”；\(\pi_\theta\!\left(y_t\mid x,y_{<t}\right)\) 就表示模型在看到提示词 \(x\) 和目标回复此前各 token \(y_{<t}\) 时，对当前位置正确 token \(y_t\) 赋予的概率。

训练通常使用教师强制（Teacher Forcing）：把 \(x\) 与 \(y\) 拼接作为输入，但只在目标回复 token 上计算损失（对提示词部分做标签掩码，label masking），避免模型被迫“复述提示词”。

SFT 的必要性，来自基础模型（Base Model）与“可用助手模型”之间的行为差异。基础模型的原始目标只是预测下一个 token，因此它本质上擅长的是续写（Completion），而不是理解人类正在发出什么指令。给它一句 “The car is”，它自然会继续补全常见续文；给它一个问题 “What is 1+1?”，它在没有对齐之前也完全可能把这当成一段待续写文本，而不是一个必须回答的任务。SFT 的作用，就是把这种“见到前缀就续写”的行为，重塑成“读懂输入意图，再输出目标答案”的行为。

全量微调（Full Fine-tuning）更新模型的全部参数，表达能力最强，但训练成本高、对数据规模与分布漂移更敏感，也更容易出现灾难性遗忘（Catastrophic Forgetting）。它与预训练在优化形式上并没有本质断裂，区别主要在于数据：预训练依赖海量无标注通用语料，全量微调则依赖规模更小但质量更高、目标更明确的标注数据集。正因为所有参数都会被更新，它在特定任务上的性能上限通常最高，但显存、训练时间和权重存储成本也最高；每做一次完整微调，本质上都在生成一个完整的新模型副本。

部分参数微调（Partial Fine-tuning / Selective Fine-tuning）处在全量微调与参数高效微调（PEFT）之间。它的基本做法不是给模型增加新的适配器参数，而是只解冻原模型中一部分已有参数，其余参数保持冻结。这样做的直接收益是显存占用更低、训练更快、过拟合风险更可控；代价则是可调空间受限，性能上限通常低于全量微调。

这类方法的核心思想是：并不是每个任务都需要改写整套参数。若下游变化主要集中在输出读出方式、输入符号分布或某一局部计算结构，那么只更新最相关的一小部分参数，往往就足以完成适配。它与后文的 LoRA、Adapter 有一个重要区别：部分参数微调优化的是原模型内部已经存在的参数子集；PEFT 则更常通过新增低秩矩阵、瓶颈层或软提示，把任务偏移写进额外参数。

输出层微调（Output-layer Fine-tuning）只更新模型最靠近输出读出的部分，例如语言建模头（LM Head）、分类头（Classification Head）、奖励头（Reward Head），或最后少数几层与任务头直接相连的参数，而把主体 Transformer 基本冻结。它最适合“底层表示已经足够好，但最终读出方式需要重塑”的场景。

对表示模型，这通常意味着冻结编码器主体，只训练顶层分类器；对生成模型或对齐流程，则常见于基于已有 SFT 模型训练奖励模型：保留主干表示层，移除原 LM Head，换成输出单一分数的奖励头，再主要围绕这个输出读出层继续训练。它的优势是参数量极小、训练稳定、成本最低；局限在于它基本不改变主干内部表示，因此当任务真正需要重排中间语义结构时，单靠输出层往往不够。

输入层微调（Input-layer Fine-tuning）主要更新输入嵌入相关参数，例如 token embedding、位置嵌入，或与新词表、新符号、新模态入口直接相连的输入投影层，而冻结大部分主体网络。它适合输入分布变化显著、但主体推理与表示能力仍然可复用的场景，例如新增领域术语、扩展专有 token、接入特殊控制符，或需要让模型先学会“看懂新输入”。

这条路线在词表扩展与领域符号接入时尤其有价值。因为很多变化并不在“模型不会推理”，而在“模型还没有为这些新符号建立合适入口”。此时先调输入层，可以把新 token 映射到已有表示空间附近，减少一开始就全模型漂移的风险。在一些更重的训练配方里，也会先单独训练输入嵌入，再逐步解冻更深层参数做融合；但其本质始终是先处理输入接口适配，再决定是否需要更深层的结构性更新。

局部结构微调（Local-structure Fine-tuning）只选择模型内部某些特定结构或参数类型来更新，例如仅训练偏置项的 BitFit、仅训练归一化参数的 LayerNorm Tuning、只解冻注意力层参数的 Attention Tuning，或只解冻最后若干层的局部 block。它的共同点是：参数选择不是按“输入端 / 输出端”划分，而是按网络内部哪类结构最可能承载任务偏移来划分。

这类方法适合算力极其受限、数据量较小，或已经对任务偏移位置有较强先验的场景。例如，若任务主要要求重新标定特征尺度或阈值边界，LayerNorm Tuning 可能就足够；若任务更多是在改变“关注哪里、聚合哪些信号”，只调注意力层可能比盲目放开全部层更高效；若只是希望用极低成本给模型一点任务校正能力，BitFit 这类只训偏置的方案也有现实价值。它们的上限通常不如更强的 PEFT，但在轻量实验、消融研究和极端资源约束环境中依然很有意义。

BitFit 的做法极端简单：冻结几乎所有权重矩阵，只训练偏置项（Bias Terms）。若某一层的线性变换写成 \(h'=Wh+b\)，BitFit 只更新其中的 \(b\)，而把 \(W\) 保持不动。它的参数量因此极小，通常只占全模型参数的很小一部分。

它背后的核心假设是：对不少下游任务而言，预训练模型已经学到了足够强的表示空间与主要变换方向，任务适配真正需要的，未必是重写整块权重矩阵，而可能只是调整各层激活的平移、阈值和默认响应水平。从这个角度看，BitFit 更像是在重新标定网络内部各单元的“触发基线”，而不是重建新的特征子空间。

这也解释了它为什么在一些小数据分类、文本匹配或轻量行为校正任务里常常表现得比直觉预期更强：如果任务边界与预训练表示已经高度接近，那么改变少量偏置，就足以让原本已经存在的特征更容易被激活，或更容易跨过最终判别阈值。反过来，当任务需要新的知识写入、复杂结构重排或明显不同的推理路径时，BitFit 往往会很快触到容量上限，因为它几乎无法改变表示之间的主导交互方向。

LayerNorm Tuning 只更新归一化层中的可学习缩放与偏移参数，典型写法可记为：

这里 \(\gamma\) 与 \(\beta\) 就是主要可训练对象，而主体权重矩阵保持冻结。它的参数量同样很小，但比 BitFit 更直接作用于每层隐藏状态的尺度（Scale）与中心（Shift）。

它背后的假设是：很多任务偏移并不需要创造全新的特征，只需要重新调节已有特征在各层中的相对幅度与数值范围。因为 Transformer 中大量残差路径都会经过归一化，LayerNorm 参数对信息流的“放大 / 压低 / 重新居中”有全局影响。于是，只调归一化参数，就可能在不改写主干矩阵的前提下，系统性地改变哪些特征更容易穿过后续层并主导输出。

这类方法尤其适合已经拥有较强基座、但需要重新校准风格、阈值、稳定性或局部行为边界的场景。它通常比 BitFit 稍强，因为它直接控制每层表示的尺度结构；但它仍然主要是在重标定现有表示，而不是构造新的复杂变换，因此面对大幅领域迁移或新知识注入时，上限仍然有限。

Attention Tuning 只解冻注意力模块中的参数，例如 \(W_Q,W_K,W_V,W_O\)，而继续冻结 FFN / MLP 与其他大部分结构。它的核心判断是：不少任务真正需要改变的，不是模型是否拥有某些知识，而是模型在当前任务中应该关注哪些 token、怎样聚合远近信息、如何在上下文中分配注意力。

它背后的假设比 BitFit 更强，也更结构化：预训练模型中的知识与模式大体已经存在，任务适配更多是在改变“信息路由（Information Routing）”而不是“知识存储（Knowledge Storage）”。如果这个假设成立，只调整注意力层就能显著改变模型的上下文读取方式，例如更关注结尾句、否定词、实体关系、长程依赖或某些格式锚点，而无需重写 FFN 中更重的参数块。

这也是为什么 Attention Tuning 在行为调整类任务上常有不错的性价比：它比 BitFit 和 LayerNorm Tuning 拥有更强的表示重排能力，又比全量微调和大范围 PEFT 更轻。但它的边界也很清楚。若任务核心是注入新事实、学习新术语本体、补足模型原本缺失的知识映射，仅靠改变注意力路由通常不够，因为许多稳定知识关联最终仍要落在 FFN / MLP 所承载的表示重编码里。

从整体上看，部分参数微调提供的是一种选择性解冻原参数的思路：输出层微调优先改读出，输入层微调优先改入口，局部结构微调优先改网络内部某个被认为最关键的子结构。若这些选择性更新已经足够，就没有必要进入更重的全量微调；若它们的容量仍然不够，下一步才更自然地转向后文的 LoRA、Adapter、Prefix Tuning 这类参数高效微调路线。

指令微调（Instruction Tuning）是 SFT 的一种数据组织方式：把任务描述（Instruction）显式写进输入，使模型学习“读懂指令并按指令输出”。典型样本是三元组：指令（instruction）、输入（input，可为空）、输出（output）。

{"instruction":"回答以下问题","input":"世界上最高的山是什么？","output":"珠穆朗玛峰。"}

对话/FAQ 场景更常用多轮消息格式（Chat Format），把 role（system/user/assistant）显式编码进序列；训练时同样只在 assistant 角色对应的目标 token 上计算损失。

{"messages":[
  {"role":"system","content":"你是一个严谨的技术助手。"},
  {"role":"user","content":"解释什么是交叉熵损失。"},
  {"role":"assistant","content":"交叉熵损失用于衡量预测分布与真实分布的差异……"}
]}

数据规模没有统一答案，但工程上最关键的是质量（Quality）与覆盖（Coverage）。常见实践：

• 领域 SFT：从 \(10^3\sim10^5\) 级别的高质量样本起步，先跑通指标与错误分析，再扩充数据与任务覆盖。
• 通用指令微调：更常见的是 \(10^5\sim10^6+\) 的多任务指令样本，用多样性换泛化。
• 偏好对齐数据：比较对（Preference Pairs）常在 \(10^4\sim10^6\) 级别，且对标注一致性要求更高。

拒绝采样微调（Rejection Sampling Fine-Tuning）本质上仍然属于监督微调路线。这里讨论的是 rejection sampling fine-tuning 这一路线，而不是近年某些语境里也会写成 RFT 的 reinforcement fine-tuning。它的核心做法是：监督数据不再完全来自人工直接编写，而是先由模型生成多个候选，再通过规则、验证器（Verifier）、奖励模型（Reward Model）或人工筛选，只保留其中最优或通过阈值的样本，最后把这些“被接受”的输出重新写回监督数据集，再按普通 SFT 的方式继续训练。

若把提示词记为 \(x\)，候选回答记为 \(\{y^{(k)}\}_{k=1}^{K}\sim \pi_{\mathrm{old}}(\cdot|x)\)，评分函数记为 \(s(x,y)\)，那么拒绝采样微调通常先从这组候选中选出满足 \(s(x,y)\ge \tau\) 的回答，或直接取最高分回答 \(y^\star=\arg\max_k s(x,y^{(k)})\)，再把 \((x,y^\star)\) 当作新的监督样本。后续优化目标并没有变成策略梯度或显式偏好损失，仍然是标准的 next-token 交叉熵。

因此，它可以被理解为一种先筛选、再监督的微调方式。与普通 SFT 相比，它利用模型自身采样与外部评分器把“哪种输出更好”这层信息先转成更高质量的目标答案；与 DPO、PPO 这类偏好优化相比，它并不直接学习候选之间的相对排序关系，而是把筛选结果硬化成新的监督标签。工程上，它经常处在普通 SFT 与显式偏好优化之间，既比纯手工 SFT 更能利用自动评估信号，又比完整 RLHF 或 DPO 更容易复用现有监督训练栈。

这条路线尤其适合存在较强可验证信号的任务，例如数学推导、代码生成、结构化输出、工具调用轨迹筛选，以及能用单元测试、规则校验、解析器或外部判分器稳定判断好坏的场景。因为一旦评分器足够可靠，拒绝采样就能把“生成多个候选、只留下正确或更优的那个”直接转化为高质量训练样本。

它的边界同样明确。若评分器本身噪声很大，或任务质量强依赖开放式偏好、语气细节、多维安全判断，那么把复杂偏好硬压成“通过 / 不通过”很容易损失信息；筛选过严还会让训练分布变得过窄，导致模型只会复现少数高分写法而削弱多样性。因此，拒绝采样微调更像一种高质量数据再蒸馏手段，而不是偏好对齐的终极替代品。

聊天微调（Chat Fine-tuning）强调多轮对话一致性：除单轮问答外，还需要覆盖上下文承接、拒答策略、工具调用格式、长对话记忆等。它通常仍是 SFT，只是数据分布更贴近真实对话。

参数高效微调（Parameter-Efficient Fine-Tuning, PEFT）把“微调”从“更新全部参数”变成“冻结基座（Base Model），只训练一小部分新增参数”。它仍然是当前大模型落地的主流选择之一：成本更低、训练更快、便于为不同任务保存多份轻量适配（例如每个业务一套 LoRA）。PEFT 并不只包含 LoRA、Adapter、IA3 这类“在模型内部加参数”的方法，也包含 Prefix Tuning、Prompt Tuning 这类软提示（Soft Prompt）路线；它们的共同点不是结构长得像不像，而是都遵循“冻结大部分预训练参数，只训练极小任务参数”这一基本范式。

Adapter 是插在每个 Transformer block 内部的一条很窄的可训练残差支路。设某一层原本输出为 \(h\in\mathbb{R}^{d}\)，Adapter 会先把它投影到一个远小于 \(d\) 的瓶颈维度 \(r\)，经过非线性后再投影回原维度，再以残差形式加回主干：

其中 \(W_{\mathrm{down}}\in\mathbb{R}^{r\times d}\) 负责降维， \(W_{\mathrm{up}}\in\mathbb{R}^{d\times r}\) 负责升维，且通常有 \(r\ll d\)。这就是所谓的瓶颈结构（Bottleneck Structure）：主干隐藏维度也许是几千，而 Adapter 内部只开放几十到几百维的可训练通道，因此新增参数量远小于全量微调。

 它通常插在自注意力子层或前馈网络子层之后，也就是“原子层输出 + LayerNorm / 残差”附近的位置。最常见的做法是在每个 block 中放两处：一处跟在 attention 输出之后，另一处跟在 FFN 输出之后。这样设计的直觉很直接：主干模型仍负责保留通用语言能力，而 Adapter 只学习相对于原模型的任务特定偏移。由于它是加法残差支路，模型一开始可以非常接近原始基座；随着训练推进，Adapter 再逐步学会把主干表示往当前任务需要的方向轻推一把。

这也是为什么 Adapter 常被初始化为近似恒等映射：例如让升维层初始非常小，使 \(\mathrm{Adapter}(h)\approx 0\)。这样做的效果是，训练初期模型几乎等同于原始基座，不会因为新增模块而立刻破坏预训练表示；随后再通过反向传播逐步放大这条残差分支，让它承担领域偏移、标签边界重塑或任务路由修正。与“直接改写主干权重”相比，这种路径更稳定，也更容易控制灾难性遗忘。

从参数量角度看，单个 Adapter 的主要新增参数就是两次线性映射，大约是 \(2dr\) 量级，而不是全层的 \(d\times d\) 或 \(d\times d_{\mathrm{ff}}\) 量级。因此，只要瓶颈维度 \(r\) 足够小，就能在保持表达力的同时，把训练显存、优化器状态和存储成本压到很低。这一点与 LoRA 的“低秩更新”在精神上相近，但它们的结构并不相同：Adapter 是显式新增一条小型 MLP 支路，LoRA 则是在原线性层内部参数化一个低秩增量。

工业实践里，Adapter 通常不是只挂在单个层上，而是分布式地插入到所有 Transformer block 中，从而让每一层都具备任务适配能力。它的一个重要工程优势是“插拔式（Plug-and-play）”任务切换：同一个基座模型可以加载不同任务的 Adapter 包，在情感分析、NER、检索重排等任务之间快速切换，而不必为每个任务都保存一整份完整模型。这也是 Adapter 在多任务部署和组织内模型复用场景中一直很有吸引力的原因。

LoRA（Low-Rank Adaptation）不改动原权重 \(W\)，而是学习一个低秩增量 \(\Delta W\)：

由于 \(r\) 很小，可训练参数与优化器状态显著减少。实践里常把 LoRA 加在注意力投影（如 \(W_Q,W_K,W_V,W_O\)）和/或 FFN 上。

截至 2026 年，LoRA 仍然是大语言模型参数高效微调里最常见的默认方案。原因并不神秘：它与主流 Transformer 线性层天然兼容，适配器权重体积小，便于为不同任务单独保存、热切换与合并；同时它对训练框架、推理框架和量化框架的兼容性也最成熟。因此，工程上常把 LoRA 看成 PEFT 的基线接口：后续很多方法，本质上都是在 LoRA 的参数化、量化方式或更新几何上继续细化。

在上面的记号里， \(A\in\mathbb{R}^{r\times d_{\text{in}}}\) 负责把原始输入方向投影到一个 \(r\) 维低秩子空间， \(B\in\mathbb{R}^{d_{\text{out}}\times r}\) 再把这个低维表示映射回输出空间。因此，对输入向量 \(x\) 而言，LoRA 增量的作用顺序是：

也就是说，先由 \(A\) 做“进低秩空间”的投影，再由 \(B\) 做“回原输出空间”的回投。直觉上， \(A\) 更像在问“哪些组合方向值得被拿出来单独调”， \(B\) 则更像在问“这些低维方向最终该怎样广播回原模型的输出通道”。

不同实现里，A、B 的命名和矩阵形状有时会看起来对调，这是因为有的库按数学乘法顺序命名，有的库按代码中参数张量的存储顺序命名。但概念并没有变：总有一个矩阵负责把高维输入压到低秩子空间，另一个矩阵负责把低秩更新再映射回原空间。只要抓住“先降到 \(r\) 维，再升回原维度”这一点，就不会被不同实现的符号差异干扰。

LoRA 的经典初始化也依赖这两个矩阵的不同角色。常见做法是让其中一个矩阵采用小随机初始化，而另一个矩阵初始化为 0；在当前这组记号下，更常见的叙述是让 \(A\) 随机初始化、 \(B\) 零初始化，于是训练开始时有：

这样做有两个直接好处。第一，训练初始时模型输出与原基座完全一致，不会因为 LoRA 分支突然注入随机扰动而破坏预训练能力。第二，参数不会陷入完全对称的零状态：若两边都初始化为 0，梯度传播会受阻；若两边都随机初始化，训练一开始又会平白给模型加上不必要的噪声。采用“单边随机、单边为零”的非对称初始化，既保证了初始增量为零，又保留了可学习性，这是 LoRA 训练稳定性的关键细节之一。

从梯度角度看，这个设计也有非常直接的理由。若记损失对增量矩阵的梯度为 \(G=\frac{\partial \mathcal{L}}{\partial \Delta W}\)，则有：

因此，当 \(A\) 随机、 \(B=0\) 时，训练开始的第一步通常会先更新 \(B\)，因为 \(\frac{\partial \mathcal{L}}{\partial B}=GA^\top\) 一般不为 0；而 \(\frac{\partial \mathcal{L}}{\partial A}=B^\top G=0\)，所以 \(A\) 会在后续几步中随着 \(B\) 脱离零状态后再开始获得梯度。也正因为如此，LoRA 的非对称初始化并不会“学不起来”，它只是让学习过程以一种更平稳的方式启动。

LoRA 真正需要重点理解的超参数并不多，但每一个都在控制不同维度的权衡：容量、增量强度、挂载范围、正则化和训练稳定性。它们之间并不是简单的“越大越好”关系。

这几个参数里，最容易被混淆的是 \(r\) 与 \(\alpha\)。 \(r\) 控制的是“允许模型沿多少个方向改”， \(\alpha\) 控制的是“这些方向的改动最终放大到多强”。前者对应容量，后者对应强度。增加 \(r\) 会改变可表达子空间本身；增加 \(\alpha\) 只是把已存在的低秩更新放大。

从经验上看，LoRA 的调参顺序通常也应当遵循这个逻辑：先确定挂载哪些模块、需要多大 rank 才能容纳任务偏移，再去调节 \(\alpha\) 与学习率，让训练稳定落在合适幅度上。若一开始就只靠提高 \(\alpha\) 去追求效果，得到的往往不是更强的表达力，而是更剧烈的扰动。

LoRA 挂在哪些线性层上，并不是纯工程细节，而与希望改变模型的哪一部分能力直接相关。若目标更偏风格迁移、格式控制、对话行为调整或路由方式改变，注意力投影层上的 LoRA 往往已经能带来明显效果；但若目标是注入新的领域术语、事实关联、实体属性映射或专业概念之间的稳定关系，FFN / MLP 往往更关键。原因在于：Transformer 里的 MLP 常被视为知识写入与模式重编码的重要位置，因此很多“新知识”最终要落到这些大规模前馈权重所张成的表示子空间里。

这也是为什么在不少实践中，LoRA 不只挂在 \(W_Q,W_K,W_V,W_O\) 上，还会同时挂在 FFN 的线性层上，甚至在资源允许时为 FFN 分配更高的秩（Rank）。低秩更新的本质是在原有权重空间附近增加一个受限的可训练子空间；如果希望修改的是知识关联本身，而不仅是信息流动方式，那么只改注意力层常常不够，需要让 MLP / FFN 也获得足够的适配容量。沿着这条思路发展的变体，如 DoRA（Weight-Decomposed Low-Rank Adaptation），本质上也是在不做全参数微调的前提下，给参数更新更强的表达能力。

这里的低秩假设作用于微调增量 \(\Delta W\)，而不是作用于预训练知识本身的存储方式。预训练模型中的知识通常以分布式表示（Distributed Representation）的方式编码在大量参数 \(W\) 里；LoRA 近似的是“为了适配当前任务，需要沿哪些方向改动这些参数”。前者讨论的是 \(W\) 如何承载知识，后者讨论的是 \(\Delta W\) 如何改变模型行为与输出边界。

很多微调任务并不要求模型写入大规模新知识，而是要求它重新组织已有表示：调整回答风格、强化指令跟随、遵守输出格式、放大某些线索、抑制另一些线索。这类任务的有效更新方向往往集中在少数子空间中，小秩 \(r\) 就足以带来明显收益。若任务要求模型稳定吸纳新的领域本体（Ontology）、术语体系、事实关系或复杂规则，适配增量的有效维度通常会上升，低秩近似就更容易成为容量瓶颈。

分布式存储也不意味着所有参数同等重要。即便在全参数微调（Full Fine-tuning）中，显著变化的往往也是少数关键方向；LoRA 的核心假设是，这些方向可以被一个较低维的子空间有效覆盖。当任务迁移幅度较小，这个假设通常成立；当关键更新分散在许多彼此独立的方向上，就需要更高的秩、更广的挂载范围，尤其是让 FFN / MLP 参与适配，必要时再转向 DoRA 或全参数微调。工程上，这体现为一条清晰的权衡：LoRA 优先优化效率，全参数微调提供更高上限；二者对应的是不同任务内在维度（Intrinsic Dimension）下的不同最优解。

LoRA 的一个工程优势是“可合并（Mergeable）”：推理前可把增量权重并入基座权重，从而不引入额外前向分支。对单个 LoRA，合并后得到的有效权重就是 \(W_{\text{merged}}=W+\Delta W\)（实践中常包含缩放系数）。

当存在多份 LoRA（多任务/多领域适配）时，最简单的合并是对增量做加权和：

这种“线性缝合”实现简单，但容易出现任务干扰（Interference）：不同 LoRA 在同一参数子空间里叠加，可能让模型对多个任务都变差。若你需要同时服务多个领域，更稳健的方案往往是“运行时选择哪一份 LoRA”或引入路由（Routing）机制，而不是把它们永久混成一份权重。

LoRA 的低秩增量在工程实现里通常写成带缩放的形式，而不是直接写成 \(\Delta W=BA\)：

这里的 \(r\) 是秩（Rank），决定低秩子空间的维度；\(\alpha\) 是缩放系数（Scaling Factor），决定这条增量支路最终以多大强度作用于原权重。把 \(\alpha\) 与 \(r\) 放在一起，不是书写习惯，而是为了在改变 rank 时尽量保持更新量的数值尺度处于可控范围。若只增大 \(r\) 而不做归一化，低秩分支的整体幅度往往也会随之增大，使不同配置之间难以直接比较。

因此， \(\alpha\) 控制的是“LoRA 支路有多强”， \(r\) 控制的是“LoRA 支路能沿多少个方向改动权重”。前者更接近幅值控制，后者更接近容量控制。单纯调大 \(\alpha\)，只是放大既有低秩方向的影响；单纯调大 \(r\)，则是在扩大可表达的更新子空间。

缩放在合并时同样不会消失。真正并回基座的不是裸 \(BA\)，而是已经乘上系数后的有效增量，因此合并后的权重应写成：

工程上，较小数据集与较轻任务迁移通常更适合温和缩放，因为此时更重要的是在保留基座先验的同时做局部修正；当任务迁移更深、希望 LoRA 更积极地重写行为边界或知识关联时，才会提高 \(\alpha\) 或放宽 \(r\)。它本质上是在调节“基座保守性”与“任务增量强度”之间的平衡。

DoRA（Weight-Decomposed Low-Rank Adaptation）的核心不是把 LoRA 的两个低秩矩阵 \(A\) 与 \(B\) 再拆一层，而是先把原始权重 \(W\) 按“幅值（Magnitude）+ 方向（Direction）”重写，再只让低秩更新作用在方向部分。对第 \(j\) 个输出通道，也就是权重矩阵的第 \(j\) 列，可先写成：

这里的 \(\frac{W_{:,j}}{\left\|W_{:,j}\right\|_2}\) 就是“把一个向量除以自己的 \(\ell_2\) 范数（L2 Norm）”。这样得到的新向量长度恰好等于 1，因此它不再携带原来的大小信息，只保留方向信息，也就是单位方向向量（Unit Direction Vector）。

这里 \(m_j\) 是一个标量，表示这一列权重的整体长度； \(\hat v_j\) 是单位向量，表示这一列“指向哪里”。这一步只是重参数化（Reparameterization）：没有改动原模型，只是把每一列从“一个普通向量”改写成“长度 × 单位方向”。

DoRA 的更新写法通常记为：

理解这条式子的关键，在于分清谁在控制方向，谁在控制大小。分式里的 \(V_{:,j}+\Delta V_{:,j}\) 先经过 \(\ell_2\) 归一化，因此无论 \(\Delta V\) 本身把这个向量拉长还是压短，归一化之后保留下来的都只有方向信息。换句话说，LoRA 产生的低秩增量 \(BA\) 在这里主要决定“这一列朝哪个方向偏转”，而不会直接把这一列的范数放大或缩小，因为范数已经被分母除掉了。

真正决定输出通道大小的是前面的标量 \(m'_j\)。如果把 \(m'_j\) 固定住，那么更新后的列向量范数始终满足 \(\left\|W'_{:,j}\right\|_2=m'_j\)，此时低秩更新确实只在改方向、不改大小；如果把 \(m'_j\) 设为可学习参数，那么 DoRA 就是在两个通道里分别学习：低秩分支 \(\Delta V\) 负责方向修正，标量 \(m'_j\) 负责幅值修正。无论是哪一种，方向与大小都不再像原始 LoRA 那样纠缠在同一个增量矩阵里。

这也是 DoRA 比原始 LoRA 更接近全参数微调的原因之一。普通 LoRA 直接对 \(W\) 加一个低秩增量 \(\Delta W\)，因此“方向变化”和“范数变化”混在同一个更新里；DoRA 则把这两件事显式拆开，使优化器可以分别决定“该往哪里转”与“该放大多少”。当任务需要更深地改写领域知识、重塑复杂判别边界或吸收更稳定的专业概念关系时，这种解耦往往更有表达力；代价则是额外的参数、归一化计算与实现复杂度。

QLoRA 在 LoRA 基础上进一步把基座权重量化（Quantize）到低比特（常见 4-bit），以极小显存加载大模型；训练时仍只更新 LoRA 参数。它把“能不能放得下”从硬约束变成可控工程问题，是许多个人/小团队微调 7B/13B 的关键技术路径之一。

其核心思路是：冻结量化后的基座权重，只在前向/反向计算时对它们做解量化（Dequantize），而真正需要学习的仍是低秩增量。一个简化写法是：

其中 \(X\) 是输入激活， \(W_q\) 是量化后冻结的基座权重， \(\mathrm{Dequant}(W_q)\) 表示把低比特权重恢复到计算精度后的近似值， \(\frac{\alpha}{r}BA\) 是 LoRA 分支， \(\alpha\) 是缩放系数（Scaling Factor），用来控制低秩增量对原模型的影响强度。

这里的“解量化”不是把模型永久还原回全精度权重再训练，而是指：权重在显存或存储中仍以低比特形式保存，只是在一次具体矩阵乘法发生时，临时把对应块恢复成计算所需的近似浮点值，再与输入激活相乘。也就是说，量化主要解决的是存储与显存占用，而解量化解决的是如何让这些低比特权重仍然参与正常线性计算。

因此，所谓“解量化计算路径”指的是：训练框架是否知道如何从低比特权重 \(W_q\) 出发，在前向过程中正确恢复近似浮点表示、完成矩阵乘法，并在反向传播时把梯度只传给 LoRA 分支而不是错误地写回量化权重本体。若这条路径存在，那么量化基座虽然被冻结，仍然可以作为可计算的主干参与训练；若这条路径不存在，量化权重就只是某种压缩后的静态文件，能用于推理加载，却不能自然地嵌入 QLoRA 的训练图中。

这里的前提不是“训练者必须先拿到一份原始全精度基座，再亲手把它量化”，而是必须拥有一份训练兼容的冻结量化基座。如果基座本身已经是可被训练框架直接加载、解量化并挂接 PEFT 的 4-bit / 8-bit 版本，那么它完全可以直接作为 QLoRA 起点；但如果它只是面向推理部署的静态量化模型，例如某些只强调推理速度或离线压缩格式的 checkpoint，那么它往往并不适合作为 QLoRA 的训练底座。决定因素不在于“是不是量化过”，而在于这种量化形式是否仍然保留了训练时所需的解量化计算路径与 PEFT 兼容性。

QLoRA 的关键不只是“4-bit”，而是分块量化（Block-wise Quantization）：权重不会用一套全局刻度统一压缩，而是被划分成许多小块，每块各自保存缩放因子。若第 \(g\) 个块的量化码为 \(\hat{w}^{(g)}\)，对应缩放因子为 \(s_g\)，则可抽象写成：

这个“分块”通常不是按语义结构切分，而是按固定块大小（例如若干连续权重为一组）直接切开。原因很简单：连续切块最容易实现，也最适合 GPU 并行。对每一个块，系统会单独估计一个比例尺 \(s_g\)，再用这个块自己的尺度去压缩和还原权重。于是更完整的写法通常是：

这里的 \(Q(\cdot)\) 表示把归一化后的数值映射到低比特量化码。也就是说，比例尺 \(s_g\) 的作用是先把第 \(g\) 个块拉到一个统一的局部数值范围，再交给 4-bit 码本处理；反量化时再乘回 \(s_g\)。在最朴素的实现里， \(s_g\) 可以由该块的最大绝对值、均方根，或其他稳健统计量导出，本质都是在问同一个问题：这一小块权重大致处在什么量级上。

一个极小的数值例子能说明为什么需要逐块比例尺。假设某一块权重大致落在 \([-0.1,0.1]\)，另一块却落在 \([-3,3]\)。如果整个张量只共享一个全局比例尺，那么为了容纳大块的幅度，小块里的许多细微差异都会被压扁，量化后落到相同的低比特值；而若分别为这两块设置 \(s_1\) 与 \(s_2\)，两块都能在自己的局部范围里充分利用有限的 4-bit 表示能力。也正因为如此，分块量化比全局共用一个缩放因子保留了更多有效信息，尤其更能缓解离群值（Outlier）对整体刻度的污染。

NF4（Normalized Float 4）进一步改进的不是“是否分块”，而是块内映射到哪一套 4-bit 码本。普通均匀量化更像是把一个区间机械地分成若干等宽小段；NF4 则利用很多 Transformer 权重在局部块内常呈现零中心、近似正态分布的事实，预先设计一套更贴近这种分布的离散代表值。于是块内每个权重更接近写成：

其中 \(c_{q_i}\) 是 NF4 码本中的代表值， \(q_i\) 是对应的 4-bit 索引。它不是假设所有权重必须严格落在同一个固定区间内，而是先按块做尺度归一化，再用更贴近正态权重分布的码本去逼近这些局部值。

双重量化（Double Quantization）与分页优化器（Paged Optimizer）则是在这套分块量化之上继续做工程压缩。前者的思路是：每个块都要保存自己的 \(s_g\) 或相关元数据，这些量的数量虽然远少于权重数，但它们的精度通常更高，而且每个因子只服务一个较小的权重块，因此把这部分成本均摊回“每个参数”之后，并不总能忽略。举例说，若一个缩放因子用 32 bit 保存、对应一个 64 权重的块，那么仅缩放因子这一项就相当于给每个参数额外分摊了 \(32/64=0.5\) bit；在 4-bit 权重场景里，这已经不是一个可以随手忽略的附加成本。双重量化做的，就是把这些缩放因子或相关元数据再压一层，继续降低这笔“元数据税”。后者则借鉴操作系统的分页思想，把优化器状态按页在 GPU 与 CPU 内存之间调度，从而避免 Adam 一类优化器把峰值显存推得过高。它们都不改变 LoRA 的学习目标，也不改变 QLoRA 的基本数学形式，而是在工程层面继续压低“把大模型微调跑起来”的资源门槛。

Q-DoRA 可以看作 QLoRA 与 DoRA 的组合：基座仍采用低比特量化以节省显存，但更新形式不再是普通 LoRA，而是“量化基座 + 方向/尺度解耦”的 DoRA 结构。一个简化表达是：

它的工程含义很直接：用 QLoRA 解决“显存放不下”的问题，用 DoRA 缓解“低秩更新表达力不够”的问题。若资源非常紧、任务主要是格式控制与轻量指令对齐，普通 QLoRA 往往已经足够；若任务更偏逻辑推理增强、专业知识注入、复杂边界判别或高质量垂直领域适配，Q-DoRA 往往是更稳妥的折中。对应代价是训练更慢、实现更复杂，且并非所有推理栈都像原始 LoRA 那样原生支持。

LoRA-MoE 可以理解为“适配器级的 MoE”：不把 FFN 变成稀疏专家，而是保留基座不变，准备多份 LoRA 作为“领域专家”，再用一个路由器（Router）按请求/句子/甚至 token 选择或加权组合这些 LoRA。直觉上，它用极小的可训练参数，为同一个基座提供多域能力，同时避免把所有任务硬合并到一份权重里。

一种抽象表达是把输出写成“基座 + 适配器混合”：

其中 \(g_e(x)\) 是路由权重，可以来自显式分类器（域识别）、检索到的任务标签，或一个可训练的 gating 网络。工程上，LoRA-MoE 的关键不在公式，而在路由与评测：你需要定义“什么输入该走哪套 LoRA”，并防止路由错误导致质量抖动。

截至 2026 年，LoRA-MoE 的实际地位更接近高级可选架构，而不是参数高效微调里的默认主流基线。它已经形成了一条持续演进的方法线，说明“多 LoRA + 路由”并非概念玩具；但在更常见的工业部署里，成熟默认方案仍然往往是“单基座 + 多个独立 LoRA 适配器”，按请求或租户切换，而不是把路由器永久并入模型主干。原因并不神秘：LoRA-MoE 除了要训练适配器本身，还要额外处理路由质量、专家利用不均、冷专家几乎不被激活、线上可观测性以及请求分布变化带来的稳定性问题。只有当任务确实需要在同一个运行图里动态融合多域能力，而不是简单地在不同 LoRA 之间切换时，LoRA-MoE 的额外复杂度才更值得支付。

比 LoRA-MoE 更常见、也更容易落地的方案，是多个独立 LoRA 共享同一个基座模型。这里的共享不是把多份 LoRA 合并成一套永久权重，而是让基座参数在 GPU 中只保留一份；不同请求到来时，再按请求绑定对应的适配器。这样做的直接收益是：显存里最重的那部分参数不需要为每个任务重复存一遍，而任务差异主要体现在额外加载的轻量增量权重上。

从推理执行角度看，这种“热切换”并不意味着每来一个请求就重新加载整个模型。更常见的做法是：基座常驻显存，LoRA 适配器按需驻留在 GPU 或 CPU 侧缓存中；请求只需声明“当前使用哪一份适配器”，调度器就会在对应层上把这一份 LoRA 增量接入当前 forward。若某个适配器近期很少被访问，它可以被换出；当请求再次到来时，再从本地盘、对象存储或 Hub 拉回。于是系统真正管理的是适配器缓存与调度，而不是整模型重载。

这条路线之所以在 2026 年更主流，是因为它把“多域能力”问题拆成了两个更容易控制的子问题：第一，训练阶段各自产出独立 LoRA，任务之间天然隔离；第二，推理阶段只做选择和缓存，不必额外训练路由器，也不会把多个领域永久混到同一组权重里。代价主要落在工程侧：适配器的 rank、目标模块集合、张量并行配置与基座版本必须兼容；同时服务系统还要决定 GPU 能同时保留多少份 LoRA、超出容量时按什么策略驱逐，以及批内是否允许不同请求混用不同适配器。

截至 2026 年，这已经不是纸面方案，而是主流高吞吐推理框架的标准能力之一。vLLM 支持按请求选择 LoRA，既可以在服务启动时预注册，也支持通过运行时 API 与解析插件动态加载；SGLang 支持同一批次中的不同序列绑定不同 LoRA，并提供适配器加载、驱逐、后端 kernel 与批内 LoRA 数量控制；Hugging Face TGI 也支持在启动时加载多份 LoRA 并在请求中指定 adapter；TensorRT-LLM 则已经提供多 LoRA 推理示例与运行时请求绑定接口。换句话说，多 LoRA 共享基座在今天更像是一种成熟的服务形态，而不是实验性质的技巧。

与 LoRA、Adapter 这类“直接改模型内部参数化”的路线不同，基于 Prompt 的微调把任务适配写在输入条件上。它的核心不是重写主干权重，而是构造一小段能够引导模型行为的任务条件，让模型在保持基座冻结的前提下，沿着这段条件生成更符合目标任务的输出。

这里需要先把两类 Prompt 区分开。硬提示（Hard Prompt）是人工编写的离散文本提示，本质上属于提示工程（Prompt Engineering），而不是参数高效微调；软提示（Soft Prompt）则是一组可训练的连续向量，通常可以看成“不对应真实词表 token 的虚拟 token embedding”。前者没有训练参数，可解释性强但搜索空间受限；后者进入连续空间后更容易通过梯度优化找到有效解，因此才构成 Prompt Tuning、Prefix Tuning、P-Tuning、P-Tuning v2 这一路软提示微调家族。

从机制上看，软提示路线的共同点是：人为构造或学习一小段任务向量，把它们拼接到原始输入或注意力状态中，再让这些额外向量参与模型的注意力计算，从而影响后续真实 token 的生成和判别。它的工程优势非常明确：主干参数无需为每个任务复制一份，多任务场景下只需切换不同的 Prompt 参数即可。

因此，硬提示、软提示与 LoRA 的差异，并不只是“参数多少”，而是任务条件被写入模型的层次不同。硬提示只改自然语言输入；Prompt Tuning 把任务条件写进输入嵌入；Prefix Tuning 把任务条件送进每层注意力；LoRA 则直接改写模型内部线性映射的参数化。条件写得越深，通常表达力越强，但实现和系统复杂度也越高。

Prefix Tuning 属于软提示类 PEFT。它学习的不是自然语言前缀文本，而是一组连续可训练向量（Continuous Prefix），并把这组向量作为每一层注意力里的额外 Key / Value 注入。若某层原本的注意力键值对为 \(K,V\)，则 Prefix Tuning 可以理解为把它们扩展成 \([K_{\text{prefix}};K]\) 与 \([V_{\text{prefix}};V]\)，让后续 token 在每一层都能访问这段任务特定“前缀记忆”。

它的关键不只是“在输入前加几个向量”，而是在所有层分别注入前缀状态。不同层的前缀通常并不共享；每一层都有自己的 prefix 参数，因为浅层和深层承担的表示功能并不相同。于是，Prefix Tuning 更像是在每一层都额外挂上一小段可学习上下文，让模型在整条前向路径中持续感知任务条件，而不是只在输入口看一眼提示后就完全交给主干自行传播。

若前缀长度记为 \(m\)、模型隐藏维度记为 \(d\)、层数记为 \(L\)，那么最粗略的参数量量级可以理解为 \(O(Lmd)\)。这也是它为什么通常比全量微调和 LoRA 更轻，但又明显重于单纯输入层 Prompt Tuning：它的参数量来自“每层各有一小段前缀”，而不是只在输入层保存一组虚拟 token。

直接把前缀向量当作自由参数去优化，并不总是最稳定。因为这些向量一开始就要进入每层注意力，如果初始化过于随意，训练前期很容易让注意力分布出现较大抖动。为此，Prefix Tuning 的经典实现常引入一层小型重参数化网络，例如用一个 MLP 先把较低维或更结构化的中间表示映射成真正送入各层的 prefix Key / Value。

这种做法的本质不是给 Prefix Tuning 增加永久推理负担，而是把训练阶段的优化空间改造成更平滑、更容易收敛的形式。训练完成后，这个 MLP 生成出的前缀状态通常可以被直接缓存或固化，推理时未必需要继续保留完整重参数化模块。因此，它更像一种训练期稳定化技巧，而不是 Prefix Tuning 必须背负的长期结构成本。

它与 Prompt Tuning 的差别不在于“前缀长短”，而在于注入位置。Prompt Tuning 只在输入嵌入层增加一小段软提示；Prefix Tuning 则把任务参数直接送进每层注意力，因此它通常更有表达力，也更接近“在每层引导模型如何读写上下文”。代价是实现更复杂，模型结构耦合更深，训练与推理栈也更需要原生支持。

到 2026 年，Prefix Tuning 仍然是成立且标准的 PEFT 方法，但它在主流大语言模型指令微调里的存在感已经明显弱于 LoRA。它最有价值的场景通常是：希望极小参数量地控制条件生成行为、使用 Encoder-Decoder 或较经典的条件生成架构，或者研究上需要把“任务条件”明确写进每层注意力。若任务是当代 Decoder-only LLM 的通用指令对齐、风格迁移或领域适配，LoRA / QLoRA 往往仍是默认起点：更稳、更通用、推理框架支持也更成熟。

Prompt Tuning（软提示/Soft Prompt）同样属于 PEFT，但它比 Prefix Tuning 更轻：只在输入嵌入层前面拼接一小段可训练“虚拟 token embedding”，而不改动 Transformer 内部层的参数结构。设输入嵌入序列为 \(E(x)\)，软提示为 \(P\in\mathbb{R}^{m\times d}\)，则模型实际看到的是拼接后的序列 \([P;E(x)]\)。训练时更新的只有 \(P\)，基座参数保持冻结。

它的核心假设是：对于某些任务，模型原本的能力已经足够，真正缺少的只是一个足够好的“任务启动条件”。如果这组输入层虚拟 token 能把模型推到合适的工作点，后面的冻结主干就能沿着原有能力完成任务。因此，Prompt Tuning 在参数量上往往可以做到比 LoRA 还小一个量级，尤其适合“大量轻任务共享同一基座”的场景。

Prompt Tuning 与 Prefix Tuning 的根本区别，不在于二者都用了虚拟 token，而在于任务条件写入的深度不同。Prompt Tuning 只在输入层插入软提示，后续所有层看到的都是这段输入在主干网络中自然传播后的结果；Prefix Tuning 则直接在每一层注意力中附加前缀状态，使任务条件持续存在于整条注意力链路中。前者最轻，后者更强。

也正因为如此，Prompt Tuning 在超大模型上有时会随着基座规模增大而变得更有效，因为大模型本身已经足够强，输入端的一点点软条件就足以触发所需能力；而在中小模型或需要强行为控制的任务上，它往往不如 Prefix Tuning、LoRA 稳定。

围绕这一路线还发展出 P-Tuning、P-Tuning v2 等变体。它们的共同目标，都是让软提示不只停留在“输入前拼一小段向量”这么简单，而是通过更强的参数化或更深层的注入方式，提高在理解类任务和较小模型上的表现。若把家族关系压缩来看：Prompt Tuning 是最轻的输入层软提示；Prefix Tuning 把软提示推进到各层注意力；P-Tuning / P-Tuning v2 则在“如何生成这些提示、提示该注入多深”上继续增强。

到 2026 年，Prompt Tuning 仍然实用，但更像轻量特化选项而不是主流默认路线：当目标是极小参数、海量任务复用、低存储部署或 prompt-adapter 风格服务时，它仍有现实价值；当目标是指令遵循、复杂格式约束、长对话行为修正或稳定领域适配时，LoRA / QLoRA 往往更稳妥，Prefix Tuning 也通常比纯输入层软提示更有表达力。

前面列出的全量微调、部分参数微调、Prompt 系软提示、Adapter、LoRA、QLoRA 并不是互相替代的“流行名词清单”，而是针对不同约束条件的不同最优解。真正决定选型的，通常不是单一维度上的“效果最好”，而是四个问题同时成立时的交集：样本量够不够、GPU 预算有多紧、任务到底是在改行为还是改知识、上线时更看重单任务极致效果还是多任务复用与切换。

样本量是第一道分界线。数据很少时，更应优先考虑冻结主干参数的路线，例如 Prompt Tuning、Prefix Tuning、LoRA、QLoRA 或更轻的部分参数微调。原因并不只是“省显存”，而是冻结主干更容易保留预训练先验，降低小数据把模型硬拉向局部模式的风险。数据足够大、分布足够稳定、目标能力又确实需要深度改写时，全量微调才更值得支付它的高成本，因为只有在这种条件下，放开全部参数带来的表达上限才真正有机会被利用。

GPU 资源是第二道分界线。若显存非常紧，QLoRA 往往是生成模型微调的现实起点；若任务更轻、希望一个基座承载大量小任务，Prompt Tuning 或 Prefix Tuning 的存储优势会更突出；若 GPU 充裕且追求最强任务特化，上限仍然在全量微调一侧。换句话说，量化 LoRA 解决的是“放不放得下”，LoRA 解决的是“如何低成本改行为”，而全量微调解决的是“是否要把整套模型一起重写”。

任务性质决定第三道分界线。若变化主要发生在输入接口，例如新增专有 token、符号或特殊控制标记，输入层微调与软提示通常比全模型更新更自然；若变化主要体现在最终读出或评分方式，输出层微调往往就够；若目标是稳定调整指令遵循、格式约束、风格边界、多轮行为或一般性领域适配，LoRA / QLoRA 通常是默认解；若真正需要吸收大量新知识、重构深层表示、改变词表、上下文长度或位置编码等底层设定，则继续预训练或全量微调才更匹配问题本质。

推理形态决定第四道分界线。多任务在线服务最看重“一个基座 + 多个轻量增量”时，LoRA 及其热切换形态通常最实用；Prompt Tuning 与 Prefix Tuning 也具备同样的任务切换优势，只是主流推理框架与工业实践对 LoRA 的支持更成熟。Adapter 虽然同样具备插拔式优点，但它会在前向路径里保留额外计算分支，因此在当代大模型场景里通常不再是默认首选。若目标是最低推理延迟，合并后的 LoRA 与单体全量微调模型通常更占优；若目标是海量任务共享一个基座、频繁热切换，则运行时加载轻量适配器更灵活。

因此，微调技术选型可以压缩成一条很实际的经验顺序：先判断是否根本不该训练参数，而应优先做参数外优化；若需要训练，再判断任务是否只是轻量行为适配，此时 LoRA / QLoRA 往往是默认起点；若样本极少且强调多任务极致轻量切换，软提示路线才更有吸引力；若任务要求深度改写底座知识或结构，再考虑继续预训练与全量微调。只有当这些路线都无法满足目标时，才值得继续向更重、更贵的训练方式推进。

再往前走一步，就是下一节的偏好对齐问题：如果模型已经学会了任务本身，却仍然不会在多个可行回答中稳定偏向人类真正想要的那个，那么问题就不再只是“选哪种微调技术”，而是要不要进入奖励模型、DPO、PPO、GRPO 这一层相对偏好优化。

强化学习对齐（RL-based Alignment）更准确的说法是“偏好对齐（Preference Alignment）”：用偏好信号把模型输出推向“更符合人类/评审标准”的区域。监督微调（SFT）解决的是“模型是否会按指令作答”，偏好对齐解决的则是“在多个看似都能回答问题的候选答案中，模型是否会稳定偏向更有帮助、更安全、更符合人类预期的那个”。两者并不重复，而是前后衔接的两层约束。

监督微调本身当然可以承担一部分对齐工作。只要训练数据里显式包含拒答样例、安全边界、好坏答案对照、批判依据（Critique Rationale）、自我修正链路，模型就能通过有监督学习吸收相当一部分“什么回答风格更合适、什么回答应当避免”的行为模式。很多现代对齐流程的第一步，本来就是把这些规则先写进 SFT 数据，再让模型学会基础行为边界。

但 SFT 的学习目标本质上仍然是给定输入，去拟合某个目标输出。若把提示词记为 \(x\)、参考答案记为 \(y\)，那么它优化的是 \(\log \pi_\phi(y|x)\) 这一类似然目标。即使数据里同时给出“好答案、坏答案、批判依据”，SFT 也主要是在学习如何复现这些文本本身，而不是直接学习“在多个候选回答之间，哪个应该被稳定偏好”。这意味着它更擅长教会模型怎样说，却不天然等价于教会模型怎样在多个可行答案里做排序。

拒绝采样微调可以看作这两层之间的一条中间路线。它先让模型对同一提示词生成多个候选，再借助验证器、规则或奖励信号只保留最好的一部分，把筛选结果重新写回监督数据，再继续做 SFT。这样做比纯手工监督更能利用自动评估，但仍然没有显式保留“胜者为何优于败者”的相对排序结构，因此它更像把偏好信号先离散化成高质量目标答案，再交给监督微调吸收。

偏好对齐之所以需要单独成层，关键就在这里。很多真实问题并不存在唯一标准答案，而是存在一组“都不算错、但质量不同”的候选回答：有的更完整，有的更安全，有的更符合语气预期，有的虽然事实没错却明显不够有帮助。把这种问题压成单一参考答案做 SFT，模型容易学到某一种写法，却未必真正学到“为什么 A 应优于 B”。批判依据也有同样的局限：模型可以学会输出一段像样的批判文本，但这并不自动保证它在自由生成时，会稳定地把这些批判原则内化为回答排序规则。

因此，今天更准确的技术分层是：SFT 可以完成基础行为对齐，而偏好优化负责处理相对偏好排序。前者让模型学会回答、学会拒答、学会遵守基本格式；后者让模型在多个都看似合理的答案之间，更稳定地偏向人类真正想要的那个。也正因为如此，现代对齐并不必然等于“强化学习”本身：PPO / RLHF 是一条路线，DPO、ORPO 等把偏好直接写进损失的路线则是另一条路线。它们解决的是同一个问题，只是优化手段不同。

这一层之所以重要，还因为大模型的质量并不能被单一指标完整刻画。古德哈特定律（Goodhart's Law）指出：一旦某个指标变成优化目标，它往往就不再是一个好的指标。放到模型对齐里，这意味着如果只盯住某个狭窄基准分数，模型很可能学会迎合该指标，却牺牲真正的可用性、稳健性与安全性。偏好对齐因此更强调相对排序、多维度评审与参考模型约束，而不是把“好答案”简化成单一静态分数。

从工程上看，主流路线分为两类：

• 显式奖励：先训练奖励模型（Reward Model），再用 PPO 等策略优化算法做 RLHF。
• 直接偏好：不显式训练奖励模型，直接用偏好对优化策略（例如 DPO）。

奖励模型（Reward Model, RM）把（提示词 \(x\)，回复 \(y\)）映射为一个标量分数 \(r_\theta(x,y)\in\mathbb{R}\)。它的职责不是生成答案，而是充当自动评审器：输入“问题 + 回答”，输出一个可比较的质量信号，用来近似人类对回答质量的偏好判断。

奖励模型的训练数据通常是成对偏好数据，而不是单条样本加绝对分数。对同一提示词 \(x\)，先让模型生成多个候选回答，再由人工标注员或更强的评审模型选择其中更优的一条，形成三元组 \((x,y_w,y_l)\)：其中 \(y_w\) 是被接受的回答（chosen response），\(y_l\) 是被拒绝的回答（rejected response）。

这种二选一偏好标注通常比直接打 1 到 5 分更稳定。原因并不复杂：绝对分数依赖个人尺度，主观漂移大；相对偏好只要求判断 A 和 B 谁更好，一致性通常更高，标注成本也更低。因此，现代偏好对齐流程更常见的监督信号是排序关系，而不是绝对评分。

奖励模型通常以已经完成 SFT 的语言模型为骨干（Backbone）进行改造，而不是从零开始训练：保留主体 Transformer 表示层，移除原先用于生成下一个 token 的语言建模头（LM Head），换成一个输出单一标量的质量头（Reward Head）。这样做的好处是，奖励模型继承了 SFT 模型对指令与回答结构的理解，只需要继续学习“哪种回答更好”这一层偏好判断。

对一对“胜/负”样本 \((x,y_w,y_l)\)，常用 Bradley–Terry / Logistic 形式把分数差转为偏好概率：

并用对数损失训练：

关键点：sigmoid 用在“分数差”上，而不是对每个 \(r_\theta(x,y)\) 再套一层 sigmoid。分数本身不需要限制在 \([0,1]\)；概率来自差值的 logistic 映射。

参数 \(\theta\) 表示奖励模型的参数集合（Parameter Set），包含全部权重矩阵与偏置项，并非单一标量。

单调性视角：因为 \(\sigma\) 单调递增且 \(-\log(\cdot)\) 在 \((0,1)\) 上单调递减，所以 \(\mathcal{L}_{\mathrm{RM}}\) 对分数差 \(\Delta r=r_\theta(x,y_w)-r_\theta(x,y_l)\) 单调递减。训练会推动 \(\Delta r\) 变大，从而把胜者分数推高、败者分数压低。

RLHF（Reinforcement Learning from Human Feedback）把整个偏好对齐流程拆成三段：先收集偏好数据，再训练奖励模型，最后用奖励模型为主语言模型提供优化信号。它的核心贡献不在于“使用了强化学习”本身，而在于把原本昂贵、缓慢、难以规模化的人类评审，转化成可以自动计算的奖励分数。

在 RLHF 里，语言生成被改写为一个强化学习问题：token 是动作（Action），策略是语言模型 \(\pi_\phi(y|x)\)，奖励来自 \(r_\theta(x,y)\)。早期最经典、也最具代表性的做法，是以 PPO（Proximal Policy Optimization）作为策略更新算法，用奖励模型给出的分数提高高质量回答的生成概率，同时压低低质量回答的概率。常见目标写成：

这里的 \(\pi_{\mathrm{ref}}\) 通常不是额外训练出来的一套神秘模型，而就是PPO 开始前那一版 SFT 模型的冻结副本。标准顺序通常是：先从预训练基座得到 SFT 模型，再把这份 SFT checkpoint 复制成两路，一路继续作为可训练策略 \(\pi_\phi\)，一路冻结为参考模型 \(\pi_{\mathrm{ref}}\)。因此并不存在“先有参考模型还是先有策略模型”的循环依赖；二者都来自同一个 SFT 起点，只是一个继续更新，一个保持不动。

式子里的 KL 项与 KL 散度（Kullback–Leibler Divergence）是直接对应的关系：这里所谓的“KL 项”，就是目标函数中的 \(\beta\,D_{\mathrm{KL}}(\pi_\phi\|\pi_{\mathrm{ref}})\) 这一项，只不过前面再乘了一个权重系数 \(\beta\)。它的作用不是做额外评测，而是作为正则约束，把当前策略锚定在 SFT 参考分布附近，防止模型为了讨好奖励模型而偏离过远，出现奖励黑客（Reward Hacking）、语言退化或能力崩塌。PPO 在这类任务里长期被广泛采用，原因正是它对策略更新幅度加了“护栏”，能在追求更高奖励和保持原有能力之间维持相对稳定的折中。

PPO（Proximal Policy Optimization）之所以长期是 RLHF 的默认优化器，不是因为它在理论上最优，而是因为它足够稳。普通策略梯度（Policy Gradient）的问题在于：一旦某次更新把策略推得过远，语言模型就可能突然偏离原有分布，表现为回复风格失真、可读性下降、奖励黑客，甚至整体能力退化。PPO 的核心改进就是限制“这一步最多改多少”，让策略朝高奖励方向移动，但每次只允许小步修正。

它最经典的形式是 clipped objective。若当前策略与旧策略的概率比记为 \(\rho_t=\frac{\pi_\phi(a_t|s_t)}{\pi_{\phi_{\mathrm{old}}}(a_t|s_t)}\)，对应优势函数（Advantage Function）为 \(A_t\)，则目标可写成：

这里的 \(\epsilon\) 是更新护栏宽度。若某次更新让概率比偏离 1 太远，clip 就会截断继续放大的收益，阻止模型为了追求更高奖励而走得过猛。对 LLM 而言，这个机制尤其重要，因为语言模型的输出分布非常高维，只要少量 token 的条件概率被过度放大，就可能连锁改变整段回答的行为模式。

放到 RLHF 流程里，PPO 的完整闭环通常是：先用当前策略对同一提示词采样若干回答，再用奖励模型评分，并结合参考模型的 KL 惩罚构造最终回报；随后估计优势 \(A_t\)，再用 clipped objective 更新策略。也正因为这里同时牵涉采样、奖励模型、参考模型、旧策略快照与优势估计，PPO 路线的工程链条明显比 DPO 更长，训练成本和调参复杂度也更高。

工业实践中，奖励往往也不是单一维度。一个典型做法是分别训练“有用性（Helpfulness）”与“安全性（Safety）”奖励模型，再按加权和形成总奖励，例如 \(R_{\mathrm{total}}=\alpha R_{\mathrm{helpful}}+\beta R_{\mathrm{safety}}\)。这样可以显式控制不同对齐目标之间的权重，而不是把所有偏好都压缩进一个不可分解的单一评分器里。

到了大模型对齐阶段，很多方法在问题定义上仍然属于强化学习，但在算法形态上已经明显偏离经典强化学习教材中的标准样子。原因并不神秘：LLM 对齐面对的是一种极其特殊的决策问题。若强行套用经典 RL 映射，可以把状态（State）理解为“当前提示词 + 已生成 token 序列”，把动作（Action）理解为“从巨大词表中选择下一个 token”，把奖励（Reward）理解为“整段回答生成完之后得到的评分”，把环境（Environment）理解为模型自身的自回归生成过程。这个映射在概念上成立，但工程代价极高。

困难主要集中在三点。第一，动作空间极大：每一步都要在成千上万个 token 中做选择。第二，奖励高度延迟：很多时候只有整段回答生成完毕后，才能得到一个总体评分，时间信用分配（Temporal Credit Assignment）比经典控制任务更棘手。第三，策略优化链条极重：若完整采用 PPO 式 RLHF，训练时往往要同时维护可训练策略、旧策略快照、参考模型、奖励模型，很多实现里还要有价值网络（Value / Critic），显存、吞吐和稳定性压力都非常大。

因此，大模型对齐逐渐出现了一条清晰演化路径：保留强化学习的问题定义，重写强化学习的求解形态。所谓“保留问题定义”，指的是目标仍然来自评估性反馈（Evaluative Feedback）而不是逐步给定的标准答案；模型仍然要学会在多个候选回答之间偏向更优者。所谓“重写求解形态”，指的是不再机械照搬经典 Actor-Critic 或全流程在线 RL，而是通过数学消元、离线偏好优化、组内相对比较、弱化价值网络等方式，把问题改写成更适合大模型训练的目标。

从这个视角看，DPO 与 GRPO 都不是对强化学习问题本身的放弃，而是对经典算法形态的工程重构。DPO 走得更远：它把“奖励建模 + 策略优化”折叠成一个静态偏好对损失，形式上已经非常接近监督学习或对比学习。GRPO 则保留了“采样 - 评分 - 更新”的策略优化闭环，但用组内相对优势替代显式价值网络，属于一种极简化的策略优化路线。前者更像对 RL 目标的解析化改写，后者更像对 PPO 结构的裁剪与瘦身。

DPO（Direct Preference Optimization）是这种“非典型 RL 形态”里最典型的一类：它直接用偏好对 \((x,y_w,y_l)\) 优化策略，不显式训练奖励模型，也不需要 PPO rollout。它的出发点很明确：既然手里已经有“哪个回答更好”的偏好数据，那么没有必要再额外训练一个奖励模型，再把奖励模型嵌入完整强化学习闭环；可以直接把偏好关系作用到策略本身。

DPO 仍然保留一个冻结的参考模型 \(\pi_{\mathrm{ref}}\) 作为锚点，并同时比较当前可训练模型与参考模型在“被接受回答”和“被拒绝回答”上的相对概率。这里的概率不是单个 token 的局部值，而是整条回答在 token 级对数概率上的汇总，因此本质上是在比较“当前模型是否比参考模型更偏向好答案、同时更远离差答案”。典型目标写成：

直觉上，DPO 直接增大“胜者相对败者”的对数概率优势（log-odds margin），同时用参考模型作为锚点。它把 RLHF 中“奖励建模 + PPO 优化”的两步折叠成一步有监督式偏好优化，因此工程更轻、训练更稳定，也更容易复用现有 SFT 训练栈。正因为这一点，DPO 已经成为许多中小团队进行偏好对齐时的默认起点。

从经典 RL 的角度看，DPO 最“不像强化学习”的地方在于：它几乎拿掉了在线探索、环境交互和显式优势估计这些传统组件，直接在离线偏好数据上优化策略。这也是为什么它在形式上看起来更像监督学习；但它解决的仍然是评估性反馈下的偏好优化问题，而不是普通的标签拟合问题。

DPO 训练并不是要把“好样本相对差样本的概率优势”硬拉到某个固定阈值才算结束。它优化的是整个偏好数据集上的相对排序损失，而不是某个预设的绝对 margin。对容易区分的样本，胜者优势会很快变大，梯度也随之减弱；对天然模糊、偏好边界不清的样本，这个优势不可能无限扩大。若继续强行训练，模型更可能开始过拟合偏好数据、放大表面写法差异，甚至损害生成分布稳定性。因此，DPO 的停止标准本质上仍然是验证集偏好指标、生成质量与分布稳定性是否已经饱和，而不是“margin 必须大于某个固定常数”。

GRPO（Group Relative Policy Optimization）比 DPO 更接近经典策略优化，但它同样属于“非典型 RL 形态”：对同一个提示词 \(x\) 采样一组候选回复 \(\{y_k\}_{k=1}^{K}\)，用奖励/偏好信号在组内排序或打分，再把“相对好坏”转成策略梯度更新。它的核心动机是：用 组内比较 构造优势（Advantage）或基线（Baseline），从而减少对显式价值网络（Critic / Value Function）的依赖。

一种常见的做法是把组内奖励做标准化得到相对优势：

并用 PPO 风格的 clipped objective 更新策略（仍然可带 KL 正则到参考模型）：

真正决定“奖惩”的不是某个回答的绝对分数，而是它在同组候选中的相对位置。若某个回答的组内奖励 \(r_k\) 高于这一组的平均水平 \(\mu_r\)，则 \(A_k>0\)，训练会提高模型再次生成这类回答的概率；若某个回答低于组内平均水平，则 \(A_k<0\)，训练会压低模型对这类回答的偏好。换句话说，GRPO 奖励的是“在同一个 prompt 下，比同组其他回答更好的样本”，惩罚的是“在同一个 prompt 下，相对更差的样本”，而不是单独给每个回答设一个全局固定门槛。

从优化角度看，这种“压制”并不是额外加一个独立惩罚按钮，而是让该回答在目标函数里贡献负优势（Negative Advantage）更新。结果上，它等价于让这类回答对应的策略概率逐步下降：模型以后再采样到相似回答时，会更倾向于远离它，而不是继续强化它。

因此，GRPO 与经典 PPO 的最大差别，并不在于“还有没有策略梯度”，而在于它把传统 Actor-Critic 结构大幅裁剪了。经典 PPO 往往依赖一个显式价值网络去估计 baseline，以降低方差；GRPO 则直接用同组候选回答之间的相对分数生成基线，把“谁比平均更好、谁比平均更差”写进组内统计量。这使它在大模型场景下明显更省显存，也更容易扩展到规则打分、程序验证和裁判模型评分等复杂奖励来源。

这种机制尤其适合答案质量强依赖上下文、很难用一个全局绝对分数刻画的场景。对某些 prompt，70 分的回答可能已经是组内最优，应当被正向强化；对另一些 prompt，80 分的回答仍可能只是组内倒数，应当被压制。GRPO 的核心就在于：目标模型并不是因为“达到某个统一分数线”而得到奖励，而是因为它在同题候选集合里相对更优而受到正向更新。

GRPO 仍然需要某种奖励/偏好信号（显式奖励模型、规则打分、对比标注等）；它改变的是“如何用这些信号构造稳定的更新”，而不是免除奖励来源本身。把几条路线放在一起看，会更清楚：RLHF + PPO 强调显式奖励建模与稳定策略更新，DPO 强调跳过奖励模型后的直接偏好优化，GRPO 则强调用组内相对比较构造更稳定的优势信号。它们共享同一个目标，只是在“偏好信号如何表达、如何被模型消化”这件事上采取了不同工程路径。

参数外优化（Parameter-free Optimization）指的是：在不更新模型权重的前提下，通过改写提示词（Prompt）、输出约束、示例组织、工具说明、工作流与评估闭环来提升系统表现。它优化的对象不是模型内部参数，而是模型与任务之间的接口层。

这条路线之所以重要，是因为很多任务的瓶颈并不在模型“不会”，而在任务描述不够精确、输出约束不够严格、示例覆盖不足，或评估回路设计不清。此时，更合理的第一步往往不是立刻进入 SFT、LoRA 或 DPO，而是先做参数外优化：不改模型参数，只改模型使用方式。

自动化 Prompt 优化（Automatic Prompt Optimization, APO）的核心思想是：把人工反复修改 Prompt 的经验循环，改写成一个自动化搜索与评估过程。它不更新模型权重，而是把 Prompt 本身当作待优化对象，再用验证集上的错误信号驱动 Prompt 迭代。换句话说，APO 优化的不是模型内部参数，而是模型与任务之间的接口描述。

这条路线之所以重要，是因为很多任务的误差并不来自“模型完全不会”，而来自任务定义不够精确、输出约束不够严格、规则优先级表达不清，或者 few-shot 示例没有覆盖真正的边界情况。对这些问题，先做 Prompt 优化通常比直接微调更便宜，也更容易定位问题来源。

APO 可以概括为一个闭环迭代过程。

1. 从当前 Prompt 出发，在固定验证集上运行模型，得到一轮可量化的表现。
2. 收集错误样本，重点关注 false positive、false negative 以及模型在边界样本上的失误模式。
3. 把这些错误样本与当前 Prompt 一起交给一个更强的语言模型，要求它分析当前 Prompt 的缺陷，例如规则表述含糊、优先级冲突、示例覆盖不足、输出格式不稳定，或对某些语义模式缺乏约束。
4. 基于这些分析生成若干候选 Prompt。候选改动可以包括：重写系统提示、重排规则顺序、增加约束语句、补充反例、加入 few-shot 示例，或强化输出格式说明。
5. 用同一个验证集重新评估这些候选 Prompt，并按预先定义的指标选出当前最优版本。
6. 重复这一过程，直到验证集指标收敛，或进一步修改已经不能带来稳定收益。

这个闭环的本质是“用验证集驱动 Prompt 搜索”。人工调 Prompt 时，工程师通常也是先看错例，再猜原因，再改写提示词，再重新评估；APO 只是把这条经验流程交给模型辅助完成，并把迭代过程系统化。

要让 APO 真正有效，至少要具备三样东西：

1. 高质量验证集：它不一定需要极大规模，但必须足够准确，且覆盖关键边界情况。
2. 清晰的评价指标：分类任务通常可以直接使用 Accuracy、Precision、Recall、F1；抽取、排序、生成任务则需要对应的可重复评价标准。
3. 被优化对象必须足够明确：例如系统提示词、用户提示模板、few-shot 示例集、输出格式约束或工具调用说明。

如果缺少这三者中的任意一个，APO 都很容易退化成“让模型随意重写 Prompt”，最终只是在做风格漂移，而不是真正基于验证信号优化任务表现。因此，APO 的核心不是“会不会改 Prompt”，而是“能否把 Prompt 修改纳入可验证的实验闭环”。

参数外优化对验证信号质量极其敏感。因为它并不通过海量训练样本去平均噪声，而是直接把验证集上的错误模式反向写入 Prompt 结构，所以一旦验证集标签本身含糊、冲突或混入大量低置信样本，优化器就很容易朝错误方向改写规则。高质量、边界清晰的验证集通常能显著提升 APO 的稳定性；相反，模糊数据会让优化过程更像是在追逐评测噪声，而不是纠正模型真实缺陷。

因此，APO 和微调并不是互相替代的关系，而更像两层不同成本的优化手段。若模型本身已经具备足够能力，但任务接口还没有调顺，先做 APO 往往收益最高；若 Prompt 已经被压到比较成熟，但模型仍然持续犯系统性错误，才更适合进入微调阶段。

APO 最适合规则可文本化、评估指标清晰、且基座模型本身已经具备足够语义理解能力的任务。例如分类、抽取、轻量结构化生成、审核规则执行、问答格式控制和工具调用提示约束，往往都能从 APO 中获益。尤其当任务规则经常变化、人工需要频繁更新 Prompt 时，APO 的价值会非常明显。

它的边界同样清晰。若任务需要模型学习新的领域知识、记住稳定事实、吸收大量风格样本，或长期存在系统性能力缺口，那么单纯修改 Prompt 的收益通常很快见顶。此时，Prompt 优化可以继续作为上层控制手段存在，但性能提升的主战场已经会转移到微调与继续预训练。

AMPO（Automatic Multi-Branched Prompt Optimization）可以看作 APO 的结构化升级版。普通 APO 往往默认“只有一条主 Prompt 流程”，优化方式主要是改写文字、调整规则顺序或补充示例；AMPO 则进一步把 Prompt 看作一种可演化的决策结构。它的目标不只是把单条 Prompt 写得更好，而是让 Prompt 从单流程逐步生长为多分支结构，使模型在面对不同输入模式时，能够沿着更合适的子路径完成判断。

这种思路来自一个很强的人类专家直觉：复杂任务往往并不是靠一条统一规则解决，而是靠“先识别情形，再走对应流程”。因此，AMPO 的真正创新不只是自动改 Prompt，而是把 Prompt 优化从“文案修订”提升成“结构搜索”。在这种框架下，提示词已经不只是几句话，而更像一个树状决策蓝图。

当任务内部同时包含多种错误模式时，单分支 Prompt 很容易不断堆叠例外说明，最后变成冗长、脆弱且难以维护的规则串。AMPO 的判断是：如果不同错误模式对应的是不同处理逻辑，就不应强行把它们揉进同一段线性指令，而应允许 Prompt 显式分叉。这样做有三个直接收益。第一，结构更清晰：每个分支各自负责一类模式，规则可解释性更强。第二，复杂场景适应性更好：模型不必在一条过长指令中硬找适用规则，而是先定位情形，再走对应分支。第三，后续维护更容易：新增模式时可以局部增补或重构特定分支，而不必重写整个 Prompt。

AMPO 的核心流程可以分成三个协同模块：模式识别（Pattern Recognition）、分支调整（Branch Adjustment）和分支剪枝（Branch Pruning）。这三个模块合在一起，构成了一个从错误样本出发、逐步生长并控制复杂度的优化回路。

模式识别负责把零散坏例归纳成少数根因模式。它通常不是直接把所有错误样本原样塞进一个大 Prompt，而是采用角色分工：一个分析器（Analyzer）逐个解释失败原因，另一个总结器（Summarizer）把这些解释压缩成更高层的模式，并给模式分配重要性。这样做的关键价值在于：优化目标从“修这几个具体坏例”转成“修这一类错误背后的共同规则缺口”。

分支调整负责决定 Prompt 结构该如何变化。这里最重要的决策不是“改不改”，而是“深化已有分支，还是新增分支”。若新模式与某个已有分支高度相关，只需补充约束或细节，那么更合理的做法是深化；若新模式与现有逻辑明显不同，继续堆进原分支只会制造冲突，就应当拓宽，新增一个独立子分支。也正因为如此，AMPO 优化的不是词句表面，而是 Prompt 的控制流结构。

分支剪枝负责抑制过拟合。多分支优化的自然风险是：随着迭代次数增加，Prompt 可能长出大量只服务于少数训练样本的局部规则，最终在未知数据上退化。AMPO 因此显式引入两层剪枝：

1. 预剪枝（Pre-pruning）：相当于基于独立验证集的早停机制。若新增分支不再带来稳定收益，就停止继续扩张。
2. 后剪枝（Post-pruning）：要求优化器在输出最终 Prompt 前重新审视各分支，删掉不必要、过于具体或明显带有训练集记忆痕迹的规则。

AMPO 的一个很有代表性的设计，是每轮并不分析大量失败样本，而是只抽取很少量的代表性坏例，例如固定 \(K=5\)。这不是随意取值，而是一种典型的小样本归纳策略：在模式识别任务里，最前面的少数高信息量样本往往已经足以揭示一类错误的共性，而继续增加样本数量，边际信息收益会快速下降。对具备较强归纳能力的 LLM 来说，少量围绕同一主题的坏例通常已经足够提炼出根本模式。

更重要的是，AMPO 并不要求 \(K\) 随总坏例数量成比例扩大。固定的小 \(K\) 让每轮优化的成本更可控，也避免分析器被大量重复、低信息量坏例淹没。参数外优化的关键不是“看尽可能多的错误”，而是“看足够有代表性的错误”。

AMPO 还提供了一个很重要的方法论提醒：分析错误原因时，并不总是必须把模型当轮生成的失败输出显式提供给分析器。很多时候，输入、当前 Prompt、正确标签以及“这条样本被判错了”这一事实，已经足以让分析器定位规则缺失。因为优化器真正需要回答的问题不是“模型具体说错了什么句子”，而是“当前指令为什么会把模型引向这类错误”。当失败输出本身噪声较大、措辞随机性较强时，强行把它加入分析，反而可能干扰模式归纳。

换言之，参数外优化的关注重点应当放在规则缺口而不是错误表面上。一个高质量分析器更像在做“指令失效诊断”，而不是对错误回答做逐字复盘。

AMPO 还强化了一个现实而重要的工程模式：用于分析与重写 Prompt 的优化器模型，并不必与实际执行任务的目标模型相同。前者更强调总结、重写和结构设计能力，后者则更关注线上推理成本、延迟、稳定性和部署约束。把“谁负责优化 Prompt”和“谁负责执行 Prompt”解耦，往往能在成本与效果之间得到更好的组合。

从论文记录呈现的实验关注点看，AMPO 主要验证了三件事。第一，优化效率：多分支结构在复杂任务上往往能更快探索到高质量 Prompt，而不是在单分支上做无穷尽的局部修补。第二，收敛性：随着迭代推进，Prompt 结构会逐步稳定下来，说明这种优化并非纯随机搜索。第三，消融结果：模式识别、分支调整和分支剪枝都不是装饰性组件，拿掉任一模块，性能与稳定性都会受到影响。与普通 APO 相比，AMPO 的价值并不只是“Prompt 更长”，而是 Prompt 结构更像一个经过错误模式驱动后生长出来的决策树。

因此，参数外优化不应只被理解成“自动改几个词”。从 APO 到 AMPO，它实际上形成了一条清晰的演进路径：先把 Prompt 当作可搜索的文本接口，再把 Prompt 当作可演化的结构接口。前者已经足以覆盖大量规则型任务，后者则更适合复杂、异质、边界模式较多的任务。

分布式训练（Distributed Training）处理的核心问题是：当单张 GPU 已经无法同时满足吞吐量、显存容量、模型规模或上下文长度要求时，训练过程应如何拆分到多张卡乃至多台机器上执行。它覆盖一组并行策略，分别对应不同的设备组织方式。不同策略的差别，主要体现在四个对象如何被分配：数据（data）、模型参数（parameters）、梯度（gradients）和优化器状态（optimizer states）。

工程上最常见的切分方向有两类。第一类是数据并行：每张卡保留完整模型，但处理不同批次数据，再通过通信把梯度同步。第二类是状态分片：参数、梯度或优化器状态本身也被拆到多张卡上，以换取更高的显存上限。前者首先解决训练速度与中等规模显存压力，后者进一步解决“模型单卡放不下”或“长上下文导致激活太重”的问题。

DDP 是 PyTorch 最标准的多 GPU 训练策略。它的基本机制很直接：每张 GPU 持有一份完整模型副本，各自处理不同数据，各自完成前向与反向传播，然后把梯度做 AllReduce 平均，最后用同一份平均梯度同步更新参数。由于每张卡的参数初值一致、梯度同步后也一致，因此各副本在每一步更新后仍保持相同权重。

若以 4 卡训练为例，每张 GPU 的本地 batch size 为 4，那么单个 step 中实际处理的样本数就是 16。更一般地，全局批大小满足 \(B_{\mathrm{global}} = B_{\mathrm{local}} \times N_{\mathrm{gpu}} \times N_{\mathrm{accum}}\)。其中 \(N_{\mathrm{accum}}\) 是梯度累积（Gradient Accumulation）步数。这个公式决定了训练稳定性、学习率缩放和吞吐估算，是理解 DDP 的第一条工程量纲。

DDP 最适合模型本体仍能放进单卡，但单卡训练已经过慢或单卡 batch 太小的场景。例如一个三亿参数量级的 Encoder，序列长度达到 4096 时，单卡既可能吞吐不足，也可能无法同时容纳更大的 batch。DDP 将这类压力分摊到多卡后，每张卡只需处理自己的本地 batch，整体吞吐通常接近线性增长，同时又保持实现逻辑相对简单。因此，在“模型放得下，但训练想更快、更稳”这一档场景里，DDP 仍然是默认起点。

DataParallel 是更早一代的单进程多 GPU 封装。它同样试图做数据并行，但实现方式与 DDP 不同：主进程通常位于 GPU 0，负责把一个 batch 切分后分发到其他 GPU，前向结果和反向梯度也要回到主卡聚合。这个结构会带来两个直接后果。第一，GPU 0 的负担显著更重，容易形成瓶颈；第二，单进程多线程模型更容易受到 Python 调度和通信组织方式的影响。

因此，DP 的优势主要只剩“接入非常简单”。一旦进入正式训练，尤其是多卡 batch 较大、模型通信频繁或训练周期较长时，DDP 几乎总是更稳、更快，也更接近现代 PyTorch 的标准实践。工程上可以把 DP 理解为历史过渡方案：适合快速原型与兼容旧代码，不适合作为持续训练体系的默认选择。

FSDP 仍然属于数据并行范式，但它把“每卡完整持有模型状态”这件事拆开了。参数、梯度和优化器状态会被分片（shard）到不同 GPU 上；在某一层真正参与计算之前，系统才临时执行 AllGather 把这一层所需参数拼回；反向传播结束后，再通过 ReduceScatter 等通信把梯度重新切回各自分片。其核心收益是显存占用大幅下降，因为大部分时间里，每张卡只保存全模型状态的一部分。

这种收益伴随更复杂的通信与调度开销。FSDP 的目标从来不是“同样模型训练得更快”，而是让原本单卡放不下的模型，或原本因为长上下文而极难训练的配置，进入可训练区间。当模型参数规模、激活开销或优化器状态已经逼近单卡上限时，FSDP 往往比单纯增加 DDP 卡数更有效，因为后者只扩展数据吞吐，并不缩小单卡必须持有的模型状态。

ZeRO（Zero Redundancy Optimizer）是 DeepSpeed 最核心的一组大模型训练技术。它的思想与 FSDP 接近，目标都是减少多卡间重复保存的状态，但切分粒度与工程形态更体系化。常见 Stage 可按三步理解：Stage 1 切分优化器状态，Stage 2 再切分梯度，Stage 3 进一步切分模型参数。随着 Stage 提升，单卡显存压力持续下降，但通信和实现复杂度也会同步上升。

ZeRO 的价值在大模型时代尤为明显，因为优化器状态和梯度本身就可能比参数还占显存。对数十亿参数模型、超长上下文训练或多机多卡集群而言，单纯复制完整状态几乎不可持续，ZeRO 这类分片机制就成为前提能力。DeepSpeed 在此基础上还会继续叠加通信优化、内存卸载（offload）、流水并行等工程能力，因此它通常更适合训练规模继续上升、需要复杂集群优化的团队环境。

分布式训练策略和高层框架并不处在同一抽象层。DDP、FSDP、ZeRO 描述的是“参数与梯度如何跨设备组织”；Accelerate、Lightning、Transformers Trainer、Keras 3、MMEngine 描述的则更多是“如何把训练循环、设备启动、日志、checkpoint 与策略配置组织起来”。前者是并行机制，后者是工程入口。

PyTorch 是这一组策略最常见的底座。DDP 与 FSDP 都属于 PyTorch 原生分布式能力，训练脚本最终仍然依赖其自动求导、张量通信和优化器更新。对需要精细控制训练循环的工程团队而言，直接基于 PyTorch 编写分布式训练脚本，通常拥有最高灵活度。

Accelerate 的定位是多设备执行抽象。它将 DDP、FSDP 与 ZeRO 等策略接入到更统一的设备管理接口中，同时封装设备发现、进程启动、混合精度与梯度同步。其核心价值在于：同一份以 PyTorch 为中心的训练代码，可以较平滑地从单卡扩展到多卡，再扩展到 FSDP 或 DeepSpeed，而不必大规模重写训练循环。

Lightning 把分布式训练放进更规范的训练引擎里。开发者主要定义模型、优化器和 step 逻辑，Trainer 再根据配置选择 DDP、FSDP、DeepSpeed 等 strategy。它适合希望减少样板代码、统一日志与 checkpoint 管理，同时保留 PyTorch 生态兼容性的团队。其代价是抽象层更高，定制极复杂训练细节时需要理解 Lightning 的生命周期约束。

Transformers 的 Trainer 更偏“模型生态入口”。当任务建立在 Hugging Face 模型、tokenizer 与数据集流水线之上时，Trainer 可以通过 Accelerate 或相关配置接入 DDP、FSDP 与 DeepSpeed。它特别适合标准微调、标准评测与模型复现实验；一旦训练流程开始高度定制，开发者通常会逐步回到原生 PyTorch 或 Accelerate 层。

Keras 3 也提供分布式 API，但其分布式能力更依赖所选后端。若后端是 TensorFlow，实际执行往往落在 TensorFlow 的分布式策略；若后端切到 JAX 或 PyTorch，则并行细节又会由各自后端负责。它适合追求统一高层建模接口、同时希望在不同后端间迁移的场景，但在超大模型训练里，社区主流实践仍然更多集中在 PyTorch + FSDP / DeepSpeed 这条路线。

MMEngine 更像视觉任务中的训练控制台。它能够把 Runner、Hook、配置系统和分布式启动流程组织起来，使检测、分割、姿态估计等复杂视觉实验更容易批量管理。其分布式能力本质上仍然建立在底层框架之上，通常不会取代 DDP / FSDP 这类并行机制本身，而是把它们纳入统一工程范式中。

在进入具体训练场景之前，通常应先判断任务应该建立在什么类型的基座模型之上。这个选择会直接决定后续数据形态、训练目标、推理链路与上线成本。很多项目的真正分水岭并不在 LoRA、QLoRA、DPO 这些技术细节，而在于一开始是否选对了模型范式：到底应当使用 BERT 一类表示模型（Representation Model），还是使用 Decoder-only 生成模型（Generative Model）。

BERT、RoBERTa、DeBERTa 一类 Encoder-only 模型，最擅长的是把输入压缩成稳定表示，再围绕固定目标做判别。它们特别适合闭集分类（Closed-set Classification）、文本匹配、检索、序列标注、重排序，以及“输入充分、标签空间明确、输出形式固定”的任务。只要目标可以被表述为“给这段输入打一个标签”或“判断这两段文本是否匹配”，表示模型通常都是更高效、更便宜、也更容易评估的选择。

这里需要明确一点：BERT 并不是完全没有顺序信息。它同样通过位置编码（Positional Encoding）与自注意力看到序列先后关系，因此能区分“先发生什么、后发生什么”。真正的限制不在“看不到顺序”，而在于它通常把整段输入压缩为一个判别表示，再直接映射到标签空间。对于需要显式执行规则、动态权衡多段证据、并把局部冲突统一到最终结论上的任务，这种一次性判别路径往往不够灵活，也缺乏可解释的中间推理结构。

生成式大语言模型的优势出现在另一类任务中：任务目标本身包含开放式语义判断、复杂规则执行、跨轮次状态整合，或者需要先形成中间结论，再决定最终输出。这类任务往往不只是“看完文本后打标签”，而是要求模型先判断哪些证据重要、哪些证据只是过程噪声，再决定最终答案。对这类问题，生成模型更容易通过指令约束、上下文推理和多步语义整合完成任务，因此更适合作为基座。

例如，在对话满意度判定中，若规则是“过程中的波折、局部负面情绪视为过程成本，只要最终方案被接受、问题收尾清晰，就优先按已解决处理”，任务本质上就不再是简单情感分类。模型需要区分中间波折与最终状态，识别“收尾是否清晰”，并对冲突信号做优先级排序。这里最困难的部分不是识别负面词，而是执行一条带有结尾优先、过程降权结构的规则。生成模型在这种场景下通常更稳，因为它更容易在长上下文中整合多段证据，并按指令执行“先看结尾，再回看过程”的判断逻辑。

只要任务满足以下条件，BERT 类模型通常仍然足够胜任：

• 输出空间固定且较小，例如满意 / 不满意、风险 / 非风险、升级 / 不升级。
• 决定标签的证据主要是局部可见、模式稳定的文本特征，而不是依赖复杂跨轮推理。
• 规则可以被充分体现在标注数据里，使模型通过监督学习稳定内化这种判别边界。

典型例子包括情感分类、意图分类、FAQ 匹配、实体识别、工单主题归类，以及大量结构清晰的客服路由任务。

若任务开始依赖以下能力，BERT 类模型的风险就会显著上升：

• 需要对长对话做结尾优先的全局判断。
• 需要把中间负面情绪降权，但又不能完全忽略。
• 需要区分“问题解决了但过程不愉快”与“问题根本没解决”。
• 需要持续引入新规则，并要求模型在推理时可控地遵循这些规则。

此时，即使通过多段编码、层级聚合、结尾加权或级联分类等工程技巧勉强构造出一个系统，上限通常也受限于任务本身的推理复杂度，而且系统维护成本往往会迅速上升。

因此，基座模型选择的真正问题不是“哪个模型更先进”，而是“任务本质上是在做判别，还是在做规则驱动的语义决策”。前者优先考虑 BERT 一类表示模型，后者通常应直接进入生成式模型范式。把这一步判断做对，后面的训练场景、微调路径和评估方式才会自然收敛。

小数据集微调（Small-data Fine-tuning）讨论的不是“有没有数据”，而是“可用于更新模型权重的有效监督信号是否足够”。到了 2026 年，这个问题已经出现一个很值得重视的经验转向：在小数据场景里，微调容量并不是越大越好。很多情况下，越轻量的适配反而越稳，尤其当数据本身同时带有长尾、噪声、分布偏移和验证波动时更是如此。

小数据微调最容易误判的一点，是把“任务复杂”直接等同于“应该开放更多可训练参数”。在大多数小样本任务里，真正需要学习的往往不是重写整套表示空间，而只是沿少数方向对基座模型做任务相关偏移。更大的可训练子空间确实提高了拟合训练集的能力，但也更容易把头部模式、局部模板、错标样本和偶然噪声一起写进参数更新，最终损害泛化。

因此，小样本适配的默认逻辑通常不是“先开大再收缩”，而是先用更强约束保护基座模型，再按验证集证据逐步放大更新空间。以 LoRA 为例，低 rank 更新 \(\Delta W = AB\) 的价值不仅是省显存，更是把参数更新限制在一个低维子空间中，使模型更难直接记忆训练集表面模式。这也是为什么在低资源任务里，参数效率与泛化能力往往不是对立关系，而是同一套约束机制的两个结果。

小数据集微调不仅要决定“调多大”，还要决定“调哪里”。这个问题通常有两个维度：第一，更新哪些层；第二，更新每层里的哪些矩阵。它们共同决定模型最终学到的是局部表面模式，还是更稳定的高层语义偏移。

从层位分工看，Transformer 各层的注意力并不是完全同质的。浅层通常更偏局部句法、词性与相邻词关系，通用性最强，因此往往不应轻易扰动；中层开始形成更复杂的语义组合，处理跨句指代、因果联系和较长范围的信息整合；深层则更接近任务特定的高层语义，情感、意图、分类边界和最终决策信号通常更多集中在这里。对于情感判断、满意度判断、意图识别等高层语义任务，优先从中深层，尤其是后部层开始微调，通常更符合信号分布。

从矩阵类型看，小数据行为调整任务通常应先从注意力侧开始，而不是默认同时打开 FFN。Q 决定“向哪里发起关注”，V 决定“实际取出什么信息”，因此它们往往最直接影响模型如何组织证据与整合线索；K 和 O 也会影响结果，但通常不是最低成本起点。若任务主要是在已有知识之上重排注意力优先级、加强长程依赖或改变决策依据，先调 Q、V 往往最稳。只有当验证集持续显示模型确实缺少领域知识写入或表示重编码能力时，再逐步把 FFN、K 或 O 纳入更新范围更合适。

小数据场景的核心矛盾是有效监督信号稀疏，模型容量却仍然巨大。如果数据高度重复、标签边界模糊、头部模式占据绝大多数样本，或者训练集与真实线上分布存在偏移，那么模型面对的就不是“少量但可靠的规律”，而是“少量规律 + 大量重复与噪声”。这时，训练往往不是训练不动，而是下降得过快、记忆得过深。

其中最容易被低估的是长尾问题。头部样本会主导梯度方向，新增容量也最容易先被头部模式吸收；结果是总体指标继续上涨，尾部类别、边界样本和罕见情形却未必同步改善，甚至可能恶化。平均 Accuracy 往往会掩盖这种退化，因此小数据微调若不单独观察尾部表现，很容易把“更会处理常见样本”误判成“整体更强”。

实践中，以下信号通常说明当前瓶颈不在容量不足，而在数据质量、长尾覆盖、验证设计或规则表达：

• 训练损失快速下降而验证集停滞。这通常说明模型正在高效记忆训练集，却没有学到可迁移的判别规律，额外容量只会让这种记忆更彻底。
• 总体指标改善但尾部类别恶化。这说明新增容量主要被头部模式吸收，模型对高频样本更熟练，却以牺牲罕见场景为代价换取平均分提升。
• 不同随机种子之间波动很大。这意味着当前结果对初始化、数据划分或训练噪声过于敏感，说明监督信号本身不稳定。这里的不稳定，通常就来自数据分布不均、标签质量不足或验证集设计过小，例如头部样本占绝大多数、尾部样本只出现几次，或同类边界样本在不同标注员之间标准并不一致。继续放大可训练空间通常只会把这种不确定性进一步放大。
• 新增参数带来的提升只集中在头部模式。这表明模型并没有真正学到更普适的决策边界，而是在更深地贴合样本最密集的局部区域。
• 模型开始出现明显的风格漂移与任务外退化。这往往意味着局部小数据已经开始覆盖预训练先验，模型虽然在当前任务里更贴近训练分布，却损伤了原本更广泛的泛化能力。

小数据场景下，更稳妥的默认策略是按证据逐步放开可训练空间：

1. 把轻量适配作为默认起点。若使用 LoRA / QLoRA，应优先把它理解为控制更新容量的手段，而不只是省显存工具。
2. 先尝试只调后半层的 Q、V，或更保守地只调最后三分之一层。它的参数量最小，过拟合风险也最低，适合监督极少、验证集波动较大的情况。
3. 若验证集显示模型对长程结构或中层语义组合仍然适配不足，再比较全层 Q、V 的极低 rank 配置。这样做的出发点是：任务信号不一定只存在于最深层，中层也可能承担一部分长程整合与语义组合；给所有层一点点可调空间，有时比只改最后几层更容易保持泛化。
4. 只有当这些方案仍然显示出明确的知识注入或表示重编码瓶颈，再把 K、O 或 FFN 逐步放开。
5. 把验证集当作主导信号，而不是训练损失。小数据场景下，训练集拟合速度通常极快，真正有意义的是验证集是否持续改善，以及尾部样本是否同步获益。
6. 把参数选择和数据问题一起看。若长尾、噪声和分布偏移没有处理好，继续增加微调容量往往只会更快过拟合这些问题。

这条顺序的核心是把可训练空间按证据逐步展开，避免在一开始就把过大的自由度交给少量数据，而不是追求一次命中最优结构。更成熟的理解方式，是把小数据集微调视为受强约束的增量适配，而不是缩小版的大规模微调。

嵌入模型（Embedding Model）并不天然等于“通用语义相似度模型”。它可以围绕特定目标进行训练，使向量空间优先保留某一类任务真正关心的判别信号。例如在情感分类（Sentiment Classification）场景里，模型更关心“正面 / 负面 / 中性”的倾向是否一致，而不一定关心两段文本在主题或措辞上是否高度相似。于是，训练得到的嵌入空间可能会把“物流很快，体验很好”和“包装一般，但整体满意”拉得较近，因为它们在情感方向上同属正向；反过来，即使两条评论都在谈“物流”，只要情感倾向相反，也可能被推向更远位置。

从更抽象的角度看，无论目标是情感、相关性、意图、风险、偏好还是图文匹配，嵌入模型始终都在学习一件事：让与当前任务定义下“相关”的文档特征在向量空间中更接近，让“不相关”或“应被区分”的特征更远离。区别只在于“相关”的定义来自哪里。通用 embedding 把相关性主要定义为语义相似；任务特化 embedding 则把相关性改写为某个业务目标下的等价关系，例如同一标签、同一情感、同一用户意图、同一风险等级，或“查询与正确答案匹配”。

正因为如此，嵌入训练与对比学习（Contrastive Learning）天然契合。只要能够构造正样本对与负样本对，就可以把任务目标转写成“哪些样本应靠近、哪些样本应分开”的几何约束。监督标签、点击行为、人工偏好、检索点击日志、FAQ 配对、复述句、图文配对，最终都可以落回这一范式：通过对比式目标把任务真正关心的结构写进表示空间。这样得到的 embedding 既可以直接用于最近邻检索、聚类和召回，也可以作为下游分类器或 reranker 的输入表示。Sentence-BERT 就是文本领域最常见的一条对比式嵌入技术路线之一，前文已经展开其结构，这里只把它当作训练范式的代表。

这里尤其要强调替代选项（Alternative Option）的重要性。对嵌入训练而言，替代选项本质上就是负样本：模型不只要知道“什么应该靠近什么”，还要知道“它为什么不是另一个看起来也很像的东西”。如果没有负样本，模型最容易学到的是一组宽泛、正确但区分度不足的共有特征；只有把相似但不同的替代选项放进训练过程，表示空间的边界才会真正被压实。

例如，如果想教模型理解“马”这一概念，只告诉它“有嘴巴、有鼻子、四条腿、长尾巴”，这些特征当然不算错，但它们并不能有效区分马和斑马，因为斑马同样满足这些描述。真正有区分度的，反而是“有没有条纹”、更接近哪种奔跑方式、整体体态和纹理模式这类能把两者分开的特征。把“马”和“斑马”作为相互竞争的替代选项放进对比训练后，模型才会被迫降低那些共有特征的权重，转而提升真正决定分类边界的特征权重。这也是为什么高质量负样本往往比继续堆更多正样本更能提升 embedding 的判别力。

如果把特定目标的 embedding 训练落到一个可执行流程，通常可以分成六步。

但无论流程写得多完整，训练或微调 embedding 模型的主要难点始终都不在 Trainer 本身，而在数据。可用数据不仅要足够大，质量门槛也很高；正例对通常相对容易收集，例如复述句、点击匹配、NLI 蕴含对、FAQ 问答对，但真正困难的是构造高质量的难负例，因为它们既要足够接近真实混淆项，又不能把本该相关的样本误标为负例。

1. 构造对比样本。最常见的起点是自然语言推断（Natural Language Inference, NLI）类句对数据，因为它天然提供“哪些句子应该更近、哪些句子应该更远”的监督信号。以蕴含（Entailment）关系作为正例、以矛盾（Contradiction）关系作为负例，是非常常见的做法；中立（Neutral）样本则可按任务目标决定是作为弱负例还是直接舍弃。工程实践里，经常直接使用 SNLI、MNLI 或二者合并后的 AllNLI。GLUE（General Language Understanding Evaluation）则更适合作为上层参照系：它汇总了九个语言理解任务，可用于分析模型在句对理解、推断和相似度相关任务上的整体表现，但并不是把九个任务原样全部转成对比样本。
2. 定义评估器。训练过程不能只看训练损失，还需要一套稳定的验证指标。最常见的选择是 STS-B（Semantic Textual Similarity Benchmark）：它由人工标注句子对相似度，原始标签通常位于 1 到 5 的区间，适合评估句向量是否学到了连续的语义距离。若需要更全面的外部评估，则可以进一步使用 MTEB（Massive Text Embedding Benchmark）一类综合基准，它覆盖多类嵌入任务与大量数据集，能更系统地检查模型在检索、聚类、分类和语义匹配等场景中的迁移能力。
3. 选择基座模型。特定目标的嵌入训练通常从一个现成的 Encoder-only Transformer 开始，例如 microsoft/mpnet-base、BERT、RoBERTa 或其领域变体。若任务更接近通用句向量，也可以直接从已经具备较强句向量能力的基座继续微调；若任务明显偏领域化，则优先选择语料分布更接近业务场景的编码器。
4. 调用 sentence-transformers 进行训练。它提供了从数据集封装、池化、损失函数到 Trainer 的完整流水线。默认情况下，模型参数并不会被自动冻结，整个编码器都会参与更新；虽然也可以手动冻结底层若干层以节省显存或降低训练不稳定性，但对 embedding 任务而言，表示空间往往需要全层共同调整，因此在资源允许时，全量解冻通常比只训练顶部少数层更容易得到更好的句向量。
5. 设置超参数。最关键的超参数通常是训练轮次（Epochs）、批次大小（Batch Size）和学习率预热（Learning Rate Warmup）。批次大小会直接影响 in-batch negatives 的数量，因此不仅关系到吞吐，也关系到对比学习的难度；训练轮次决定模型能否真正把目标关系写入向量空间；预热则用于降低训练初期的梯度震荡，避免刚开始就把预训练表示空间破坏掉。
6. 选择损失函数。若目标是得到高质量 embedding，一般不建议把 SoftmaxLoss 当作默认选项，因为它更偏向“把当前任务做成分类”，而不是直接优化向量空间的几何结构。若手里有连续相似度分数，常用余弦相似度相关目标，例如 CosineSimilarityLoss；若任务是检索、召回或通用句向量训练，MultipleNegativesRankingLoss 往往是默认优先尝试的方案之一，因为它会把同一 batch 中其他样本自然当作负例，直接优化“正确匹配更近、错误匹配更远”的排序关系。不过它并不是所有任务上的统一最优解，最终仍取决于数据格式、负样本质量和任务目标。

这六步背后的主线始终一致：先定义“相关”和“不相关”，再把这种关系写进向量空间。任务标签、蕴含关系、点击行为和人工偏好只是构造这种几何关系的不同来源；一旦正负样本定义清楚，训练目标就会自然收敛到对比学习的框架里。

在这条主线里，难负例（Hard Negatives） 往往能够显著提升嵌入模型的判别力。随机负例通常太容易，模型很快就能把它们推远；真正能继续塑造决策边界的，往往是那些“表面上很像、但在任务定义下并不相关”的样本。对检索、匹配和语义区分任务而言，负例越接近真实混淆项，模型越容易学到更有区分度的表示。

一个常见的负例收集流程如下：

1. 获取简单负例（Easy Negatives）。最直接的方法是从训练集里随机采样文档或句子，和当前 query/anchor 拼成负样本对。这一步成本最低，适合快速建立基础对比信号，但训练到中后期往往会变得过于容易。
2. 获取半难负例（Semi-hard Negatives）。可以先用一个预训练 embedding 模型遍历训练集，为每个样本召回一批“看起来较相似”的候选，再排除真实正例、重复样本和语义等价样本，把剩余候选作为半难负例。这类负例已经靠近当前表示空间的边界，通常比随机负例更能提升检索质量。
3. 获取难负例（Hard Negatives）。更强的做法是人工构造，或借助数据合成（Data Synthesis）生成高混淆样本。例如为同一个 query 人工编写“主题相关但答案错误”的文档，或利用大模型生成与正例高度相似但标签相反、结论错误、实体错配的文本。这样的负例最有训练价值，但也最容易混入假负例（False Negatives），因此质量控制必须更严格。

难负例并不是越难越好。若负例实际上与正例同样合理，或者只是标注遗漏导致的“假负例”，模型就会被迫把本应接近的样本推远，反而损害 embedding 空间的结构。真正有效的 hard negative，是对模型足够难、但在任务定义下又明确应该分开的样本。

从头训练嵌入模型（Embedding Model）通常不是多数团队的首选路径。原因并不神秘：它既需要大规模高质量句对或 query-document 数据，也需要持续的负例挖掘、评估基准建设和较长训练周期；若多语言还要兼顾长文本、跨语言检索和任务泛化，成本会进一步抬升。对绝大多数工程团队而言，更高效的做法是从一个已经具备稳定表示空间的基座继续微调（Fine-tuning），把现有 embedding 几何结构朝业务目标方向“推一小步”，而不是从零发明一整个向量空间。

这也是为什么 embedding 项目的真正瓶颈往往不在“有没有训练框架”或“能不能跑通微调”，而在于能否拿到足够多、足够干净、又足够贴近业务分布的数据。正例对开发相对直接，难的是负例设计，尤其是高价值 hard negatives：它们决定模型能否学会区分那些最容易混淆、最接近真实线上错误的样本。

Sentence-BERT（SBERT）路线的实用价值就在这里体现得很明显：它并不要求必须从头构建一个新的 embedding 模型，而是允许直接以现有 SentenceTransformer 模型或预训练编码器为基础继续训练。这样做的收益有两个。第一，预训练阶段已经学到大量通用语言结构，微调只需要重塑与当前任务最相关的距离关系。第二，训练资源会集中花在“任务适配”而不是“重新学习基本语言知识”上，因此更适合企业内部检索、垂直领域分类、多语言 RAG 和跨语言匹配这类目标明确的场景。

实际选基座时，不应只看单一榜单名次，而应同时看四个因素：语言覆盖、上下文长度、是否指令化（Instruction-aware）、以及微调成本。榜单可以帮助筛掉明显过时的模型，但真正决定工程效果的，往往是“它是否与你的数据形态和训练预算匹配”。截至 2026 年 3 月，下面几类开源基座尤其值得优先考虑，尤其是在多语言场景中。

若强调“当前最强的开源多语言底座”，Qwen3-Embedding 系列是首先应试的对象；若强调“检索形态复杂、需要 dense + sparse + rerank 协同”，BGE-M3 的工程灵活性仍然非常突出；若更在意成熟的指令式 query-document 训练范式，multilingual-E5-large-instruct 依然是很稳的起点；若希望在同一基座上兼顾多任务并降低任务切换成本，jina-embeddings-v3 的任务适配设计更有吸引力。

因此，特定目标的嵌入微调并不是“随便挑一个 embedding 模型然后继续训”。更合理的顺序是：先根据任务选择合适的基座拓扑，再设计正负样本与评估器，最后用微调把表示空间朝业务目标压缩。对今天的大多数团队来说，真正的竞争力很少来自“从零训练一个全新 embedding 模型”，而更多来自“是否用合适的底座，把微调目标、负例设计和评测体系做对”。

在标注数据非常有限的场景里，增强型 SBERT（Augmented SBERT）提供了一条经典而务实的路径：用少量高质量标注，扩展出一套足够大的嵌入训练集。它利用的是双编码器（Bi-Encoder）与交叉编码器（Cross-Encoder）的互补性：双编码器推理快、适合检索，但通常需要较多训练数据；交叉编码器推理慢，却能在句对打分上提供更高精度。因此，可以先让交叉编码器学会目标任务，再利用它为大量未标注句对生成伪标签，最后反过来训练一个可高效部署的 SBERT。

这个方法的关键不在于引入全新的模型结构，而在于重新组织数据生产流程。少量人工标注但可靠的数据，构成黄金数据集（Gold Dataset）；由交叉编码器离线打标生成的大规模伪标签数据，构成白银数据集（Silver Dataset）。黄金数据集负责提供可信监督，白银数据集负责放大覆盖面。两者组合后，就能把“标注稀缺”的问题转化成“高精度慢模型辅助生成训练信号”的问题。

因此，增强型 SBERT 本质上是一种低数据场景下的数据增强（Data Augmentation）与知识蒸馏（Knowledge Distillation）策略：先用少量黄金数据把交叉编码器调准，再让交叉编码器把自己的句对判断能力迁移给双编码器。最终得到的不是一个更慢的模型，而是一个依然可以做大规模向量检索、但在目标任务上明显更强的嵌入模型。

增强型 SBERT 的整体流程可以概括为四步。

1. 先用少量黄金数据集微调交叉编码器。这里的黄金数据通常规模不大，但标签质量高，足以让交叉编码器学会“在当前任务里什么样的句对应该更相似，什么样的句对应该更远”。
2. 再生成一批新的候选句子对。这一步既可以来自额外的未标注语料，也可以从现有语料中重新组合样本，目的是构造一个远大于黄金数据集的候选池。
3. 然后让已经微调好的交叉编码器为这些候选句子对打分，生成白银数据集。这里的标签不是人工真值，而是高精度模型给出的伪标签，因此质量通常高于简单启发式规则，却又远比全人工标注便宜。
4. 最后用“黄金数据集 + 白银数据集”一起训练双编码器。这样训练出来的 SBERT 保留了双编码器可预编码、可缓存、可做向量检索的速度优势，同时通过白银数据学到了更多与目标任务一致的距离关系。

白银数据集的质量，决定了增强型 SBERT 能否真正成立。若手里本来就有大量未标注句对或 query-document 数据，最直接的做法就是把它们交给交叉编码器离线标注，再转成伪标签训练集。这是最标准也最稳定的路径，因为候选样本来自真实语料分布，白银数据更接近真实任务。

如果没有现成的大规模未标注句对，也可以从现有黄金数据出发构造更多候选样本。例如把不同句子的前半部分与后半部分重新组合，或把不同 query 与 candidate 文档重新配对，生成新的候选对。但纯随机组合通常会制造过多明显不相似的负例，导致数据分布过于偏斜，模型学到的主要是“轻松区分非常不像的样本”，而不是处理真正困难的边界。

因此，更有效的做法通常是先用一个预训练 embedding 模型做粗检索：为每个句子或 query 召回若干看起来较相似的候选，再把这些候选送给交叉编码器做精标。这样生成的白银数据会包含更多“高混淆但仍可判别”的样本，训练价值明显高于随机拼接。换句话说，预训练 embedding 在这里不负责给出最终标签，而是负责提高候选样本的质量；真正的伪标签仍然由交叉编码器给出。

增强型 SBERT 的价值，在低资源场景下尤其明显。少量黄金数据本身往往不足以直接把 SBERT 微调到理想状态，因为双编码器更依赖足够多的成对训练信号去塑造向量空间；但这同一小批黄金数据，往往已经足够把交叉编码器调成一个“能较准打分”的教师模型。之后，只要有额外候选样本，教师模型就能持续扩充白银数据集，从而把训练信号放大很多倍。

这也是它与普通监督微调的根本差别：普通微调直接把少量标注样本喂给双编码器；增强型 SBERT 则多加了一层“教师打标”环节，用交叉编码器把少量高质量监督扩展成大量可用监督。因此，它特别适合文本匹配、语义检索、问答匹配、句子对排序等 pairwise sentence scoring 任务。

增强型 SBERT 并不是“数据越少越万能”。它仍然要求黄金数据足够准确，否则交叉编码器会先学歪，再把错误批量复制到白银数据里。它也要求候选样本池与真实任务分布足够接近，否则伪标签再多，也只是把错误分布放大。更关键的是，白银数据集并不能替代最终评估：真正决定模型是否可用的，仍应是人工标注的黄金验证集与测试集。

因此，这条路线最适合的场景不是“完全没有数据”，而是“有少量高质量标注、但不足以直接训练出强双编码器”。在这种情况下，增强型 SBERT 提供了一条非常自然的过渡路径：先用高精度慢模型吸收黄金数据，再把这种判断能力蒸馏成一个推理高效的嵌入模型。

增强型 SBERT 已经把监督数据需求压得很低，但它仍然依赖少量黄金数据去微调交叉编码器。再往前推进一步，现实里还存在更苛刻的场景：没有人工标注句对，甚至没有可靠的点击日志、排序日志或问答配对数据。此时，嵌入模型训练只能转向无监督学习（Unsupervised Learning）或更准确地说，自监督学习（Self-supervision）：训练信号不再来自显式标签，而来自原始语料自身的结构、扰动视图（Augmented Views）或重建目标。

因此，无监督嵌入模型训练处理的是“零标注”条件下的表示学习问题。它并不是放弃监督，而是把监督信号改写为模型可以从原始文本中自动构造出的约束：哪些表示应该在扰动前后保持一致，哪些句子应被视为同一语义对象的不同视图，哪些带噪输入必须恢复到原始句子。这类方法尤其适合冷启动和领域适配，因为垂直领域最容易获得的往往不是标签，而是大量原始文本。

无监督嵌入训练的核心目标仍然是学习一个有判别力的句向量空间，只是实现方式不同。当前常见路线可以概括为四类。

这些方法的共同点是：都在尝试从原始文本中自动制造训练信号；差别在于信号是来自对比、重建，还是生成式伪标签。无监督训练真正的难点依然是数据，只不过难点从“标注是否充足”转移成“自监督信号是否有效”。如果正样本过于容易、负样本过于随机，模型学到的往往只是表面相似性；若扰动方式破坏了核心语义，模型又会被迫学习错误的不变性。

TSDAE（Transformer-based Sequential Denoising Auto-Encoder）是无监督句嵌入中非常重要的一条路线，尤其适合领域适配（Domain Adaptation）。它的核心思想可以概括为“破坏 - 重建”：先对原始句子加噪，例如随机删除部分词、打乱局部结构或施加其他轻度破坏；再让模型从这个带噪版本重建原始句子。模型若想完成这项任务，就不能只记住局部 token，而必须把句子的整体语义压缩到编码表示中。

TSDAE 与掩码语言建模（Masked Language Modeling, MLM）的差别也很关键。MLM 主要学习“根据上下文补出被遮住的词”，重点仍然是词级预测；TSDAE 学习的是“从受损输入恢复整个句子”，目标天然更偏句级语义表示。因此，TSDAE 训练出来的编码器更容易直接拿来生成句嵌入，而不必再从词级预测目标里间接提炼句向量。

这条路线在垂直领域里尤其有效。原因是领域适配最常见的现实条件正是：有大量目标域原始文本，但缺乏成对标注数据。TSDAE 可以先在这些无标签文本上训练一个更贴近目标领域分布的编码器，把通用嵌入空间向领域语义挪动；随后若再获得少量黄金数据，就可以继续用常规 SBERT 或增强型 SBERT 做最后一步任务对齐。

从工程角度看，最有价值的是把“监督训练”“少样本微调”“无监督训练”看成一条连续路线，而不是彼此割裂。标注充足时，直接做监督训练；标注很少时，用增强型 SBERT 放大黄金数据；标注几乎为零但有大量原始语料时，先做 TSDAE 或类似无监督适配，再在后续叠加少量监督微调。这样就形成了一个完整闭环：覆盖有监督、低监督到零监督三种数据条件。

因此，无监督嵌入训练并不天然优于监督微调。它的价值在于为 embedding 模型打地基，并在领域迁移时先把表示空间校正到目标语料分布附近。若后续能够获得少量高质量黄金数据，再叠加监督微调，通常会比单独依赖无监督训练更稳，也更接近真实业务目标。

表示模型继续预训练（Continued Pretraining）处理的是这样一种典型情况：基座表示模型已经在通用开放语料上完成预训练，例如互联网文本、维基百科、新闻语料或大规模网页数据，因此具备稳定的通用语言能力；但它并不天然掌握特定领域知识，例如医学术语、金融表述、法律条文、企业内部缩写和业务语境。此时，问题往往不在于模型“不会语言”，而在于模型虽然懂通用语言，却还不够懂目标领域。

这正是继续预训练的切入点。传统 BERT 路线通常只有两阶段：先在通用语料上做预训练，再直接在下游分类或序列标注任务上微调。继续预训练在两者之间插入了一个新的中间层，形成通用预训练 → 领域继续预训练 → 下游任务微调的三阶段流程。它的目标不是立刻输出分类结果，而是先用目标领域的无标注文本，重新校正编码器的词汇分布、上下文统计与语义偏好，让表示空间先贴近领域，再去做具体任务。

通用预训练模型对“movie”“doctor”“interest”“appeal”这类词的理解，默认来自开放语料中的统计分布；一旦进入垂直场景，这些词的含义和搭配方式可能会明显变化。医学文本中的 drug、lesion、metastasis，金融文本中的 guidance、yield、hedging，法律文本中的 plaintiff、statute、liability，都承载着更窄、更稳定、更专业的语境。如果直接拿通用模型去做下游微调，模型往往会在专业术语、长尾表达和领域共现关系上吃亏。

继续预训练的价值就在于：它允许模型先用领域无标注数据补上这层知识，再进入任务微调阶段。因此它本质上是一种领域自适应预训练（Domain-Adaptive Pretraining, DAPT）策略。医疗领域的 BioBERT、金融领域的 FinBERT、法律领域的 LawBERT，本质上都属于这一路线的不同落地版本。

对 BERT 一类 Encoder-only 表示模型而言，继续预训练最经典的目标仍然是掩码语言建模（Masked Language Modeling, MLM）。它可以理解成一种受控的“完形填空”：随机选择输入序列中约 15% 的 token 作为预测目标，其中 80% 替换成 [MASK]，10% 替换成随机 token，剩余 10% 保持不变，但仍要求模型预测原始 token。这样做的目的，是迫使模型根据双向上下文恢复被遮蔽的信息，从而继续学习领域语料中的词汇、搭配和上下文统计。

在继续预训练场景中，MLM 的关键价值不在于“学会猜词”本身，而在于让词向量与上下文表示持续向领域分布靠拢。通用 BERT 看到 What a horrible [MASK]! 时，可能只学到通用情绪词与常见名词；若继续在影评语料上做 MLM，它会更容易把 horror、ending、premise、performance 这类领域表达织进表示空间。医学、金融、法律乃至企业内部文档都是同样的道理。

如果把表示模型继续预训练落到一个可执行的理论流程，通常可以分成六步。

1. 确定基础模型。起点通常是一个已经完成通用预训练的表示模型，例如 BERT、RoBERTa、DeBERTa 或其领域相近变体。这里不需要从头训练模型，而是直接继承已有语言能力。
2. 收集目标领域的无标注语料。继续预训练最重要的资源不是标签，而是高质量领域文本。它既可以来自公开领域语料，例如 PubMed 医学文献、金融新闻、法律判例，也可以来自企业内部数据，例如业务文档、客服对话、知识库与工单记录。
3. 完成分词与语料预处理。继续预训练阶段通常不再保留下游标签，只保留原始文本并转换成模型输入序列。此时最重要的是保证文本清洗、截断策略、特殊符号处理与分词器保持一致，因为模型更新的是对领域文本分布的内部表示，而不是标签映射。
4. 选择掩码策略。最基础的是词元掩码（Token Masking），即对子词粒度随机掩码；若希望模型更充分学习完整术语和专业表达，也可以使用整词掩码（Whole Word Masking, WWM），让一个完整单词的所有子词同时被遮蔽。整词掩码通常训练更难、收敛更慢，但在领域术语密集的场景下更有价值。
5. 执行继续预训练。用领域无标注语料继续运行 MLM 目标，让模型参数在不丢失通用语言能力的前提下，逐步适配目标领域。这个阶段更新的不是分类头，而是整个编码器本身，因此它更像“重塑表示空间”，而不是“学习某个具体任务标签”。
6. 切换到下游微调。等继续预训练完成后，再把更新后的表示模型接到具体任务上，例如文本分类、语义搜索、命名实体识别（Named Entity Recognition, NER）或关系抽取。此时，下游微调面对的已经不是通用基座，而是一个更懂目标领域语境的表示模型。

继续预训练在企业内部尤其有价值。很多企业并不缺文本，而是缺可公开复用的标注数据。客服对话、知识库、工单、合同、操作手册、会议纪要、内部 wiki，这些数据天然带有组织级语境和术语。如果直接把通用模型拿去做企业任务微调，模型经常会在缩写、术语和内部表述上显得迟钝；但若先用这些无标注内部数据继续预训练，再做客服主题分类、语义搜索或实体识别，下游效果通常会明显更稳。

因此，继续预训练最适合的不是“领域知识已经充分内化到通用模型”的场景，而是“目标领域有大量原始文本，但通用模型对其语境仍然陌生”的场景。它本身不是终点，而是一个连接通用语言能力与领域任务能力的中间适配层。

除了直接训练 embedding 模型，另一条非常常见的路线是围绕分类目标（Classification Objective）微调表示模型（Representation Model）。这类方法的基本结构是：以预训练编码器作为基座，在顶层接一个专用分类头（Classification Head），然后用分类损失共同优化表示与决策边界。它适用于情感分类、主题分类、风险识别、意图分类等闭集标签任务，目标不是学习一个通用距离空间，而是让表示尽可能服务于当前分类边界。

在这种设定下，基座模型参数既可以冻结（Freeze），也可以与分类头一起更新。冻结时，训练只发生在分类头，优点是显存占用小、训练稳定、对小数据集更保守；缺点是表示空间几乎不变，模型只能在既有语义表征上学习一个浅层决策边界。若不冻结，则分类头与基座参数会在训练中协同进化：分类头不断把梯度传回编码器，编码器又持续调整自己的表示方式去配合分类目标，最终得到更贴近任务边界的内部表征。这通常能带来更高上限，但也更依赖数据质量、学习率设置和正则化控制。

从经验上看，把基座模型全部冻结后，分类微调效果通常会明显受限，尤其当任务分布与预训练语料存在偏移时更是如此。资源受限时，部分解冻（Partial Unfreezing）是一种常见折中：只更新分类头往往太弱，而全量解冻又可能超出显存或训练预算。在某些具体实验里，只解冻少数几个 Transformer 模块就已经能得到足够好的结果。对文本分类而言，更常见、更合理的做法通常是优先解冻靠后的高层模块，因为后层表示更接近任务语义与决策边界；前层更偏向词法与局部句法特征，保留冻结状态往往问题不大。若任务与预训练域差异很大，或输入风格明显特殊，再考虑进一步向下解冻更多层。换句话说，部分解冻的关键不在于固定解冻“哪 N 层”，而在于把有限资源优先用在最可能影响任务边界的高层表示上。

以烂番茄影评数据集（Rotten Tomatoes Movie Review Dataset）的情感分类为例，分类目标表示模型微调通常可以拆成六步。

1. 选择任务与数据集。烂番茄影评数据集是二分类情感任务：输入是一段影评文本，输出是正面或负面标签。它非常适合说明“表示模型 + 分类头”这一路线，因为情感边界往往依赖整体语义与局部措辞共同决定。
2. 加载数据并完成划分。最基本的划分是训练集（Training Set）与测试集（Test Set）；若训练流程中还需要调超参数或做早停，则还应额外保留验证集（Validation Set）。这里的重点不是机械切分比例，而是保证测试集不参与模型选择，从而让最终分类指标具有解释价值。
3. 加载基座模型与分词器（Tokenizer）。基座通常选择预训练 Transformer 编码器，例如 BERT、RoBERTa、DeBERTa 或更轻量的蒸馏版本；分词器负责把原始文本转成 token 序列、attention mask 以及模型可接收的输入张量。模型与 tokenizer 必须配套，因为词表、特殊 token 和预训练时的文本规范共同决定了输入表示。
4. 进行分词与样本编码。文本在进入模型前需要完成截断（Truncation）、编码与必要的长度控制。这个阶段的目标不是简单把字符串变成整数，而是把“原始语言序列”转换成“可被编码器稳定处理的张量化输入”。序列最大长度、是否保留句首句尾、以及是否对长文本做裁剪策略，都会直接影响分类效果。
5. 构建专用数据整理器（Data Collator）。它负责把长度不一的样本动态组织成批次（Batch），例如按当前 batch 的最长序列做填充（Padding），并同步构建 attention mask，保证同一批次内张量形状一致。更进一步，数据整理器也可以承载轻量数据增强策略，例如随机裁剪、句段保留或噪声注入；但它的最基本职责仍然是稳定、高效地完成批次构造，而不是单纯“把数据拼起来”。
6. 定义评估指标函数。分类目标的训练不仅需要损失函数，还需要一组与业务目标对齐的评估指标。最基本的是 Accuracy；若类别不平衡或更关心误报 / 漏报，则通常还要同时看 Precision、Recall 与 F1。对情感分类这类任务，宏平均 F1（Macro-F1）往往比单独 Accuracy 更能反映模型是否真正学到了稳定的标签边界。

这种训练路线与前文 embedding 微调的根本区别在于优化目标。embedding 微调强调“让相关样本在向量空间中更近，让无关样本更远”；分类目标微调强调“让表示空间直接服务于当前标签决策”。前者更适合检索、聚类、匹配与召回，后者更适合闭集判别任务。实际工程中，两条路线并不冲突：很多系统会先训练或微调一个较强的 embedding / encoder 基座，再在其上叠加分类头完成特定标签任务。

少量样本分类目标微调（Few-shot Classification Fine-tuning）处理的是另一类很常见的现实约束：标签体系已经明确，但每个类别只有极少数标注样本，往往只有 8、16、32 或几十个例子。这类场景下，直接按常规监督流程全量微调一个分类模型，很容易过拟合到表面措辞或偶然噪声；真正有效的方法通常不是“把普通微调硬做小”，而是换用对低样本更友好的训练机制。

少样本分类本质上仍然属于监督学习，只是把“每类有大量标注样本”的常规设定，收缩成“每类只有极少量高质量样本”的稀缺设定。它特别适合标注成本高、样本获取慢、但标签体系明确的任务，例如小众领域文本分类、垂直领域情感分析、专业工单归类或内部知识标签识别。少样本方法的核心，不是让模型凭空学会分类，而是尽可能榨出每一条标注样本中的监督信号。

SetFit（Sentence Transformer Fine-tuning）是少样本文本分类里最实用的一条路线之一。它基于 sentence-transformers 生态构建，但并不直接把少量样本喂给一个普通分类器，而是先把这些样本改写成大量句子对训练信号，再用两阶段流程完成分类。它的核心价值在于：仅靠极少量标注样本，就能让嵌入模型学到任务相关的类别结构，随后再用一个很轻量的分类头完成判别。

SetFit 的完整流程可以概括为三步：

1. 采样训练数据。先基于少量原始标注样本构造句子对：同一类别下任意两个文本组成正例，不同类别下的文本组成负例。这样一来，即使每类只有 2 到 8 条样本，也能通过类内 / 类间组合迅速扩展出大量训练对。少样本的关键不再只是“原始样本有多少”，而变成“能否从这些样本中构造出足够有判别力的相似 / 不相似关系”。
2. 微调嵌入模型。利用这些正负句子对，对预训练的 Sentence Transformer 做对比学习微调。正例要求模型把同类文本的句向量拉近，负例要求模型把异类文本推远。这个阶段优化的是表示模型本身，也就是 SetFit 的 body。
3. 训练分类器。等嵌入模型被调到更适配当前任务后，再用这些高质量句向量作为特征，训练一个轻量分类头（head），例如逻辑回归、线性分类器或其他简单监督分类器。最终推理时，文本先被编码成嵌入，再由分类头输出类别概率。

这套设计的本质是两阶段训练：第一阶段先让嵌入空间学会“同类靠近、异类远离”；第二阶段再在这个已经整理过的表示空间里学习分类边界。相比直接对大模型做全参数分类微调，这种路线对小样本更稳定，也更节省资源。

SetFit 的优势主要体现在四个方面。第一，少样本效率高：每类只需极少数标注样本，就可能逼近常规大数据分类微调的效果。第二，无需提示词：它不像提示式 few-shot 方法那样依赖 prompt 或 verbalizer 设计。第三，训练成本低：大部分计算都集中在句向量微调和轻量分类头训练上。第四，数据利用率高：通过句子对采样，有限标注被最大化放大。

以烂番茄影评（Rotten Tomatoes）这类二分类情感任务为例，SetFit 的典型做法是先按类别均衡抽取极少量样本，例如每类 16 条；之后通过正负配对把几十条原始样本扩展成上千个训练对，再完成对比学习与分类头训练。这个例子最能说明 SetFit 的关键巧思：真正被放大的不是“文本本身”，而是文本之间的监督关系。

SetFit 也有边界。它最适合短文本、句子级、闭集标签明确的分类任务；若类别语义高度重叠、任务严重依赖复杂推理，或标签本身更像开放式生成目标，那么单纯依赖句向量空间分离的办法未必最优。在这些场景里，提示式 few-shot 或更强的生成式模型可能更有优势。

另一大类主流方案是提示式（Prompt-based）few-shot 微调，其代表方法包括 PET（Pattern-Exploiting Training）和 LM-BFF（Better Few-shot Fine-tuning of Language Models）。它们不再直接把分类任务看成“输入文本 → 标签 id”，而是把任务改写成 cloze 风格或自然语言提示，让预训练语言模型去预测标签词（label words）或完成模式匹配。PET 的特点是利用 prompt 把少样本监督对齐到语言模型原本更擅长的预训练目标，并进一步用少量标注模型为未标注样本分配软标签；LM-BFF 则把 prompt 搜索、label word 选择和 demonstration 设计系统化，以提高 few-shot 稳定性。

这类方法在标签语义清晰、prompt 设计得当时非常强，但工程代价通常高于 SetFit。它们更依赖 prompt 模板、verbalizer 质量以及不同随机种子的稳定性，迁移到新任务时也往往需要额外搜索和调参。换句话说，提示式 few-shot 的上限很高，但工程摩擦也更大。

第三类主流路线是参数高效微调（Parameter-Efficient Fine-Tuning, PEFT），例如 LoRA、IA3、Prefix Tuning、Prompt Tuning 等。它们的共同点是：大部分预训练参数保持冻结，只训练一小部分新增参数或适配器参数，从而显著降低显存与存储成本。这类方法更直接解决“模型太大，如何降低微调成本”的问题，因此在大基座模型上尤其有价值。

PEFT 与 SetFit 的关注点并不相同。SetFit 解决的是“样本太少，如何更高效地榨出监督信号”；PEFT 更直接解决“模型太大，如何降低微调成本”。在少样本分类里，二者并不互斥：完全可以把少样本策略与参数高效策略叠加。例如，当基座模型较大、显存非常紧张时，可以优先采用 LoRA / IA3 这类方法；若样本极少且更看重训练稳定性与部署成本，则 SetFit 往往是更直接的起点。

如果任务是典型的短文本或句子级闭集分类，且每类只有极少样本，SetFit 往往是首选起点，因为它训练快、对样本效率高、工程上也最直接。若任务标签本身具有很强自然语言语义，且团队愿意投入 prompt 设计与搜索成本，PET / LM-BFF 这类提示式 few-shot 往往有更高上限。若主要矛盾不是样本太少，而是模型太大、显存和部署预算太紧，则应优先考虑 LoRA、IA3 或其他 PEFT 方案。实际系统中，最稳妥的做法通常不是先争论“哪条路线绝对最好”，而是先判断当前瓶颈究竟是样本、算力，还是 prompt 工程复杂度。

生成模型高效微调（Parameter-Efficient Fine-Tuning for Generative Models）面向的是 Decoder-only 大语言模型（Large Language Model, LLM）的指令对齐与领域适配场景。它处理的不是“如何训练一个分类器”或“如何训练一个检索向量空间”，而是如何在显存、训练时间和存储预算都有限的条件下，让基座生成模型学会遵循指令、稳定输出目标格式，并吸收特定领域的表达习惯。对绝大多数 7B、13B 乃至更大规模的开源生成模型而言，基于 QLoRA 的 PEFT 已经成为默认起点。

这一路线最适合三类任务。第一类是指令微调（Instruction Tuning），即让基座模型从“擅长续写”转向“稳定遵循用户指令”；第二类是风格或格式约束，例如客服回复风格、结构化 JSON 输出、企业内部答复模板；第三类是轻量领域适配，例如让模型更熟悉某个组织、行业或产品线的术语与常见问答模式。若主要瓶颈是显存不足，QLoRA 往往优于全量微调；若目标是深度改写模型底层知识、继续预训练大规模领域语料，或修改上下文长度、词表与位置编码等底层结构，则继续预训练或全参数微调仍然更合适。

从理论上看，基于 QLoRA 的生成模型高效微调通常遵循六步流程。

1. 确定基座模型与任务目标。基座一般选择已经具备稳定因果语言建模能力的生成模型，例如 Llama、Qwen、Mistral 或 TinyLlama 一类架构；任务目标则通常是监督微调（Supervised Fine-Tuning, SFT）意义上的指令跟随，而不是从头学习语言能力。
2. 构造高质量指令数据。训练样本通常采用instruction / input / output三段式结构，或更一般的多轮对话消息结构。这里最关键的不是样本数量本身，而是格式与质量：用户角色、助手角色、轮次边界、结束标记、系统提示词都必须稳定一致。若基座模型已经绑定特定 chat template，就应沿用同一模板组织训练语料；否则模型学到的首先不是任务能力，而是混乱的对话边界。实际工程里，过滤后的 UltraChat 风格指令对话之所以常被拿来做示例，核心原因也正在于此：它提供了相对稳定、结构清晰的监督信号。
3. 以低比特方式加载基座。QLoRA 的“Q”来自量化（Quantization）：基座权重以 4-bit 形式存储，常见配置包括 NF4、双重量化以及 BF16 / FP16 计算精度。这样做的目的不是改变模型结构，而是把静态权重占用压到足够低，使更大模型能够在有限显存中完成微调。NF4 尤其适合这一场景，因为它针对 Transformer 权重常见的零中心、近似正态分布做了量化设计。
4. 挂接 LoRA 适配器。QLoRA 的训练对象不是量化后的基座权重，而是附加在目标投影层上的低秩适配器参数。实践中通常会把 LoRA 挂到注意力层的 \(q\) / \(k\) / \(v\) / \(o\) 投影上，必要时再扩展到 MLP 的 up / down / gate 投影。这样得到的是“冻结量化基座 + 可训练低秩分支”的结构：原模型保留通用语言能力，增量参数专门负责吸收任务相关行为。
5. 执行监督微调。训练过程本质上仍然是自回归下一个 token 预测，只是训练语料已经被改写为指令遵循格式。由于显存约束依然存在，单卡 batch size 往往较小，因此通常依靠梯度累积（Gradient Accumulation）来获得更合理的等效批大小；学习率调度常采用 warmup 后接 cosine 衰减；优化器常配合分页优化器以压低峰值显存；最大序列长度则决定模型一次看到多少上下文，也直接决定训练成本。
6. 导出训练产物。训练完成后，最常见的保存形式有两种：一种是只保存 LoRA 适配器，部署时与同一基座模型组合使用，这最适合多任务、可插拔部署；另一种是把适配器权重合并回基座，得到单体模型，便于独立推理与分发。前者更省存储、更灵活，后者更接近传统“一个模型直接上线”的部署习惯。

QLoRA 的表现很大程度上由少数关键超参数决定。它们分别约束适配器容量、优化稳定性、上下文覆盖范围与显存预算。

QLoRA 的核心优势是把“生成模型微调”从高门槛算力工程，压缩成可在有限资源上反复迭代的日常流程。因此，只要任务主要是指令跟随、格式控制、轻量领域适配或特定风格注入，它通常都应作为第一选择。它的边界同样明确：当任务需要深度改写基座知识、吸收大规模新领域语料、重构模型底层能力或逼近全参数微调的极限上限时，QLoRA 更适合作为基线而不是终点。此时更合理的路线通常是继续预训练、Q-DoRA，或直接转向更重的全参数微调。

生成模型拒绝采样微调处理的是这样一类场景：模型已经具备基本生成能力，甚至已经完成一轮 SFT，但仍希望进一步提高答案正确率、格式稳定性或可验证任务表现；同时，团队又不希望立刻进入完整 RLHF、PPO 或 DPO 训练链路。此时，最自然的做法往往不是直接改写优化目标，而是先让模型对同一提示词生成多个候选，再通过外部评分器筛选出最优答案，把它重新写回 SFT 数据，再继续监督训练。

从训练形态上看，它通常遵循五步流程。

1. 确定起点模型。起点通常是 Base Model 经过一轮指令微调后的模型，因为拒绝采样依赖“先能生成基本可读候选”这一前提；若模型连任务格式都不稳定，后续筛选只会浪费大量采样预算。
2. 为每个提示词生成多个候选。生成阶段的目标不是一次命中标准答案，而是提供一个足够有区分度的候选池，因此通常会适度提高采样多样性，让模型在同一问题上给出若干不同解法、表述或结构。
3. 使用外部评分器做筛选。评分器可以是规则校验、可执行验证、单元测试、格式解析器、奖励模型、人类打分，或它们的组合。只要能较稳定地区分“明显更好”和“明显更差”，就足以支撑拒绝采样式数据构造。
4. 把通过筛选的样本回写成监督数据。最常见的做法是只保留每个提示词下得分最高或达到阈值的候选，把它们整理成新的 prompt-response 数据集。这样做之后，后续训练仍然是标准 SFT，而不是显式偏好优化。
5. 按监督目标继续训练，并周期性重新采样。随着模型能力提升，旧一轮采样得到的高分样本可能不再代表新的最优边界，因此很多实践会多轮迭代：采样、筛选、回写、再训练，再用更新后的模型继续采样。

这条路线的关键超参数主要有五类：每个提示词生成多少候选、采样温度与 top-p 等多样性控制、接受阈值或保留比例、评分器本身的一致性与噪声水平，以及每轮回写数据占原始 SFT 数据的比例。它们共同决定一个核心权衡：候选越多、筛选越严格，样本平均质量可能越高，但成本也越高，且更容易把训练分布压窄；候选太少或筛选过松，则回写数据与原始 SFT 的差异不够明显，改进幅度往往有限。

与 DPO 相比，拒绝采样微调不会直接保留“胜者优于败者”这层相对关系，而是只把胜者留下来，因此信息利用率更低，但训练链路更简单；与 PPO 相比，它没有显式策略优化与在线回报建模，因此更容易稳定落地。工程上，它特别适合答案是否正确较容易验证的任务，而对开放式偏好、帮助性、安全性与语气细粒度排序，更常需要再叠加 DPO、RLHF 或其他偏好优化方法。

生成模型直接偏好调优（Direct Preference Tuning for Generative Models）处理的是生成模型训练中的下一层目标：模型已经通过监督微调（SFT）学会了基本的指令跟随，但在多个可行回答之间，仍未必稳定偏向人类真正想要的输出。此时，训练重点不再是“把任务教给模型”，而是“把偏好写进模型”。在当前工程实践里，DPO（Direct Preference Optimization）是最典型、也最实用的直接偏好调优方案。

它之所以称为“直接”，就在于它绕开了“先训练奖励模型，再用 PPO 做强化学习”的显式 RLHF 流程，直接用偏好数据本身更新策略。对资源受限、希望复用现有 SFT 训练栈的团队而言，这通常是比传统 RLHF 更轻、更稳的选择。

直接偏好调优几乎总是建立在一个已经完成 SFT 的模型之上，而不是直接从 Base Model 开始。原因很直接：偏好数据表达的是“在两个都还算合理的回答之间，哪个更好”；如果模型连基本指令都还不会遵循，那么偏好优化得到的首先不是更好的对齐，而是更混乱的行为。因此，标准路径通常是Base Model → SFT / QLoRA SFT → DPO。若显存非常紧，DPO 阶段也仍然可以继续沿用 LoRA / QLoRA 这一类参数高效微调方案。

从工程与理论结合的角度看，生成模型直接偏好调优通常可以拆成六步。

1. 确定起点模型。直接偏好调优的起点通常不是原始基座，而是已经完成指令微调的模型。若前一阶段使用的是 LoRA / QLoRA，则这里有两种常见路径：要么先把 SFT 适配器合并回模型，再继续挂接新的 DPO 适配器；要么保留 SFT 结果作为起始状态，在其之上继续叠加偏好调优适配器。无论采用哪条路径，本质都一样：DPO 学习的是“在 SFT 行为之上继续排序优化”，而不是重新学习指令能力。
2. 构造偏好数据集。训练样本的基本形态是三元组：提示词（prompt）、被接受回答（chosen）、被拒绝回答（rejected）。它要求两条回答都与同一个提示词对应，并且都具备一定可读性，否则优化信号会退化成“学会排除明显坏答案”，而不是学习细粒度偏好边界。高质量 DPO 数据的关键，不只是 chosen 比 rejected 更好，还在于两者足够接近、足够可混淆，这样模型才会被迫学习真正决定人类偏好的因素，例如信息完整性、语气、格式遵循、安全边界与事实可靠性。
3. 建立参考模型。DPO 不显式训练奖励模型，但仍然需要一个冻结的参考模型（Reference Model）作为锚点。这个参考模型通常就是 SFT 后的模型快照，它定义了“原本模型认为哪些回答更可能”。训练模型的目标不是盲目提高 chosen 的概率，而是相对于参考模型，进一步提高 chosen 的相对优势，并压低 rejected 的相对优势，从而避免模型在优化偏好时过度漂移。
4. 配置可训练参数。若采用 PEFT 路线，训练对象通常仍是 LoRA 适配器，而不是全参数更新。此时需要重新决定 DPO 阶段的 LoRA 容量与挂载范围。实践中，一个常见选择是让 DPO LoRA 覆盖注意力投影与 MLP 投影，因为偏好优化往往既涉及回答内容选择，也涉及风格、结构和安全边界的重排。若只覆盖极少数层，偏好容量可能不足；若覆盖过广，则训练成本与过拟合风险都会上升。
5. 执行直接偏好优化。DPO 训练时会同时比较当前模型和参考模型在 chosen / rejected 两条回答上的条件概率。优化目标可以概括为：让当前模型比参考模型更偏向 chosen，同时更远离 rejected。与 PPO 不同，这一过程不需要 rollout、奖励建模或价值函数估计，因此训练流程更接近“带特殊损失函数的 SFT”，也更容易保持数值稳定。
6. 保存与合并训练产物。若使用 LoRA / QLoRA，训练完成后最常见的产物仍然是 DPO 适配器，而不是完整模型。部署时可以只加载适配器与基座组合使用；若希望得到单体模型，也可以按顺序把 SFT 适配器与 DPO 适配器依次合并。这个顺序很重要，因为偏好调优是在指令能力之上继续修正输出排序，若跳过 SFT 阶段直接只保留 DPO 适配器，模型通常不会得到预期行为。

直接偏好调优的关键超参数主要决定四件事：偏好优化强度、可训练容量、序列覆盖范围，以及在有限显存下能否稳定收敛。

推理优化（Inference Optimization）目标是在质量约束下同时降低延迟（Latency）、显存（Memory）和成本（Cost）。主线方法包括量化（Quantization）、KV Cache 优化、推测解码（Speculative Decoding）和连续批处理（Continuous Batching）。

量化（Quantization）通过降低数值精度减少带宽与显存占用。常见路径：FP16/BF16 到 INT8/INT4/FP8。大模型推理最常见的是权重量化（Weight-only Quantization），因为它实现简单、收益稳定；进一步的激活量化（Activation Quantization）能带来更大的加速空间，但对硬件与校准（Calibration）更敏感。

常见概念：

• PTQ（Post-Training Quantization）：训练后量化，依赖少量校准数据估计尺度（Scale）与零点（Zero-point）。
• QAT（Quantization-Aware Training）：训练时模拟量化误差，通常精度更好但成本更高。
• 按粒度：per-tensor / per-channel / group-wise，粒度越细通常越准但开销更高。

• INT8：8-bit 整数量化，精度与兼容性通常最稳，常作为权重量化的保守起点。
• INT4：4-bit 整数量化，压缩率更高，但更依赖量化算法、分组方式与校准质量。
• FP8：8-bit 浮点格式，动态范围通常优于 INT8，更适合高端硬件上的高吞吐推理与训练。
• GGML：最早的本地 CPU/GPU 推理张量库与算子生态，强调轻量、本地部署与量化推理。
• GGUF：建立在 GGML 生态上的统一模型文件格式，用于封装权重、词表、量化元数据和模型配置，已成为 llama.cpp 一类本地推理工具的主流分发格式。

KV 缓存（Key-Value Cache, KV Cache）用于避免重复计算历史 token 的 Key/Value。在解码器（Decoder-only）模型中，生成第 \(t\) 个 token 时需要与前 \(t-1\) 个位置做注意力；若不缓存，每一步都会重复算一遍历史的 K/V，代价极高。

代价分解常用“预填充（Prefill）+ 解码（Decode）”来理解：Prefill 处理提示词（Prompt）并写入 KV；Decode 每生成一个 token 只需计算新 token 的 Q/K/V，并与缓存做一次注意力。这把每步成本从“重算整段历史”降为“读取缓存并做一次加权求和”。

KV Cache 的主要代价是显存：缓存规模与层数、头数、上下文长度线性增长，因此优化会围绕缓存布局（如 Paged Attention）、压缩（如 KV 量化）与复用策略展开。

粗略的量级估算：若每层缓存张量形状近似为 \(K,V\in\mathbb{R}^{L\times n_{\text{kv}}\times d_k}\)，则单 batch 的显存规模约为

其中 \(n_{\text{kv}}\) 在 GQA/MQA 中显著小于 Query 头数，因此 GQA/MQA 往往是降低 KV Cache 的一阶有效手段；进一步的手段包括 KV 量化、Paged KV（按块管理与回收）、以及对重复前缀做复用/持久化（Prompt Caching）。

Paged Attention 是一种面向推理阶段的 KV Cache 分页管理与访问机制。它把逻辑上连续的一段 KV 序列拆成固定大小的块（Blocks / Pages），再用块表把请求看到的连续上下文，映射到物理上未必连续的显存块，从而支持动态分配、回收与复用。

它解决的重点不是“如何把 KV Cache 压得更小”，而是“如何把不断增长的 KV Cache 更高效地组织、分配和访问”。

这种设计的收益主要有三点。第一，减少显存碎片（Fragmentation）：请求长度不断变化时，不再需要为每条序列预留一整段连续大内存。第二，提升动态批处理与并发调度效率：不同请求可以共享统一的块分配与回收机制，更容易在在线服务里做 token 级调度。第三，和前缀复用天然兼容：当某段前缀已经生成过，对应的 KV blocks 可以直接挂到新请求的块表上，而不必搬移整段缓存。

因此，Paged Attention 的本质是KV Cache 的分页管理与访问优化，而不是新的注意力数学形式。它不改变注意力结果本身，改变的是推理引擎如何在显存里存放和调度这些历史状态。也正因为如此，它通常与连续批处理（Continuous Batching）、Prompt Caching 和块级回收策略一起出现，是高吞吐推理引擎里的基础设施级组件。

若沿用传统的连续分配思路，系统通常需要为每条请求预留一大段连续显存，用来容纳“未来可能继续增长”的 KV Cache。但生成长度在服务开始时并不可知：有的请求很快结束，有的请求会持续生成很长文本。于是，预留得太保守会频繁扩容甚至失败，预留得太激进又会浪费大量显存。

这会同时带来两类碎片。内部碎片（Internal Fragmentation）来自“已经预留但尚未使用”的那部分连续空间；外部碎片（External Fragmentation）则来自请求不断进入和退出后，显存里出现许多零散空洞。即使总空闲显存仍然足够，也可能因为拿不到一整段足够长的连续区域，而无法容纳新的长请求。Paged Attention 的出发点正是消除这种“连续大块内存”假设。

Paged Attention 借鉴了虚拟内存（Virtual Memory）的分页思想。推理引擎先把可用于 KV Cache 的显存切成大量固定大小的物理块（Physical Blocks），每个块只容纳固定数量 token 的 K/V。对单条序列而言，模型逻辑上仍然看到一段从位置 1 到位置 \(t\) 的连续上下文；但在物理层，这些 token 对应的 KV 可能分散存放在许多互不相邻的块里。

块表（Block Table）负责维护这种映射关系：逻辑上的第 \(i\) 个块，对应显存中的哪一个物理块。当当前尾块写满后，系统只需从空闲池中再取一个新块，把它挂到块表末尾即可，并不要求新块和前一块在物理地址上相邻。这样一来，序列增长就从“申请更长的一整段连续空间”变成了“追加一个固定大小的新块”。

这种布局把碎片问题压到很小的范围内。内部浪费通常只会出现在最后一个尚未写满的尾块中，而不会沿整条序列累计；外部碎片则因为不再要求大块连续空间而大幅缓解。工程上真正被频繁分配和回收的，不再是“整条请求的整段缓存”，而是细粒度、等尺寸的块。

在 Paged Attention 中，注意力访问路径（Access Path）指的是：当前 query 如何找到并读取历史 token 对应的 Key / Value，再完成注意力计算。它改变的是这条访问路径，而不是注意力公式本身。对当前 query 而言，模型仍然需要与全部历史 token 的 Key / Value 交互；不同之处在于，这些历史状态不再通过一块连续显存读取，而是由 kernel 按块表顺序逐块定位、聚合并完成注意力计算。逻辑上的序列连续性由块表保证，物理上的离散布局由运行时屏蔽。

因此，Paged Attention 更准确地说是一种分页式 KV 访问内核。它要求注意力实现能够接受“逻辑连续、物理离散”的缓存布局，并在 kernel 内高效完成地址映射、块级遍历和结果聚合。也正因为如此，Paged Attention 并不是简单的内存分配器技巧，而是需要推理 runtime 与注意力 kernel 协同设计的系统级能力。

分页布局还自然支持前缀共享（Prefix Sharing）。当多个请求拥有相同前缀时，它们可以在块表层共同指向同一组前缀块，而不必各自复制一份完整的前缀 KV。这种共享对系统提示词固定、多轮追问、束搜索（Beam Search）或树状探索都很重要，因为这些场景往往存在大段公共前缀。

一旦不同请求在后续 token 上开始分叉，系统再为各自分配新的尾部块即可；已经共享的旧块保持只读并可继续复用。这就是写时复制（Copy-on-Write）的典型思想：真正发生差异时才复制，未分叉前尽量共享。后文的 Prompt Caching 可以看作这种能力在“跨请求、跨时间窗口前缀复用”上的工程化延伸。

Prompt Caching（前缀缓存）缓存的是“提示词前缀的 KV Cache”，目标是避免在多轮对话或重复前缀场景下反复做 Prefill：当新请求的开头 token 序列与某个已缓存前缀完全一致时，推理引擎可以直接复用这段前缀的 KV blocks，只对新增 token 做增量计算。

它直接优化两个指标：

• 首 token 延迟（Time To First Token, TTFT）：减少或跳过重复前缀的 Prefill。
• 成本：若推理服务对缓存命中（Cache Hit）的前缀按更低费率计费，则输入 token 成本显著下降。

Prompt Caching 的工程前提是“字节级一致（Exact Prefix Match）”：通常要求 tokenizer 后的 token 序列完全一致，任何空格/标点/系统提示词差异都会导致 cache miss。因此它更适合“系统提示词固定 + 文档前缀固定 + 多次追问”的产品形态，而不是随意变化的自由对话。

这类缓存的生命周期通常不是固定 TTL，而更像一种受显存压力驱动的短生命周期缓存。最常见的形态是直接驻留在 GPU 显存里，只要显存充足就保留，一旦新请求挤压缓存池，就按 LRU 等策略优先淘汰不活跃前缀。也有系统会把不活跃的 KV blocks 下沉到 CPU 内存形成分层缓存，以换取更长的可复用时间；但完整 KV Cache 很少作为常规路径直接落盘长期持久化，因为它体积大、回读慢、反序列化开销高，往往不如重新做一次 Prefill 划算。

在共享推理后端中，Prompt Caching 必须严格做多租户隔离（Multi-tenancy Isolation）：缓存命中不能只依赖“前缀文本哈希”，还需要把租户/用户身份与模型版本纳入缓存键（Cache Key），避免跨用户“串台”与侧信道泄露。典型复合键（Composite Key）包括：

• 租户 ID（Org/User ID）
• 模型版本（Model/Weights Version）
• 前缀 token 哈希（Prefix Hash）与长度等元数据

缓存生命周期通常很短：KV Cache 占用显存，后端会用 LRU（Least Recently Used）等策略在压力下淘汰缓存；因此“隔天再聊成本回到原价”是常见现象。若业务需要跨小时/跨天复用长前缀，工程上一般转向两类手段：长效上下文缓存（Context Caching，若服务支持）或 RAG/摘要把长前缀变成可检索的外部状态。

KV Cache 压缩（KV Cache Compression）讨论的是：在不显著破坏注意力行为的前提下，把每个 token 需要缓存的 Key / Value 表示存得更小。它的直接目标不是训练提速，而是长上下文推理时的显存占用、带宽压力和并发能力。因此，从优化对象看，Latent KV、MLA、KV 量化、TurboQuant 都属于推理阶段优化；只是从实现方式看，它们并不全是推理后处理技巧，有些方法需要在模型架构和训练阶段就内建进去。

一条路线是潜空间压缩（Latent-space Compression）。它不是直接缓存完整维度的 Key / Value，而是先把每个 token 的 KV 投影到更低维的潜空间（Latent Space），缓存潜变量；当需要参与注意力计算时，再由模型内部结构把潜变量还原成用于打分和聚合的表示。这类方法常被概括为 Latent KV，典型代表就是 MLA（Multi-head Latent Attention）。

这类方法的本质是一种架构级的推理友好设计。它服务的是推理阶段的 KV 成本问题，但并不是像 KV 量化那样在现成模型外部直接套一个压缩器；模型通常需要在训练时就学会如何在潜空间里存储和恢复有效的注意力信息。因此，它应被放在推理优化里讨论，但不能误解成“任何现有模型都可无缝加上的后处理插件”。

相对于 GQA/MQA 只是在“头数”上减少缓存，Latent KV / MLA 更进一步，直接压缩每个 token 的 KV 表示维度。收益通常体现为更长上下文、更高并发和更低带宽占用；代价则是算子更复杂、实现更依赖内核与数值稳定性，而且表示压缩本身会改变模型的内部信息流，因此往往需要专门的训练配方与模型容量补偿。

DeepSeek V4 在 KV Cache 压缩上的推进，不再只压缩“每个 token 的 KV 向量有多宽”，而是进一步压缩“历史序列里需要保留多少条 KV 条目”。这条路线的代表就是混合注意力（Hybrid Attention）中的 CSA（Compressed Sparse Attention）与 HCA（Heavily Compressed Attention）。如果说 MLA 关注的是单条缓存的表示维度，那么 CSA / HCA 关注的就是整段历史在序列轴上的压缩与检索。

设历史序列中已有 \(n\) 个 token 的 KV 条目，普通注意力会让当前位置的 Query 直接面对这 \(n\) 条历史记录。CSA / HCA 的共同思路是：先把相邻若干条 KV 条目聚合成压缩块，再让 Query 对这些压缩块做注意力。若每 \(m\) 个 token 压成一个块，则序列级缓存长度大致从 \(n\) 降到 \(\frac{n}{m}\)；若压缩率更大，长度还会进一步下降。这时压缩块可抽象写成

其中 \(c_j\) 表示原始 KV 条目， \(\tilde c_i\) 表示第 \(i\) 个压缩块，权重 \(\alpha_{ij}\) 由模型学习得到。这个式子表达的不是简单平均，而是带位置偏置与内容权重的可学习块聚合：一个压缩块内部，哪些 token 更该代表这一段历史，由模型自己决定。

若按组件拆开看，CSA 基本可以分成三步。第一步是 Token-Level Compressor：把每 \(m\) 个 token 压成一个压缩块。第二步是 Lightning Indexer：不给每个 Query 暴力遍历所有压缩块，而是先用一个更轻的索引器对压缩块打粗分，再做 top-k 选择。第三步是 Shared KV MQA：被选中的压缩块不再分开维护多组 Key / Value，而是以共享 KV 的 Multi-Query Attention 方式参与核心注意力。图里的“先压缩、再挑重点、最后精读”正对应这三层结构。

CSA 的关键在于“先压缩，再稀疏检索”。它先把历史 KV 压成较细粒度的压缩块，然后再为当前 Query 构造一个轻量索引器，对这些压缩块打分，只保留最相关的 top-k 块参与核心注意力。若把被选中的块集合记为 \(\mathcal{S}_t\)，则当前位置 \(t\) 的核心注意力可写成

这意味着 CSA 不再让 Query 面对全部历史，而是先在压缩后的历史摘要中做一次粗检索，再只对最值得关注的若干块做精算。它本质上是一种“压缩后的稀疏注意力”：既利用块压缩降低历史长度，又利用 top-k 选择避免在所有压缩块上做全量注意力。这里的 Lightning Indexer 之所以重要，是因为它把“找哪些块值得看”这件事从昂贵的全量注意力里剥离出来，先用一个更便宜的门禁系统完成粗召回。

HCA 的设计更激进。它同样先做块压缩，但压缩率 \(m'\) 更高，而且不再对压缩块做 top-k 稀疏选择，而是直接在这些高度压缩后的全局摘要上做稠密注意力。若把 HCA 的压缩块记为 \(\hat c_i\)，则它的核心形式更接近

因此，HCA 牺牲的是块内细节，换来的是一种非常便宜的全局视野：每次注意力看到的不是细粒度历史，而是“高度概括过的整段上下文骨架”。它和 CSA 最大的结构差异有两点。第一，HCA 的压缩更重，例如官方配置里常见 \(m=4\) 对应 CSA，而 \(m'=128\) 对应 HCA。第二，HCA 没有 Lightning Indexer，不做 top-k 挑块，而是直接在这些高度压缩后的块上做稠密注意力。因此，CSA 更像“压缩后再精确召回”，HCA 更像“极粗粒度的全局扫视”。二者混合使用，形成的就是一条局部更细、全局更粗、但总体成本受控的长上下文建模路径。

从直观上看，可以把它类比成查阅一本极长的技术手册。MLA 做的是“把每一页字缩得更紧一些，但页数不变”；CSA 做的是“先把相邻几页整理成摘要，再从这些摘要里只抽最相关的若干段精读”；HCA 做的是“先把整本书压成更粗的章节提要，再快速通览全部章节提要”。三者都在降成本，但压缩的对象并不相同。

DeepSeek V4 还在 CSA / HCA 外围加入了一组保证可用性的细节。其一，压缩后的 Query 与 KV 条目在进入核心注意力前还会再做一次 RMSNorm，以控制 attention logits 的数值尺度；其二，只对最后一部分维度施加部分旋转位置编码（Partial RoPE），避免压缩后的表示完全丢失相对位置信息；其三，额外保留一条滑动窗口注意力分支，让最近若干 token 仍以未压缩形式参与计算，从而补回块压缩天然会削弱的局部精细依赖。于是整个混合注意力的真实行为并不是“只看压缩摘要”，而是远处靠压缩块，近处靠局部窗口；全局靠 HCA，重点靠 CSA。

这张图里“精读 + 略读”这个比喻还有一个很关键但容易被忽略的实现含义：DeepSeek V4 不是在同一层里把两种注意力简单相加，而是把它们按层交替堆叠（interleaved）。官方给出的 Pro 配置是 61 层，其中前两层先用 HCA，后续层再让 CSA 与 HCA 交替出现。这样做的好处是，不需要让每一层同时承担“精细检索”和“全局粗读”两套昂贵职责，而是让不同层在长程建模里分工：有些层负责重点块召回，有些层负责全局背景扫描。

从技术谱系上看，CSA / HCA 也说明 KV Cache 优化已经分成两条正交路线：一条是 MLA 这类表示维压缩，压缩每个 token 自身的 KV 宽度；另一条是 CSA / HCA 这类序列维压缩，压缩需要保留的历史条目数量。前者更像“把每张卡片做薄”，后者更像“把很多卡片归并成索引块”。它们解决的是同一个 KV Cache 瓶颈，但发力点不同。

KV 量化（KV Quantization）指的是：在保留 Key / Value 语义角色不变的前提下，把 KV Cache 从 FP16 / BF16 等较高精度压缩到更低 bit 的数值格式，以减少存储开销与读取带宽。它服务的仍然是原始注意力结构，只是把缓存表示改成更节省显存和带宽的低比特形式。

这条路线不依赖潜空间替换，而是保留原始 Key / Value 的语义角色，直接压缩缓存张量。这类方法更接近传统意义上的推理后处理：对现有模型更友好，工程接入成本通常低于 Latent KV / MLA，但量化误差是否会放大到注意力分布中，是成败关键。

TurboQuant 是一种面向 KV Cache 的内积保真量化（Inner-product-preserving Quantization）方法。它属于 KV 量化路线，但优化目标并不只是在坐标层面重建原向量，而是尽量保住注意力计算真正依赖的内积关系。

这也是它与普通低比特量化的关键区别。对 Key 而言，最重要的不是逐坐标把原向量还原得多么精确，而是尽量保住 \(q\cdot k\) 这类内积关系，因为注意力分数本身就是由这些内积驱动的。换句话说，TurboQuant 优先保护的是注意力几何结构，而不只是原始向量外形。

如果只从存储角度看，KV Cache 似乎只是把一串浮点数改成更低 bit 的数字格式；但注意力并不是逐坐标读取这些数，而是先计算

然后再用 \(\alpha_i\) 去聚合对应的 \(v_i\)。这意味着，Key 上很小的量化误差，一旦改变了 \(q\cdot k_i\) 的相对大小，就可能在 softmax 之后被放大成明显不同的注意力分布。也正因为如此，普通“逐坐标尽量还原”的量化器未必就能得到好的注意力质量，因为它优化的是向量外形，而注意力真正依赖的是内积排序与相对间隔。

从这个角度看，TurboQuant 更像一种面向在线内积估计的向量量化，而不是普通的低比特存储。它特别适合 KV Cache 这类在线场景：缓存必须边生成边写入，解码时又要反复读取并参与 \(QK^\top\) 计算，因此量化器不能只在离线重建误差上表现好，还必须在在线注意力分数上尽量稳定。

TurboQuant 的核心直觉可以概括为一句话：先把向量变成更容易量化的形状，再用极低成本修补量化后最关键的内积偏差。如果把原始向量直接送进低比特量化器，少数高能量坐标、异常值和不均匀分布往往会主导误差；而注意力最敏感的又不是“某一维少了多少”，而是“整体内积关系是否还成立”。因此，TurboQuant 并不把压缩过程当作一次简单的数值离散化，而是分成了主压缩与内积校正两个层次。

它的整体结构可以理解为两阶段。第一阶段负责主量化（Main Quantization）：先对向量施加随机旋转（Random Rotation），再执行高质量的低比特量化。第二阶段负责残差校正（Residual Correction）：不再追求把每个坐标补得更精确，而是针对第一阶段留下的残差，额外附加一个极轻量的编码，用来降低量化后内积估计的系统偏差。这样一来，TurboQuant 的目标就从“压缩向量”推进成了“压缩后仍尽量保住注意力分数”。

若用概念来源去理解，这条路线可以看成“PolarQuant 风格的主量化 + QJL 风格的残差校正”的组合。前者解决“怎么把向量本体存得足够省且失真足够低”，后者解决“怎么让压缩后内积估计不要系统性跑偏”。这也是为什么 TurboQuant 看上去像一个量化方法，实际上却比普通低比特缓存更接近一个面向注意力运算的压缩管线。

随机旋转的作用是改善向量分布的可量化性，而不是“制造随机性”。原始 KV 向量往往各维统计特性差异很大，有的维度能量特别集中，有的维度接近冗余；直接低比特量化时，少数尖峰维度会迫使量化器把刻度对齐到这些极端值，结果是大量普通维度的有效分辨率被浪费掉。随机正交旋转之后，向量能量会更均匀地摊到各个方向上，各维统计特性更接近，量化器就更容易在固定 bit 预算下稳定工作。

更直观地说，随机旋转做的是“先把难量化的尖峰分布打散，再做统一压缩”。这一步并不改变向量之间真正的几何关系，却显著改变了逐坐标量化时面对的数值形态。因此，它服务的不是语义本身，而是后续低比特编码的数值条件。

如果只有第一阶段，TurboQuant 仍然只是一个“更会量化向量”的方法，还不能真正保证注意力分数稳定。问题在于：即使主量化已经把总体失真压得很低，内积估计仍可能存在系统偏差，而 softmax 对这种偏差非常敏感。于是第二阶段不再继续追求全面重建，而是把预算集中用在“修正内积”这件事上。

这种设计背后的判断非常重要：在注意力里，全面重建所有坐标并不是最高优先级，优先级更高的是让“谁该被关注、关注强度大概多大”不要被量化误差改写。也正因为如此，TurboQuant 的第二阶段看起来只加了很轻的一层编码，却能显著改变注意力保真度，因为它修补的是最承重的误差，而不是平均分摊误差。

TurboQuant 的收益并不主要体现在“把某个向量压缩得多漂亮”，而体现在相同显存下能缓存更长上下文，或在相同上下文下支持更高并发。它直接作用于解码阶段最贵的那部分状态，即各层持续增长的 KV Cache。对长上下文推理而言，这通常比单步算子优化更承重，因为一旦缓存存不下，系统就会被迫降低 batch、缩短上下文，或转向更慢的外部交换路径。

但这类收益能否真正转化为吞吐提升，还取决于实现细节。若压缩后每一步都要做很重的解码、解包和额外访存，理论上的存储优势就可能被运行时开销抵消。因此，TurboQuant 不只是一个“理论上更省”的方法，它是否好用还取决于推理引擎是否能把旋转、量化、残差校正与注意力计算做成足够紧的执行路径。

因此，TurboQuant 与 Latent KV / MLA 的差异非常明确。TurboQuant 是量化压缩，核心是把同一个 KV 向量存得更省，同时尽量保住注意力内积；Latent KV / MLA 是潜空间压缩，核心是先换成更低维的内部表示再缓存。前者更接近推理栈里的压缩器，后者更接近模型架构层面的推理优化设计。它们都属于 KV Cache 压缩，但技术路线和接入条件并不相同。

推测解码（Speculative Decoding）用一个更小更快的草稿模型（Draft Model）一次提出多个候选 token，再由大模型（Target Model）并行验证并接受其中尽可能长的前缀。若接受率高，就能显著减少大模型需要执行的解码步数；若接受率低，则会退化并产生额外验证开销。实际收益取决于草稿模型速度、分布匹配程度与实现细节。

批处理（Batching）讨论的是：如何把多个请求或多个 token 步骤拼到同一轮计算里，以提高硬件利用率。它本质上是在吞吐（Throughput）、单请求延迟（Latency）和调度复杂度之间做权衡。推理系统里常见的批处理并不只有一种，固定批处理、动态批处理和连续批处理服务的是不同流量形态。

固定批处理（Static Batching）是最传统的做法：先攒够固定数量的请求，再统一组成一个 batch 执行。它的优点是实现简单、执行路径稳定、硬件利用方式容易预测，因此很适合离线推理、批量评测、Embedding 批处理或输入长度相近的后台任务。

它的问题同样直接。第一，等待时间明显：如果系统必须凑满 batch 才发车，单请求延迟会被批量收集时间拉长。第二，padding 浪费常常很大：当同一批次中的序列长度差异明显时，短序列必须补到与长序列对齐，等于用无效 token 占用了算力。也正因为如此，固定批处理通常更适合“任务离线、流量可控、长度相近”的环境，而不适合作为通用在线 LLM 服务的主调度方式。

动态批处理（Dynamic Batching）是在固定批处理上的现实改进。系统不再死等“凑满固定 batch”，而是在一个较短时间窗口内，把相近时间到达的请求尽量拼进同一批次里。这样做的好处是：既能保留一部分并行执行收益，又能避免固定批处理带来的长时间等待。

它适合中等并发的在线推理服务，尤其是在请求长度相对可控、生成长度不算太长的场景里表现不错。但它仍然主要以“请求”为单位成批，而不是以“token 步骤”为单位重组，因此当不同请求的生成过程拉得很长、长度分化越来越大时，批次内部的同步等待和 padding 问题依然存在。换句话说，动态批处理改善了固定批处理的僵硬性，但还没有真正解决 LLM 自回归解码里的异步性问题。

连续批处理（Continuous Batching）面向在线服务：请求不断到达、序列长度各不相同。与“固定 batch + padding”相比，连续批处理按 token 粒度调度，把不同请求的下一步解码拼到同一个批次里，从而提升吞吐并减少 padding 浪费。它不再把“一整条请求”视为不可拆分的调度单位，而是把系统里所有活跃序列都当作可持续重组的解码状态。

这类方法之所以重要，是因为 LLM 解码阶段天然是异步的：有的请求很快结束，有的请求仍在长输出，有的请求刚刚进入系统。若继续用请求级批处理，GPU 经常会被“最慢那几个序列”拖住；而连续批处理允许系统在每一步把已经完成的序列移出，再把新请求或其他活跃序列的下一步补进来，使 batch 始终维持较高利用率。

静态批处理的问题并不只是“padding 多一点”这么简单，而是它把一整条请求当成不可拆分的运行单元。假设同一批里有四个请求，其中三个很快生成结束，另一个却还要继续生成很长一段文本，那么 GPU 在后续很多步里实际上只能继续为这一个长请求服务，原先空出来的位置却不能被新请求及时填补。这样造成的不是数学错误，而是硬件空转：算力被“批次里最慢的那个请求”绑住了。

因此，连续批处理真正改变的不是 batch 的大小，而是调度颗粒度。传统静态批处理按“请求”调度，连续批处理按“下一 token 的解码步”调度。只要某个请求结束、被取消、或暂时被抢占，调度器就可以立刻把它从运行队列中移出，再用等待队列里的新请求补位。

在 vLLM 这类系统里，所谓“连续”指的是：调度器会以 decode 迭代为粒度，持续重组当前运行中的请求集合，而不是一次性固定一个 batch 直到所有请求全部结束。连续批处理的“连续”，本质上是运行队列和解码步的持续流动。

具体来说，调度器会在几乎每一次 decode 迭代之后重新审视当前运行集合。若当前正在运行的请求集合记为 \(\mathcal{R}_t\)，每个请求在第 \(t\) 轮各生成一个新 token，那么在进入第 \(t+1\) 轮之前，系统就会检查：哪些请求已经生成到结束符、达到最大长度或被上层中断；哪些等待中的新请求应被拉入运行队列。于是，运行中的 batch 并不是一次性固定下来的，而是在 decode 过程中持续流动。

这也是为什么连续批处理本质上更像token 级流水调度，而不是传统意义上的“把若干完整请求捆成一批”。高吞吐来自这种持续补位机制：只要有位置空出来，调度器就尝试让新的工作立刻进来，从而保持 GPU 上活跃序列数尽量稳定。

连续批处理的工程难点在于，新进来的请求并不处在和老请求相同的计算阶段。老请求通常已经进入逐 token 解码（Decode），而新请求刚到达时还需要先完成整段提示词的预填充（Prefill）。这两个阶段的计算特征并不相同：Prefill 更接近长序列的大矩阵计算，往往更偏计算密集；Decode 则更依赖 KV Cache 读取与单步增量计算，往往更偏带宽与调度密集。

高吞吐推理引擎的关键能力之一，就是能把这两类工作纳入同一套调度体系，而不是强制等所有 Prefill 做完才统一进入 Decode。于是，新请求在进入系统后会先经历一次 Prefill，把提示词对应的 KV 写入缓存；随后它就能在下一个调度周期加入解码队列，和其他正在生成的请求一起按 token 粒度推进。工程实现上是否在同一次前向里混合执行 Prefill 与 Decode，取决于具体 runtime 的算子与调度设计；但从系统抽象看，它们必须被统一编排，否则连续批处理就无法真正发挥价值。

连续批处理之所以直到近年的高吞吐推理引擎才真正成熟，一个核心原因就在 KV Cache 管理。若每条请求都必须占据一整段预留好的连续显存，那么请求不断进出时，显存会迅速碎片化：短请求结束后留下很多小空洞，长请求却可能因为拿不到足够长的一段连续内存而无法被调度进去。此时即使调度逻辑想连续补位，底层显存布局也会把它卡死。

这正是 Paged Attention / Paged KV 发挥作用的地方。通过把 KV Cache 切成固定大小的块，再用块表去描述逻辑上的连续序列，系统就不再要求“每个请求必须拥有一整段连续显存”。于是，块可以被细粒度分配、回收、复用和共享，连续批处理才真正有了工程基础。也正因为如此，在现代 LLM 服务栈里，Paged KV 与 Continuous Batching 几乎总是成对出现：前者解决“缓存如何活着”，后者解决“调度如何持续流动”。

它的实现难点也最高。连续批处理要和 KV Cache 管理、Paged Attention、块分配/回收、抢占策略和流式输出协同设计，还必须在吞吐与 P99 延迟之间做持续权衡。也正因为如此，它通常不是单独存在的一项小优化，而是高吞吐推理引擎的核心调度机制。

推理框架（Inference Serving Stack）把“模型权重 + 推理图 + 调度策略”封装成可部署的服务。选型时优先看三件事：是否支持你的模型与精度（Compatibility）、是否能把 KV Cache 与批处理调度做对（Scheduler + KV Management）、以及在你的硬件上能否稳定达到目标吞吐/延迟（Performance Envelope）。

如果只看最常见的部署分叉，Ollama 与 vLLM 实际上分别代表了两种完全不同的目标函数。Ollama 解决的是“如何让个人开发者或小团队在本地几乎零门槛地把模型跑起来”；vLLM 解决的则是“如何让同一份模型在服务端硬件上稳定承载更多请求，并把 KV Cache、批处理和显存调度做到足够高效”。前者更像本地模型工厂，后者更像生产环境推理引擎。

部署体验上的差异最直接。Ollama 把模型下载、量化版本管理、本地 API 与交互入口统一封装起来，目标是尽量减少环境配置摩擦；vLLM 则仍然更像一个服务端运行时，需要围绕 Python / CUDA / PyTorch 版本、模型路径、并发参数、显存预算和服务启动方式做明确配置。二者服务的优化目标不同：Ollama 优先优化可用性，vLLM 优先优化服务效率。

性能侧的分界点通常出现在并发与显存管理。低并发、单人本地交互时，Ollama 往往已经足够顺畅，而且对量化模型和消费级显卡更友好；当请求数上升、上下文变长、需要更稳定地榨出 GPU 吞吐时，vLLM 的 PagedAttention、连续批处理（Continuous Batching）和更系统化的 KV 管理优势就会明显体现出来。前一节所说那种按 token 步骤持续补位的调度机制，正是 vLLM 一类高吞吐引擎的核心能力之一。换句话说，Ollama 更偏“把一次请求跑得足够方便”，vLLM 更偏“把很多请求一起跑得足够经济”。

因此，可以把这条选型规则压缩成一句话：本地开发、个人使用、边缘设备与隐私优先场景更偏向 Ollama；企业服务、高并发 API、多租户平台和多卡扩展场景更偏向 vLLM。若一个项目未来很可能从“个人原型”走向“在线服务”，最常见的工程路径也往往是先用 Ollama 快速验证模型行为，再迁移到 vLLM 一类更强的服务端推理栈。

vLLM 是面向大模型推理的高吞吐推理引擎（Inference Engine），核心目标是在显存受限的情况下提升并发与吞吐。它的代表性设计是 PagedAttention：把 KV Cache 按固定大小切成块（Blocks），用块表（Block Table）把“逻辑连续的序列”映射到“物理上不必连续的显存块”。

这样做的收益是：按需分配 KV、降低内存碎片（Fragmentation），并支持前缀共享（Prefix Sharing）：当多个请求共享同一段前缀（例如相同系统提示词/相同文档前缀）时，可以复用同一份缓存块，从而节省显存并降低 Prefill 成本。

vLLM 的真正价值并不只在某个单独算子，而在于它把KV Cache 管理、连续批处理、调度和服务接口统一成了面向高并发场景的整体系统。具体到调度层，它做的正是前文展开的那种 token 级连续批处理：每一轮 decode 之后重审运行队列，把已经结束的序列移出，再让等待中的新请求完成 Prefill 并尽快补入后续 decode 周期。对企业级 API、RAG 服务、多轮聊天机器人或多租户平台而言，请求通常不会整齐地同时开始和结束；连续批处理能让系统在 decode 过程中持续吸纳新请求，而不是死板地按静态 batch 切分，这正是它在生产环境里更占优势的原因。

它的边界也很清楚。vLLM 本身不是给普通用户做交互体验优化的工具，而是给工程团队做吞吐、延迟、监控和资源利用率优化的 runtime。于是它更适合有明确服务化目标的团队：需要 API 暴露、监控指标、批处理调优、多 GPU 并行和较强可观测性时，vLLM 往往比本地导向工具更自然；但在单机小显存、低并发、快速原型阶段，它未必是最省力的第一选择。

TensorRT-LLM 是面向 NVIDIA GPU 的大模型推理加速栈，重点在于高效算子（Kernel）与图级优化（Graph-level Optimization）：通过更强的算子融合、更贴近硬件的精度与布局选择（例如 FP16/BF16/FP8、weight-only quantization），把通用 Transformer 计算编译成更高吞吐、更低延迟的推理执行计划。

它更偏“部署与性能工程”路径：需要围绕目标 GPU、精度与 batch/seq 长度做构建与调优；换来的是更稳定的延迟与更高的吞吐上限。

Ollama 是面向本地开发的模型运行与分发工具：提供统一的模型拉取、量化版本管理与本地推理接口，降低“把模型跑起来”的工程摩擦。它更适合个人/小团队在本机进行原型验证与离线实验；若追求高并发在线服务，通常会使用更专业的推理引擎与服务编排。

它的核心价值并不在于把吞吐推到极限，而在于把本地使用路径做得足够短：模型名称、下载、版本切换、交互入口和本地 API 都被统一包装起来。对个人学习、隐私敏感的小规模应用、本地插件开发或“先验证模型行为再说”的探索阶段，这种低门槛通常比极致性能更重要。

也正因为如此，Ollama 对消费级机器往往更友好。单卡、小显存、量化模型、本地命令行交互，这些都是它的舒适区；但一旦目标转向多租户、高并发、细粒度监控和多卡线性扩展，它就不再是最自然的中心组件。更准确地说，Ollama 优化的是单机可用性与本地开发体验，而不是生产环境下的系统吞吐极限。

TGI（Text Generation Inference）是面向 HuggingFace 模型生态的通用推理服务：提供标准化的 HTTP/gRPC 接口与常见的批处理/流式输出能力，适合把“能跑的模型”快速变成“可用的服务”。它的价值在于工程整合与稳定性，而不是把每个场景都推到极致性能。

SGLang 强调“把推理当作可编排的程序执行”：当应用需要多步生成、结构化输出、工具调用或复杂控制流时，推理框架不仅要快，还要能把控制逻辑表达清楚并与 KV Cache 调度协同。它更像是服务端的“推理 DSL + runtime”。

llama.cpp 是一套本地/边缘推理 runtime：围绕 GGUF/量化权重与 CPU/GPU 混合执行做了大量工程优化。它在“把模型放到普通机器上跑起来”这一目标上极具性价比，但并不追求云端多租户场景下的极限吞吐。

The post 人工智能理论知识 - Transformers和大模型 appeared first on 绿色记忆.

这一篇从任务视角进入现代 AI 的几个核心应用方向，重点讨论自然语言处理、计算机视觉、语音和音频处理、搜索/推荐/广告预估，以及时序建模和时间序列。前一篇已经建立了机器学习、神经网络与深度学习的基本方法，这一篇继续回答这些方法究竟被拿来解决哪些真实任务、每类任务的输入输出结构是什么、经典路线如何演进到今天的主流方案；再往后才会进入 Transformer、大模型与系统层落地。

自然语言处理（Natural Language Processing, NLP）研究的是：如何让机器表示、理解、检索、生成和操作人类语言。它处理的对象既可以是词、短语、句子、段落，也可以是整篇文档、对话、多轮交互与语音转写后的文本。这个方向覆盖的任务非常广，从最基础的分词、句法分析和语言建模，到信息抽取、问答、翻译、摘要、对话和语义推理，都属于 NLP 的核心版图。

下面会按照不同任务逐一展开，说明每类任务到底在解决什么问题、输入输出通常长什么样、为什么它在实际系统中重要，以及它与其他 NLP 任务之间如何衔接。

从方法论上看，整章内容大致沿着“表示与匹配 - 结构化分析 - 生成与编辑 - 理解与验证 - 交互入口”这几条主线展开。不同任务的表面形式差异很大，但它们在实际系统里往往会被串成同一条流水线：先表示和召回，再抽取和验证，最后生成、编辑或交互输出。

词嵌入（Word Embedding）处理的核心问题是：怎样把离散 token 映射成连续向量，使语义与语法关系在向量空间中变得可计算。若把词表记为 \(\mathcal{V}\)，词嵌入本质上是在学习一个映射 \(e:\mathcal{V}\rightarrow\mathbb{R}^d\)。这个映射一旦建立，模型就不再把单词当成纯符号，而是能在向量空间里比较相似性、组合上下文并进行梯度优化。

早期主线是语境无关（Context-free）词向量。Word2Vec 用 CBOW / Skip-gram 从局部上下文预测词，GloVe 直接分解全局共现统计，fastText 则进一步把子词（Subword）信息纳入表示，因此对未登录词和形态丰富语言更稳。这一路线在 2013 到 2018 年左右几乎是 NLP 标配，但它的根本局限也很明显：同一个词在不同句子里的词义会被压成同一个静态向量。

随后进入语境相关（Contextual）阶段。ELMo 通过双向语言模型让词表示依赖上下文；Flair 使用字符级语言模型表示 token；BERT、XLNet 进一步把上下文表示能力提升到 Transformer 时代。到了这一步，“词嵌入”不再是单独训练一张静态 embedding 表，而是更接近“由编码器按当前上下文即时生成表示”。

到 2026 年，真正主流的并不是单独讨论“词向量”，而是讨论专用嵌入模型（Embedding Model）。语义检索和相似度系统常直接使用 E5、BGE、BGE-M3、jina-embeddings、Qwen3-Embedding 这类专门为句子、段落和文档向量优化的模型，而不是把 Word2Vec 或 GloVe 直接塞进系统中。静态词向量仍有价值，但更多出现在教学、轻量模型、资源受限场景，或作为某些传统系统的初始化手段。

Word2Vec、GloVe、fastText 这条线之所以重要，不只是因为它们“比 one-hot 更好”，而是因为它们第一次让大量 NLP 任务可以在稠密连续向量空间上工作。文本分类会把词向量做平均、卷积或循环编码；序列标注会把词向量喂给 BiLSTM-CRF；信息检索和相似度任务会把句子表示建立在词向量聚合之上。fastText 进一步把子词纳入建模，因此在拼写变体多、形态变化强的语言里格外有用。

这一路线今天并未完全消失，但已经从“系统主干”退到“轻量基线和历史里程碑”。原因很简单：它只能给同一个词一个固定向量，无法区分多义词在不同上下文里的语义角色。对现代问答、信息抽取、检索和对话系统而言，这个缺陷通常过大。

ELMo、Flair、BERT、XLNet 这一代方法真正改变的是：表示不再先验固定，而是由整句上下文共同决定。命名实体识别、词性标注、自然语言推理、阅读理解和文本分类，都因此从“人工特征 + 浅层模型”快速转向“预训练编码器 + 任务头微调”。导图里把 ELMo、Flair、BERT、XLNet 放在词嵌入一侧是成立的，因为在很多下游系统里，它们首先承担的正是表示生成器的角色。

不过，到了这一阶段，“词嵌入”这个词本身已经有些偏窄。更准确的说法通常是 token 表示、上下文化表示或编码器隐藏状态。也正因为如此，后续很多任务文献虽然不再反复强调 embedding，却仍然本质上建立在更强的表示学习之上。

现代嵌入模型通常直接服务于检索、聚类、重排前召回、RAG 和文本去重。最常见的用法是：先用 bi-encoder 把查询和文档独立编码为向量，再做余弦相似度或向量索引召回；若系统还要求更高精度，则在召回后再叠加 cross-encoder 重排。BGE-M3 这类模型甚至把密集检索、稀疏检索和多向量检索统一进同一模型接口；Qwen3-Embedding 一类新模型则更强调多语言与通用语义检索能力。

因此，今天的嵌入模型已经不只是“词表示技术”，而是很多 NLP 系统的第一层基础设施。它们决定了召回质量、聚类几何结构、RAG 证据覆盖率，以及后续大模型究竟能看到哪些上下文。

文本语义相似度（Text Semantic Similarity）研究的是：给定两段文本 \(x_1,x_2\)，怎样判断它们在语义上有多接近。它既可以是回归问题，例如输出 \(s\in[0,1]\) 的相似分数；也可以是分类问题，例如判断是否复述（Paraphrase）、是否语义重复、是否属于同一意图。

这一任务在搜索、推荐、问答召回、重复问题合并、知识库去重和检索增强生成（RAG）中极其关键。真正落地时，很多系统并不直接做复杂推理，而是先问一句：库里哪段文本和当前查询最像。这个“像不像”的基础设施，就是文本相似度模型。

思维导图里提到的 MwAN、DIIN 更偏向句对建模和复述判别时代的代表，它们强调多路注意力、交互式特征融合；GenSen、XLNet 则代表“用更强预训练表示做句对判断”的阶段。这些模型在各自时代都很重要，但今天的主流已经明显转向两条路线：第一条是双编码器（Bi-Encoder）嵌入模型，先把文本各自编码成向量，再做余弦相似度或向量检索；第二条是交叉编码器（Cross-Encoder）重排模型，把两段文本拼接后联合打分。前者适合大规模召回，后者适合小候选集精排。

因此，现代系统往往把“文本相似度”做成两阶段：先用嵌入模型快速召回，再用更重的交叉编码器或 LLM 重新判断。单纯依赖早期句对网络，今天已经不是主流最优解。

复述判别（Paraphrase Identification）是文本相似度里最经典的一支。它要求模型回答的不是“像不像一个主题”，而是“这两句话是否表达了同一个命题”。MwAN、DIIN 这类模型在这一阶段很有代表性，因为它们会显式建模词对词、短语对短语的交互，再把这些交互特征汇总成最终判断。它们很适合中小规模句对任务，但在超大语料召回里代价太高。

若候选库有百万到十亿级文档，系统不可能把查询与每篇文档都拼接后送进重模型。因此，工程上几乎都会先用双编码器把文档离线编码入库，再在向量索引里做近似最近邻搜索。这个阶段的重点是召回率、吞吐、延迟和可扩展性，而不是单对文本判得多细。

这也是为什么文本相似度在现代 NLP 中经常和嵌入模型、向量数据库、RAG 绑在一起讨论。它早已不是孤立 benchmark，而是搜索与知识系统的底层检索能力。

召回之后，系统通常会把前几十到前几百个候选交给交叉编码器、NLI 模型或 LLM 精排。这里的目标已经从“高覆盖找候选”切换成“在小候选集内做高精度判断”。因此，一个成熟的相似度系统常常同时包含两种模型：前端轻、后端重；前端负责广撒网，后端负责最后一锤定音。

如果把现代文本相似度的演进再往前推一步，Sentence-BERT（SBERT）几乎是必须点名的关键节点。它把 BERT 从“适合句对联合编码的模型”改造成“适合独立产出句向量的模型”，直接推动了句向量检索的大规模实用化。随后，SimCSE 进一步说明：仅靠对比学习和 dropout 增广，也能把句向量空间训得非常有判别力。

再往后的检索系统则开始出现多向量路线，例如 ColBERT 这类 late interaction 方法。它不再把整段文本压成单一向量，而是保留更细粒度的 token 级匹配信号，在召回和精度之间取得另一种折中。这说明文本相似度并没有收敛到单一范式，而是在“单向量快召回”和“多向量细匹配”之间持续演化。

自然语言推理（Natural Language Inference, NLI）要求模型判断一对文本之间的逻辑关系。给定前提句 \(p\) 和假设句 \(h\)，模型通常输出三类标签之一：蕴含（Entailment）、矛盾（Contradiction）或中立（Neutral）。这比普通文本分类更接近“句间逻辑判断”，因此长期被视为语言理解能力的重要基准。

NLI 在事实核验、法律文本比对、问答验证、检索精排、对话一致性检查等场景里都有直接用途。很多系统表面上做的是“相似度”或“问答”，底层真正需要的却是更强的蕴含判断。例如“文章是否支持这个结论”“这段证据是否足以回答用户问题”，本质上都更接近 NLI。

思维导图里把 XLNet 和 Transformer LM 放在这一节，是预训练 Transformer 主导 NLI benchmark 的典型阶段。今天的主流仍然是强预训练编码器或指令微调模型，但模型代际已经更新到 RoBERTa、DeBERTa、ModernBERT、T5、以及大量 instruction-tuned LLM。旧的 NLI 竞赛模型并没有失效，但如果目标是工程实用，通常更倾向于：编码器微调做高吞吐分类，LLM 做复杂解释型推理或低资源迁移。

NLI 在工程上很少以“单独上线一个 NLI 产品”的形式存在，更常见的是作为校验模块。事实核验会用它判断证据是否支持结论；检索问答会用它判断候选段落是否真正回答了问题；多轮对话会用它检查当前回复是否与历史事实冲突。也就是说，NLI 经常承担的是语义一致性过滤器的角色。

机器翻译（Machine Translation, MT）研究的是：给定源语言句子 \(x\)，生成目标语言句子 \(y\)，同时尽量保持语义、语气、术语和语法结构的一致性。它是 NLP 中最成熟、最系统化的任务之一，因此也最能看清整个领域从“规则和统计”走向“深度学习与基础模型”的完整演进。

传统主线是统计机器翻译（Statistical MT, SMT），尤其是短语级机器翻译（Phrase-based SMT）。思维导图中提到的 IBM1 到 IBM4、双语对齐、调序模型、短语抽取、语言模型、柱搜索（Beam Search），正是这条路线的核心流水线。IBM1 到 IBM4 负责从双语平行语料中学习词对齐；短语抽取把对齐好的词组织成更长的短语映射；调序模型解决语序差异；语言模型保证目标句流畅；柱搜索则在巨大候选空间里找近似最优译文。

这条路线今天已经不再是工业主流，但并没有“毫无价值”。它仍然是理解对齐、解码、译文流畅性与可解释错误分析的最好教材。在低资源、强术语控制、可解释对齐分析等特定场景中，SMT 思想依然有借鉴意义。

深度学习阶段先由 Seq2Seq 带动。最早的 Seq2Seq 往往由 RNN / LSTM 编码器-解码器构成，随后加入注意力机制；ConvS2S 则尝试用卷积并行建模序列；真正改写主线的是 Transformer。到今天，RNN-Seq2Seq 和 ConvS2S 更像历史里程碑，而不是大规模翻译系统的默认选择。

现代翻译系统的主流已经是 Transformer、mT5 / ByT5 这类文本到文本模型，以及大规模多语言翻译基础模型。例如 NLLB-200 把高质量多语翻译推进到 200 语言量级，MADLAD-400 则代表了更大语种覆盖和大规模多语言翻译训练的方向。Beam Search 仍然没有过时，它在神经机器翻译里依然是常见解码器，只是位置从“统计解码核心”变成了“神经生成阶段的搜索策略”。

因此，今天谈机器翻译时，IBM 对齐和短语 SMT 应归入历史主线与基础知识；真正要落地时，应优先理解 Transformer、多语言预训练、术语约束解码、领域自适应和评测体系。

IBM1 到 IBM4 的价值在于把翻译拆成了一条清晰流水线：先做词对齐，再做短语抽取，再做调序，再用语言模型保证目标句自然，最后靠 Beam Search 在候选空间中搜索高分译文。它之所以曾长期主导工业界，是因为每个环节都能单独分析、替换和调优。缺点同样明显：误差会在流水线中逐级累积，而且很多语言现象需要跨环节协同才能解释。

Seq2Seq、ConvS2S、Transformer 的核心变化，是把原来分散在多个模块中的对齐、重排序和流畅性建模，尽可能收拢进一个端到端神经模型中。RNN-Seq2Seq 解决了“从输入序列生成输出序列”的基本范式，注意力解决了固定长度表示瓶颈，ConvS2S 用卷积换取更强并行性，而 Transformer 最终在长程依赖与训练效率之间取得了最好平衡，因此成为主流。

2026 年的机器翻译系统，重点通常已经不是“能不能翻”，而是低资源语言覆盖、术语一致性、长文档上下文、领域迁移和评测对齐。这也是 NLLB-200、MADLAD-400 一类多语言模型重要的原因。与此同时，传统 Quality Estimation、术语词典约束、人工后编辑和文档级一致性控制并没有消失，反而经常作为神经翻译系统的外围组件继续存在。

词汇正规化（Lexical Normalization）处理的是“非标准写法如何映射回标准写法”的问题。它常见于社交媒体文本、OCR 错误、ASR 转写、用户口语化输入、拼写变体和历史文本处理。典型输入不是一句已经很干净的标准语言，而是像缩写、错别字、方言拼写、口语连写、拼音混杂或英文网络俚语这样的噪声文本。

导图里的 MoNoise、联合词性标注与正规化、基于音节的方法，代表的是社交媒体和噪声文本时代的经典路线。它们强调候选生成、上下文判别、词性线索和发音相似性，尤其适合拼写波动很大的文本。到今天，这类方法仍有现实价值，但多数已不再是最强主线。

现代正规化越来越多地使用字符级、字节级或文本到文本模型，例如 ByT5、mT5、T5 系列编辑模型，以及指令微调 LLM。原因很直接：正规化本质上就是一个局部条件生成或编辑问题，而字节级 / 字符级模型对噪声拼写、形态变化和未登录词更稳。导图里的“基于音节的方法”在特定语言和口语输入里仍有帮助，但已经不是通用主干。

传统词汇正规化一般分成两步：先生成若干可能的标准写法候选，再结合上下文做判别。MoNoise、联合词性标注与正规化、发音相似或音节相似方法都属于这一范式。它们的优势是每一步都较可控，容易接入词典、发音规则和领域知识；缺点则是候选覆盖与上下文建模容易彼此割裂。

文本到文本模型把正规化直接视为序列编辑任务：输入噪声文本，输出标准化文本。这样做的收益是模型可以在一个统一框架里同时处理缩写展开、错拼纠正、形态恢复和局部重写。代价则是输出稳定性更依赖训练数据与解码约束，因此很多生产系统仍会在生成模型外面包一层词典校验或格式规则。

词汇正规化和拼写纠错、语法纠错相邻，但边界并不相同。拼写纠错通常更关心“这个词是不是打错了”；GEC 更关心句法、搭配、时态等整句层面的错误；词汇正规化则更强调把非标准表达映射成标准表达，哪怕原写法对人类完全可理解。例如社交媒体缩写、方言拼写、网络俚语、口语化省略和代码混写，都可能不是“拼错”，却仍然需要正规化。

也正因为如此，正规化常被放在更前的文本清洗层。它的目标不是提升文法优美度，而是把后续分类、解析、抽取和检索所依赖的输入分布拉回训练数据熟悉的范围。

ByT5 一类字节级模型在这个任务上很自然，因为正规化问题经常发生在字符粒度甚至字节粒度。用户可能少打一两个字母、把多个词连写、夹杂表情或外文字符，也可能用语音近似拼写一个词。若模型从词级开始建模，很多噪声在入口就已经被打碎；而字节级或字符级模型可以直接在更细粒度上学习“从噪声表面形态到标准形式”的映射。

这也是为什么词汇正规化在近年经常与多语言字节级模型绑定在一起讨论。它们不仅对未登录词更稳，也更适合社交媒体、OCR 和 ASR 这类高噪声输入。

正规化最直接的收益，是改善下游系统对噪声文本的稳健性。社交媒体情感分析、客服意图识别、OCR 后信息抽取和口语转写后的结构化解析，往往都会因为输入更标准而显著受益。但这个步骤也有风险：如果系统把本来有语用价值的变体都强行“洗平”，就可能丢掉风格、方言、情绪强度甚至身份信号。

因此，现代系统越来越强调任务依赖的选择性正规化。面向检索、分类和解析时，正规化通常应更积极；面向风格分析、作者识别、对话个性保留时，则未必应该把所有非标准写法都抹平。是否正规化、正规化到哪一步，本身就是上游任务设计的一部分。

以“ASR 转写文本做客服工单分类”为例，原始输入里常会出现同音字、口语省略、数字口语化和夹杂英文品牌名。若系统直接把这类文本送进分类器，模型往往会把噪声当成类别特征，导致跨渠道泛化能力很差。更稳的做法通常是：先做轻量正规化，把明显的 ASR 噪声、缩写和常见别名拉回标准表达，再进入分类、检索或抽取模块。

但这一步也不能无限增强。例如用户情绪、方言身份和话语风格本身可能就是业务信号。若把“气死我了真的服了”一律改写成过度标准化文本，情绪强度和用户画像信息就会被抹掉。因此，正规化最好是按任务定制的局部编辑，而不是无条件全量改写。

语言模型（Language Model, LM）回答的是一个看似简单、实际上极其基础的问题：给定前文，下一段语言出现的概率分布是什么。若用序列 \(x_1,\dots,x_T\) 表示一句话，自回归语言模型通常写成

这个定义之所以关键，是因为它把“理解语言”和“预测语言”统一到了一个概率框架里。模型若想把下一个 token 预测准，就被迫学习词法、句法、搭配、常识和某些推理结构。

传统语言模型以 n 元语法（n-gram）和 Pitman-Yor 一类平滑概率模型为主，强调局部上下文频率统计。它们今天在主流大模型系统里已经不是核心，但仍然是理解平滑、稀疏性、解码和语言先验的基础。深度学习阶段先后出现 AWD-LSTM、Gated CNN、Transformer-XL 等路线，其中 AWD-LSTM 曾是强语言建模基线，Transformer-XL 用分段记忆缓解上下文长度限制。

到 2026 年，主流显然已经是 Decoder-only Transformer 大语言模型。AWD-LSTM、Gated CNN、Transformer-XL 不应被当成“当前最先进路线”，但它们分别代表了循环网络时代、卷积语言模型时代和长上下文过渡阶段。理解这些模型的意义，在于看清当代 LLM 为什么几乎统一收敛到“大规模预训练 Transformer + 指令对齐 + 外部工具”这一组合。

n-gram 语言模型在历史上是很多系统的“流畅性后验”。语音识别会用它约束转写结果，统计机器翻译会用它筛掉不自然译文，拼写纠错会用它判断哪种候选更像真实语言。Pitman-Yor 这一类方法的重要性则在于它把长尾词汇与平滑问题处理得更系统，因此在语言建模理论史上占据一席之地。

AWD-LSTM、Gated CNN、Transformer-XL 虽然已不是主流终局，但它们分别回答了三个关键问题：循环网络如何把语言模型训稳，卷积是否能替代循环建模局部上下文，以及长上下文能否在不完全重算历史的情况下持续扩展。很多今天看似理所当然的工程细节，例如记忆缓存、长上下文分段、激活正则化，都是在这一阶段被系统打磨出来的。

现代 Decoder-only 语言模型不再只是一个“下一个词预测器”，而是很多 NLP 任务的统一接口。翻译、摘要、问答、信息抽取、文本分类、对话和代码生成，都可以被改写成条件生成问题。这并不意味着传统任务边界消失，而是意味着许多任务开始共享同一种底座与同一套 token 级概率建模机制。

信息抽取（Information Extraction, IE）研究的是：如何把自然语言中的非结构化描述，转成实体、关系、事件、属性和值等结构化结果。它并不要求模型生成长文本，而是要求模型从文本中抽取可落库、可检索、可计算的知识单元。命名实体识别、关系抽取、事件抽取、三元组抽取和名词短语规范化都属于这一大类。

导图里提到的信息抽取分支包括命名实体、三元组抽取和名词短语规范化；三元组抽取下又提到依存句法和知识库方向，以及 BERT、CNN、RNN 这些不同阶段的编码器。这些都属实，但今天如果只把 IE 理解成“先做一个 BERT 分类器”，就太窄了。

当前主流至少有三条。第一条是任务专用抽取头，例如 span-based NER、relation extraction、event extraction。第二条是统一抽取框架，代表如 UIE（Universal Information Extraction），尝试用统一的文本到结构生成范式处理多类 IE 任务。第三条是LLM 指令抽取，即把 schema、字段定义和约束写进 prompt，让模型直接按模板产出结构化结果。前两条更适合高精度、可评测的工程场景，第三条更适合快速扩 schema 和弱监督启动。

因此，CNN / RNN 抽取器和单一依存规则法更适合作为历史阶段代表；现代信息抽取的主线已经明显转向“统一 schema + 强编码器 / LLM + 结构约束 + 后处理校验”。

命名实体识别（Named Entity Recognition, NER）是信息抽取里最基础也最关键的一步。它回答的是：文本里的哪一段 span 是人名、组织名、地名、产品名、时间、金额或领域实体。早期规则系统依赖有限状态自动机、词典和角色规则；后续进入序列标注阶段，常见 IOB、BIOES、IOBES 等标签体系，配合 CRF、BiLSTM-CRF、BERT-CRF 做解码。

再往后，NER 明显从“给每个 token 打标签”走向“直接对实体边界和内部结构建模”。Global Pointer 这一类 span-based 架构直接给起止边界打分，适合嵌套实体和高效率抽取；W²NER 这类 relation/grid-based 架构则显式预测词间结构关系，更适合复杂实体结构和不连续实体。两者都属于现代深度学习 NER 架构，但它们已经不再是传统概率图模型那一路，而是建立在预训练编码器上的神经抽取头。

如果把定义写得更形式化一些，NER 输出的并不是单点标签，而是实体集合

其中 \(s_k\) 与 \(e_k\) 表示第 \(k\) 个实体的起止位置， \(c_k\) 表示实体类型。这个写法直接揭示了 NER 的本质：它最终是一个区间抽取 + 类型判定问题，而不是纯粹的逐 token 分类问题。

Global Pointer、W²NER 不是 BERT、RoBERTa、ModernBERT 这种通用编码器（Backbone / Encoder），也不是 HMM、CRF 那类经典概率图模型；它们更准确的定位是接在编码器之上的 NER 专用任务头或结构化解码架构。系统链路通常可以概括为：

其中编码器负责把原始文本转成上下文化表示 \(H=[h_1,\dots,h_n]\)，而 NER head 决定如何把这些表示转成实体集合。若任务头选的是逐 token 分类，输出就更接近 BIO 标签；若任务头选的是 span 打分或词间关系建模，输出就更接近实体区间本身。Global Pointer 和 W²NER 的差别，主要就体现在“实体应该怎样从隐藏表示中被读出来”这一层。

把 NER 当作序列标注有一个很自然的优点：实现简单，训练直接，和 token 级监督天然对齐。但它也有明显边界。第一，实体在语义上是一个整体区间，而序列标注把问题拆成逐位置判断，再依赖标签体系和解码规则把局部标签拼回实体，这会引入“局部预测正确但整体边界不稳”的误差。第二，当数据里存在嵌套实体（Nested Entity）时，例如较长实体内部还包含较短实体，单层 BIO 标注就会开始变得别扭。第三，若实体跨度很长，模型需要通过一串连续标签间接表达“这一整段属于同一个实体”，而不是直接对整个 span 打分。

因此，深度学习时代的很多 NER 方法开始直接面向 span 建模。核心想法是：与其先预测每个 token 的局部标签，再回头拼边界，不如直接让模型回答“从第 \(i\) 个位置到第 \(j\) 个位置，是否构成某一类实体”。这样，实体边界就从隐式结构变成了显式建模对象。Global Pointer 正是这条路线里非常典型的方法。

Global Pointer 的核心思想是：把每一种实体类型都看成一个“起点 - 终点匹配问题”。给定编码器输出 \(H=[h_1,\dots,h_n]\)，模型先把每个位置投影成适合做起点查询和终点键值匹配的向量，再对每种实体类型的每一对位置 \((i,j)\) 计算一个 span 分数。若这个分数足够高，就认为“从 \(i\) 到 \(j\) 的片段属于该类型实体”。

一种简化写法是：

这里 \(c\) 表示实体类型， \(q_i^{(c)}\) 表示位置 \(i\) 作为该类实体起点时的表示， \(k_j^{(c)}\) 表示位置 \(j\) 作为终点时的表示。很多实现会进一步加入 RoPE（Rotary Position Embedding）一类位置编码，使相对位置信息直接进入打分过程。

这个结构的关键优势有三点。第一，它天然输出 span，而不是先输出 BIO 标签再回拼实体，因此边界目标与任务定义更一致。第二，它对嵌套实体非常自然：同一个起点可以与多个终点形成不同 span，不同类型之间也互不冲突。第三，它对长实体更友好，因为模型直接给 \((i,j)\) 这一对边界打分，不必靠一长串内部标签层层传递“这是同一个实体”的信号。

从工程角度看，Global Pointer 也是很受欢迎的一类 NER 头。它的实现相对简洁，主要开销来自构造每种类型的 \(n\times n\) 打分矩阵，训练与推理都比较直接。它因此特别适合需要嵌套实体支持、但又希望结构尽量简单的场景。

W²NER（通常写作 W2NER）走的是另一条路线：它把 NER 视为词与词之间关系的二维建模问题。与其直接给一个 span 打分，它更关心“两个位置之间是什么关系”，再通过这些局部关系把完整实体组装出来。也就是说，模型不是直接回答“ \((i,j)\) 是不是实体”，而是先在一个 \(n\times n\) 的词对关系网格上预测关系标签。

它常见地使用两类关系标签：

• NNW（Next-Neighboring-Word）：表示一个实体内部相邻词之间的连接关系。
• THW-{type}（Tail-Head-Word）：表示某个实体的尾词和头词之间闭合成一个特定类型实体。

在这个框架里，模型先构造词对表示，再用 biaffine、条件层归一化（Conditional Layer Normalization, CLN）、二维卷积（2D Convolution）等模块在整个关系网格上做局部模式建模。最终，实体不是由一次 span 打分直接得出，而是由一条词间关系链和一个闭合关系共同定义出来。

这条思路的最大价值在于表达力更强。因为模型显式建模的是词与词之间的结构关系，所以它不仅能处理嵌套实体，还更容易扩展到不连续实体（Discontinuous Entity）或更复杂的局部结构。代价也同样明显：它的关系网格更重，中间表示更大，计算和显存开销通常高于较轻量的 span 打分方法；同时，二维卷积式建模也让工程实现和调参复杂度明显上升。

二者都属于深度学习时代的 NER 架构，但它们的设计哲学并不相同。Global Pointer 更像“直接给候选实体区间打分”；W²NER 更像“先预测实体内部关系，再把实体结构拼出来”。前者更直接、更轻量，后者结构表达更强。

因此，若任务重点是常规实体抽取、嵌套实体支持和较好的工程效率，Global Pointer 往往是更干净的设计；若任务存在复杂实体结构、关系链式表达或不连续实体，W²NER 一类 relation/grid 方法会更有吸引力。它们没有谁在所有场景中绝对更强，差异主要来自任务结构本身。

关系抽取（Relation Extraction）要求模型在识别实体之后，进一步判断实体之间存在哪一种关系；三元组抽取则把结果组织成 \((h,r,t)\) 形式。传统路线常结合依存句法、模板规则或 CNN / RNN 编码器做句级分类；BERT 时代之后，则更常见 span pairing、table filling、pointer 网络或联合抽取框架。

事件抽取又再往前一步，不只抽“谁和谁有什么关系”，还要抽“发生了什么事件、谁是论元、时间地点在哪里”。这也是为什么现代 IE 很强调统一 schema 和结构约束：不同子任务虽然形式不同，但本质上都在把自然语言映射成结构化记录。

导图中提到的名词短语规范化（Noun Phrase Normalization），本质上是在解决“表面写法不同，但是否应归并到同一个标准概念”这一问题。它和实体链接相邻，但更偏向文本内部或领域词表内部的规范化，而不一定要求链接到外部百科实体。医学术语归一、商品名称归并、日志字段规范化，都属于这一类。

这条路线在现代系统里常和 NER、EL、术语词典、向量检索放在一起做。原因很直接：只有把抽出的 mention 进一步规范化，后续统计、检索和知识入库才真正可用。

UIE 这类统一框架的重要性，在于它不再把 NER、RE、事件抽取完全拆成彼此独立的数据格式和训练头，而是尝试用统一的结构化生成接口覆盖多类 IE 任务。这样做的收益是 schema 扩展更容易、任务迁移更自然；代价则是解码与评测都更复杂。

LLM 指令抽取则把这一路线继续推向更灵活的方向。做法通常是把字段定义、输出 JSON schema、约束规则和示例直接写进 prompt，让模型输出结构化结果。它的优势是启动快、跨 schema 成本低；缺点是稳定性、边界一致性和可验证性通常不如专用抽取模型。因此，高要求生产系统常采用“LLM 负责快速泛化，专用抽取器负责高精度主干”的混合模式。

在真实系统里，NER、实体规范化、关系抽取、事件抽取和实体链接很少孤立运行。一个更完整的链路通常是：先找出 mention，再把 mention 归一到标准实体或术语，再判断实体之间的关系或事件角色，最后把结果写入知识库、检索索引或下游规则系统。也就是说，信息抽取真正交付的不是若干分散标签，而是一套可以被数据库、搜索和推理系统消费的结构化记录。

这也是为什么 IE 的误差会级联传播。上游 NER 边界一旦偏掉，后续关系抽取、实体链接和事件论元识别都会被拖偏；反过来，若系统能利用知识库约束、schema 校验和下游一致性反馈，上游抽取结果也能被部分纠正。因此，现代 IE 越来越像一条带反馈的结构化流水线，而不是几个彼此隔离的小任务。

问答（Question Answering, QA）研究的是：给定问题 \(q\) 与可能的知识来源，如何输出正确答案 \(a\)。真正的差异不在“有没有问题和答案”，而在于答案来自哪里、是否允许外部知识、是否需要长文检索、是否要跨文档推理。

导图把 QA 分成基于知识、基于检索、阅读理解和完形填空四类，这是非常经典的划分。基于知识的问答常围绕知识图谱和实体关系做推理，过去会用 Gated Graph Neural Networks、Bidirectional Attentive Memory Networks 一类结构；基于检索的问答强调先找证据再回答，Denoising QA、DecaProp 属于早期深阅读器时代；阅读理解里，Gated-Attention Reader、AoA Reader、XLNet 代表的是抽取式 / 阅读器模型的不同阶段；完形填空则更接近“填空推理”基准。

到 2026 年，问答的真正主线已经是检索增强生成（RAG）与长上下文问答。很多系统不再把“问答模型”独立训练成单一 reader，而是用检索器找证据，再交给 LLM 生成和引用答案。知识图谱问答依旧存在，但不再是唯一核心路线；阅读理解型模型也仍有价值，但更多转化成“作为专用 reader 或 reranker 的组件”。因此，传统 Reader 模型并没有完全过时，但它们今天更像 QA 系统里的模块，而不是系统本体。

知识库问答（Knowledge-base QA, KBQA）通常要求模型把自然语言问题映射到知识图谱查询路径、逻辑形式或候选实体关系组合。Gated Graph Neural Networks、记忆网络一类模型之所以重要，是因为它们代表了“在图结构上做推理”的阶段。这条路线今天仍有价值，尤其在高精度企业知识库、医疗知识库和金融知识图谱中。

抽取式阅读理解模型解决的是：答案就在给定段落中，系统只需找出正确 span。AoA Reader、Gated-Attention Reader、XLNet 阅读器等都属于这一路。它们在 benchmark 上曾非常强，也塑造了“question + passage -> answer span”这一经典范式。今天它们更多承担 reader、reranker 或 teacher 的角色，而不是完整 QA 系统本体。

现代问答系统的核心通常是“先证据，后答案”。检索器负责召回，重排器负责压缩候选，LLM 负责综合、归纳、生成并引用证据。若上下文窗口足够长，还可以把多段证据一起送入模型完成跨文档回答。这使 QA 从“单段抽取”升级为“检索、证据组织、推理、生成”一条完整链路。

完形填空（Cloze-style QA）和早期阅读器模型之所以在发展史上重要，不只是因为它们是早期 benchmark，而是因为它们迫使模型显式学习“从上下文恢复缺失信息”。Reading Strategies Model、Hidden Coherence Model 这类方法今天已经明显不是主流系统，但它们代表了阅读理解任务从浅层词匹配走向深层语义建模的过渡阶段。

问答系统表面上像一个单独任务，实际上经常站在多项 NLP 能力的交汇点上。检索负责把相关证据找出来，信息抽取负责把文档中的实体、事件和结构化事实整理清楚，NLI 或 reranker 负责判断哪些证据真的支持答案，摘要或生成模块再把证据组织成最终回答。若缺少这些中间环节，系统很容易要么答非所问，要么生成看似流畅但缺乏依据的答案。

因此，现代 QA 更适合被理解为一个任务编排层。它并不总是靠某个单独 reader 或 LLM 一步完成，而是依赖检索、抽取、排序、验证和生成协同工作。也正因为如此，问答的上限通常不只取决于生成模型本身，还取决于前面各层证据组织得是否足够干净。

实体链接（Entity Linking, EL）处理的是：文本里出现的某个实体提及（Mention），究竟对应知识库中的哪一个真实实体。它的难点不在于发现“这里提到了一个名字”，而在于做消歧（Disambiguation）。例如“Jordan”可能是国家、姓氏或篮球运动员；“Apple”可能是水果，也可能是公司。

导图里提到 DeepType、ELDEN、联合实体识别与消歧、WAT，代表了实体消歧和端到端 EL 的几个典型阶段。WAT 这类 Wikipedia-based linking 工具曾经非常实用，但若从今天的主流看，它已经更像传统成熟系统，而不是最前沿方案。

当前实体链接的强主线是检索 + 精排。BLINK 这类系统先用 bi-encoder 在向量空间检索候选实体，再用 cross-encoder 细排；GENRE 这类方法则把链接问题转成“生成实体名称或唯一标识”的 constrained generation。再往前一步，很多 LLM 应用会把 EL 与检索、知识库调用和 schema 约束整合起来。也就是说，纯规则或纯局部分类式 EL 今天已经明显偏旧，现代 EL 更像“候选召回 + 全局上下文消歧 + 知识库约束”的组合系统。

实体链接几乎总是分成两步。第一步是候选生成（Candidate Generation），也就是先把可能对应的实体缩到几十个甚至几个；第二步是实体消歧（Entity Disambiguation），利用上下文、局部语义和知识库结构做最后判断。若没有第一步，搜索空间太大；若没有第二步，系统很容易只凭表面字符串做错决策。

GENRE 一类方法出现后，实体链接开始从“多分类 / 排序问题”扩展成“受约束生成问题”。模型不再只在固定候选里二选一，而是直接生成实体名称、页面标题或唯一标识，再由解码约束保证输出合法。这种方法在开放域和超大知识库场景下很有吸引力，但它通常仍需要检索、别名库和知识库约束配合，不能把它理解成彻底摆脱候选集。

实体链接里最典型的错误，并不是模型完全不理解上下文，而是候选集一开始就召回错了。如果候选生成阶段没有把正确实体放进候选池，后面的精排器再强也无从挽回。别名缺失、缩写歧义、跨语言拼写差异和长尾实体冷启动，都是这一层最常见的来源。

另一类错误发生在上下文消歧上。系统看到了正确候选，却没有真正理解当前语境中的实体角色。例如“Apple 发布财报”与“苹果富含果胶”共享同一个表面字符串，但上下文语义完全不同。也正因为如此，实体链接的误差分析通常必须把召回失败与消歧失败拆开看，否则很难判断问题究竟出在检索、别名库还是上下文建模。

实体链接通常是知识系统的入口对齐层。信息抽取负责把 mention 找出来，实体链接负责把 mention 对到知识库中的唯一实体，后续关系推理、知识图谱查询和事实聚合才能真正建立在同一个对象上。若没有这一层，系统很容易把同一实体的不同别名拆成多份记录，或把不同实体错误合并。

因此，EL 很少单独作为终点任务交付，更常作为检索、知识库、问答和推荐系统里的基础设施存在。它把开放文本里的表面字符串，转换成数据库里可被唯一索引的实体标识，这正是知识系统能稳定扩展的前提。

关系预测（Relation Prediction）在导图语境里更接近知识图谱补全（Knowledge Graph Completion）或链路预测（Link Prediction）：给定头实体 \(h\)、关系 \(r\)、尾实体 \(t\) 中的部分信息，预测缺失边是否存在，或哪一个关系最合理。

TransE、ConvE、ConvKB、KBAT 都是这一方向的典型模型。TransE 用平移假设 \(h+r\approx t\) 建模关系，是最经典的知识图谱嵌入基线；ConvE、ConvKB 用卷积操作增强三元组交互；KBAT 则引入图注意力。到今天，这些模型仍然经常作为 benchmark baseline 出现，但已经不能被视为“当前知识推理系统的全部”。

现代路线至少多了两层扩展。第一层是更强的知识图谱嵌入与图神经网络；第二层是把 KG 与 LLM 结合，用文本语义、路径推理和外部知识共同预测缺失关系。也就是说，导图里这些模型没有错，但它们更像经典 KGE 主线，而不是 2026 年全部主流。

TransE 代表最早的几何平移建模思想，结构简单、解释直接；ConvE、ConvKB 试图用更强的非线性交互提升表达力；KBAT 则把图结构邻域显式纳入建模。它们的共同前提是：知识已经以三元组形式存在，模型的任务是从结构中补全缺失边，而不是直接从原始自然语言中抽知识。

若把这条线再补完整，DistMult、ComplEx、RotatE 也是必须知道的代表模型。DistMult 用双线性打分，是最经典的张量分解式基线之一；ComplEx 通过复数空间解决对称关系表达不足的问题；RotatE 则用复平面旋转刻画关系变换。这几类模型一起构成了知识图谱嵌入从“平移”到“更强代数结构建模”的主干。

现代知识系统很少只依赖图结构本身，因为大量关系证据其实散落在原始文本、文档描述和外部检索结果中。于是，关系预测开始越来越像“知识图谱结构 + 文本语义 + 检索证据 + LLM 推断”的混合问题。传统 KGE 在封闭图谱 benchmark 上仍有价值，但面对开放世界知识更新时，单靠静态嵌入往往不够。

关系预测最常见的误判之一，是把图中共现误当成真实关系。某些实体因为在图谱中高频出现，会让模型学到“它似乎和很多东西都能连上”，从而在评测集上看起来不错，但一到开放世界或冷启动实体就迅速失真。静态图嵌入在这一点上尤其明显，因为它们更擅长记住结构统计，而不一定真的理解关系语义。

另一个常见问题是封闭图谱假设过强。很多 benchmark 默认实体和关系集合是固定的，但真实业务里知识会持续增长，文本证据也会不断出现。若系统只依赖既有图结构，而不把文档语义、别名变化和新事实注入进来，就会在知识更新场景里很快退化。

关系预测与关系抽取并不是同一件事，但在现代知识系统里两者越来越紧密。关系抽取从原始文本中发现候选事实，关系预测则在知识图谱结构和文本证据上判断哪些边应被补全、强化或修正。若把两者结合起来，系统就不再只是“从文本抽三元组”，而是能够持续把文本世界的新增事实并入图谱世界。

因此，关系预测在今天越来越像一个知识融合层：上游接文本抽取、实体链接和检索证据，下游接图谱补全、问答和推荐。它的价值不只在 benchmark 上补对几条边，而在于让知识图谱随着外部世界变化持续更新。

语法纠错（Grammatical Error Correction, GEC）要求模型把含有语法、拼写、搭配、时态或词法错误的句子，改写为更符合标准书面语言的版本。它本质上是一个“受约束文本编辑”任务，而不是开放式生成任务：模型既要改对，又不能无故改动本来正确的部分。

导图里的 Copy-Augmented Transformer、CNN Seq2Seq + Quality Estimation、Transformer，都代表了从“序列到序列改写”走向“更受控编辑”的过渡阶段。尤其是 copy 机制，在 GEC 中很自然，因为绝大多数 token 其实应该原样保留。

今天的主流更偏向 T5、mT5、BART 这类 encoder-decoder 文本编辑模型，以及 LLM 驱动的纠错器。CNN Seq2Seq 已明显过时，更多作为历史阶段代表；纯通用 Transformer 也通常不会直接裸用，而是会配合差分标注、最小编辑目标、错误类型建模或后验置信度校准。若系统要求可解释和高精度，还会加入语言规则、置信度过滤和多候选 rerank。

GEC 和摘要、开放式写作不同，它的最优输出通常离输入很近。也正因为如此，copy 机制、最小编辑距离目标、差分标注和受控解码在这一任务里格外重要。一个好的纠错器不仅要会改错，还要会尽量少改，否则很容易把本来正确的表达也改坏。

现代 GEC 系统通常会把生成模型与后验筛选结合起来：模型先生成候选改写，再结合语言规则、质量估计、置信度阈值或多候选 rerank 选出最稳的版本。若场景对可解释性要求高，例如教育批改，还会额外输出错误类型和修改依据，而不是只给最终改写句。

GEC 的核心难点并不只是“识别错误”，而是控制修改边界。很多模型在训练后会出现过度修改（Over-correction）：它们把风格差异、可接受变体甚至作者有意保留的表达都改成自己更熟悉的形式。这样得到的句子可能更像标准语料，却不一定更符合用户真正需要。

因此，GEC 的高质量系统往往必须额外监控两类指标：一类是错误纠正率，另一类是无错句保持率。若只盯着改对多少错句，而不管原本正确句子被误改多少，系统在真实使用中往往会显得“很积极，但不可信”。

语法纠错在教育批改、写作辅助、客服质检和文本清洗里都很常见，但不同场景的目标并不相同。教育场景需要错误类型和解释，写作辅助更强调流畅与风格建议，客服质检可能只关心是否满足模板规范，训练数据清洗则更看重低风险批量修复。也正因为如此，同样叫 GEC，系统输出可以是改写句、差分标注、错误标签或多候选建议，而不一定只有一种形式。

这也解释了为什么很多系统不会让 GEC 模型直接“改完即落地”。更稳的做法通常是：模型给出候选修改，规则与置信度模块筛掉高风险改写，再由用户确认或下游流程决定是否接受。换句话说，现代 GEC 更像受控编辑器，而不是完全自动重写器。

对话（Dialogue）不是单一任务，而是一组彼此耦合的子任务集合。导图中列出的对话行为分类、对话状态跟踪、检索式聊天机器人、生成式聊天机器人、意图分类、槽填充，本质上共同构成了传统对话系统的技术栈。

若是任务型对话（Task-Oriented Dialogue），系统通常先做意图分类（Intent Classification）和槽填充（Slot Filling），再通过对话状态跟踪（Dialogue State Tracking, DST）维护用户目标。Neural Belief Tracker、自注意力 DST、CRF-ASN、BiLSTM-CRF 都是这一代方法的代表。若是开放域聊天，历史上往往分检索式与生成式：Poly-encoder、BERT、ELMo 更偏检索匹配；TransferTransfo、Seq2Seq 更偏生成。

到 2026 年，对话系统的中心已经显著转向LLM 驱动的统一对话代理。这并不意味着意图分类、槽填充和 DST 失效了，而是它们经常被吸收到更大的系统里，作为工具、状态缓存、结构化约束或评测子项存在。传统模块化对话系统仍然适用于高可控、高合规、流程稳定的客服和交易场景；而开放式、多工具、多轮任务对话则几乎都在向“LLM + memory + retrieval + tool use”的路线收敛。

任务型对话的关键不是“聊得自然”，而是把用户目标稳定推进到可执行状态。因此它天然重视意图分类、槽填充、DST、策略学习和接口调用。导图里的 CRF-ASN、BiLSTM-CRF、Neural Belief Tracker 等模型，正对应传统任务型对话系统的典型子模块。今天在强流程、高合规场景里，这条路线依然有效。

开放域聊天和多工具对话则更强调上下文理解、长期记忆、外部检索和工具协作。这里的核心不再只是单轮回复质量，而是多轮一致性、任务分解、工具调用正确性和用户状态持续跟踪。也正因为如此，现代对话系统越来越像一个由 LLM 驱动、但周围包裹记忆、检索、函数调用和安全控制的系统，而不是一个单独的“聊天模型”。

指代消解（Reference Resolution）处理的是：文本中的代词、名词短语或省略表达，究竟指向哪个先行项。更狭义的共指消解（Coreference Resolution）关注同一实体在文档中的多次提及，例如“OpenAI 发布了新模型。它……”，其中“它”指回“OpenAI”或“新模型”，就需要结合上下文判断。

导图中把它分成共指、回指、所指，按方法又区分规则系统和统计方法，这是经典教科书式划分。规则系统里，Hobbs 算法和知识库规则曾经非常重要；统计阶段则经历了 Mention Pair、Mention Ranking、Entity-Mention 等一系列建模范式。后来深度学习又把问题统一成端到端 span 推断，例如 end-to-end neural coreference 与后续 SpanBERT 路线。

今天规则法已经不是主流最优，但在小数据、强格式文本和高可解释场景里仍有生命力。真正的主线是端到端 span 模型 + 预训练编码器，以及近两年的 LLM 辅助共指消解。值得注意的是，LLM 虽然能做不少指代任务，但在长文档一致性和幻觉控制上并不天然完美，所以共指消解并没有因为 LLM 出现而“自动解决”。

规则法之所以在早期有效，是因为很多指代现象确实和句法位置、性数一致、语义类别约束强相关。统计阶段的 Mention Pair、Mention Ranking、Entity-Mention 则逐步把问题从“写规则”转成“学习哪些候选更像同一实体”。这几代方法虽然已不是前沿，但仍然决定了今天端到端 span 模型的评价方式和候选组织逻辑。

现代大模型能在短上下文里做不少共指判断，但长文档、多实体交织和跨段落所指漂移依然容易出错。也正因为如此，共指消解至今仍是很多文档理解、法律文本分析和长篇问答系统的重要中间模块，而不是一个已经“被 LLM 顺手解决”的旧任务。

时间处理（Temporal Processing）研究的是：如何从文本中识别时间表达、恢复时间值、推断事件先后关系，以及估计文档的成文时间。它不仅关心“2026 年 4 月”这种显式时间实体，也关心“上周五”“三个月后”“发布前一天”这类相对、模糊或依赖上下文的时间表达。

导图里提到文档时间标记和时间提取两个方向，这是很好的切分。NeuralDater、BurstySimDater 属于文档时间推断阶段的代表；时间提取则通常包括时间实体识别、时间实体链接 / 归一化、时间表达合成和时间值补全。这里真正困难的地方往往不是识别出“这是一个时间片段”，而是把它映射成统一、可计算的时间值。

现代时间处理仍然保留很强的规则 + 学习混合特征。原因是时间正规化对格式和日历知识高度敏感，纯神经网络不一定比规则安全；但时间识别、文档定年和跨句时间推理又越来越依赖强编码器与 LLM。因此，这个方向并没有被某个单一大模型彻底替代，而是长期保持 hybrid 风格。

时间处理至少包含两层不同问题。第一层是识别：找出文本中哪些片段在表达时间；第二层是归一化：把“明天下午”“上个季度”“发布前三天”这类表达映射成统一时间值或时间区间。第一层更像实体识别，第二层则更依赖日历规则、基准时间和上下文推断。

NeuralDater、BurstySimDater 这类方法关注的是整个文档大概写于何时，或者文中事件时间如何组织。这类任务常需要把局部时间表达、主题词汇、事件背景和文档风格一起纳入判断，因此比简单时间实体识别更接近高层语义推断。

时间正规化至今仍大量依赖 HeidelTime、SUTime 一类规则系统，原因不是这个方向“还不够现代”，而是时间表达本身高度格式化、依赖日历知识，并且错误代价很高。学习模型擅长召回和上下文推断，规则系统擅长最后一步标准化，这正是时间处理长期保持 hybrid 风格的根本原因。

时间处理里一个经常被忽略的重点是：模型最后到底要把时间表示成什么。TIMEX3 和 ISO-TimeML 提供的是经典标准化框架，它们让系统能够把“2024 年底”“两周后”“此前一天”这类表达写成统一注释格式，便于不同系统共享数据与评测。HeidelTime 之所以长期有生命力，也和它紧贴 TIMEX3 规范有关。

不过，传统 TIMEX3 表示在面对组合式、事件相对型和多片段时间表达时会显得偏紧。近年的时间正规化研究开始更多借助SCATE 这类更接近语义组合的表示，把时间表达理解成可执行的语义构造，而不是只生成一个表面规范字符串。这条线本质上让时间正规化越来越像语义解析任务，而不只是模式匹配。

时间处理不只关心单个时间片段，还关心事件之间的先后、重叠和包含关系。例如“签约后一个月交付”“开庭前提交证据”“发烧三天后住院”，真正决定业务含义的往往是事件与时间、事件与事件之间的相对次序。因此，Temporal Relation Extraction 和事件时间排序常与时间实体识别共同组成一套系统，而不是互相独立。

这类任务比时间实体识别更难，因为它需要跨句、跨段落乃至跨文档整合证据。模型既要知道哪些词是事件，又要知道它们如何被时间信号词、时态、语气和篇章结构共同约束。也正因为如此，时间关系推理往往是时间处理里最接近高层语义理解的一块。

时间处理在实际系统里常出现在时间线构建、医疗病程整理、法律事实排序、新闻事件追踪、文档检索过滤和时效问答里。很多系统真正需要的并不是“找出一个时间 mention”，而是把它绑定到统一时间轴上，再与事件记录、数据库字段或搜索索引对齐。这里一旦时间归一化错了，后续检索、排序和分析都会系统性偏移。

因此，现代时间系统常采用分层结构：前段用规则与模型联合做时间识别和归一化，中段做事件-时间对齐与关系推理，后段再把结果注入检索、问答或知识库模块。LLM 可以提高覆盖和解释能力，但最终落库的时间值仍然往往需要规则或可执行语义层做最后校验。

时间处理里的典型错误，往往不是“完全没识别出时间”，而是识别对了 mention，却归一化错了值。例如“下周一”必须相对于文档创建时间解析；“第三季度”必须结合业务日历；“术后三天”甚至需要先找出手术事件发生点。模型若把这些表达直接映射成表面日期字符串，而没有绑定正确参考系，最终结果会在时间线上整体漂移。

另一类常见错误发生在事件排序上。句子里同时出现多个事件、多个时间锚点和跨句照应时，系统很容易把“复诊后三天再次住院”理解成“住院后三天复诊”。这类错误在医疗、法律和新闻场景里代价很高，因此时间处理的误差分析通常必须同时检查 mention 检出、归一化和关系推理三层，而不能只看实体识别 F1。

词法分析（Lexical Analysis）处理的是句子进入更高层语义与句法建模之前的基础语言单位处理。它关心的通常不是整句含义，而是文本如何被切分、归一、标注成更适合后续处理的符号序列。导图中列出的分词、词干提取、词形还原、词性标注、命名实体识别，确实常在传统 NLP 流程图里被放在这一级。

分词（Tokenization / Word Segmentation）在中文和英文里的问题形态并不相同。英文天然有空格，因此基础 tokenization 常从空格和规则切分开始，再处理标点、缩写和复合词；中文没有显式词边界，因此需要额外决定“哪些字应该组成一个词”。中文分词的经典路线包括：基于词典的 Trie / DAT / AC 自动机，配合正向最长、逆向最长、双向最长等扫描规则；基于统计的 n 元语法 + 最短路径 / N 最短路径；以及基于深度学习的序列标注。

到 2026 年，深度学习时代讨论“分词”时，很多场景已经转化成了子词切分（Subword Tokenization）问题。英文里，BPE、WordPiece、Unigram Language Model 和 SentencePiece 比传统有限状态切分更重要；中文里，大模型通常直接采用统一 tokenizer，而不再把传统中文分词作为唯一入口。也就是说，传统中文分词并没有消失，但在大模型系统里，它不再是唯一中枢。

英文侧若回到更传统的 NLP 管线，还会见到有限状态自动机（Finite State Automaton, FSA）和规则分词器。它们在今天的大模型训练里不再是主角，但在工业文本清洗、词法分析器和需要强规则控制的场景里仍然常见。

中文分词之所以长期是独立问题，是因为汉语书写天然不提供稳定词边界，而很多后续任务又需要比“单字”更高一级的词汇单位。基于词典的方法本质上是在字符串流上做高效匹配，Trie、双数组字典树（DAT）和 AC 自动机解决的是“如何快速找到候选词”；正向最长、逆向最长、双向最长解决的是“当词典里有多个可匹配长度时如何选边界”。这一路线速度快、实现稳、易于接入领域词典，但对新词和上下文歧义无能为力。

统计分词把切分看成路径搜索或序列概率最大化问题。做法通常是先构造词图，再用 n 元语法、最短路径或 N 最短路径寻找最优切分。与纯词典法相比，它能利用上下文偏好解决部分歧义，例如“研究生命起源”应切成“研究 / 生命 / 起源”还是“研究生 / 命 / 起源”。深度学习路线则进一步把问题改写成字级序列标注或 span 预测，让模型直接学习“字与字之间是否应该断开”。到了预训练模型时代，中文分词甚至可以被吸收到更大的表示学习框架中，不再必须先手工做干净切分。

英文表面上“有空格就够了”，但真正进入模型前仍需解决大量边角问题，例如缩写、连字符、URL、数字、标点、特殊符号、大小写和多语言混杂。传统规则切分器和 FSA 在这一步很强，因为它们能精细控制清洗行为；但在现代预训练系统里，真正决定词法入口的往往是子词算法。BPE、WordPiece、SentencePiece 和 Unigram Language Model 的核心目标都不是还原语言学上的“真实词”，而是在词表大小、未登录词鲁棒性和序列长度之间做工程折中。

因此，今天很多 NLP 模型的第一步已经不是“先分词再建模”，而是“按 tokenizer 规则把文本编码成 token 序列”。这也是为什么传统中文分词、英文规则切分和现代 tokenizer 不能混为一谈。前两者更偏语言学和预处理，后者则直接决定模型输入空间本身。

词干提取（Stemming）和词形还原（Lemmatization）都在解决“不同表面形态如何映射到更稳定的词汇单位”这一问题。波特词干算法（Porter Stemmer）属于典型规则式词干提取；词形还原则更依赖词典和词法知识，例如把

went

go

词性标注（Part-of-Speech Tagging, POS）则是给每个 token 赋予语法类别，例如名词、动词、形容词。早期系统常用 HMM、CRF；深度学习阶段出现了 Meta-BiLSTM、Flair 等模型；今天多数高质量 POS 系统已经建立在强预训练编码器之上。需要注意的是，POS 在大模型时代没有“消失”，只是很少再作为独立明星任务出现，而更多是下游结构化分析的一部分。

至于 NER，虽然很多传统课程把它挂在词法分析旁边，但从任务本质看，它更适合归入信息抽取，因此本文主体也放在信息抽取一侧理解。

词干提取和词形还原经常被混用，但它们解决的问题并不完全相同。词干提取追求的是把多个形态变体压缩成可聚合的表面核心，因此允许输出一个并非真实单词的“词干”；词形还原追求的则是恢复词典意义上的规范词元，因此通常需要结合词性和词法规则。信息检索时代大量使用 stemming，是因为它可以提高召回；而高质量语言分析更偏好 lemmatization，因为它保留了更强的语言学一致性。

在现代 NLP 管线里，POS 很少再单独成为最终产品，却经常作为隐式中间结构存在。句法分析器会利用词类信息稳定局部结构判断；信息抽取和关系抽取在某些低资源场景下也会把 POS 作为辅助特征；语法纠错与教学反馈系统则仍然需要显式输出词性标签。HMM 和 CRF 代表的是“局部发射 + 转移约束”的经典序列标注时代，BiLSTM、Flair 和预训练编码器代表的是“上下文表示更强，显式特征工程更少”的阶段。今天若只谈 POS 标签集而不谈编码器，往往已经不够贴近实际系统。

传统 NLP 往往把词法分析看成严格前置流水线：先分词、再词形还原、再词性标注、再进入句法和语义模块。现代大模型系统中，这种刚性的前后级联已经明显减弱，因为大量词法信息会被预训练编码器隐式吸收。但词法分析并没有消失，它只是从“每个系统都要显式暴露的一连串步骤”变成了“在 tokenizer、预处理器、结构化分析器和数据清洗器里各自承担不同角色”的基础层。

真正落地时，是否显式做词法分析，取决于任务边界。如果目标是训练一个通用编码器，往往只需要稳定 tokenizer；如果目标是做中文检索、领域规则抽取、教育批改、法律文书结构化或高质量句法分析，显式的分词、词形还原和 POS 仍然会显著影响系统上限。也正因为如此，词法分析不能被简单理解成“旧时代遗产”，它依然是许多高精度系统的入口控制层。

句法分析（Syntactic Parsing）研究的是：一个句子的结构应该怎样被组织起来。它通常分成短语结构分析（Constituency Parsing）和依存句法分析（Dependency Parsing）两大主线。前者更关心句子如何被递归切成词组、短语和从句；后者更关心词与词之间谁依附谁、主谓宾修饰关系怎样组织。

短语结构分析的经典路线是概率上下文无关文法（PCFG）与 CKY 动态规划。PCFG 让规则带概率，CKY 负责在句子上做高效 chart parsing。之后出现了判别式和深度学习阶段，例如递归神经网络语法器、自注意力编码器语法器，以及 Self-Attentive Encoder + ELMo 这类代表模型。今天若追求高精度，强预训练编码器和自注意力句法器显然比纯 PCFG 更常见，但 PCFG 和 CKY 仍然是理解语法解析的基础。

短语结构树的价值，在于它直接保留了“短语由哪些更小成分构成”的层级信息。例如名词短语、动词短语、从句边界和附着位置，在 constituency tree 中都能被显式表达。因此，它在语言学分析、句法驱动生成、教育语法反馈和某些高精度语义解析任务里仍然很重要。PCFG 解决的是“在文法规则给定时如何估计一棵树的概率”，而 CKY 解决的是“如何在指数级候选树空间里做可计算的动态规划搜索”。

深度学习时代的 constituency parser 则把“树结构评分”交给神经编码器完成。递归神经网络语法器强调沿树组合表示，自注意力语法器则更擅长利用全局上下文。到了预训练模型阶段，parser 往往不再自己从零学习词法和局部组合，而是直接站在强编码器隐藏状态之上做 span 打分或 chart 打分。这意味着 PCFG 仍然是理论骨架，但现代高精度系统的打分函数已经明显神经化。

依存分析的经典划分是基于图（Graph-based）与基于转移（Transition-based）。图方法把整棵依存树看成全局优化问题，典型算法包括项目树场景下的 Eisner 算法，以及非项目树场景下的最大生成树与 Chu-Liu-Edmonds；转移方法则通过 Arc-Standard、Arc-Eager、Arc-Swift 一类转移动作逐步构树。静态规范（Static Oracle）和动态规范（Dynamic Oracle）则属于训练策略，不应与解码算法混成一层。

深度学习阶段最有代表性的路线是Biaffine Parser。它用强编码器得到词表示，再通过 biaffine 打分 head-dependent 关系。到今天，预训练编码器 + biaffine head 依然是句法分析的强主线。导图里部分“Eisner / BiAffine / 生成式”关系有些混杂，实际应区分：Eisner 和 Chu-Liu-Edmonds 是解码算法，Biaffine 是神经打分头，二者解决的问题不同。

图方法的优势在于全局最优视角。模型先为候选弧 \((h,m)\) 或带标签弧打分，再在全句范围内搜索满足树约束的最高分结构。这使它在整体一致性上通常更稳，也更容易与强打分头结合。转移方法则更像在线决策过程：解析器维护栈、缓冲区和部分弧集合，通过一连串动作逐步把句子变成依存树。它的优势在于速度和增量构树自然，特别适合流式或局部决策分析。

Arc-Standard、Arc-Eager、Arc-Swift 这些名称说的不是不同损失函数，而是不同的构树动作系统。Arc-Standard 更偏保守、构树动作整洁；Arc-Eager 允许更早地建立依存关系；Arc-Swift 进一步通过更大跨度动作减少决策步数。静态规范与动态规范则回答另一个问题：训练时，到底用“唯一标准动作序列”监督，还是允许模型在偏离正确路径后仍获得合理指导。把这些概念拆开，依存句法的结构才会清晰。

Biaffine parser 的关键不在于“用了一个新层”，而在于它把依存弧打分写成了适合现代编码器的参数化双线性形式。编码器先为每个词产生上下文化表示，再把“作为 head 的表示”和“作为 dependent 的表示”分别投影，最后用 biaffine 分数建模它们之间的方向性关系。这样一来，句法分析的难点就被集中到两个地方：一是编码器是否真的学到了句子结构线索，二是解码算法能否把局部弧分数组装成合法整树。

这也是为什么“Eisner 很强”或“Biaffine 很强”这种说法都不完整。前者是结构约束下的搜索器，后者是局部打分器；真正高性能 parser 是二者与预训练编码器共同组成的系统，而不是某一个名字单独决定一切。

虽然大模型可以在不显式输出句法树的情况下完成很多任务，但句法分析并没有失去价值。信息抽取会用依存结构缩短实体关系路径，文本纠错会用句法边界限制改写范围，语义角色标注和 AMR 解析也常把句法作为辅助约束。对于法律、医学、教育和语言学场景，显式句法树仍然提供了预训练模型隐表示难以直接替代的可审计结构。

因此，今天的句法分析更像一个高价值结构化中间件。它不一定每次都站在系统最前台，却仍然在需要可解释结构、精细边界控制和复杂语义映射的任务里发挥作用。

语义分析（Semantic Analysis）讨论的是：句子到底表达了什么意义，而不仅仅是它在词法或句法层面长什么样。导图把这一章拆成词义消歧、语义角色标注、语义依存分析、抽象语义表示、问句转 SQL，这种拆法很合理，因为它们正好对应从局部词义到全句结构语义，再到可执行结构表示的几条主线。

词义消歧（Word Sense Disambiguation, WSD）要求模型判断一个词在当前上下文里究竟是哪一个义项。传统监督法常用互信息、贝叶斯、最大熵；无监督方法包括 ShotgunWSD、MCS Estimation；知识库方法则依赖词典定义、Yarowsky 路线或结构树信息。深度学习阶段出现了 Att-BiLSTM、ELMo 等模型。今天 WSD 仍是一个真实问题，但它已不像早年那样作为独立核心 benchmark 被频繁单独强调，因为强预训练模型在很多下游任务里已经隐式承担了部分消歧工作。

语义角色标注（Semantic Role Labeling, SRL）则关注“谁对谁做了什么”。早期方法常依赖短语结构树、依存句法树或语块边界；现代方法更多使用预训练编码器、span 预测和联合谓词-论元学习。换句话说，语法信息仍然重要，但已经不再总是以手工管线方式显式注入。

WSD 的本质是把一个词面形式映射到正确义项，因此它天然会围绕三类信息展开。第一类是监督数据，也就是人工标注过的“这个上下文里是哪个 sense”；第二类是分布信息，即同一义项在什么上下文里更常出现；第三类是外部词典或知识库，把定义、同义词、上位词和例句作为先验。互信息、贝叶斯、最大熵、Yarowsky、ShotgunWSD 这些方法虽然分属不同年代，但都在尝试回答同一件事：上下文中哪些证据最能决定义项。

强预训练模型出现后，WSD 的讨论方式发生了变化。模型不一定显式输出 WordNet sense id，但在阅读理解、问答、检索和翻译中已经隐式完成了大量消歧工作。这也是为什么 WSD 在现代论文里不再像早期那样处于舞台中央，却依然是很多错误分析中的核心因素。

SRL 的目标不是画出句法树，而是明确事件语义里的参与者结构。例如一个谓词对应的施事、受事、工具、地点和时间，往往比单纯主谓宾更贴近任务语义。早期系统严重依赖句法树，因为句法边界提供了天然候选论元；现代系统虽然可以用预训练编码器直接做 span 分类或 token 级角色标注，但语法与谓词框架知识仍然经常以隐式或显式方式进入模型。

也正因为如此，SRL 长期被视为连接“句法结构”和“事件语义”的中间层。问答、信息抽取、事件抽取和摘要若想真正理解谁做了什么，往往都会从 SRL 式表示中获益。

语义依存分析（Semantic Dependency Parsing）试图构建比句法依存更贴近语义关系的图结构。导图里提到基于图的 BiAffine + BERT 和基于转移的 list-based Arc-Eager + Tree RNN，这恰好对应两大经典路线。当前主流仍然是强编码器配合图结构预测，传统转移式语义依存已明显不如图方法常见。

抽象语义表示（Abstract Meaning Representation, AMR）把句子语义编码成图。早期的 JAMR、CAMR、AMREager、Sequence-to-Graph Transducer 都是重要里程碑；而现在更强的路线已经扩展到 seq2seq AMR 解析器与 LLM 微调。旧方法不能说“没用”，但更适合理解 AMR 发展史，而不是视为今天唯一主干。

问句转 SQL（Text-to-SQL）则属于可执行语义解析。最早系统多用语义分析器和 Seq2Seq；后续出现了 schema-aware parser、RAT-SQL、PICARD 等更强系统；到 2025 到 2026 年，LLM-based Text-to-SQL 已经成为最活跃主线，重点转向 schema linking、约束解码、工具调用和数据库执行反馈。导图里只写 Seq2Seq 和语义分析器，历史上没错，但今天显然不够覆盖主流。

语义依存分析和 AMR 都在追求“比句法更贴近意义的结构”，但它们不是同一种任务。语义依存通常仍紧贴原句 token，把语义关系建在词级节点之间；AMR 则进一步走向概念图表示，允许一个句子被抽象成与表面词序不完全同构的语义图。前者更像“在句法树上做语义增强”，后者更像“把句子翻译成概念图语言”。这也是为什么 AMR 解析往往更接近图生成或 seq2seq 任务，而语义依存更接近结构预测任务。

Text-to-SQL 之所以难，不只是因为要生成 SQL 语法，而是因为模型必须同时解决自然语言理解、数据库模式理解、字段对齐和执行约束。用户问“上季度销量最高的华东区域产品前三名”，系统不仅要理解聚合、排序、时间范围和地域过滤，还要知道这些语义应该落到数据库里哪些表和列上。这就是 schema linking 的核心难点。

Seq2Seq 是最早把问题端到端写成“自然语言到 SQL”的统一框架，但它对复杂 schema 的对齐能力有限。RAT-SQL 这类模型通过关系感知编码把库表结构显式纳入建模，PICARD 则把 SQL 语法约束直接并入解码过程，减少非法输出。到了 LLM 时代，模型在少样本泛化上更强，但执行一致性、表结构歧义和高风险 SQL 约束仍然需要工具化约束与数据库反馈闭环。

如果说词法分析解决的是“语言单位怎样切出来”，句法分析解决的是“结构怎样组织起来”，那么语义分析解决的就是“这些结构最终表达了什么”。它的任务边界天然最宽，因此也最容易被强预训练模型“部分吸收”。但被吸收不等于问题消失。WSD、SRL、AMR、Text-to-SQL、语义依存这些任务仍然在要求模型输出显式语义结构，而不是只在隐空间里“懂了”。

在工程实践里，语义分析经常出现在高价值接口层。知识问答需要把自然语言转成可执行查询，信息抽取需要把句中角色和事件结构抽出来，企业数据助手需要把口语问题映射成数据库操作，法律和医疗系统需要可审计的语义关系。这些场景共同说明：显式语义结构并没有因为 LLM 普及而过时，反而在高风险、高精度应用里变得更重要。

文本聚类（Text Clustering）要求在没有明确标签的情况下，把语义相近的文本自动分到同一组。它本质上是无监督学习问题，因此关键不只是聚类算法本身，还包括文本如何表示。导图里提到“聚类算法”和“特征提取”两支，这是正确的，因为向量表示常常比具体聚类器更决定上限。

传统阶段，文本通常先做分词、停用词过滤、特征选择，再用词袋或 TF-IDF 表示，随后接 K-Means、重复二分法、DBSCAN、层次聚类。聚类数量常借助 Gap Statistic、平方误差和（WCSS）或轮廓系数（Silhouette）估计。今天这些方法仍然有用，尤其在轻量场景和解释性要求较高时。

现代路线则越来越多地使用句向量或文档向量，再在嵌入空间聚类。例如“embedding + UMAP + HDBSCAN + topic labeling”已经成为短文本发现主题的常见工作流。严格说这已经和主题模型发生了交叉，因此很多 2026 年的“文本聚类系统”本质上更像嵌入驱动的语义分群，而不是单纯稀疏向量上的 K-Means。

文本聚类里最关键的变化，是“难点从聚类算法本身前移到了表示学习”。在 TF-IDF 时代，K-Means、层次聚类和 DBSCAN 的差别固然重要，但更大限制通常来自稀疏词袋无法稳定表达同义改写、长距离语义相似和短文本语义压缩。进入嵌入时代后，只要文档向量本身足够好，很多看起来普通的聚类器也能得到比旧系统更合理的簇结构。

这也是为什么现代文本聚类讨论越来越频繁地和 embedding model 绑在一起。今天若只列 K-Means、DBSCAN、层次聚类而不讨论向量表示，往往已经抓不住真正决定效果的主因。

K-Means 假设簇大致呈球状，适合簇规模相近、聚类数可预设、向量空间较规整的场景；DBSCAN 更强调基于密度发现簇，不要求预先指定类别数，也更能识别噪声点，但对高维空间和参数敏感；层次聚类则保留了簇的多层结构，适合做探索式分析和可视化解释。没有任何一个聚类器能在所有文本几何结构下都占优，因此算法选择必须与表示空间形状一起考虑。

现代文本聚类里非常常见的一条工作流是：先用句向量模型把文本编码到稠密语义空间，再通过 UMAP 等降维方法整理局部几何结构，随后用 HDBSCAN 一类密度聚类器发现簇，最后再为每个簇生成关键词或标签。BERTopic 之所以流行，就是因为它把这条流程工程化了：前面用 embedding 捕捉语义相似，后面再用 c-TF-IDF 为每个簇生成可解释主题词。

这一流程说明，现代文本聚类不再只是“给每个点分个组”，而是同时追求语义几何结构、噪声点处理和簇级解释。也正因为如此，聚类与主题发现的边界越来越模糊，很多系统最终交付的其实是“簇 + 标签 + 代表文档”的完整探索结果。

文本聚类的困难之一，在于它没有监督学习那样直接清晰的正确标签。轮廓系数、Davies-Bouldin、Calinski-Harabasz 这类内部指标可以评价簇内紧致度和簇间分离度，但它们未必等价于“语义上真有意义”。如果手头有少量人工标签，还可以用 ARI、NMI 等外部指标做辅助评估；若没有标签，很多时候必须结合人工审阅、代表样本查看和下游任务收益一起判断。

因此，聚类系统的交付往往不应该只有一个分数。更有价值的输出通常是：每个簇的规模、关键词、代表文本、离群点比例，以及这一聚类结果能否真正支持运营分析、主题发现、知识整理或数据清洗。

文本聚类常被用于工单归类探索、舆情主题发现、搜索日志归并、问答库清洗、异常文本发现和训练数据审计。它最大的价值并不总是“最终分类”，而是帮助人先看清数据里自然形成了哪些模式。因此，在很多真实系统里，文本聚类不是终点模型，而是建标签体系、做数据治理和发现长尾问题的上游分析工具。

进入 LLM 时代后，聚类之后再用大模型生成簇标签、总结簇差异和抽取代表问题，也成为越来越自然的工作流。此时，聚类负责组织结构，LLM 负责生成解释，两者结合往往比单独依赖其中一方更稳。

文本聚类最常见的误判有两类。第一类是表面词重合但语义不同，例如都出现“退款”但一个在投诉物流、另一个在讨论账单系统；若表示学习不够强，系统会把它们错误合并。第二类是语义相近但表面词差异大，例如“登录不上去”“账号一直转圈”“验证码过期”其实都属于访问失败主题，但 TF-IDF 类表示可能把它们拆散。

还有一个经常被忽略的问题是簇规模不平衡。真实业务数据里往往存在一个超大通用簇和大量细小长尾簇，如果仍然机械使用固定 \(k\) 的 K-Means，就容易把长尾问题淹没进大簇中。因此，文本聚类的失败模式往往不是算法“算错了”，而是表示空间、聚类假设和业务目标本来就没有对齐。

文本分类（Text Classification）要求把文本映射到预定义标签空间 \(\mathcal{C}\)，例如新闻主题、垃圾邮件、风险等级、工单类别、法务标签或用户意图。它是 NLP 里最基础、最常落地的任务之一，因为大量业务问题最后都能被写成“这段文本属于哪一类”。

传统流水线是：分词、停用词过滤、特征选择、词袋向量，再接线性分类器。导图里提到的卡方检验和互信息，是很典型的特征选择方法。这个路线今天并没有完全消失，在小数据、强解释、低资源和高吞吐场景里仍然实用。

深度学习阶段经历了 ULMFiT、BERT、XLNet 等代表模型；今天主流则是预训练编码器微调、参数高效微调（PEFT），以及在少样本条件下直接使用 instruction-tuned LLM 做 zero-shot / few-shot 分类。也就是说，BERT 和 XLNet 仍然是应知应会的主线，但若追求最新工程效果，通常还要把 LLM 分类器、检索增强分类或多标签约束一起纳入考虑。

传统文本分类之所以长期有效，是因为很多业务标签本来就和词项分布高度相关。垃圾邮件识别、主题分类、工单路由、舆情监控，这类任务即使用 TF-IDF + 线性模型也往往有很强基线。它的优势在于训练快、解释清楚、部署轻；劣势则是对同义改写、跨领域迁移和长上下文语义组合能力有限。

BERT、XLNet、ModernBERT、T5 等模型让文本分类从“词项匹配”升级成“上下文语义判别”。在高质量标注数据充足时，编码器微调通常仍然是吞吐和精度都很稳的方案；在标注数据很少、标签定义变化频繁时，LLM 的 zero-shot / few-shot 分类则更灵活。很多系统最终会结合两者：先用 LLM 帮忙定义标签边界或生成弱标注，再训练专用分类器承接高吞吐上线。

情感分析（Sentiment Analysis）本质上是文本分类的一个重要子集，但它关注的不是主题归属，而是文本的主观极性、态度和情绪取向，例如正面、负面、中性，或更细粒度的愤怒、喜悦、失望、讽刺等。

从技术上看，情感分析既可以直接复用文本分类框架，也可能比普通分类更难。原因在于情感经常依赖否定、反讽、上下文立场、领域词义漂移和目标对象。例如“这家餐厅排队两小时，菜倒是很普通”与“这家餐厅普通得让我想哭”在词面上都不激烈，但情绪极性不同。

因此，现代情感分析通常会区分句级情感、方面级情感（Aspect-based Sentiment Analysis, ABSA）和多模态情感。导图里把它视作文本分类子集是合理的，但若真正展开工程实践，它常常值得单独建模，而不是简单看作“普通分类任务换个标签名”。

句级情感分析回答的是“这段话整体偏正面还是负面”；方面级情感分析则更细，要求模型回答“用户对哪个方面持什么态度”。例如一条评论可能同时包含“物流很快，但客服态度很差”，此时整体情感并不等于对每个方面的情感。ABSA 之所以长期是独立方向，正是因为它需要同时建模目标对象与情绪极性。

情感表达高度依赖语境、立场对象和修辞。否定、让步、反讽、双关和领域词义变化都会让简单关键词方法迅速失效。因此，现代情感系统往往不仅做分类，还会显式建模目标实体、方面词、情绪触发词和上下文关系。也正因为如此，它虽然可归入文本分类，但在实际工程里常常需要专门的数据设计与误差分析。

文本摘要（Text Summarization）要求模型在尽量保留关键信息的前提下，把长文本压缩成更短、可读性更高的表示。它通常分为抽取式（Extractive）和生成式（Abstractive）两类：前者从原文中挑句子或片段，后者重新组织语言生成新摘要。

导图里的抽取式部分分得很完整：无监督的 TextRank、LexRank，监督学习的二分类、序列标注、回归排序，以及深度学习模型。这里的旧模型名里有一些已经明显不再是主流，例如某些早期 RNN 摘要器、GAN 摘要器和特定数据集专用网络，今天更多属于阶段性代表。真正仍有持续影响力的是“抽取式排序 / 句子选择”这一大思路本身。

生成式摘要的现代主线已经非常清晰：BART、PEGASUS、T5、LongT5、指令微调 LLM 与长上下文模型。GAN、KIGN、DCA 一类旧生成摘要器现在基本不是主流第一选择。若是新闻摘要、会议纪要、长文档摘要或多文档摘要，今天几乎都会优先考虑强 encoder-decoder 模型或长上下文 LLM，再配合事实一致性与引用校验。

抽取式摘要的核心不是“重新写”，而是“选得准”。TextRank、LexRank 用图排序估计句子重要性，监督式方法则把句子选择写成排序或分类问题。它的优势在于事实忠实度通常更高，因为输出直接来自原文；缺点是可读性和压缩灵活性有限，尤其在需要跨句融合时更受约束。

生成式摘要追求的是重写能力：模型可以融合多句信息、压缩冗余并重组表达。代价是事实漂移风险更高，因此现代摘要系统往往会把事实一致性校验、引用对齐和长文切块策略放到与模型本身同等重要的位置。旧式 GAN 摘要器在今天已明显偏历史阶段，真正主流已经转向 BART / T5 / PEGASUS / 长上下文 LLM 这一线。

如果把生成式摘要的发展再补一块，Pointer-Generator Network 是很关键的过渡模型。它把“从词表生成新词”和“从原文复制关键信息”结合起来，显著缓解了早期生成式摘要中事实词汇漂移严重的问题。今天它已不是最强主线，但在摘要发展史上是从纯 Seq2Seq 走向更可控生成的重要桥梁。

到了长文档摘要阶段，问题又不只在生成能力，而在于上下文预算与文档结构利用。LongT5、分块摘要、层次摘要和长上下文 LLM 的出现，正是在回答“当输入不再是一篇短新闻，而是一整份报告、会议记录或多文档材料时，摘要系统该怎样组织证据”。

主题模型（Topic Modeling）试图在没有显式标签的前提下，发现文档集合中的潜在主题结构。经典问题不是“这篇文章属于哪一个给定类别”，而是“这些文档内部自然长出了哪些主题簇，它们各自由哪些高频语义词汇构成”。

概率模型主线包括潜在语义分析（Latent Semantic Analysis, LSA）和隐狄利克雷分配（Latent Dirichlet Allocation, LDA）。LSA 通过奇异值分解（SVD）在词-文档矩阵中寻找主方向；LDA 则用层次贝叶斯生成过程，把文档看作主题混合、把主题看作词分布，并常借助吉布斯采样或变分推断求解。LDA 到今天仍是最经典的可解释主题模型之一，但已经不再代表全部前沿。

深度学习阶段出现了自动编码器、受限玻尔兹曼机（RBM）、语义哈希等路线；而近年的强主线则明显转向嵌入驱动主题建模，例如 BERTopic 通过 Transformer embedding、聚类和 class-based TF-IDF 组织主题。也就是说，LSA / LDA 仍然是基础，BERTopic 和各种 neural topic model 则更贴近 2026 年的常用实践。

LSA 和 LDA 的价值主要在于可解释性和理论清晰度。LDA 尤其适合回答“一个文档由哪些主题混合而成、每个主题又由哪些词分布构成”这类问题，因此在社会科学、数字人文和需要审计的分析任务里仍然常见。它的问题在于对短文本、语义改写和深层语义相近但词面不同的文本不够敏感。

BERTopic 一类方法把现代嵌入模型直接引入主题发现流程。文档先被编码到语义空间，再用聚类找到簇，最后用 c-TF-IDF 或关键词抽取给每个簇生成可解释标签。这种路线在短文本、跨领域语料和语义近义表达丰富的场景里更强，也正因为如此，它已经成为很多现代主题发现系统的默认起点。

计算机视觉（Computer Vision, CV）处理的是：如何把像素、视频帧和图像区域转成可计算的语义结构。它和 NLP 的差别，不只是输入模态不同，更在于视觉任务天然要处理空间结构、局部纹理、尺度变化、遮挡关系和几何一致性。因此，同样是“识别一个对象”，视觉里往往还要回答它在哪、轮廓是什么、动作是什么、与其他对象如何组合。

从任务视角看，视觉系统的输出粒度可以从粗到细展开：最粗的是整张图的类别，进一步是图中的目标框，再进一步是像素级分割、实例级分割、关键点和三维结构。也正因为如此，计算机视觉不是一个单一任务，而是一整组围绕“从视觉信号恢复结构化世界表示”的任务簇。

图像分类（Image Classification）要求模型判断整张图主要属于哪个类别。它是视觉中最基础的任务之一，因为它回答的是最粗粒度的语义问题：这张图里最重要的是什么。LeNet、AlexNet、VGG、ResNet、EfficientNet 到 Vision Transformer（ViT），都曾把图像分类作为核心 benchmark。

分类任务看似简单，实际上承担了视觉表示学习的“预训练入口”角色。大量检测、分割、检索和多模态系统，最早都建立在分类 backbone 上。到了基础模型阶段，图像分类不再只是终点任务，更像是视觉表示质量的最小检验：若连整图语义都难以稳定提取，更细粒度任务通常也很难做好。

从业务视角看，图像分类通常对应商品识别、质检分档、医学影像初筛、内容审核、遥感地物分类等“整图判断”任务。它的难点并不只在类别数目，还在于细粒度差异、类间相似、类内变化、多标签共存和开放集识别。也正因为如此，现代分类系统经常会区分单标签分类、多标签分类、细粒度分类和开放词汇分类，而不是把所有问题都压成一个 softmax。

在技术路线上，经典 CNN 通过局部卷积和层级感受野提取纹理到语义的递进表示，ViT 则把图像切成 patch 后用自注意力建模全局关系。到了开放词汇阶段，CLIP 一类视觉-语言预训练模型进一步把“图像分类”扩展成“图文对齐后的零样本识别”，这使分类任务从固定标签预测走向可迁移视觉语义理解。

图像分类最核心的技术演进，首先体现在特征提取骨干的变化上。LeNet、AlexNet、VGG 代表卷积网络早期阶段；ResNet 通过残差连接解决深层网络难训练问题，长期成为最重要的视觉 backbone 之一；EfficientNet 则强调在宽度、深度和分辨率之间联合缩放。进入 Transformer 阶段后，ViT、Swin Transformer 等模型把视觉 token 化处理，显著提高了大规模预训练的可扩展性。

今天若是做常规分类任务，CNN 并没有被彻底淘汰。中小数据集、边缘设备和低延迟场景里，卷积模型仍然有很强实用价值；而在大规模预训练、跨任务迁移和统一多模态建模中，Transformer 与视觉-语言编码器已经成为更强主线。

很多真实分类问题并不是“每张图只有一个互斥标签”。商品图可能同时包含品类、材质、风格和品牌；医学影像可能同时出现多种征象；遥感图像也可能包含多类地物。这就把问题从普通单标签分类扩展为多标签分类、层级分类和细粒度分类。

细粒度分类尤其依赖局部判别区域和部件级差异，例如鸟类品种、车型版本、工业缺陷等级。这里常见的技术包括注意力机制、局部区域对齐、度量学习和 part-based 建模。它们的目标不是把整图压成一个粗语义向量，而是显式利用“哪些局部细节区分了高度相似的类别”。

到 2026 年，图像分类最重要的变化已经不是再刷新固定封闭标签集上的 top-1，而是把分类能力嵌入更一般的视觉-语言表征中。SigLIP 2 一类视觉-语言编码器在 2025 年继续强化了零样本分类、检索以及对下游定位和稠密预测的迁移能力，说明现代分类 backbone 正在向统一视觉语义编码器收敛。传统只针对 ImageNet 风格封闭分类优化的模型仍然重要，但已不再代表全部前沿方向。

因此，这一任务今天更应理解为视觉基础表示的入口，而不是孤立终点。分类模型既服务于直接判别任务，也服务于检索、检测、分割和多模态理解等更复杂任务的初始化与特征抽取。

目标检测（Object Detection）要求模型同时回答两件事：图里有什么，以及它们各自在哪里。输出通常是边界框（Bounding Box）加类别标签，因此它比图像分类多了一层空间定位问题。Faster R-CNN、YOLO、SSD、RetinaNet 和 DETR 系列，分别代表了两阶段检测、单阶段检测和集合预测检测几条主线。

检测任务在工业中极其重要，因为很多真实系统并不满足“整张图只有一个核心对象”。安防、自动驾驶、零售盘点、工业检测、仓储机器人和内容审核，真正需要的往往是多目标定位而不是整图分类。检测系统的难点也集中在这里：小目标、密集目标、遮挡、长尾类别和实时延迟约束会同时出现。

从方法演进看，两阶段检测先生成候选区域，再做分类和框回归，精度通常较高；单阶段检测直接在特征图上输出类别和框，更强调速度；DETR 一类集合预测方法则把检测写成对象 query 到目标集合的匹配问题，减少了手工 anchor 设计。三条路线长期并存，本质上对应的是不同的精度、延迟和工程复杂度权衡。

检测系统的评估也比分类复杂得多。它不仅看类别是否正确，还看定位框是否足够贴近目标，因此会同时受到 IoU 阈值、召回率、误检率和延迟指标影响。很多业务里，漏掉一个小目标的代价远高于多报几个框，因此真正上线时往往要围绕类别阈值、NMS、误报成本和业务容忍度做细致调参。

两阶段检测以 Faster R-CNN 为代表，先提出候选区域，再在候选上做分类和框回归，长期是高精度场景的重要方案。单阶段检测以 YOLO、SSD、RetinaNet 为代表，直接在特征图上预测目标位置和类别，结构更适合实时部署。DETR 系列则把检测改写为集合预测问题，用 bipartite matching 统一训练和解码流程，显著减少手工 anchor 设计和启发式后处理。

这些路线都没有被彻底淘汰。实时视频监控、边缘设备和工业相机仍然大量使用 YOLO 系谱；强调极致精度的离线分析系统依然偏好更重的高精度检测器；而 DETR 路线在统一建模和与多模态接口兼容方面具有更好扩展性。

检测领域这几年的关键变化，是任务正从封闭标签检测走向开放词汇检测（Open-Vocabulary Detection）和文本驱动 grounding。用户不再只能让系统识别预定义的几十或几百类，而是可以直接用自然语言描述目标，例如“穿红衣服的人”“灭火器”“桌上的蓝色马克杯”。

这一方向的代表工作包括 OWLv2、Grounding DINO 以及后续将视觉-语言模型知识迁移到检测头的路线。它们共同利用图文预训练带来的开放语义空间，使检测器不再完全依赖人工框标注类别表。对于长尾类别、机器人感知和通用视觉助手，这条线已经成为 2026 年最重要的检测前沿之一。

当前检测系统越来越像“通用定位接口”。一方面，开放词汇检测通过视觉-语言预训练显著扩展了类别空间；另一方面，统一视觉基础模型正在让检测与 grounding、分割、跟踪和问答共用更接近的表示。闭集检测器仍然在高可靠工业任务中占据主流，但从研究与平台能力建设的角度看，检测已经不再只是框回归问题，而是在向“语言可指定、跨任务可迁移的通用视觉定位”演进。

语义分割（Semantic Segmentation）要求对每个像素赋予语义类别，也就是把“这是什么”细化为“图上每个位置分别属于什么语义区域”。它的输出不是几个框，而是一张像素级标签图。FCN、U-Net、DeepLab 和后来的 SegFormer 等模型，都是这一方向的重要代表。

分割之所以重要，是因为很多任务需要的不只是粗框，而是区域级理解。医学影像要求精确勾出病灶区域，遥感要求识别道路、水体和建筑边界，自动驾驶要求区分车道、路缘、行人区域。只做检测，很多边界与面积信息会丢失；做语义分割，系统才真正具备了像素级空间理解能力。

语义分割的核心难点在于同时兼顾局部边界和全局语义。模型既要识别大范围上下文，知道一块区域为什么属于道路而不是阴影，又要保住细边界，不把车道线、病灶边缘和文本轮廓抹平。因此 encoder-decoder、空洞卷积、多尺度特征融合和跳跃连接会长期出现在分割模型里。

从分辨率操作的角度看，分割几乎就是“下采样与上采样如何配合”的代表任务。编码器一侧不断下采样，把原图压成更小但语义更强的特征图；解码器一侧再逐步上采样，把粗语义恢复到像素级输出网格。若只有下采样，模型会失去边界细节；若只有上采样而缺少浅层跳跃连接，输出往往会显得轮廓模糊、边缘发虚。U-Net、FPN 和各类 decoder head 长期有效，本质上都在解决这个矛盾。

从业务形态看，分割任务常常不是“只有一个统一标签图”这么简单。很多系统还要进一步输出面积占比、轮廓长度、区域拓扑或边界置信度，因为真正的下游问题通常是测量、监控和决策，而不仅仅是把像素染色。也正因为如此，分割系统在工程上常与后处理、连通域分析和几何约束一起部署。

FCN 首次系统性地把分类 CNN 改造成像素级预测网络，奠定了现代语义分割的基本框架。U-Net 强调编码器与解码器之间的跳跃连接，在医学影像等数据量较小、边界极重要的任务中影响尤其深远。DeepLab 系列则通过空洞卷积与多尺度上下文模块强化大感受野建模，长期是高质量语义分割的重要主线。

这些模型今天依然值得保留，因为它们不是简单的历史名词，而是三种非常稳定的设计思想：全卷积密集预测、编码器-解码器重建细节、多尺度上下文聚合。后续很多 Transformer 分割模型，实际上也仍在复用这些思想，只是把编码器与全局建模机制换成了新的骨架。

分割方向在 2023 年以后出现了明显结构变化。SAM 把“给定点、框或粗提示，分割出目标”做成了通用接口；SAM 2 又把这件事扩展到了图像与视频统一的 promptable segmentation，并通过流式记忆机制支持实时视频分割。到 2025 至 2026 年，SAM 3 一类工作开始把任务进一步推进到 concept-level segmentation，即不只是响应点和框，还能响应短语和概念描述。

这意味着，语义分割的前沿不再只是在固定标签集上追求 mIoU，而是在向“可提示、可泛化、可与语言接口对接”的方向移动。传统监督分割仍然是自动驾驶、遥感和医疗的主力，但 foundation model 正在重新定义分割任务的接口形式。

到 2026 年，最合理的判断不是“传统分割被 SAM 取代”，而是分割出现了双主线。业务里对固定类别、严格标注和高可靠边界要求极高的任务，仍然主要依赖专门监督模型；而交互式标注、跨域迁移、开放概念分割和下游多模态系统，则越来越依赖 promptable segmentation 与视觉基础模型。两条路线会并存很长时间。

语义分割能告诉系统“哪些像素属于人”，但无法区分“这是第一个人还是第二个人”。实例分割（Instance Segmentation）正是在此基础上继续细化：它要求系统为每个对象实例分别给出独立掩码。Mask R-CNN 是这条主线最经典的代表之一。

再往前一步，全景分割（Panoptic Segmentation）试图把语义分割和实例分割统一起来：既要标出可数目标的实例，也要标出天空、道路、墙面这类不可数背景区域。它更接近机器最终需要的场景理解形式，因为真实世界本来就同时包含“一个个对象”和“连续背景材质”。

实例分割的业务场景通常集中在“需要知道每个对象边界且对象彼此相邻”的问题上，例如工业零件计数、仓储抓取、细胞分析、零售货架盘点和自动驾驶障碍物理解。这里检测框通常不够，因为框会把相邻实例混在一起；语义分割也不够，因为它不区分具体个体。实例级掩码正是为了补上这个粒度缺口。

全景理解进一步强调“一个场景应由对象与背景共同组成统一表示”。这让视觉系统更接近机器人和自动驾驶真正需要的世界模型，因为决策系统既关心“前方有几辆车”，也关心“当前位置是不是可通行区域”。从这个角度看，全景任务不是简单把两个 benchmark 拼起来，而是在逼近更完整的场景语义表达。

实例分割早期最有代表性的路线，是在检测器基础上增加掩码预测分支。Mask R-CNN 正是这一思路的经典实现：先定位对象，再在 RoI 内预测像素级掩码。这种设计的好处是充分继承成熟检测器的定位能力，因此在实例级边界抽取上非常稳定。

后续也出现了 query-based 实例分割与 one-stage 掩码方法，使实例分割逐渐从“检测的附属任务”走向更统一的目标集合预测框架。但无论结构如何变化，核心问题始终不变：同类目标必须被分开，且边界要足够精细到能支撑下游计数、抓取和测量。

全景分割要求模型同时处理 things 与 stuff 两类视觉实体。things 指可数对象，例如人、车、箱子；stuff 指不可数背景区域，例如道路、天空、草地。把这两类输出统一到一张场景图里，是场景理解比普通分割更进一步的地方。

这类任务对于自动驾驶、机器人和数字孪生系统尤其关键，因为它们的决策依赖既包括“对象实例”，也包括“环境区域”。因此，全景理解不仅是一个 benchmark，而是在逼近下游系统真正使用的环境表征形式。

实例与全景方向当前也在向开放词汇和 promptable mask prediction 收敛。Open-Vocabulary SAM、基于 CLIP/SAM 组合的开放概念实例分割，以及更通用的 VLM-based detection and segmentation 路线，都在说明：实例分割不再局限于封闭标签表，而是开始与开放语义空间打通。对需要长尾对象识别的真实系统而言，这一变化比单纯再提升几个 benchmark 点数更重要。

关键点检测（Keypoint Detection）与姿态估计（Pose Estimation）要求模型输出对象内部的结构点，例如人体关节、面部特征点、手部骨架或工业零件的定位基准点。它关心的不是“一个人在哪”，而是“这个人的身体结构如何展开”。

这类任务广泛出现在动作分析、手势交互、AR/VR、运动捕捉、驾驶员监测和人机交互系统中。其难点在于，模型必须处理视角变化、遮挡、多人交叠和快速运动；输出形式也常从单帧关键点扩展到时序姿态轨迹，因此它天然和视频理解、跟踪以及三维重建相连。

从方法上看，关键点估计常分为 top-down 和 bottom-up 两类。前者先检测对象，再在每个对象内部预测关键点，精度通常更高；后者直接在整图上定位关键点并做分组，更适合多人密集场景。进一步往三维姿态和多视角重建发展后，问题又会从二维热力图预测扩展到几何约束和跨相机一致性。

这类任务的系统价值在于，它输出的是结构化运动信息而不是静态类别标签。一个动作识别系统若能显式利用骨架轨迹，就更容易理解“举手”“跌倒”“挥拍”这类与姿态变化强相关的事件。因此，姿态估计常被当作上游中间表示，为行为分析、康复评估、体育分析和机器人模仿学习服务。

二维人体姿态估计长期围绕两条路线展开。top-down 先检测人框，再在框内预测关键点，精度高但计算成本随人数增长；bottom-up 直接在整图上预测关键点和连接关系，对多人密集场景更友好。两者并无绝对替代关系，而是服务于不同密度与实时性约束。

关键点回归本身也有两类常见范式：直接坐标回归和热力图回归。热力图方法通过空间概率分布表达不确定性，长期更稳定；直接回归则在轻量模型和端侧部署里更有吸引力。

一旦任务从二维扩展到三维，问题就不再只是“点落在哪个像素”，而是“这个结构在空间里如何展开”。三维姿态需要结合相机几何、多视角一致性或人体先验约束；手部与面部关键点则更强调局部高精度和细粒度遮挡处理。这些任务常常共享骨干网络，但损失函数、后处理与先验建模差异很大。

也正因为如此，姿态估计不是一个单独小分支，而是连接视觉理解、动作建模、AR 交互和三维重建的重要桥梁任务。

到 2026 年，关键点和姿态估计越来越多地作为更大系统的中间表示使用。例如动作分析、手势控制、体育分析和机器人模仿学习，往往不是最终关心关键点本身，而是关心由关键点轨迹编码出的结构化运动模式。因此，这个方向的价值正在从“单独 benchmark”转向“为下游时空理解提供可解释结构”。

OCR（Optical Character Recognition）研究的是：如何从图像或扫描文档中检测文本区域并识别字符内容。传统 OCR 曾高度依赖版面规则、字符切分和语言后处理；深度学习阶段则逐步收敛到“文本检测 + 文本识别 + 版面理解”的组合系统。

今天的文档视觉早已不止是“把图片里的字读出来”。发票解析、表单理解、版面分析、图文混排文档检索、票据审计和知识入库，都要求系统同时理解文字内容、阅读顺序、表格结构和视觉布局。也正因为如此，OCR 现在通常更适合放在“文档智能（Document Intelligence）”这条更宽的任务线上理解。

从任务分解看，文档视觉通常包含文字检测、文字识别、版面分析、表格结构恢复、字段抽取和文档问答等子问题。很多错误并不来自字符本身认不出来，而是来自阅读顺序错乱、跨栏合并失败、表格单元格边界识别不准，或者字段和值没有正确对齐。因此，文档视觉的关键不是孤立字符识别，而是二维布局与语义结构的联合建模。

现代文档模型也已经从“先 OCR，再单独做 NLP”逐渐走向联合编码。LayoutLM、Donut 以及更广义的文档多模态模型，都会把文本内容、位置坐标和视觉 patch 一起输入模型，使系统直接学习“这个词出现在什么区域、与哪些框相邻、在版面上承担什么角色”。这条路线尤其适合票据理解、合同解析和复杂表单抽取。

把 OCR 讲清楚，至少要分三层。第一层是文本检测，解决“文字在哪”；第二层是文本识别，解决“写了什么”；第三层是结构理解，解决“这些文字在文档中如何组织”。很多系统只把前两层叫 OCR，但在现代业务里，第三层往往才决定系统是否真正可用。

例如表格解析、表单抽取和合同理解，核心难点并不只是字符识别，而是单元格之间、标题与字段之间、段落与图表之间的关系建模。也正因为如此，文档视觉必须显式利用二维布局与阅读顺序。

传统 OCR pipeline 把检测、识别、版面分析和信息抽取分成多个模块，优点是可解释、可替换、可局部优化；缺点是误差会在模块之间层层传递。2024 至 2026 年，文档智能明显转向端到端 Vision-Language Model。Florence-2 展示了统一 prompt-based 视觉任务接口；Ocean-OCR、PaddleOCR-VL 等模型则进一步表明，文档解析可以在一个较统一的视觉-语言框架中同时处理文本、表格、公式和图表。

这条线的价值在于，它不再把文档理解视为“先 OCR，再做 NLP”的串行流水线，而是直接把页面理解成多模态结构预测问题。

到 2026 年，文档视觉最明显的趋势是统一化和多语言化。PaddleOCR-VL 把文档解析压缩到一个相对紧凑的 VLM 中，并覆盖上百种语言与复杂元素；Ocean-OCR 则强调 MLLM 也可以具备专业 OCR 能力。纯规则版面系统和传统 OCR 仍然在很多生产场景中长期存在，但前沿已经明显从“单点字符识别最优”转向“端到端文档理解最优”。

人脸识别（Face Recognition）和生物特征验证（Biometric Verification）关注的不是通用类别，而是身份一致性。它们更常把输入映射到嵌入空间（Embedding Space），再通过距离判断“是不是同一个人”。FaceNet、ArcFace 一类方法的核心价值，就是把“看起来像不像”转成可度量的向量相似度。

这类系统的工程要求通常比普通分类更苛刻，因为它面对的是开放集（Open-set）识别：系统不只是要在固定几类中选一个，而是要应对大量从未见过的身份、跨设备成像差异、伪造攻击和极低误识率约束。手机终端中的 Face ID、本地门禁、支付风控和公共安全，都属于这一任务线的典型落地场景。

人脸任务通常至少区分验证、识别、检索和聚类四种形式。验证回答“两张脸是否同一人”，识别回答“这是谁”，检索回答“库里最像的是谁”，聚类则回答“哪些样本应归为同一身份”。它们共享嵌入表示，但阈值设置、误报代价和评估协议并不相同，因此不能被简单视为同一个分类问题。

现代生物特征系统还必须显式处理活体检测、呈现攻击和隐私合规。也就是说，真正的系统目标不是把相似脸分开这么简单，而是在低误识率、低拒识率和高安全性之间维持平衡。对于终端解锁、支付认证和门禁系统而言，伪造攻击防御往往和识别精度同等重要。

人脸识别最关键的技术范式，是把人脸映射到判别性嵌入空间，再用距离或相似度进行验证和检索。FaceNet 用 triplet loss 推动同人更近、异人更远；ArcFace、CosFace 等 margin-based loss 则进一步强化了类间可分性，长期成为现代人脸系统的核心训练范式。

这与普通闭集分类有本质不同。人脸系统最终面对的是开放集身份空间，因此训练阶段的分类器通常只是学习判别 embedding 的工具，而不是上线时真正的输出接口。

生物特征验证从来不是“相似度大于阈值”这么简单。真实系统必须同时处理照片翻拍、视频回放、面具攻击、跨设备成像差异和环境光变化。于是，活体检测、呈现攻击检测、分布外样本拒识和阈值校准都会成为完整链路的一部分。

从工程意义看，一个极高精度但无法抵御攻击的人脸模型并不真正可用。安全性、误受理率和误拒识率共同定义了人脸系统的质量。

近两年这一方向的一个重要发现是，foundation model 并不会自动在 face recognition 上直接最优。FRoundation 的结论显示，通用 foundation model 原始状态往往不如专门训练的人脸模型，但在数据有限场景下，通过适当 fine-tuning 可以取得很有竞争力的结果。这说明人脸识别虽然受益于大规模预训练，但任务专用数据分布、损失设计和安全约束仍然不可替代。

因此，2026 年的人脸识别主线不是“完全交给通用视觉基础模型”，而是“以 foundation model 为起点，再做任务专用适配、安全增强与阈值校准”。

视频理解（Video Understanding）把视觉任务从静态图像推进到时序视觉信号。它研究的是：一段视频里发生了什么，哪些对象在如何运动，动作何时开始和结束，事件之间怎样衔接。动作识别（Action Recognition）、时序定位、视频问答、视频检索和多目标跟踪，都是这一方向的重要子任务。

与图像相比，视频多了一条时间轴，因此模型不仅要理解空间结构，还要处理运动模式与跨帧一致性。早期方法用双流网络、3D CNN、时序池化等方式捕捉动态信息；后续主线逐步转向视频 Transformer、时空注意力和视频基础模型。视频任务的难点通常来自长时依赖、帧冗余、计算成本和标注昂贵。

从业务角度看，视频理解既包括“整段视频是什么行为”这类粗粒度任务，也包括“异常事件何时开始”“某个动作在哪一秒出现”“一个对象在多帧中如何持续跟踪”这类细粒度任务。安防巡检、赛事分析、交通监控、内容审核和短视频理解，对时间粒度的要求完全不同，因此模型设计也会在 clip-level 表示与 frame-level 定位之间切换。

视频基础模型的出现，使这条线越来越接近多模态理解。系统不再只预测动作标签，还会回答视频问答、生成描述、根据文本检索视频片段，甚至结合音频和字幕做统一事件理解。也正因为如此，视频理解正在从“纯视觉动作分类”扩展成“时空多模态语义建模”。

视频理解最早的重要路线，是通过双流网络分别建模 RGB 外观和光流运动信息；随后 3D CNN 把时间维直接并入卷积核，形成统一时空特征提取。进入 Transformer 阶段后，模型逐渐转向时空 token 和注意力机制，能更灵活处理长时依赖和跨帧关系。

这些路线的差别，不只是网络结构不同，而是对“视频中什么最重要”的假设不同。双流强调显式运动线索，3D CNN 强调局部时空模式，Transformer 则更强调长距离依赖与统一建模能力。

视频理解不是单一 benchmark。动作识别关注整段 clip 的主行为标签；时序动作定位关注行为开始和结束时间；视频问答则要求把视频内容转成可推理的语义表示；视频检索与视频字幕生成又分别强调检索匹配和自然语言生成。因此，一个“视频模型”并不能自动覆盖所有子任务。

理解这一点很重要，因为不同任务需要的时间粒度完全不同。短动作分类可能只需几十帧；长视频事件理解则可能需要跨分钟甚至更长时间的多模态上下文。

到 2026 年，视频理解最重要的研究变化，是从“专门视频架构”转向“视频基础模型与多模态统一理解”。近期综述表明，视频 foundation model 已覆盖十余类视频任务，而一个值得注意的结论是：纯图像 foundation model 经过适配后，在不少视频任务上依然很强；更进一步，融合图像、视频、音频和文本的 universal model 在视频任务上往往更有优势。这说明视频理解的真正上限，越来越依赖跨模态统一建模，而不只是视频专用编码器本身。

视觉生成任务不再问“图里是什么”，而是问“能否生成一张符合条件的新图”。它包括图像生成、图像修复、超分辨率、风格迁移、图像到图像翻译和受控编辑。GAN 曾长期是这条线的主角，随后扩散模型（Diffusion Model）把高质量、可控生成推到新的主线位置。

在系统层面，视觉生成的价值不只在创作，还在于数据增强、设计辅助、内容编辑、工业缺陷模拟和交互式视觉工具。它与传统视觉理解任务的关系也越来越紧：现代视觉系统往往同时需要“看懂图像”和“按条件修改图像”，这正是视觉基础模型不断走向统一接口的重要原因。

这类任务内部也有明显分工。无条件生成追求逼真样本分布，条件生成强调按文本、草图、分割图或参考图控制输出，图像编辑则要求在“保留原图主体结构”和“精确修改局部属性”之间取得平衡。ControlNet、Inpainting、Image-to-Image、超分辨率和局部重绘，本质上都在回答“怎样把生成能力约束到用户真正需要的方向上”。

从业务落地看，视觉生成已经不只是内容创作工具。商品图生成、广告素材改写、设计草图上色、工业仿真数据合成、医学图像增强和隐私保护合成数据，都会使用生成模型。但这条线也天然伴随可控性、版权、水印、事实一致性和安全审核问题，因此真正可上线的生成系统通常需要严格的内容约束与后处理机制。

GAN 阶段的核心贡献，是第一次把高保真图像生成推到可用水平，并带动了图像翻译、超分辨率和风格迁移等大量任务。扩散模型随后成为主线，因为它在样本质量、训练稳定性和条件控制方面展现出更强优势。再往后，Diffusion Transformer（DiT）把扩散生成与 Transformer 骨架结合，使大规模预训练与统一多模态接口更自然地接轨。

因此，GAN 在今天更接近历史里程碑和部分特定场景工具，而 diffusion / DiT 已经成为生成与编辑的默认主干。若只把视觉生成理解成 GAN，就已经落后于当前主线。

图像编辑任务看似只是“生成模型 + 指令”，实际上比无条件生成更难。系统必须同时满足三件事：正确理解编辑指令、只修改该修改的局部、保持人物身份与场景结构不被无关破坏。也正因为如此，视觉编辑长期围绕 inpainting、mask-guided editing、ControlNet、reference-guided editing 和 instruction-based editing 展开。

一个编辑模型是否优秀，关键不只是生成好不好看，而是编辑是否精准、保真是否稳定、多轮编辑是否可控。这些要求比单次文本到图像生成严格得多。

到 2026 年，视觉生成的前沿重点已经明显转向“高质量基础生成模型之上的可控编辑”。2024 至 2025 年的综述表明，扩散编辑已形成完整技术谱系；而 2025 年的 In-Context Edit 则进一步展示，大规模 DiT 可以通过 in-context editing 和极少参数更新，在指令编辑上取得很强效果。这意味着当前竞争焦点已不只是能不能生成，而是怎样以更少数据、更少参数、更高控制精度完成编辑。

在工程层面，这也解释了为什么生成模型越来越像通用视觉接口的一部分：它们不仅负责“造图”，还要负责按自然语言、草图、参考图和结构约束进行交互式视觉操作。

语音和音频处理研究的是：如何从连续波形中恢复语言内容、说话人信息、环境事件和声学结构。它和 NLP 的关系很紧，但本体并不属于 NLP，因为这里首先要处理的是声学信号本身，而不是离散 token 序列。语音系统真正面对的输入是采样点、频谱和时频结构，因此它天然要解决噪声、混响、口音、重叠说话和实时延迟等问题。

从任务角度看，这一方向可以分为语言内容恢复、说话人建模、声学净化、事件识别和声音生成几条主线。它们共享的底层问题是：连续信号怎样被编码成更高层的结构表示；但最终输出可以是文字、声纹向量、增强后的波形、事件标签或新的合成音频。

在这个方向里，上采样与下采样首先表现为采样率（Sampling Rate）和时间分辨率的变化。原始波形可能从 \(48\,\text{kHz}\) 降到 \(16\,\text{kHz}\) 以降低计算量，也可能在声码器（Vocoder）阶段把较粗的声学表示重新上采样为高分辨率波形。进一步看，卷积前端、梅尔频谱（Mel Spectrogram）和 Conformer 编码器也常沿时间轴做下采样，把长音频压缩成更短的帧级表示；语音合成与音频生成系统则经常需要沿时间轴逐级上采样，把低帧率表示还原成连续可播放的声音。

语音识别（Automatic Speech Recognition, ASR）研究的是：如何把连续语音信号转写为离散文字序列。它在系统角色上和 NLP 强相关，因为很多对话、语音助手、会议纪要和多模态系统，都会先把语音变成文本，再交给后续 NLP 模块处理。

传统 ASR 往往由声学模型、发音词典和语言模型构成。前端会用傅里叶变换、倒谱均值归一化（CMVN）、声道长度归一化（VTLN）等技术提取和校正声学特征；后端则常用 HMM 和 n 元语法做解码。这条路线今天不再是最热前沿，但在工业和教学中仍非常重要，因为它清楚展示了声学、发音和语言约束如何组合。

深度学习阶段先经历 CNN、LSTM-HMM、神经网络语言模型，再逐渐过渡到端到端 ASR。当前主线包括 CTC、Attention、RNN-T、Conformer、自监督预训练（如 wav2vec 2.0）以及大规模弱监督语音模型（如 Whisper）。Conformer 和 RNN-T 在实时 ASR 中非常强，Whisper 则代表了“超大规模弱监督、多语言、零样本鲁棒转写”的基础模型方向。

因此，导图里的 CNN、LSTM-HMM、神经网络语言模型都应该保留，因为它们是历史关键节点；但若要说明今天真正主流，就必须把端到端 Conformer / RNN-T、预训练声学表示和 Whisper 类基础模型补进来。传统发音词典在纯端到端系统里不再总是必需，但在高精度行业语音和混合系统中仍然经常保留。

端到端 ASR 并不是单一做法。CTC（Connectionist Temporal Classification）擅长在未显式对齐的条件下学习声学到文本的对齐关系，结构简洁、训练稳定；Attention Encoder-Decoder 更强调直接条件生成，在离线高质量转写中很强；RNN-T 和其后续变体则更适合流式实时识别，因为它们能够边听边输出。理解这三条线的差别，有助于看清为什么实时语音助手、会议转写和离线高精度转录常常不会使用同一套 ASR 架构。

wav2vec 2.0、HuBERT、后续 Conformer 化声学编码器，以及 Whisper 这一类大规模弱监督模型，共同推动了 ASR 从“任务专用声学模型”走向“可迁移语音基础模型”。前者强调先学通用声学表示，再在少量标注数据上微调；后者则进一步把海量弱标注语音直接并入训练，使模型具备更强的多语言和噪声鲁棒性。

传统 ASR 的声学模型、发音词典和语言模型并不是三个松散部件，而是明确分工的系统结构。声学模型负责把连续声学特征映射成更接近音素或状态的概率；发音词典负责把单词拆成音素序列，承担“声音如何对应词”的桥梁；语言模型负责在候选词序列里偏向更自然、更可能的组合。只有三者联合起来，系统才能把含噪连续波形稳定转写成文本。这也是为什么传统 ASR 的可解释性很强，错误能清晰地归因到声学混淆、发音歧义或语言先验不足。

LSTM-HMM、CNN-HMM 这类混合系统处在一个很关键的过渡位置。它们保留了 HMM 解码框架，但用神经网络替代传统 GMM 声学建模，从而显著提升了表示能力。再往后，CTC、Attention Encoder-Decoder 和 Transducer 才真正把“声学建模、对齐和文本生成”逐步并入统一神经模型。这个演进过程说明，端到端 ASR 并不是突然出现的，而是在混合系统长期积累之上完成的架构收敛。

ASR 在工程上必须区分流式（Streaming）与离线（Offline）两类场景。语音助手、实时字幕、车载交互要求模型边听边出结果，因此偏爱 RNN-T、流式 Conformer 或 chunk-based 架构；会议纪要、媒体转录、长音频归档则更看重最终转写质量，可以使用更重的双向编码器、Attention 解码器或 Whisper 一类离线大模型。两者的最优架构往往不同，因为延迟约束会直接改变模型可利用的上下文范围。

wav2vec 2.0、HuBERT 和 Whisper 这类模型的重要性，不只是 benchmark 指标更高，而是它们改变了数据依赖方式。自监督模型先从海量无标注语音中学通用表征，再在少量标注语音上微调，因此特别适合低资源语种、口音多样或标注昂贵场景；Whisper 这类弱监督大模型则进一步通过海量带噪转写数据获得多语言鲁棒性，使零样本迁移成为现实。

在现代语音系统里，这些基础模型通常不会孤立存在。它们常与语音活动检测、说话人分离、热词偏置、标点恢复、术语后处理和下游 LLM 理解模块一起工作。也就是说，ASR 的输出虽然是一串文本，但真正可用的语音系统往往是一整条“音频前处理 + 识别 + 后处理 + 语言理解”的复合流水线。

到 2025 至 2026 年，语音理解已经明显从“纯 ASR 模型”延伸到 Speech LLM 与更广义的 Spoken Language Model。新的主线不只是把音频转成文字，而是希望模型直接利用语音中的韵律、情感、重音和非语言线索完成理解、对话和推理。因此，ASR 正在从独立前端模块，逐步变成更大语音智能系统中的一个子能力。

同时，基础 ASR 模型也暴露出新的工程问题。Whisper 及其变体在多语言、弱监督和离线转写上表现很强，但流式延迟、资源占用和幻觉转写风险也越来越被正视。2026 年的实际系统设计里，识别精度已经不是唯一目标，可靠性、拒答能力、术语稳定性和部署成本同样是主线约束。

语音合成（Text-to-Speech, TTS）研究的是：如何把文字、音素序列或更高层语义表示生成为自然、可懂、可控的语音波形。它不只是“把文字念出来”，还要决定韵律、停顿、语速、情感和说话人风格，因此本质上同时涉及语言规划和声学生成。

传统 TTS 常由前端文本分析、声学模型和声码器组成；深度学习阶段则经历 Tacotron、FastSpeech、WaveNet、HiFi-GAN 以及后来的语音生成基础模型。今天的主流重点已经从“是否能发声”转向“是否像真人、是否稳定、是否可控”，因此零样本音色克隆、情感控制、多语种一致性和低延迟推理成为关键工程问题。

从任务拆解看，TTS 通常包含文本规范化、音素或发音表示生成、韵律建模、声学特征生成和神经声码器合成几个阶段。很多听感问题并不来自音色本身，而来自重音落错、停顿不自然、数字和专名读法错误，或者长句韵律塌陷。因此，一个高质量 TTS 系统既是生成模型，也是语言与发音规则系统。

近年的语音生成基础模型把 TTS 推向了更强的说话人可迁移与风格控制能力。系统可以只用几秒参考音频完成音色克隆，也可以按情感、语速和场景风格控制输出。这让 TTS 从“固定播报器”逐渐走向“可编排声音接口”，广泛进入客服、车载助手、有声内容、无障碍辅助和数字人系统。

TTS 的经典深度学习路线可以拆成两部分：上游声学模型负责把文本或音素映射到梅尔频谱等中间表示，下游神经声码器负责把这些中间表示还原为最终波形。Tacotron 推动了端到端语音合成的普及，FastSpeech 通过显式时长建模提高了稳定性与速度，WaveNet、WaveRNN、HiFi-GAN 等声码器则决定了最终听感质量。

这条路线今天仍然非常重要，因为它清楚表达了 TTS 的系统分工：语言侧负责发音和韵律，声学侧负责音色与波形细节。很多商用系统即使已经采用 foundation model，也仍然在内部保留类似分层结构。

近年的 TTS 竞争重点，已经从“自然度够不够”转向“控制力够不够”。零样本音色克隆要求系统只看极少参考音频就能复现说话人音色；可控 TTS 要求系统显式调节情感、语速、重音、风格和语种切换；更进一步，Metis、Spark-TTS 一类工作开始把语音生成视为更统一的 foundation model 问题，不再局限于单一 TTS 任务。

这类模型通常依赖语音 codec token、LLM 式自回归建模或更统一的离散 token 生成接口，使文本到语音、语音到语音转换、说话人迁移和语音编辑之间开始共享更接近的生成骨架。

到 2026 年，TTS 的关键问题已经不只是 MOS 还够不够高，而是系统是否真的可控、可评估、可安全上线。近年的综述已经把 controllable TTS 单独作为主题展开，说明情感、音色、风格和自然语言指令控制正在成为主线；与此同时，零样本 voice cloning 的快速进展也让深度伪造、授权与责任评测成为必须正视的问题。

因此，现代 TTS 既是生成任务，也是安全任务。一个高质量系统除了自然度，还必须处理身份授权、滥用检测、可解释评测和风格失真控制。

说话人识别（Speaker Identification）和声纹验证（Speaker Verification）关注的是“这是谁在说话”，而不是“他说了什么”。系统通常会把语音片段映射到声纹嵌入空间，再比较向量距离或相似度。x-vector、ECAPA-TDNN 及其后续嵌入模型长期是这一方向的重要技术基线。

这类任务广泛用于身份认证、会议分轨、通话质检和说话人聚类。其难点来自跨设备录音条件、背景噪声、短时语音片段和伪造攻击。也正因为如此，现代声纹系统往往要把活体检测、反欺骗和跨域校准一起纳入，而不是只做一个单纯分类器。

从业务形式上看，说话人任务通常还包括说话人分离与说话人日志（Diarization），即回答“谁在什么时候说话”。会议纪要、法庭记录和客服通话分析，不仅需要转写内容，还需要把不同说话人的发言切分出来。于是声纹嵌入、分段、聚类和 ASR 往往会在同一条流水线上协同工作。

声纹系统的工程难点在于阈值极度敏感。开放场景里，误受理和误拒识的代价往往都很高，因此系统常需要按设备、场景和语种做校准，并配合活体检测、回声抑制和前端增强模块。也就是说，声纹验证不是孤立的 embedding 相似度问题，而是完整语音安全链路的一部分。

现代说话人验证的核心范式，是先把变长语音片段压缩成固定长度 speaker embedding，再在 embedding 空间里做相似度判别。x-vector 奠定了这一主流范式；ECAPA-TDNN 则通过更强的通道注意力、层间聚合和多尺度时序建模，长期成为说话人验证的强基线。

这类模型之所以稳定，是因为它们把“谁在说话”从具体内容中相对剥离出来。系统不需要逐词理解语义，只需提取稳定的声道与说话习惯特征。

声纹任务不能只理解为“比两个 embedding 像不像”。会议、客服和法庭记录里更常见的问题是 diarization，即在长音频中标出“谁在什么时候说话”。这要求系统把分段、嵌入、聚类、重叠说话处理和 ASR 联合起来，而不仅是做单对单验证。

因此，说话人技术的真正系统形态通常是：前端做语音活动检测与可能的分离，中间做说话人嵌入与聚类，后端把说话人标签与转写结果绑定到时间轴上。

近两年的一个重要趋势，是声纹系统越来越强调跨语种和跨场景泛化，而不只是在单一英文数据集上刷分。已有工作专门分析了语言相似性对跨语种 non-target speaker verification 的影响，说明说话人验证并不会天然摆脱语言分布变化的干扰。与此同时，语音深度伪造和 replay attack 使反欺骗、活体检测和校准评测进一步前置。

这意味着，2026 年的声纹主线是“embedding + 安全链路”，而不是“孤立的验证模型”。

语音增强（Speech Enhancement）和语音分离（Speech Separation）处理的是“听不清”和“同时有人说话”这两类基础问题。增强任务试图从带噪、带混响语音中恢复更清晰的目标说话声；分离任务则试图把多个重叠说话源拆开。它们往往是 ASR、会议系统和远场交互的前置模块。

传统方法多依赖频谱减法、维纳滤波和统计掩码估计；深度学习阶段则出现了时频掩码网络、Conv-TasNet、DPRNN、SepFormer 等路线。今天的主流趋势是把增强、分离和下游识别协同优化，因为“增强后波形听起来更好”并不一定等于“识别效果一定更好”。

增强、分离和降噪虽然经常一起出现，但目标并不完全相同。增强更强调提升目标语音可懂度与清晰度，分离更强调把多个源拆开，降噪则是更广义地去除背景干扰。不同任务的最优损失函数和评价指标也不同，听感质量、字错率改善和说话人保持度往往不能被同一个指标完全覆盖。

在真实系统中，这类模块常用于会议转写、耳机通话、远场麦克风阵列、车载交互和工业录音清洗。阵列波束形成、回声消除、语音活动检测和后续 ASR 通常会一起部署，因为单独追求“更干净的音频”并不足够，系统最终还是要服务于识别、理解或通信质量目标。

传统增强和分离长期在频谱域操作，依赖噪声估计和掩码预测；深度学习阶段的一个关键变化，是模型开始直接在时域或更接近原始波形的表示上操作。Conv-TasNet、DPRNN、SepFormer 一类方法推动了语音分离对“鸡尾酒会问题”的建模能力显著提升，也让增强与分离的边界变得更接近。

这条演进的意义在于，系统不再只是“对频谱做滤波”，而是能够更完整地重建源语音结构和相位信息。

增强和分离在工程上几乎从不作为独立终点。会议转写、远场交互、助听设备和车载系统最终关心的是字错率、通话质量或用户可懂度，而不是某个离线音频指标单独更好。因此，现代系统越来越强调端到端协同：前处理模块必须为后续 ASR、声纹或通信链路服务。

也正因为如此，增强模型的评测也在发生变化。参考信号可得时可以用传统失真指标；真实场景里则越来越需要无参考评价和下游任务驱动评价。

2024 至 2025 年的 URGENT 挑战和近期分离综述都说明，这一方向正在从“单失真、单数据集优化”走向“通用增强与分离”。语言依赖、多失真类型、采样率变化和真实噪声条件都被放进统一评测框架中。同时，ReFESS-QI 一类工作表明，无参考语音分离评估正在成为必要能力，因为真实混合音频往往根本没有干净真值可用。

这意味着，2026 年这条线真正难的不是模型再堆多深，而是怎样获得跨场景稳健性，以及怎样在没有参考音频时仍然可靠评估系统质量。

关键词检测（Keyword Spotting, KWS）与语音唤醒（Wake Word Detection）要求系统在持续监听中及时发现特定短语，例如“嘿 Siri”或“OK Google”。它和完整语音识别不同，因为它更强调低延迟、低功耗和极低误唤醒率，而不是完整转写整句内容。

这类任务通常部署在端侧设备上，因此模型容量、推理稳定性和噪声鲁棒性比离线精度更关键。很多系统会先用轻量 KWS 模型做前门，再在唤醒后启用更重的 ASR 与语言理解模块，这样可以在功耗、实时性和体验之间取得平衡。

KWS 的技术核心是“在非常长的负样本背景中可靠抓到极短目标片段”。因此它尤其关注误唤醒率、漏唤醒率、持续监听功耗和设备端鲁棒性。家庭环境、车载环境和会议室环境的噪声模式差别极大，一个实验室里效果不错的唤醒词模型，到了真实空间里往往要重新做前端和阈值设计。

很多现代端侧系统还会把 KWS、VAD 和小型流式 ASR 串成分层触发结构。第一层只判断“有没有唤醒迹象”，第二层再确认短语内容，第三层才启动完整理解链路。这种分层架构的价值不在模型更复杂，而在于它能把低功耗常驻监听与较重的后端推理隔离开来。

KWS 的第一原则不是追求最大模型精度，而是在极低功耗和极小内存预算下稳定工作。也正因为如此，小模型设计、量化、蒸馏、特征压缩和 TinyML 部署始终是这一方向的核心问题。近年的 small-footprint KWS 综述进一步把这一点说得很清楚：端侧约束不是附加条件，而是任务定义本身的一部分。

这使 KWS 与很多其他音频任务不同。它的最佳方案常常不是最强大的 foundation model，而是经过蒸馏和硬件共设计后的轻量系统。

唤醒词任务的另一个关键难点，是环境变化会迅速破坏模型稳定性。家居噪声、口音差异、麦克风位置变化和设备回声，都可能显著拉高误唤醒率。AdaKWS 一类工作开始把 test-time adaptation 引入 KWS，说明鲁棒性问题已经不再只是训练集扩增能完全解决的。

与此同时，公平性也开始成为明确问题。2026 年已有工作直接讨论 wake word detection 的 demographic bias，说明唤醒系统不能只在平均指标上看起来不错，而必须关注不同性别、年龄和口音人群之间的性能差异。

到 2026 年，KWS 的主线已经非常清楚：第一，继续做更小、更省电的前门模型；第二，用分层触发把唤醒检测与后端 ASR / LLM 解耦；第三，把鲁棒性、公平性和设备端时延纳入同一目标函数。它不是一个“简化版 ASR”，而是端侧语音交互的系统门卫。

音频事件检测（Audio Event Detection）研究的是：一段声音里发生了什么事件，例如玻璃破碎、警报、犬吠、机器异常、咳嗽或交通噪声。它关心的不是语音语言内容，而是声学场景和事件类别，因此更接近“听觉版分类与检测”任务。

这类任务常用于安防监测、工业巡检、智能家居、车载感知和医疗辅助。技术上，系统既可以做整段分类，也可以做时间轴上的事件定位。难点在于背景噪声复杂、事件持续时间差异大、同类事件跨场景变化强，因此它常常需要时频表示、弱监督标注和多实例学习一起配合。

从任务层级看，环境声音理解通常包含声学场景分类、事件检测、事件分段和多标签识别。一个录音片段里可能同时存在雨声、引擎声和人声，也可能只有一次短暂的撞击事件，因此系统既要建模整体背景，也要捕捉瞬时异常。频谱图、对数梅尔特征、卷积编码器和音频 Transformer 是这里最常见的技术骨架。

这类任务近年来也越来越依赖预训练音频表示。大规模音频基础模型可以先学习通用声音模式，再迁移到工业异常、医疗咳嗽检测或野外生物声监测等小数据任务。与语音识别类似，这条线的收益不只在指标更高，还在于跨任务迁移能力显著增强。

音频事件检测长期默认闭集设定，即系统只检测固定类别表中的声音事件。由于精确逐帧标注昂贵，很多工作会结合弱标签、多实例学习和伪标签传播，让模型在只有片段级标签或部分强标签时仍能学习时间定位能力。这也是为什么 SED 一直比普通音频分类更难。

因为真实音频场景中事件经常重叠、边界模糊、类别长尾，单一 hard label 很难完整描述声音世界。

近两年的关键变化，是音频事件检测开始明显向开放词汇和音频-文本建模移动。Audio-Language Model 综述已经把这一趋势系统化：自然语言监督比固定标签更适合描述复杂真实音频。具体到 SED，近期工作开始直接使用文本查询、机器生成 caption 或多模态 query 来指导事件检测，这让“Detect Any Sound”一类开放词汇设定成为现实方向。

这与开放词汇视觉检测的变化非常相似，说明环境声音理解也在从闭集分类器转向语言可查询的通用音频理解接口。

到 2026 年，环境声音理解的前沿已经不再只是固定 10 类、20 类事件的检测分数，而是开始关心零样本迁移、开放类别、文本查询、噪声鲁棒性与推理能力。Large Audio-Language Model 的兴起也使评测本身成为问题：不仅要测分类和定位，还要测知识、推理、安全与可信度。因此，这条线正在迅速向“通用音频理解”靠拢。

音乐与音频生成任务不再问“声音里发生了什么”，而是问“能否生成新的声音内容”。它包括音乐生成、伴奏生成、风格迁移、语音克隆、音效生成和音频修复。技术路线既可以从符号音乐入手，也可以直接在波形或潜空间中生成连续音频。

这条线的难点与图像生成不同，因为音频天然是时序信号，长程一致性、节奏稳定性和细节纹理都必须同时处理。也正因为如此，音乐和音频生成通常要在“局部音色质量”和“长时间结构组织”之间做复杂权衡。

从表示形式上看，音乐生成至少有两条大路线。符号音乐生成在音符、和弦和节拍层面建模，更容易控制结构与编曲；直接音频生成则面向波形或压缩后的音频 token，更强调真实音色和制作质感。两者常常结合使用，因为结构控制和最终听感通常不由同一层表示单独决定。

音频生成在业务上覆盖背景音乐、配音、游戏音效、影视后期、交互式创作和数据扩增，但其约束比图像更苛刻。轻微的节奏崩坏、爆音和相位异常就会明显破坏体验，因此真实系统常把生成模型与后处理、母带质量控制和版权检测一起使用。

音乐生成最基本的技术分裂，是生成符号序列还是直接生成音频。符号音乐方法更容易控制和弦、节拍、结构和编曲，因此在作曲辅助和可编辑场景中很重要；直接音频生成则更接近最终可听结果，适合生成完整音色、演唱与制作细节。

很多现代系统实际上会组合两层表示：先在高层决定结构，再在低层合成真实声音。这与 TTS 中“语言规划 + 波形生成”的分层逻辑非常相似。

近年的音乐生成已经明显 foundation model 化。YuE、ACE-Step、AudioX 一类工作表明，文本到音乐、长时歌词到歌曲、跨模态控制和多任务音频生成正在逐渐被统一到更一般的音频 token 生成框架中。这里最大的难点不是局部音色，而是长时间结构是否仍然连贯、歌词和旋律是否对齐、风格控制是否稳定。

这也解释了为什么音乐生成研究越来越重视长时一致性、多模态条件和统一评测，而不只是若干秒短音频的主观试听。

音乐与音频生成在 2025 至 2026 年的一个突出问题，是生成能力上涨很快，但评测体系明显滞后。新的综述和 benchmark 工作都在反复强调，客观指标与人类偏好之间常常并不一致，长程结构、情感表达、创造性和版权风险也很难被单一自动指标捕捉。因此，这一方向未来不只是更强生成模型的竞赛，也是在补齐可靠评测、可控生成与合规机制。

搜索、推荐和广告预估处理的是同一类工业问题：在海量候选文档、内容、商品或广告中，如何为当前用户挑出最值得展示的少数结果。三者都不只是做一个静态分类器，而是在解决召回、排序、价值预估、约束满足与在线策略优化共同存在的决策链。差别主要在于用户意图的来源不同：搜索由 query 显式表达意图，推荐更多依赖历史行为和上下文推断意图，广告则还要把商业出价、预算和拍卖机制纳入同一系统。

从系统结构看，这三个方向本质上都可以概括为“理解需求 - 生成候选 - 精排重排 - 在约束下完成最终展示”。搜索系统需要理解 query 与文档相关性，推荐系统需要理解用户兴趣与内容匹配，广告系统则要在相关性与商业价值之间做动态平衡。因此，三者虽然业务目标不同，但底层技术长期共享向量召回、学习排序、重排、多目标优化、校准与策略控制等一整套方法栈。

搜索（Search / Information Retrieval）处理的是：用户带着一个明确问题、需求或目标词串进入系统，系统如何在海量语料里找出最相关的结果。它与推荐最核心的区别在于，推荐更多是在“没有明确 query 时”推断用户想看什么；搜索则是围绕显式 query 展开，因此 Query Understanding、文档匹配和排序相关性成为系统主轴。

一个现代搜索系统通常至少分为四层：查询理解、候选召回、排序重排和结果组织。查询理解负责把用户输入转成可计算的检索意图，例如分词、纠错、改写、意图识别、实体识别、同义词扩展和 query embedding；召回层负责从超大文档库里先捞出一批高潜候选；排序层进一步判断哪些结果更相关、更权威、更新或更满足业务目标；结果组织则决定最终页上的展示方式，例如直答、摘要片段、高亮、聚合卡片和多路结果混排。

搜索是 AI 应用的重要方向，因为它天然要求模型同时理解语言、语义匹配、用户行为反馈和系统约束。一个好搜索系统需要判断文档是否真正回答了 query、是否符合当前上下文、是否应该优先展示某类垂直结果，并在高并发、低延迟场景下稳定输出；关键词命中只是其中最基础的一层。

传统搜索的第一性原理是倒排索引（Inverted Index）与词项匹配。文档被切成词项并建索引，query 到来后先查哪些文档包含这些词，再用 TF-IDF、BM25 一类相关性函数做初步排序。这一路线极其重要，因为它速度快、可解释、对精确词面匹配非常强，直到今天仍是大多数搜索系统的底座。

但词面匹配并不能充分表达语义等价、长尾表达和上下文含义，因此现代搜索几乎都会加入语义检索。做法通常是把 query 与 document 编码成 embedding，在向量空间中做近似最近邻（ANN）搜索，从而召回词面不同但语义接近的候选。双塔编码器、Sentence-BERT、dense retrieval、dual encoder reranker 等路线，本质上都在把“相关性”从字符串共现扩展到表示空间邻近。

真实工业系统通常不会在“词法检索”和“语义检索”之间二选一，而是采用混合召回（Hybrid Retrieval）。倒排索引负责高精度命中精确词项、品牌词、数字和稀有实体，向量召回负责补充同义改写、语义近邻和长尾表达。这样做的原因很直接：纯词法系统容易漏掉语义等价表达，纯向量系统又可能牺牲可控性、可解释性和硬约束匹配能力。混合召回把两者的强项叠加起来，是近年搜索系统的主流工程形态。

搜索排序（Learning to Rank）要解决的是：候选已经召回出来后，哪些结果应该出现在最前面。这里的相关性不再只是“像不像”，而是更细粒度的综合判断，包括主题匹配、答案性、权威性、时效性、点击后满意度和位置偏差。经典做法包括 pointwise、pairwise、listwise 三类学习排序方法；模型上则经历了从手工特征 + GBDT/LambdaMART，到 BERT cross-encoder、late interaction 和多阶段 reranker 的演化。

重排层通常会用更贵但更准的模型，对前几十或前几百个候选做深度语义交互。Cross-Encoder 把 query 和 document 拼成一段输入，让 Transformer 直接建模逐 token 交互，因此相关性判断通常更强；代价是吞吐低，无法在全库上直接跑。这就形成了搜索里的经典多阶段结构：第一阶段用倒排或双塔快速召回，第二阶段用更强的交互模型精排，必要时再加业务规则、多样性和去重层做最终重排。

生成式搜索则是在此基础上的进一步演化。大语言模型（Large Language Model, LLM）可以参与 query 改写、答案抽取、结果摘要、Multi-Hop 检索和 Retrieval-Augmented Generation（RAG），让搜索从“返回文档列表”扩展到“在文档支持下生成结构化回答”。与此同时，检索系统的重要性反而更高了：只要召回文档不对、排序证据不稳，生成答案就会连带失真。因此生成式搜索的主线应理解为检索、排序与生成的协同工作。

从系统抽象看，搜索、推荐和广告其实都可以写成“从超大候选集合中做检索与排序”的问题。搜索的显式意图最强，目标是回答 query；推荐的隐式意图更强，目标是预测用户此刻最可能消费什么；广告则在相关性之外额外叠加出价、预算、转化价值和拍卖机制。也就是说，三者的差异首先是目标函数不同，其次才是模型形态不同。

这也是为什么很多底层技术会反复跨领域复用。ANN 检索既能做搜索语义召回，也能做推荐召回；学习排序既能用于网页搜索，也能用于推荐 feed 和广告竞价；校准、多目标优化和重排，三者同样都离不开。放在同一章里理解，能更清楚地看到它们共享的是一条“retrieve, rank, optimize under constraints”的统一工程主线。

召回（Retrieval / Matching）要解决的是：在数百万到数十亿候选里，先快速筛出一小批“值得进一步细排”的候选集合。它的核心目标是保证高潜力内容不要在第一层就被漏掉，而把最终精细排序留给后续层完成。协同过滤、双塔模型（Two-Tower Model）、向量检索和图召回是这一层最常见的路线。

召回系统的关键点在于“广而不乱”。候选太少会漏掉好内容，候选太多又会把后续排序层拖垮。也正因为如此，现代推荐系统常会并行运行多路召回：基于兴趣相似、基于内容相似、基于热门趋势、基于图邻接和基于规则保底，然后再统一交给后续排序层整合。

从系统角色看，召回层更像一个高速过滤器。它通常要求毫秒级响应和极高吞吐，因此模型结构必须足够轻，且能够与 ANN 检索、倒排索引或图搜索深度耦合。双塔模型之所以长期流行，就是因为它把用户和物品分别编码成向量，使“离线建库 + 在线近邻搜索”成为可能。

召回问题的真实难点还在于覆盖长尾与新内容。若系统只依赖历史点击共现，高质量但尚未被看见的新内容几乎无法进入候选池。因此很多工业系统会显式保留探索召回、内容理解召回和规则保底召回，让召回层先具备基本多样性，再把精细判断交给排序层完成。

推荐召回最经典的工业范式，是把“候选空间极大”转化为“近邻检索问题”。早期协同过滤和矩阵分解通过用户-物品共现学习潜在表示；深度学习阶段的双塔模型则把用户和物品分别编码到向量空间中，再通过近似最近邻（ANN）索引实现高速检索。这条路线之所以长期有效，是因为它在吞吐、延迟和可扩展性之间取得了非常稳定的平衡。

即便到了 foundation model 时代，双塔也没有失去价值。因为只要线上系统仍要在毫秒级从海量库中筛候选，向量化检索就是最自然的工程接口。

真实推荐系统很少只依赖单一路召回。图召回利用用户、物品、作者、主题和社交关系之间的高阶连接，适合发现协同结构；内容召回依赖文本、图像和多模态特征，适合新内容与长尾内容；热门召回和规则保底则保证系统不会过度塌缩到窄兴趣空间。多路召回的本质，是在召回阶段先把“覆盖率”做出来，再让排序去做精细取舍。

也正因为如此，召回阶段的关键指标从来不只是离线精度，而是覆盖、去重、多样性、冷启动能力与后续排序承压能力的综合平衡。

到 2025 至 2026 年，召回领域出现了两个明显方向。第一是图基础模型（Graph Foundation Model）与图-语言融合模型开始进入推荐，试图把用户物品图结构与文本语义统一进更可迁移的表示；第二是生成式推荐开始把召回理解成“从统一语义空间生成或选择下一个候选”的问题，而不只是 ID 近邻搜索。对于跨域推荐和冷启动，这类路线尤其有吸引力。

不过，工程上最现实的判断仍然是：生成式和 foundation model 更像是在增强召回表示与跨域泛化，而不是短期内完全取代高吞吐双塔检索。

排序（Ranking）关心的是：在召回出来的候选里，哪几个应该排在最前面。它通常是推荐系统最直接影响用户体验的一层，因为最终展示顺序几乎完全由这里决定。经典路线从逻辑回归、GBDT、Wide&Deep、DeepFM 一直到多任务排序网络和 Transformer 式序列排序器，基本都在这条线上演进。

重排（Reranking）则是更靠后的精细优化层，它会在较小候选集合上显式考虑位置偏差、多样性、去重、探索、业务约束和列表级目标。随着系统复杂度提升，排序越来越接近“在整个列表层面组织一个满足多约束的展示结果”，而不再只是给每个候选打一个孤立分数。

排序建模既可以是 pointwise，也可以是 pairwise 或 listwise。前者把每个候选单独打分，工程实现最直接；后两者更强调“谁应该排在谁前面”或“整个列表质量如何”。在真实系统里，这几类方法常常混合出现，因为训练目标、线上排序器和最终业务指标未必天然一致。

重排层的重要性在于，它第一次显式面对列表级体验问题。连续出现相似商品、同质短视频或重复广告，会明显伤害用户感受，即便每个单项分数都不低。因此，重排往往会把去重、多样性、公平曝光、商业约束和探索策略统一纳入，而不再把推荐看成若干独立样本的排序问题。

排序层的工业主线非常清晰。逻辑回归和 GBDT 奠定了大规模点击预估与排序的可解释基线；Wide&Deep、DeepFM、DCN 等模型把稀疏 ID 特征、交叉特征和深度表示结合起来，长期成为 CTR/CVR 排序系统的中坚方案。这些模型之所以常青，不是因为它们最时髦，而是因为它们稳定、易训、易扩展、易与生产特征系统对接。

因此，很多平台即使在探索 Transformer 和 LLM 方案，核心线上排序器仍然大量保留这条经典工业栈。

排序目标的差异会直接影响模型学到的偏好。pointwise 训练关注单个样本的点击或转化概率；pairwise 强调相对顺序；listwise 则试图让整个列表质量与用户体验更一致。近期的一些工作，如 Hierarchical Group-wise Ranking，也在继续尝试把更强的排序损失并入 CTR/CVR 训练，以缩小“分类目标”和“排序目标”之间的错位。

重排层则把问题从“给每个候选打分”进一步推进到“把这份列表组织成用户更愿意看的样子”。这里多样性、去重和位置偏差往往比单点概率本身更重要。

2025 年以后，推荐排序的研究焦点之一，是如何把更大的 Transformer 或 LLM 式模型真正用于判别式排序任务。近期工作已经开始探索用生成式预训练支撑 CTR/CVR 等判别任务，缓解大模型在稀疏推荐数据上容易过拟合的问题。同时，也有框架尝试把预训练语言模型适配到工业级推荐排序。

但到 2026 年，最稳妥的判断仍然是：大模型在推荐排序里更像增强器和研究前沿，而不是已经全面替代传统深度排序器的成熟工业标准。

推荐系统长期的一条主线，是怎样把用户历史行为压缩成可更新的兴趣表示。早期方法更依赖统计特征和聚合特征；后续出现了 DIN、DIEN、BST、SASRec、Transformer4Rec 一类模型，把点击序列、停留序列和会话上下文直接做时序建模。

这类任务的难点在于兴趣并不是静态向量，而是会漂移、分裂和受上下文触发。用户昨天在看婴儿车，未必意味着长期兴趣都转向母婴；用户今晚在搜酒店，也可能只是一次性出行需求。因此现代推荐中的用户表征，越来越强调短期兴趣、长期偏好、场景上下文和跨域行为的联合建模。

从特征来源看，用户表征通常同时吸收 ID 特征、内容特征、行为序列、社交图关系和实时上下文。现代系统很少再满足于“一个静态 user embedding”，而是会根据当前页面、当前时刻、当前候选集和最近行为重新计算条件化兴趣表示。这也是序列模型和注意力机制在推荐中持续重要的根本原因。

用户兴趣建模的另一个核心问题是可迁移性与可更新性。大型平台常希望同一用户表示同时服务首页推荐、广告、搜索和通知触达，但不同场景对兴趣的时间尺度和噪声容忍度完全不同。因此，统一用户表征与场景专属表征之间的分工，是推荐架构设计中的长期主题。

用户表征的演进，核心是从“一个用户一个静态向量”走向“一个用户在当前上下文下的动态兴趣状态”。DIN 强调目标感知的局部兴趣激活，DIEN 引入兴趣演化，BST、SASRec、Transformer4Rec 等模型则更明确地把用户行为当作序列来建模。这一演进反映的不是模型时髦程度，而是对用户兴趣本质的认识更精细了。

因为兴趣本身具有时序性、阶段性和条件触发性，静态 embedding 很难长期承担全部表达任务。

现代平台记录的用户行为远不止点击。曝光、停留、收藏、加购、购买、分享和跳出都在表达不同强度的偏好，因此多行为推荐成为明确方向。2025 年的多行为推荐综述已经把这一点系统化：输入建模、编码方式和训练策略都会因为行为类型不同而改变。与此同时，文本、图像和视频内容也在进入用户表征，使兴趣建模不再只是 ID 共现问题。

这意味着，用户表征越来越像“行为图 + 内容语义 + 场景上下文”的联合编码器，而不是单一行为序列模型。

当前一个非常明显的前沿，是尝试用 foundation model 处理序列推荐与跨域推荐。例如 RecGPT 试图摆脱传统 ID-only 表征，直接从文本特征构建 item 表示，以获得更强的零样本和跨域泛化能力。这条路线对冷启动尤其有吸引力，因为它正面回答了“新物品没有交互历史怎么办”。

但到 2026 年，ID 信号仍然没有消失。更现实的趋势是：强表征模型越来越多地同时吸收 ID、文本、图像和图结构，而不是简单宣布某一类信号过时。

点击率预估（CTR Prediction）、转化率预估（CVR Prediction）和价值预估，本质上是在回答“展示一个候选之后，用户后续会发生什么行为”。它们是排序与广告系统最核心的监督信号来源，因为展示决策最终都要落到点击、加购、购买、停留和长期价值上。

这类预估任务看似只是二分类或回归，实际上有大量特有难点：样本选择偏差、曝光偏差、延迟反馈、极端正负不平衡和归因问题。也正因为如此，推荐领域的模型设计往往不只围绕结构本身，还要围绕校准（Calibration）、样本构造、负采样和反事实纠偏展开。

CTR、CVR 和价值预估在链路中的分工也不同。CTR 更接近“用户是否愿意点开”，CVR 更接近“点开之后是否会转化”，价值预估则进一步把价格、利润、时长或长期收益纳入。很多工业系统会显式构造多阶段漏斗模型，例如先预估点击，再在点击条件下预估转化，避免把不同阶段的数据偏差混在一起。

此外，这类模型常常不仅要“排得对”，还要“概率可信”。如果输出分数被用于出价、预算分配或自动决策阈值，校准误差就会直接变成业务损失。因此，推荐和广告系统会比普通分类任务更重视概率校准、延迟标签回填和线上 A/B 实验中的稳定性监控。

CTR、CVR 和价值预估本质上对应用户行为漏斗的不同层级。CTR 关注是否点开，CVR 关注点击后是否完成转化，价值预估则把金额、利润、时长或长期收益继续纳入。把这些任务硬合并成单一标签往往会损失信息，因此工业系统更常采用分层建模、多任务学习或条件概率分解。

这也是为什么推荐预估模型通常不只是一个二分类器，而是一组围绕行为漏斗设计的联合模型。

预估任务最棘手的部分，不在网络结构本身，而在数据是被旧策略选择出来的。曝光偏差、样本选择偏差、延迟反馈和极端不平衡，都会让模型学到“日志里的相关性”而不是真正的用户倾向。因此，propensity modeling、IPS、Doubly Robust、负采样设计和概率校准在这条线上都非常关键。

特别是在 CVR 与广告出价场景里，校准问题会直接影响业务收益。近期关于不确定性校准和 propensity calibration 的工作，正是在补这一块基础设施。

一个值得注意的新变化，是更大的 Transformer 和生成式预训练开始被拿来增强判别式推荐任务。2025 年已有工作专门研究如何用 generative pretraining 支撑 CTR/CVR 这类 discriminative recommendation，核心动机是缓解数据稀疏条件下大模型直接训练容易过拟合的问题。这说明生成式方法在推荐里并不只服务于对话或内容生成，也开始反过来增强传统点击预估。

真实推荐系统很少只优化单一目标。用户体验希望提高满意度和留存，商业侧希望提高 GMV、广告收入和库存周转，平台治理又要求控制重复曝光、内容安全和公平性。因此，多目标优化（Multi-objective Optimization）几乎是推荐系统的常态，而不是例外。

工程上常见做法包括多任务学习、加权打分、约束重排和列表级优化。关键难点不在于“写几个损失函数”，而在于不同目标天然冲突：极致点击不一定带来长期留存，极致广告收益不一定带来用户满意，极致个性化又可能牺牲内容多样性。因此，推荐系统真正难的是怎样在多目标之间维持稳定平衡。

从优化视角看，多目标问题通常可以写成显式加权，也可以写成主目标加约束。前者更容易工程落地，后者更容易表达“某些指标绝不能跌破底线”。例如广告收入可以提升，但内容安全和用户投诉率必须受控；点击可以提高，但重复率和生态多样性不能失衡。推荐系统的策略层，往往就是在把这类业务规则转成可执行优化问题。

这一层还常与因果推断和反事实评估结合。因为当系统策略改变后，数据分布本身也会随之改变，模型很容易把“被展示过”误当成“本来就更优”。因此，多目标推荐不是纯粹的监督学习扩展，而是包含反馈回路与策略干预效应的动态优化问题。

多目标推荐最常见的三种工程形式，是多任务学习、显式加权打分和约束优化。多任务学习适合共享表征并联合学习多个行为信号；加权打分最易上线，便于快速调节业务策略；约束优化则更适合表达“收入可以提升，但投诉率或重复率不能越线”这类硬约束。三者经常同时存在，而不是彼此替代。

因此，多目标优化的难点从来不只是模型结构，而是目标之间的可交易性和组织层面的策略选择。

当目标从单项点击扩展到多样性、留存、公平性和生态健康时，列表级优化会越来越重要。近期关于 generative AI 时代多目标推荐的综述已经明确指出，推荐系统的目标早已超过单纯 accuracy，生成式模型与 agent 式推荐为联合优化提供了新的接口。这类方法试图不只给单个 item 打分，而是直接组织更符合全局目标的候选列表。

不过，这条路线也带来了可控性和评估复杂度问题，因为生成式策略更容易把目标耦合到黑箱决策中。

到 2026 年，一个非常明确的变化是：推荐系统越来越少把单一精度指标当作总目标，而越来越多把满意度、收入、多样性、公平性和长期价值放到统一框架里看。这并不意味着准确率不重要，而是准确率已经被降级为更大系统目标中的一部分。

冷启动（Cold Start）处理的是“新用户、新物品和新广告缺少历史数据”这一问题。若系统只依赖既有交互统计，就会天然偏向老内容和老用户画像，新内容几乎没有被看见的机会。这正是推荐系统必须引入探索（Exploration）的根本原因。

进一步看，很多收益并不会在一次展示后立刻体现。例如一个内容今天点击一般，却可能显著提升用户长期留存；一个广告今天看似收益高，却可能长期伤害平台体验。这使推荐系统天然和强化学习、因果推断、bandit 方法以及长期价值建模相连。也正因为如此，“短期点击最优”通常不是推荐系统真正的终局目标。

冷启动的解决方式通常包括内容特征建模、跨域迁移、元学习式快速适配和显式探索流量分配。新物品至少要先被正确表征，系统才能知道它可能与哪些用户匹配；新用户至少要通过少量交互快速建立初始画像。于是，内容理解模型、用户 onboarding 问卷、短序列兴趣建模和 bandit 探索会共同参与冷启动链路。

长期价值问题则要求系统从“这次曝光赚了多少”扩展到“这次曝光对未来行为有什么影响”。停留、留存、复访、满意度和生态健康都属于长期信号。真正成熟的推荐系统不会只看一跳指标，而会通过长期奖励建模、因果归因和阶段性约束，避免系统陷入只追逐短期反馈的局部最优。

冷启动之所以难，是因为传统协同过滤几乎完全依赖历史交互，一旦没有历史就会失明。因此，冷启动系统通常必须引入内容特征、用户属性、知识图谱、跨域行为和显式探索流量。2025 年关于 cold-start recommendation 的综述也表明，LLM 与更强内容理解能力正在显著改变这条线，因为它们能更好利用文本描述、商品元数据和跨域语义先验。

这意味着，冷启动的现代解法越来越偏向“用内容和语义补足交互稀缺”，而不是只等待日志积累。

探索和长期价值是同一类问题的两个侧面。若系统永远只推最确定会点的内容，就很难发现新偏好，也很难获得长期收益信号。因此，bandit、强化学习和因果推断会在这条线上持续出现。它们共同回答的是：怎样在当前收益与未来学习收益之间做平衡。

长期价值建模也要求系统重新定义 reward，不再只看单次点击，而是把留存、满意度、复访和生态健康纳入目标。

foundation model 和生成式推荐确实在改进冷启动，尤其是在文本充分、跨域丰富的场景里更明显；但它们并没有让探索问题消失。因为即便模型能更好理解新物品语义，它仍然需要真实用户反馈来校准平台特定偏好和长期效应。到 2026 年，更现实的路线仍然是“强内容表征 + 探索机制 + 长期价值建模”的组合，而不是幻想单一大模型自动解决冷启动。

广告系统与内容推荐共享很多基础技术，但它额外引入了出价（Bidding）、预算（Budget）、归因（Attribution）和流量约束，因此更接近“机器学习 + 在线市场机制”联合系统。模型不只要判断用户会不会点，还要判断这一展示值多少钱、是否值得消耗预算、是否应当在当前流量时段出价更积极。

因此，广告预估的真正系统目标通常是“预估 + 排序 + 竞价 + 节奏控制（Pacing）”的联合优化。CTR、CVR、eCPM、ROI、LTV 和预算完成率不会天然一致，模型稍微偏一点，系统收益和广告主体验就会同时受影响。这也是为什么广告系统常常比普通推荐系统更强调校准、稳定性和策略解释。

在广告拍卖链路中，模型分数通常会直接进入排序或出价公式，例如用 pCTR、pCVR、预估价值与 bid 共同形成最终竞争分数。因此，广告预估模型并不是一个孤立分类器，而是市场机制的一部分。分数稍有偏差，就可能导致高价值广告被低估、预算过早打满，或者后段流量投不出去。

预算控制与节奏控制进一步把问题变成动态资源分配。系统不仅要知道“这次值得不值得投”，还要知道“今天剩余预算应当怎样随时间分配”“不同流量时段应不应提高或压低出价”。因此，广告系统通常需要把预测模型、竞价策略、预算 pacing 和归因反馈放在统一控制闭环中理解。

广告排序和内容推荐虽然共享很多建模技术，但目标函数有本质区别。广告系统必须同时考虑用户点击、转化、广告主 ROI、平台收入和预算约束，因此排序分数往往直接进入拍卖机制。也就是说，广告模型输出的不是纯粹的“喜欢概率”，而是影响真实市场分配的 scoring signal。

这就是为什么广告系统会比普通推荐更敏感于校准误差、延迟标签和竞价机制变化。

近年的广告研究明显转向 autobidding 和 auction design。相关综述已经把这一方向单独系统化，说明自动出价正在成为广告生态核心接口。与此同时，预算 pacing 也不再只是一个老工程细节，而是整个投放系统的关键控制器，因为预算花太快、太慢或分布不均都会直接影响收益和广告主体验。

近期的基准和方法工作也说明，这一方向越来越强调离线 benchmark、约束优化和策略可评估性，而不只是在线黑箱调参。

到 2025 至 2026 年，广告系统也出现了明显的大模型化趋势。例如面向广告推荐与 auction scoring 的大规模训练基础设施、面向 auto-bidding 的生成式模型，以及专门为广告推荐设计的 foundation model 适配框架，都说明这一领域正在吸收 foundation model 能力。

但广告场景比内容推荐更难放任黑箱模型自由发挥，因为预算、ROI、CPC、节奏控制和拍卖公平性都是硬约束。也正因为如此，广告系统的大模型化大概率会长期呈现“强模型 + 强约束 + 强校准”的形态。

时序建模和时间序列任务处理的是：当数据按时间顺序展开时，模型如何利用过去信息理解当前状态并预测未来变化。它和一般表格学习的根本差别在于，样本之间不是互相独立同分布的点，而是被趋势、季节性、周期性、突变和滞后关系串起来的动态过程。

这类任务广泛出现在金融行情、传感器监控、设备运维、能源负荷、交通流量、用户行为序列和医学监测中。它们共同要求模型尊重顺序、处理非平稳性，并面对一个长期存在的现实问题：未来的数据分布很可能和过去并不完全相同。

在时序任务里，上采样与下采样通常不再表现为空间分辨率变化，而是表现为时间粒度变化。把秒级序列聚合成分钟级、把分钟级聚合成小时级，是典型下采样；把缺失区间插值补回更细时间轴、把低频预测映射回更高频输出，则是典型上采样。多尺度时序模型、patch 化建模、层级卷积和部分状态空间模型，经常都在不同时间分辨率之间切换，以便同时看到短期波动与长期趋势。

时序预测（Time Series Forecasting）要求模型根据历史观测预测未来值。它是最经典的时间序列任务，典型输出可以是未来一个点、多个时间步，或一个概率区间。ARIMA、指数平滑、状态空间模型代表传统统计路线；LSTM、TCN、Temporal Fusion Transformer、PatchTST 等则代表深度学习阶段的重要主线。

预测任务真正难的地方，不只是拟合历史曲线，而是处理趋势变化、节假日扰动、外部变量和概念漂移。也正因为如此，现代预测系统越来越强调多变量建模、概率预测和不确定性估计，而不是只输出一个单点数值。

从业务角度看，预测任务既可能是短期滚动预测，也可能是中长期规划预测。库存调度、能源调峰、产能规划和交通调度，对预测 horizon 和误差容忍度的要求完全不同。因此，单步预测、多步直接预测、递归预测和概率区间预测会在不同场景下分别占优。

现代时序预测还越来越重视全局模型与局部模型的分工。过去很多系统为每条序列单独建模；今天则更常见用一个共享模型同时学习成千上万条相关序列，再用个体特征或静态协变量进行条件化。这种“跨序列共享统计强度”的思路，是深度时序模型相对传统逐序列建模的重要优势之一。

时序预测的第一条主线，是统计建模。ARIMA、指数平滑、卡尔曼滤波与更一般的状态空间模型，依靠对趋势、季节性、噪声和滞后结构的显式假设来做预测。它们的优势在于参数可解释、数据需求小、在短数据和规则业务场景里很稳；不足在于面对复杂非线性、多变量交互和跨序列共享时，表达能力有限。

即便到了 2026 年，这条线也没有过时。很多高价值场景依然把统计模型作为强基线、集成组件或可解释 fallback，而不是被完全替代。

深度学习阶段把时序预测从“单序列局部拟合”推进到“跨序列共享表示”。LSTM 和 TCN 先解决了非线性时序依赖与长程建模问题；Temporal Fusion Transformer（TFT）进一步把静态协变量、已知未来特征和注意力机制统一到一个框架里；PatchTST 则把时间序列切成 patch 后再建模，显著提升了长窗口预测能力。

这些模型之所以成为主线，不只是因为精度更高，而是因为它们更适合现代工业数据形态：多变量、长历史、跨实体共享和复杂外部特征。

近两年的最大变化，是 forecasting 已经明显 foundation model 化。TimesFM 把 patched decoder 风格带入 zero-shot 预测；Chronos 通过量化和 tokenization 把数值序列转成类似语言建模问题；Timer-XL、Moirai-MoE、Moirai 2.0 则继续把统一预测、长上下文和大规模预训练推进到更强的泛化范式。到了 2025 年后，这条线已经不再只是“能不能 zero-shot”，而是在比较不同 foundation model 的概率预测、效率和跨域泛化能力。

更进一步，Chronos-2 已开始明确处理多变量和带协变量 forecasting，说明时间序列 foundation model 正在从单变量 zero-shot 走向更接近真实业务的统一预测接口。

时序分类（Time Series Classification）研究的是：给定一段时间序列，它属于哪种状态、设备类型、故障模式或行为类别。例如心电序列诊断、设备振动模式分类、行为轨迹识别和金融形态识别，都属于这一方向。

和普通分类不同，时序分类的判别依据不只是特征值大小，还包括随时间展开的模式形状、局部子序列、相位偏移和持续时间。传统路线常用动态时间规整（DTW）和距离度量；现代路线则更依赖 CNN、RNN、TCN 和 Transformer 编码器把整段序列压成判别性表示。

这类任务的关键难点在于时间对齐并不总是稳定。同一种故障或生理模式，可能只是出现得更早、更晚、更快或更慢；若模型只盯逐点位置，很容易把本质相同的模式判成不同类别。这也是 shapelet、DTW 和时序卷积长期重要的原因，它们都在试图捕捉“形状相似”而非“逐时刻完全重合”。

很多时序分类系统还会把原始序列与频域特征、统计量和事件级特征结合起来。例如心电诊断往往同时使用波形形状、心率变异和频谱信息；工业故障诊断则会结合振动信号的时域和频域表示。也就是说，时序分类并不排斥特征工程，而是更强调表征与序列结构的联合设计。

时序分类最早的强基线并不是深网，而是距离度量与判别子序列。DTW 通过弹性对齐处理速度和相位差异，shapelet 则显式寻找最有区分力的局部片段。这些方法的价值在于，它们直接针对时序分类最核心的问题发力：模式可能相同，但发生得更早、更晚、更长或更短。

因此，即使深度学习已经成为主流，DTW、shapelet 和频域/统计特征工程仍然是理解时序分类问题结构的重要参照系。

现代时序分类更多依赖可学习表示。CNN 擅长抽取局部形状模式，RNN 擅长序列状态传递，Transformer 则更容易统一长程依赖与多变量交互。很多系统还会把时域、频域、事件级特征与原始序列共同编码，因为在医疗、设备诊断和生理监测中，单一视角往往不足以稳定区分类别。

也正因为如此，时序分类越来越像“多视角表征学习”问题，而不只是把一串数字塞进分类头。

Foundation model for time series 的综述已经把 classification 作为重要下游任务之一，但这一方向和 forecasting 不同，尚未形成像 TimesFM 或 Chronos 那样一统天下的标准接口。更现实的趋势是：预训练时序 backbone 正在成为通用特征提取器，而具体分类任务仍然强依赖领域先验、数据规整程度和标签定义。对于 irregular time series，PYRREGULAR 与 Time-IMM 这类基准也在提醒一个事实：真实分类数据远比标准 benchmark 更脏、更稀疏、更异步。

时序异常检测（Time Series Anomaly Detection）要求系统发现时间轴上“不应该出现”的模式，例如设备突发故障、传感器漂移、交易异常、网络流量攻击或病理生理异常。它和静态异常检测不同，因为异常可能表现为单点突刺，也可能表现为趋势漂移、周期破坏或跨变量联动失衡。

这类任务通常需要同时建模局部短时异常和长期基线变化。也正因为如此，很多方法会把预测误差、重建误差、密度估计和变点检测结合起来，而不是只依赖一种分数。实际系统里，异常检测还必须控制误报，因为一个高召回但误报极多的报警系统通常无法真正落地。

异常检测的另一个难点是标注稀缺且异常定义随业务变化。很多系统几乎拿不到完整异常标签，只能依赖正常样本建模、弱监督标签或人工审核回流。因此，重建式自编码器、预测式模型、对比学习表示和在线阈值更新会同时出现，目的都是在标注极少的条件下维持可用性。

从业务流程看，异常检测从来不是“算出一个分数”就结束。系统通常还需要解释异常来源、聚合同类告警、控制告警风暴，并把检测结果回写给运维或业务规则引擎。一个无法解释、无法抑制重复噪声的异常模型，即便离线分数再高，也很难长期部署。

时序异常检测最经典的三条主线，是预测式、重建式和变点检测式。预测式方法假设正常模式可预测，异常会导致未来偏离；重建式方法假设正常模式可压缩重构，异常重建困难；变点检测则直接寻找统计分布发生突变的时刻。三者各有盲点，因此工业系统往往不会只押一类分数。

例如某些异常不是突发尖峰，而是缓慢漂移；某些复杂正常模式本身难预测，容易被误判为异常。正是这些失败模式使单一方法很难长期独立承担生产告警。

异常检测最麻烦的地方，是异常标签天然稀少、定义动态变化，而且误报成本往往极高。一个报警系统若每天触发数千条低质量告警，最终通常会被业务团队忽略。因此，检测模块之外还必须有告警聚合、相似事件去重、优先级分层和人工反馈回流机制。

也就是说，异常检测从一开始就不是纯模型问题，而是模型、规则和运维流程共同构成的系统问题。

近年的 foundation model 综述已经把 anomaly detection 纳入时间序列 FM 任务图谱，但这一方向也暴露出明显困难。Towards Foundation Models for Zero-Shot Time Series Anomaly Detection 指出，许多 TSAD foundation model 仍然依赖 reconstruction-style pretraining，而这会造成目标错位：模型可能把复杂正常模式当异常，也可能忽略微弱异常。TimeRCD 一类路线正是在试图修正这种预训练与检测目标之间的不匹配。

因此，2026 年的关键问题不是“能否把 anomaly 也塞进 foundation model”，而是“预训练目标是否真正服务异常检测”。

有些时序任务关心的不是未来值，也不是整段类别，而是“某个事件在什么时候开始、什么时候结束”。这类任务可以概括为序列分割（Segmentation）与事件检测（Event Detection），例如设备工作阶段切换、睡眠阶段划分、故障开始点定位和行为片段检测。

它和视频时序定位很相似，本质上都是在一条时间轴上找结构边界。模型既可以做逐时刻标签预测，也可以直接回归事件区间。难点在于边界通常模糊、标注不稳定，而且不同事件持续时间可能相差很大，因此它常常需要局部感受野和长时上下文同时存在。

从方法上看，这类任务既可以视作序列标注，也可以视作变点检测或区间提议问题。前者强调逐时刻分类，适合边界较密的任务；后者更强调直接发现状态切换点或事件片段，适合阶段结构明显的场景。不同业务会在“时间分辨率”和“边界解释性”之间做不同取舍。

事件检测类任务通常还面临标签定义主观的问题。一个故障究竟从轻微波动开始算，还是从明确超阈值开始算，不同专家的标准可能不同。因此，序列分割系统往往需要和规则、人工审阅和后验平滑结合，而不是完全依赖端到端模型一次性裁决。

序列分割与事件检测至少有三种常见建模视角：逐时刻标注、区间提议和变点检测。逐时刻标注适合边界较密、类别较清晰的任务；区间提议更像视频时序定位，适合持续事件；变点检测则更强调统计结构何时发生变化。这三类方法在业务里常常混用，因为真实事件既有类别属性，也有边界和持续时间属性。

这也是为什么事件检测很难只靠一个分类头解决，它天然带有定位结构。

序列边界常常带有人为主观性。一个故障、睡眠阶段或生理事件究竟从哪个采样点开始，本身就可能存在专家分歧。因此，边界建模越来越重视后验平滑、不确定性和结构性解释。近期的 causal discovery-driven change point detection 也说明，在多变量场景里，变化不仅是“数值变了”，还可能是变量间因果关系变了。

这让 change point detection 从简单阈值问题，逐步推进到更接近结构变化分析。

到 2026 年，序列分割和事件检测的一个明显趋势，是从“找出边界”走向“理解边界意味着什么”。在工业、医学和气候应用里，系统越来越被要求说明变化的来源、涉及哪些变量、是暂时波动还是机制改变。因此，这一方向正在与 anomaly detection、causal modeling 和根因分析更紧密地连起来。

真实时间序列几乎不可能完全规整。传感器会掉点，日志会延迟，医学监测会中断，用户序列会稀疏。因此，缺失值补全（Imputation）与插值（Interpolation）本身就是独立的重要任务，而不是简单预处理步骤。

补全任务的难点在于，缺失机制本身可能带有信息。例如某设备在高负荷时更容易丢包，这时“缺失”本身就是异常信号。也正因为如此，现代时序补全越来越强调显式建模观测掩码、采样不规则性和跨变量依赖，而不是机械地做线性插值。

在技术路线上，简单插值适合短缺口和平稳信号，但在长缺失段、多变量强耦合或不规则采样场景中往往不够。卡尔曼滤波、Gaussian Process、BRITS 一类循环补全模型，以及基于注意力的不规则时间编码方法，都是为了更好地利用时间间隔和跨变量关联。

补全质量对下游影响极大。若补全结果被继续输入预测、诊断或告警系统，错误的插值不仅会模糊真实异常，还可能制造虚假模式。因此，成熟系统通常会同时输出补全值和不确定性，甚至保留“哪些点原本缺失”的掩码供下游模型继续使用。

补全问题最早依赖线性插值、样条插值、卡尔曼滤波和 Gaussian Process 等统计工具。它们在短缺口、平稳数据和噪声较轻场景中依然很强，因为这些方法天然带有平滑性或状态转移假设，且不需要大规模训练数据。

这条路线今天仍然不可忽视，尤其是在数据量小、需要不确定性解释或采样机制较规则的应用里。

深度学习把补全推进到更复杂的场景。BRITS 等模型通过双向递归和显式掩码，把缺失值本身纳入状态更新；后续基于注意力和连续时间编码的方法，则更适合不规则采样和长缺失段。这里最关键的变化是：模型不再把缺失当作纯粹的空洞，而是把“缺失发生在何时、持续多久、与哪些变量同时缺失”都当作信息来源。

这正是补全与普通插值的分界线。现代补全更接近结构推断，而不是单纯光滑曲线。

Time-IMM 和 PYRREGULAR 这类基准都在强调一个现实：很多时间序列并不是规则采样、单模态、偶尔丢点，而是从生成机制上就存在异步、多模态和大面积缺失。也正因为如此，2026 年的补全主线已经明显从“规则表格上的插值技巧”转向“真实世界 irregular multivariate time series 的统一建模”。在这类场景里，补全、预测和分类之间的边界也开始模糊，因为系统经常需要一边补一边推理。

很多真实系统不是单变量序列，而是一组彼此耦合的时间变量。电网负荷、交通路网、工业产线和天气监测，都要求模型同时处理多变量依赖和空间关系。这时问题会从普通时序预测扩展成多变量时序（Multivariate Time Series）甚至时空预测（Spatio-temporal Forecasting）。

一旦进入这类场景，模型就不仅要问“昨天如何影响今天”，还要问“邻近节点、相连设备或上下游系统如何共同影响当前点位”。这也是为什么图神经网络、时空 Transformer 和图时序混合模型会在这一方向持续出现，因为单纯把每条序列独立建模，往往会遗漏系统级联动结构。

时空预测的核心在于同时建模两种依赖：时间上的滞后与空间上的传播。交通拥堵会沿路网扩散，电力负荷会在网络中传导，城市传感器也存在显著的空间相关。于是，邻接图、地理距离、拓扑结构和外部事件就会与时间编码一起进入模型，而不再只是普通特征列。

这类系统通常还要处理尺度不一致问题。某些变量以分钟为粒度变化，某些外部因素以小时或天为粒度变化；某些节点高度同步，某些节点几乎独立。真正高质量的时空模型，不只是堆叠一个 GNN 和一个 Transformer，而是要明确哪些依赖值得共享、哪些依赖必须局部化建模。

多变量时序最早的重要工具包括 VAR 和更一般的多变量状态空间模型，它们擅长刻画变量之间的线性滞后依赖。进入深度学习阶段后，图神经网络、时空卷积和时空 Transformer 成为主线，因为它们更适合同时建模时间依赖与空间拓扑传播。交通、气象和电网等任务尤其受益于这种结构建模。

这里的核心思想非常清晰：节点之间不是独立序列，而是处在传播网络中。

时空预测真正困难的地方，在于图并不总是静态的。交通路网会受到事故和施工影响，电网负荷会被天气和节假日扰动，工业节点关系也可能因工况变化而改变。因此，现代时空模型越来越强调动态图结构、外部变量融合和多尺度传播，而不是假设一个固定邻接矩阵就足够。

也正因为如此，时空预测和普通 multivariate forecasting 的界限越来越取决于“变量间关系是否需要显式结构建模”。

2025 年的 foundation model 综述已经把 multivariate 与 spatiotemporal tasks 明确纳入统一时间序列 FM 版图；而 2025 年的 Spatiotemporal Forecasting as Planning 进一步把时空预测推进到 generative world model 与 model-based reinforcement learning 框架。这说明当前前沿不再满足于“给出一个最优点预测”，而是开始探索如何生成多种可能未来、支持规划和非可微目标优化。

换句话说，时空预测正在从被动预测器，逐步向可用于决策和模拟的环境模型演进。

The post 人工智能理论知识 - 主要应用领域 appeared first on 绿色记忆.

这一篇从常用算法进入机器学习基础概念、经典机器学习与神经网络，重点讨论“模型如何被构造、训练、评估与正则化”。前一篇给出了数学语言，这一篇开始进入真正的建模问题：数据怎样表示，损失怎样定义，优化怎样推进，不同模型家族各自擅长什么；再往后才会过渡到 Transformer 与大语言模型。

这一节处理的核心问题是：当面对搜索、更新、统计、调度、最短路径、依赖分析或训练流水线等任务时，数据应该怎样组织，操作应该怎样执行，才能既正确又高效。数据结构（Data Structure）决定“数据在内存里如何表示”，算法（Algorithm）决定“在这种表示上如何完成查询、插入、删除、遍历、排序与优化”。很多系统性能问题，本质上不是算力不足，而是底层组织方式与操作方式不匹配。

可以把它理解成“仓库布局与搬运规则”的组合：同样一批货物，若排成连续货架、串成链式节点、组织成树状目录，或连接成路网，后续的查找、插入、合并与运输成本会完全不同。现代 AI 工程虽然把注意力集中在模型上，但数据加载器、特征流水线、参数缓存、向量检索、计算图调度、图学习和索引系统，最终都建立在这些基础结构之上。

复杂度表只给出渐近上界，不能直接替代工程判断。真实系统还要同时考虑缓存友好性（Cache Locality）、常数项、并发开销、内存占用和实现复杂度。例如链表在理论上支持常数时间插入，但它对 CPU 缓存并不友好；数组在理论上中间插入较慢，但顺序扫描极快，因此在现代硬件上经常更有优势。

数组（Array）处理的核心问题是：当元素类型一致、数量可以按顺序编号时，如何支持最低成本的随机访问与批量扫描。它的关键性质是连续内存（Contiguous Memory）。若每个元素大小为 \(s\)，首地址为 \(\text{base}\)，则第 \(i\) 个元素地址为

这个式子说明数组访问为何是 \(O(1)\)：位置可以直接计算，不需要沿指针逐步跳转。矩阵、张量、mini-batch、时间序列缓存、本地特征块和 embedding 表中的一行，本质上都依赖这种“地址可算”的结构。

数组的代价也非常明确：若在中间插入或删除元素，后面的元素必须整体搬移，因此复杂度通常是 \(O(n)\)。这意味着数组适合“读多写少、顺序稳定”的任务，不适合“在任意位置频繁插入”的任务。

动态数组（Dynamic Array）是在数组上的工程扩展：容量不足时申请更大的连续空间，把原有元素整体拷贝过去，再继续追加。一次扩容代价很高，但若容量按倍数增长，则追加操作的均摊（Amortized）复杂度仍可视为 \(O(1)\)。Python 的 list、C++ 的 vector、Java 的 ArrayList 都遵循这一思想。

直觉上，数组像按编号排好的货架：拿第 137 件货非常快，但若要把一件货塞进中间，后面整排货物都要整体后移。

链表（Linked List）处理的是另一类问题：当序列顺序经常变化时，能否避免数组那样的大规模搬移。链表不要求连续内存，而是让每个节点（Node）保存数据和指向下一个节点的指针（Pointer）；双向链表（Doubly Linked List）还会额外保存前驱指针。

若已经拿到某个节点的位置，那么在其前后插入或删除节点只需要调整局部指针，代价通常是 \(O(1)\)。但链表无法像数组那样通过下标直接定位第 \(i\) 个元素，查找往往必须从头逐个走过去，因此通常是 \(O(n)\)。

链表适合做“结构改动频繁、定位方式不是按下标而是按已有节点句柄”的任务。例如 LRU 缓存中，经常需要把刚访问的元素移到头部；若配合哈希表记录节点位置，链表就能高效完成重排。

链表像一串用绳子串起来的标签。改顺序很方便，但想直接摸到第 500 个标签，就只能沿着绳子一个个数过去。

栈（Stack）定义的是一种后进先出（Last In First Out, LIFO）的访问约束。它处理的问题不是“怎样存更多数据”，而是“怎样强制最近进入的状态最先退出”。典型操作包括入栈 push、出栈 pop 与查看栈顶 top，它们都发生在同一端，因此实现代价通常是 \(O(1)\)。

函数调用栈、递归回溯、表达式求值、括号匹配、深度优先搜索中的显式状态保存，都依赖这种结构。其本质是把“尚未处理完的上下文”按嵌套顺序压起来，等内部任务结束后再按相反顺序恢复。

单调栈（Monotonic Stack）是栈在算法中的重要变体。它通过维护一个单调递增或单调递减的栈，把“下一个更大元素”“柱状图最大矩形”等问题从 \(O(n^2)\) 降到 \(O(n)\)。原因在于每个元素最多入栈和出栈各一次。

队列（Queue）定义的是先进先出（First In First Out, FIFO）的访问约束。进入得早的元素先被处理，后来进入的元素排在尾部等待。它适合表达“任务排队、波前扩张、按到达顺序消费”的过程。

广度优先搜索（Breadth-First Search, BFS）之所以使用队列，正是因为 BFS 要按距离层层扩展：先处理距离起点为 1 的节点，再处理距离为 2 的节点。这个“分层推进”机制与 FIFO 完全一致。

循环队列（Circular Queue）通过把底层数组首尾相连，可以避免频繁搬移；双端队列（Deque）则允许两端都做插入和删除，因此能够支持滑动窗口最值、0-1 BFS 等更复杂的算法模式。

哈希表（Hash Table）处理的核心问题是：当数据按“键（Key）”组织，而不是按位置组织时，如何快速找到对应的值（Value）。其思想是先通过哈希函数（Hash Function）把键映射成一个整数，再把这个整数映射到桶（Bucket）或槽位（Slot）上。

若哈希函数分布均匀，且装载因子（Load Factor）控制合理，则查找、插入和删除的平均复杂度都可接近 \(O(1)\)。这正是词表映射、去重、缓存索引、参数名字典和特征 ID 映射大量采用哈希表的原因。

哈希表的难点在冲突（Collision）处理。多个键可能映射到同一位置，常见解决方案包括链地址法（Separate Chaining）和开放定址法（Open Addressing）。因此“哈希表平均 \(O(1)\)”并不意味着永远常数时间，它依赖于哈希函数质量、负载控制和冲突处理策略。

Bloom Filter 本质上属于概率型数据结构（Probabilistic Data Structure），更准确地说，是一种近似集合成员查询结构（Approximate Membership Query, AMQ）。它解决的问题并不是“把元素精确存下来”，而是“用极小内存快速判断某元素是否可能出现过”。因此它通常作为哈希表、数据库索引或缓存系统之前的一层预过滤结构。

Bloom Filter 由一个长度为 \(m\) 的比特数组 \(B\in\{0,1\}^m\) 和 \(k\) 个哈希函数 \(h_1,\dots,h_k\) 构成，其中每个哈希函数都把元素 \(x\) 映射到区间 \(\{0,1,\dots,m-1\}\) 中的一个位置。插入元素 \(x\) 时，执行

查询元素 \(x\) 时，检查 \(B[h_1(x)],\dots,B[h_k(x)]\)。只要其中至少有一个位置为 0，就可以断定 \(x\) 一定不在集合中；若这些位置全部为 1，则只能说明 \(x\) 可能在集合中。

这一定义直接带来 Bloom Filter 最重要的判定性质：它允许假阳性（False Positive），但不允许假阴性（False Negative）。原因在于，不同元素可能把同一批 bit 位置反复置为 1，于是一个从未插入过的元素也可能“碰巧”命中全 1；但只要某个位置仍为 0，就说明没有任何已插入元素覆盖过这条哈希路径，因此该元素一定不存在。

设一共插入了 \(n\) 个元素，则某个 bit 在所有插入结束后仍为 0 的概率近似为 \(\left(1-\frac{1}{m}\right)^{kn}\approx e^{-kn/m}\)。于是查询一个未出现元素时， \(k\) 个位置恰好都为 1 的假阳性概率近似为

这里 \(m\) 是 bit 数组长度， \(n\) 是已插入元素数， \(k\) 是哈希函数数目， \(p\) 是假阳性概率。这个公式揭示了 Bloom Filter 的基本权衡： \(m\) 越大，冲突越少； \(n\) 越大，数组越接近被“染满”； \(k\) 太小会降低区分能力，太大则会过度占满 bit 位。固定 \(m\) 与 \(n\) 时，常见的近似最优选择是

直觉上，Bloom Filter 像一排共享的指示灯。每来一个元素，就按亮若干盏灯；查询时，只要对应灯中有一盏没亮，就可以确认它从未出现过。若全部亮着，也只能说明“这些灯曾被某些元素点亮过”，却不能保证就是当前这个元素点亮的。

Bloom Filter 最适合用于“先快速排除绝大多数不存在项，再把少量可疑项交给精确结构复核”的场景。例如缓存系统可先判断某个 key 是否可能在缓存中，若 Bloom Filter 直接给出“不在”，就可以避免无意义回源；LSM-Tree 存储系统可用它判断某个键是否可能存在于某个 SSTable；爬虫去重、黑名单预过滤、向量检索候选预筛都大量使用这一思想。

Bloom Filter 的边界也很明确。第一，它不保存原始元素，因此不能枚举集合内容，也不能像哈希表那样返回关联值。第二，标准 Bloom Filter 不支持安全删除，因为把某个 bit 清零可能误伤其他元素留下的痕迹；若确实需要删除，通常要改用计数 Bloom Filter（Counting Bloom Filter）。第三，当假阳性代价非常高、系统需要完全精确的成员判断时，应优先使用哈希表、B 树或其他精确索引结构。

树（Tree）处理的是“层次结构”和“递归划分”问题。树中的节点之间具有父子关系，除了根节点（Root）外，每个节点都有唯一父节点。它天然适合表达目录层级、决策分裂、区间划分、优先级组织与前缀共享。

树之所以重要，在于它把原本线性的搜索空间组织成递归结构，使很多操作能通过“向左还是向右”“进入哪个子树”逐步缩小问题规模。若每次都能把候选空间缩小到原来的一半，复杂度就会从线性级下降到对数级。

二叉树（Binary Tree）规定每个节点至多有两个孩子。前序遍历（Preorder）、中序遍历（Inorder）、后序遍历（Postorder）和层序遍历（Level-order）分别对应不同的信息读取顺序：前序适合序列化结构，中序适合读取二叉搜索树中的有序键，后序适合先处理子问题再合并，层序适合按深度观察整体形状。

二叉搜索树（Binary Search Tree, BST）在每个节点上保持“左子树键值更小、右子树键值更大”的顺序约束，因此查找、插入和删除都可以沿着比较路径进行。若树高度为 \(h\)，这些操作的复杂度一般与 \(O(h)\) 成正比。

问题在于普通 BST 在极端情况下会退化成链表，此时 \(h=n\)。平衡树（Balanced Tree）如 AVL 树、红黑树（Red-Black Tree）通过旋转（Rotation）维护高度受控，使 \(h=O(\log n)\)，从而把查找、插入和删除稳定在对数复杂度。数据库索引和有序映射容器大量依赖这一思想。

堆（Heap）维护的是局部顺序，而不是整棵树的全局有序性：在最小堆（Min-Heap）中，每个父节点都不大于子节点，因此根节点始终是全局最小值；最大堆（Max-Heap）则相反。它通常用数组实现，父子下标关系可以直接计算。

堆最适合实现优先队列（Priority Queue）：每次都要快速取出当前最重要、最小或最大的元素时，插入和弹出都只需 \(O(\log n)\)。Dijkstra、A* 搜索、任务调度、Top-K 维护和流式中位数都大量依赖优先队列。

Trie 树（Prefix Tree）把字符串按前缀共享组织起来。若插入单词集合 \(\{w_1,\dots,w_m\}\)，公共前缀只存一次，因此“是否存在某个前缀”“以某前缀开头的词有多少”都可以沿字符路径直接完成。

Trie 特别适合词典匹配、自动补全、敏感词过滤和子词切分。它牺牲了一部分空间，换来按字符长度而非按词典规模进行搜索的能力。

图（Graph）处理的是最一般的关系结构。若顶点集合为 \(V\)，边集合为 \(E\)，则图可写成 \(G=(V,E)\)。树本质上是图的一个特殊子类，但图允许环、允许多条连接、允许方向和权重，因此能表达社交关系、知识链接、网页跳转、道路网络、依赖图与神经网络计算图。

图的常见表示方式有邻接矩阵（Adjacency Matrix）和邻接表（Adjacency List）。前者适合稠密图，能 \(O(1)\) 判断两点是否相连；后者适合稀疏图，空间复杂度更低，遍历邻居更高效。

广度优先搜索（BFS）与深度优先搜索（DFS）是图遍历的两种基本组织方式。BFS 使用队列按层推进，适合无权最短路、层次扩展与最少步数问题；DFS 使用递归或显式栈沿一条路径尽量走深，适合回溯、环检测、拓扑排序、强连通分量与树形动态规划。

对邻接表表示的图，两者的时间复杂度通常都是 \(O(|V|+|E|)\)。区别不在渐近复杂度，而在访问顺序：BFS 保证按距离层层扩展，DFS 更擅长描述“先深入、后回退”的结构性问题。

最短路径（Shortest Path）问题处理的是：从起点到终点，总代价最小的路径是什么。若图无权，BFS 就能得到边数最少的路径；若边权非负，常用 Dijkstra 算法。它每次从优先队列中取出当前距离估计最小的顶点，并尝试松弛（Relax）相邻边。

Dijkstra 的核心更新为

其中 \(\mathrm{dist}[u]\) 是当前已知的从源点到 \(u\) 的最短距离估计， \(w(u,v)\) 是边权。这个公式表达的是最短路的本质：若“先到 \(u\)，再走到 \(v\)”更便宜，就更新对 \(v\) 的距离认知。

拓扑排序（Topological Sort）处理的是有向无环图（Directed Acyclic Graph, DAG）中的依赖顺序。若边 \(u\to v\) 表示“\(u\) 必须先于 \(v\)”，那么拓扑序就是一种满足全部先后约束的线性排列。

课程先修关系、编译依赖、工作流调度、神经网络计算图执行次序，本质上都属于这一问题。拓扑排序的价值不只是“排出一个顺序”，而是把依赖图转成一条能够实际执行的流水线。

最小生成树（Minimum Spanning Tree, MST）处理的是这样的问题：给定一个连通无向带权图 \(G=(V,E)\)，需要从边集合 \(E\) 中选出一部分边，把所有顶点连成一个整体，同时不产生环，并使总权重最小。若把所有生成树的集合记为 \(\mathcal{T}(G)\)，则标准形式可以写成

其中 \(T^*\) 是最优生成树；\(w(e)\) 是边 \(e\) 的权重；\(\sum_{e\in T} w(e)\) 表示树中全部边的总代价。这里的“生成树”有三个同时成立的约束：第一， \(T\subseteq E\)；第二，图在边集 \(T\) 下必须连通；第三， \(T\) 不能含环，因此边数必然满足 \(|T|=|V|-1\)。

这个定义明确了 MST 不是“找一棵看上去便宜的树”，而是在所有能够覆盖全部顶点的无环连通方案中做全局最小化。只强调“连通”会多出冗余边，只强调“边权小”又可能导致图不连通；MST 同时满足这两个条件。

直觉上，可以把 MST 理解成“以最低总造价把一组城市接通，但不修多余的回路”。如果形成了环，说明这条网络中至少有一条边是重复支出；如果某些城市没有接入，说明方案根本不可用。MST 就是在“全覆盖”和“最低成本”之间取得最紧的平衡。

MST 成立的核心理论基础是割性质（Cut Property）：把顶点集切成两个不相交部分后，跨越这个切分的最小权边，一定存在于某棵最小生成树中。这个性质的含义是：局部最便宜的“安全边（Safe Edge）”可以被逐步加入，而不会破坏全局最优性。Prim 与 Kruskal 虽然组织方式不同，但本质上都在不断选择这样的安全边。

Prim 算法的思路是“从一个起点向外生长一棵树”。设当前已经纳入树中的顶点集合为 \(S\)，则 Prim 每一步都在所有满足 \(u\in S,\ v\notin S\) 的边中，选择权重最小的一条，把新顶点接入当前树。这个过程像不断把新城市接入已经建好的主干网，因此特别适合用优先队列维护“当前边界上最便宜的边”。若图用邻接表存储并配合二叉堆实现优先队列，时间复杂度通常为 \(O(|E|\log |V|)\)。

Kruskal 算法的思路是“按全图范围从便宜到昂贵依次选边”。它先对所有边按权重升序排序，然后从小到大扫描：若当前边连接的是两个不同连通块，就把它加入结果；若会在当前结构中形成环，就跳过。为了高效判断“两个端点是否已经连通”，Kruskal 通常配合并查集（Disjoint Set Union, DSU）。排序代价主导总复杂度，因此复杂度通常写成 \(O(|E|\log |E|)\)，与 \(O(|E|\log |V|)\) 在数量级上接近。

两种算法解决的是同一个优化问题，但适合的工程语境不同。Prim 更像“从局部网络不断扩张”，适合稠密图或从某个核心节点逐步向外建设的场景；Kruskal 更像“全局看所有候选边，再逐一合并连通块”，在边集天然可排序、图较稀疏时实现尤其直接。

一个最小例子可以把公式和过程连起来。设四个顶点 \(A,B,C,D\)，边权为： \(w(A,B)=1\)， \(w(B,C)=2\)， \(w(A,C)=4\)， \(w(B,D)=3\)， \(w(C,D)=5\)。Kruskal 会先按边权排序： \((A,B),(B,C),(B,D),(A,C),(C,D)\)。前 3 条边分别把 \(A\) 与 \(B\)、 \(B\) 与 \(C\)、 \(B\) 与 \(D\) 连起来，此时已经得到 \(|V|-1=3\) 条边，且图连通无环，于是生成树为

其总代价为

若改选边集 \(\{(A,B),(A,C),(B,D)\}\)，总代价是 \(1+4+3=8\)；若再加入 \((B,C)\)，虽然成本局部看不高，但边数会超过 \(|V|-1\) 并形成环，因此不再是树。这个例子把“最低成本”“连通”“无环”三项约束如何同时生效展示得很清楚。

MST 常见于网络布线、电力传输、骨架路网设计、图像分割、聚类和图压缩。层次聚类中的单链接（Single Linkage）就可以通过图的最小生成树来理解：先把点看成顶点，把样本间距离看成边权，再在 MST 上剪断最长的若干条边，就得到若干连通簇。这也是为什么 MST 不只是图论题型，而是很多数据分析与机器学习方法的底层结构。

MST 也有明确边界。它只适用于无向、连通、带权图上的“全连通最低总成本”问题；若任务要求的是“从源点到其余点的最短路”，应使用最短路径算法；若图有方向，目标就不再是普通 MST，而会进入最小树形图（Minimum Arborescence）等更复杂的问题。

动态规划（Dynamic Programming, DP）处理的是这样一类问题：目标是求一个全局最优值、最优路径，或所有路径的总和，但如果直接把所有可能性全部枚举出来，计算量会迅速爆炸。它常见于序列决策、路径规划、字符串匹配、图搜索，以及隐马尔可夫模型（HMM）、条件随机场（CRF）这类结构化预测模型。

这类问题通常有两个共同特征。第一，重叠子问题（Overlapping Subproblems）：同一个中间子问题会被反复计算。第二，最优子结构（Optimal Substructure）：大问题的最优解可以由小问题的最优解递推得到。例如，在长度为 \(T\) 的序列上，若每一步有 \(|\mathcal{S}|\) 个可能状态，直接枚举所有状态路径往往需要考虑 \(|\mathcal{S}|^T\) 条候选路径；当 \(T\) 稍大时，这种暴力方法几乎不可用。

动态规划的核心在于：先定义能够代表子问题的状态，再写出状态之间的递推关系，并把已经算过的结果缓存下来复用。因此，它本质上是一种计算组织方式，而不是某个固定公式。

一个直观比喻是出差换乘。设想要从起点出发，经过很多站点，最终到达目的地。暴力法会把“到达每一站的所有走法”全部记下来；动态规划不会这样做。它只会为每个中间站保留一份最有价值的摘要，例如“到达这个站的最低成本”或“到达这个站的最大得分”。当继续前往下一站时，系统只需要查这份账本，而不必回头展开所有历史路径。

因此，动态规划通常包含四个步骤：定义状态、定义边界条件、写出转移方程、确定计算顺序。状态定义决定“中间结果要存什么”；边界条件决定“第一步从哪里开始”；转移方程决定“当前结果如何从更小问题得到”；计算顺序则保证所有依赖项在使用前已经计算完毕。

动态规划能够丢弃大量“暂时看起来不够好”的前缀路径，前提是状态（State）已经完整刻画了未来决策所需的全部信息。一旦这个条件成立，到达同一状态的两条前缀路径，未来能够接上的可行后缀集合完全相同，因此只需要保留其中更优的那一条。

设两条前缀路径都到达同一状态 \(s\)，其当前累计代价分别为 \(f_1(s)\) 与 \(f_2(s)\)，且 \(f_1(s)\le f_2(s)\)。若从状态 \(s\) 出发，后续任意可行决策产生的附加代价记为 \(g(s)\)，并且这个附加代价只由当前状态决定，而不再依赖此前的完整历史，则有

这个不等式表明：在同一状态上，较差的前缀会被较优前缀完全支配（Dominated）。无论后面接哪一段后缀路径，较差前缀都不可能反超。因此 Bellman 最优性原理允许动态规划只保留“到达该状态的最优值”，而不必保留全部历史路径。

所谓“一个当前次优的路径，后来却通向全局最优”，本质上对应另一种情形：这条路径与当前更优路径虽然看起来到达了同一个位置，但它们对未来的可行动作并不相同。此时它们实际上并不属于同一个状态，而是状态定义缺失了关键信息。

一个典型例子是带资源约束的路径规划。若状态只写成当前位置 \((i,j)\)，那么两条到达同一格子的路径会被合并；但若其中一条还保留一次传送机会，另一条已经把传送用掉，则它们未来的决策空间显然不同。正确的状态应扩展为 \((i,j,\mathrm{used})\) 或 \((i,j,\mathrm{fuel})\) 这类更完整的形式。只有在状态把“剩余资源、上一步动作、已使用预算、是否持仓”等会影响未来的因素都编码进去后，动态规划的剪枝才是安全的。

因此，动态规划处理“局部次优可能导向全局最优”的方式，不是保留所有看起来有潜力的路径，而是通过正确设计状态，使真正会影响未来的差异体现在不同状态上。同一状态内部只保留最优前缀；不同状态之间分别递推。动态规划的正确性，最终依赖的正是这一点：未来只依赖当前状态，而不依赖通向当前状态的完整历史。

若记 \(t\) 为阶段或时间步， \(s\) 为当前状态，一个非常典型的动态规划写法是：

这条式子表达的是：要得到“第 \(t\) 步处于状态 \(s\) 时的最优值”，不必重新枚举所有完整路径，而是只需查看所有能够转移到 \(s\) 的前驱状态 \(s'\)，并在它们已有的最优值基础上，加上这一步的局部得分，再从中取最大。

• \(\mathrm{DP}[t,s]\)：第 \(t\) 步、状态为 \(s\) 的最优子问题值。
• \(\mathrm{Prev}(s)\)：所有可以转移到状态 \(s\) 的前驱状态集合。
• \(\mathrm{score}(s',s,t)\)：从 \(s'\) 转移到 \(s\) 时，在第 \(t\) 步新增的局部得分或代价。
• \(\max\)：表示当前任务要找“最好的一条路径”。若任务目标是最小代价，则可改为 \(\min\)；若任务目标是把所有路径概率加总，则可改为 \(\sum\)。

边界条件通常写成：

其中 \(\mathrm{init}(s)\) 表示序列从状态 \(s\) 开始的初始代价或初始分数， \(\mathrm{local}(s,1)\) 表示第一步在该状态产生的局部贡献。没有这个起点，后续递推就无从展开。

动态规划真正带来的收益来自复杂度压缩。以一阶序列模型为例，若每一步有 \(|\mathcal{S}|\) 个候选状态、总长度为 \(T\)，暴力枚举往往需要考虑 \(|\mathcal{S}|^T\) 条完整路径；而若采用“时间步 + 当前状态”的动态规划状态定义，则通常只需在每个时间步枚举所有前驱状态，计算复杂度可以降为 \(O(T|\mathcal{S}|^2)\)。这种从指数级到多项式级的下降，正是动态规划在序列模型中不可替代的原因。

若任务不仅要求最优值，还要求恢复最优路径，则通常还会额外保存“当前最优值来自哪个前驱状态”的回溯信息（Backpointer）。这意味着动态规划不仅能回答“最优值是多少”，还能回答“这条最优路径具体怎么走”。

更重要的是，动态规划并不只对应一种运算。对于最优路径问题，递推中的核心运算往往是 \(\max\) 或 \(\min\)；对于总概率、配分函数这类问题，核心运算则是 \(\sum\)。这也是为什么 HMM 的维特比算法、前向算法，以及 CRF 的前向后向算法，虽然目标不同，但都属于动态规划。

在 HMM 中，动态规划最典型地体现在两类问题上。第一类是维特比算法（Viterbi Algorithm）：它要求“给定观测序列后，哪一条隐藏状态路径最可能”，因此递推中的核心运算是 \(\max\)。第二类是前向算法（Forward Algorithm）：它要求“所有隐藏状态路径合起来，总概率是多少”，因此递推中的核心运算是 \(\sum\)。两者使用的是同一张状态网格，只是“每一步如何聚合前驱信息”不同。

在 CRF 中，动态规划同样是核心计算工具。训练时，需要对所有可能标签路径做归一化，这对应配分函数（Partition Function）的计算；解码时，需要找得分最高的那条标签路径，这对应最优路径搜索。在线性链 CRF 中，这两件事都可以通过“时间步 + 当前标签”的动态规划状态来高效完成，否则若直接枚举所有标签序列，计算量会随序列长度呈指数增长。

因此，在机器学习语境里，动态规划可以概括为：把原本必须整体枚举的结构化问题，改写成一系列局部状态上的递推计算，并通过缓存中间结果把重复计算消掉。一旦看到“序列路径很多、局部决策可递推、同类子问题会重复出现”这三个信号，通常就应该优先考虑动态规划。

设字符串 \(A=a_1a_2\dots a_m\) 与 \(B=b_1b_2\dots b_n\)。编辑距离要回答的问题是：至少经过多少次插入、删除、替换，才能把 \(A\) 变成 \(B\)。若直接枚举所有编辑序列，可能性会指数增长；但若定义 \(\mathrm{DP}[i,j]\) 表示“把 \(A\) 的前 \(i\) 个字符变成 \(B\) 的前 \(j\) 个字符所需的最小编辑次数”，问题就能递推解决。

这里三项分别对应：删除 \(a_i\)、插入 \(b_j\)、或把 \(a_i\) 替换成 \(b_j\)（若本来相同，则替换代价为 0）。边界条件是 \(\mathrm{DP}[0,j]=j\)、\(\mathrm{DP}[i,0]=i\)，因为空串变成长度为 \(j\) 的串需要做 \(j\) 次插入，反之需要做 \(i\) 次删除。这个例子非常典型地体现了动态规划：状态是前缀长度，转移是三种编辑操作，目标是求最小总代价。

设一个 \(m\times n\) 网格，每个格子 \((i,j)\) 都有进入代价 \(w_{i,j}\)，只能向右或向下移动。问题是：从左上角走到右下角的最小总代价是多少。若定义 \(\mathrm{DP}[i,j]\) 表示“到达格子 \((i,j)\) 的最小总代价”，则递推很直接：

因为到达 \((i,j)\) 只有两种可能：从上方 \((i-1,j)\) 走下来，或从左侧 \((i,j-1)\) 走过来。边界条件是第一行与第一列只能沿单一路径累计。这个例子说明，动态规划并不局限于字符串或序列模型；只要问题具有“局部来源有限、全局目标可递推”的结构，就可以用同样的思路求解。

贪心算法（Greedy Algorithm）处理的是这样一类问题：希望快速构造一个全局可行解，并且每一步都只做当前看来最优的局部选择，而不回头修改已经作出的决定。它广泛出现在排序、调度、压缩、近似优化，以及许多机器学习训练与推断流程中。

贪心的核心假设是：当前最好的局部选择，能够导向全局最优，或至少导向足够好的近似解。它像走山路时每一步都先选眼前最高、最稳的落脚点，而不是先把整座山的所有路径都完全规划出来。贪心的优势是快、简单、容易实现；风险是局部最优未必等于全局最优。

若记第 \(t\) 步可选动作集合为 \(\mathcal{A}_t\)，一个抽象的贪心选择可写为：

这里 \(\mathrm{score}(a\mid \text{current state})\) 是当前状态下动作 \(a\) 的局部收益；\(\arg\max\) 表示从所有可选动作里挑出得分最高的那个。贪心算法关心的是“眼下哪一步最好”，而不是“未来所有步骤联合起来后哪条完整路径最好”。

因此，贪心方法是否正确，取决于问题本身是否满足贪心选择性质（Greedy-choice Property）。如果这个性质成立，局部最优就能拼成全局最优；如果不成立，贪心通常只能作为启发式方法或近似算法。

决策树训练就是一个典型例子。每个节点都不会提前规划整棵树的全局最优结构，而是只在当前节点上选择信息增益、基尼下降或误差下降最大的切分。这个过程本质上就是贪心：每一步都先把当前最值得切的地方切开。它训练快、解释性强，但也正因为是局部选择，单棵树通常不是全局最优树结构。

分治算法（Divide and Conquer）处理的是“大问题可以被拆成若干个同结构小问题”的场景。它广泛出现在排序、搜索、矩阵运算、索引构建，以及大规模数据处理与并行计算中。

分治的思想可以概括为三步：分解（Divide）— 递归求解（Conquer）— 合并（Combine）。它像整理一大堆文档时，先按主题拆成若干小堆，再分别处理，最后再合并成有序结果。与动态规划不同，分治更强调“子问题相互独立”，而不是“子问题结果需要反复复用”。

分治算法的时间复杂度常写成递推式：

这里 \(n\) 是问题规模；\(a\) 表示被拆成多少个子问题；\(n/b\) 是每个子问题的规模；\(f(n)\) 是“分解 + 合并”本身的额外代价。这个式子不告诉我们具体怎么做，但它准确描述了分治算法的结构骨架。

例如，归并排序（Merge Sort）把长度为 \(n\) 的数组分成两个规模约为 \(n/2\) 的子数组，递归排好序后再线性合并，因此它的复杂度递推就是 \(T(n)=2T(n/2)+O(n)\)。

在机器学习工程中，分治思想常见于大规模近邻索引构建。例如构建 kd-tree 时，算法会按某个维度把样本集递归切成两半，再在左右子集上继续构树。这样得到的层次化空间划分，能显著加速后续的近邻搜索。它的本质并不是“学习一个模型”，而是通过递归拆分把原本需要全表扫描的搜索过程组织得更高效。

许多软件与机器学习问题都可以抽象成图（Graph）：节点（Node）表示状态、样本、词、网页或知识实体，边（Edge）表示转移、相似性、依赖关系或可达关系。图搜索与最短路径算法要回答的问题是：如何从起点高效找到目标节点，或找到总代价最小的一条路径。

图搜索的核心是“沿着边扩展状态空间，但尽量避免无意义的重复探索”。无权图最短路径常用广度优先搜索（BFS），因为它按层扩展，第一次到达目标通常就是步数最少的路径；带非负权图常用 Dijkstra，因为它总是优先扩展当前总代价最小的候选节点。

带权最短路径算法里的基本更新步骤通常写成“松弛（Relaxation）”：

这里 \(\mathrm{dist}(u)\) 是当前已知从起点到节点 \(u\) 的最小代价， \(w(u,v)\) 是边 \(u\rightarrow v\) 的权重， \(\mathrm{dist}(u)+w(u,v)\) 则是“先到 \(u\) 再走到 \(v\)”这条新候选路径的总代价。若它比当前记录的 \(\mathrm{dist}(v)\) 更小，就更新。

这个式子看起来和动态规划很像，原因是二者都在做“由已知子结果递推新结果”。区别在于：图搜索更强调如何选择下一个要扩展的节点，以及如何在一般图结构中避免重复访问。

在语音识别、机器翻译和图搜索推断中，解码过程经常会把候选状态组织成图或格（Lattice）。此时，寻找最优输出序列本质上就是图上的路径搜索问题。很多动态规划解码器也可以从“图上最优路径”的角度理解，因此图搜索是连接通用软件算法与结构化机器学习推断的重要桥梁。

二分查找（Binary Search）处理的是“搜索空间有序，或可行性判断具有单调性”的问题。它不仅用于有序数组查找，也广泛用于阈值搜索、参数调优、数值逼近和工程系统中的边界定位。

二分查找的核心是：每次利用单调性砍掉一半搜索空间。它像猜数字游戏：如果知道答案一定在某个区间里，而且中点左侧和右侧满足不同性质，那么每问一次都能把候选范围减半。

若当前搜索区间为 \([l,r]\)，中点通常取：

接着依据单调判定函数 \(\mathrm{check}(\mathrm{mid})\) 缩小区间：

• 若 \(\mathrm{check}(\mathrm{mid})\) 为真，说明答案在左半边或恰好是中点，则令 \(r=\mathrm{mid}\)。
• 若为假，说明答案在右半边，则令 \(l=\mathrm{mid}+1\)。

算法正确性的关键不在于公式本身，而在于维护区间不变式（Invariant）：在每一步更新后，真正的答案仍然留在当前区间中。

在机器学习里，二分查找常用于阈值定位。例如，当需要找到“使召回率至少达到某个目标值的最小分类阈值”时，只要阈值越大召回率越低这一单调关系成立，就可以在阈值区间上做二分查找，而不必逐点穷举。类似地，很多数值求根、超参数边界搜索、分位数定位问题也都可写成二分框架。

随机采样（Random Sampling）处理的是这样一类问题：总体太大、精确计算太贵，或者目标本身就是概率性的，因此只能通过抽样近似整体行为。它是统计学习、蒙特卡洛估计、bootstrap、自助重采样、mini-batch 训练和负采样的共同基础。

随机采样的核心是：不必每次都看完整总体，而是通过足够有代表性的随机子样本估计总体性质。它像民意调查：不可能每天逐个询问所有人，但若抽样方式合理，少量样本也能给出相对稳定的总体估计。

若目标是估计随机变量 \(X\) 下某个函数 \(f(X)\) 的期望 \(\mathbb{E}[f(X)]\)，最常见的蒙特卡洛估计写为：

这里 \(x_i\sim p(x)\) 表示样本 \(x_i\) 是按分布 \(p(x)\) 随机抽到的； \(n\) 是样本数； \(\hat{\mu}\) 是用样本均值近似真实期望的估计量。样本越多，估计通常越稳定，但代价也越高。

这一思想在机器学习里非常普遍：SGD 不是每次都在全量数据上算梯度，而是用 mini-batch 的样本均值近似全数据梯度；negative sampling 不是对所有负类都求和，而是随机抽一小部分负样本近似完整目标。

bootstrap 是一个很典型的例子。随机森林训练时，会对原始训练集做有放回采样，得到多份不同的 bootstrap 子集，再分别训练多棵树。这里真正起作用的不是“树”本身，而是随机采样制造了多个略有差异的数据视角，从而让集成后的模型更稳。

机器学习基础概念（Machine Learning Foundations）回答四类核心问题：数据从哪里来、模型在学什么、模型为什么能泛化、结果该如何评价。把这些问题分开看，会比死记算法名称更有效：学习范式决定监督信号来自哪里，假设空间与归纳偏置决定模型愿意相信什么，数据集工程决定模型实际看到了什么，模型评估决定这些学习结果是否真的能迁移到未见样本。

这四个词描述的是同一条“训练=优化”的概念链，但位于不同层级。把层级理清后，公式与实现会自然对齐：模型 \(f_\theta\) 先给出预测，再用损失函数把预测变成数值误差，最后把误差在数据集上汇总成代价函数，并加入正则/约束得到最终的目标函数。

假设函数（Hypothesis Function）也常被直接称为模型（Model）或预测函数（Predictor），记作 \(f_\theta\)。它回答的问题是：给定输入 \(x\)，模型输出什么。参数 \(\theta\) 决定这条映射的具体形状。

线性回归（Linear Regression）的假设函数是最经典的例子：

目标函数（Objective Function）记作 \(J(\theta)\)，是优化器真正要优化的函数。工程上最常见、也最清晰的写法是：目标函数 = 代价函数 + 正则化项（没有正则化时可视为正则项为 0，因此 \(J(\theta)=L(\theta)\)）。

在线性回归里，若用 L2 正则（Ridge / Weight Decay），常见目标函数可以写成：

把 \(L(\theta)\) 展开后，就是：

代价函数/成本函数（Cost Function）记作 \(L(\theta)\)，通常指把样本损失在训练集上做平均或求和后的整体量，也就是经验风险（Empirical Risk）。不少教材会把它直接称为训练损失（training loss），并且在不引起歧义时把它与目标函数混用。

在线性回归里，常用“均方误差的平均”作为代价函数：

把 \(\ell_i(\theta)\) 取为平方误差后，等价写法是：

损失函数（Loss Function）记作 \(\ell\)，通常定义在单个样本上，把“预测与目标的差距”映射为一个标量。它回答的问题是：这一条样本我错了多少。

在线性回归里，最常见的单样本损失是平方误差：

同一份训练数据，之所以会被不同模型学出完全不同的规律，根源在于每个模型都自带一套“允许学什么、不允许学什么”的结构约束。假设空间（Hypothesis Space）、模型容量（Model Capacity）与归纳偏置（Inductive Bias）共同描述的，就是这套约束。

假设空间（Hypothesis Space）是模型可表达函数的集合，常记为 \(\mathcal{H}\)：

这里 \(f_\theta\) 是由参数 \(\theta\) 决定的预测函数， \(\Theta\) 是参数可取的范围。这个定义的关键不在于“参数有多少”，而在于模型最终允许出现哪些映射形状。例如，一元线性回归的假设空间只包含直线；二次多项式回归的假设空间包含抛物线；深度神经网络的假设空间则更大，能表示复杂得多的非线性函数。

因此，训练并不是在所有可能函数中盲目搜索，而是在某个特定假设空间里找一个最合适的函数。假设空间太小，真实规律可能根本装不进去；假设空间太大，模型又容易把偶然噪声也解释成模式。

模型容量（Model Capacity）描述的是假设空间的表达能力有多强，也就是模型能拟合多复杂规律。容量高，不代表一定更好；它只表示模型“有能力”表示复杂函数。是否真的学得好，还取决于数据量、正则化、优化过程和任务本身。

容量可以从多个角度理解。参数更多通常意味着容量更高，但这不是唯一标准；树的深度、核方法的核函数形式、特征维度、网络层数、隐藏维度、注意力头数，都会改变容量。工程上常用一个朴素判断：如果模型连训练集主要结构都拟合不了，容量偏低；如果训练集几乎完美、验证集却明显变差，容量往往偏高或约束不足。

容量与复杂度控制始终是一组平衡。表格数据上的浅层树模型可能已经足够；图像、语音、自然语言这类高度复杂任务，则通常需要更高容量的模型族。容量本身不是缺点，关键在于它是否与数据规模和任务难度匹配。

欠容量（Undercapacity）指模型或可训练适配器的表达能力不足，无法为当前任务提供足够大的可行函数空间。它讨论的是模型有没有能力表示这类规律，因此属于成因层概念。

这和欠拟合不同。欠拟合是结果层现象，表示当前训练结果不够好；欠容量只是欠拟合的一种常见原因。一个模型可能因为容量太小而欠拟合，也可能因为学习率不对、训练步数不足、输入被截断、特征表达差而欠拟合。反过来，一个高容量模型如果训练明显不充分，也会暂时呈现欠拟合外观。

工程上判断欠容量，常见信号包括：训练 loss 长期降不下去；训练集指标存在明显硬上限；增大模型尺寸、隐藏维度、树深、LoRA rank 或可训练模块后，训练集和验证集一起改善。若这些现象同时出现，就更像是表达能力本身不够，而不是单纯还没训练够。

归纳偏置（Inductive Bias）是模型在有限样本下从已见数据推广到未见数据时，默认采用的结构性偏好。只靠训练集上有限个点，无法唯一确定整个输入空间上的函数；模型之所以还能做出泛化判断，是因为它隐含地偏好某些解释，而排斥另一些解释。

把学习目标写成经验风险最小化时，这一点会更清楚：

这里 \(\hat R_n(f)\) 是经验风险（Empirical Risk），表示函数 \(f\) 在训练集上的平均损失； \(\hat f\) 是最终选出的模型。关键约束正是 \(f\in\mathcal{H}\)：优化并不是在所有可能函数中找最优解，而是在一个被模型结构预先限制过的空间里找解。这个限制本身就是归纳偏置。

归纳偏置的来源很多。线性模型偏好线性关系；KNN（K-Nearest Neighbors）偏好局部相似样本给出相似输出；卷积神经网络（CNN）偏好局部连接与平移等变（Translation Equivariance）；树模型偏好分段常数的轴对齐切分；Transformer 则偏好通过注意力在 token 之间建立可变依赖。正则化、数据增强、参数共享、预训练初始化、优化器的更新轨迹，也都会进一步塑造模型的归纳偏置。

在统计学习（Statistical Learning）里，训练目标可以从三个层次来理解：期望风险（Expected Risk）描述模型在真实数据分布上的平均误差；经验风险（Empirical Risk）描述模型在有限训练集上的平均误差；结构风险（Structural Risk）则在经验风险之外，把模型复杂度一并纳入考虑。三者回答的是同一个问题的不同版本：模型到底应该怎样才算“学得好”。

期望风险也常被称为真实风险（True Risk）或总体风险（Population Risk）。若真实数据来自未知分布 \(P(X,Y)\)，模型为 \(f\)，单样本损失为 \(\ell(f(x),y)\)，则期望风险定义为：

这条式子的含义很直接：把模型放到所有可能出现的真实样本上，计算平均损失。理论上，这才是机器学习真正想最小化的对象，因为泛化能力最终取决于模型在未知数据上的表现，而不是只取决于训练集上的表现。

困难在于，真实分布 \(P(X,Y)\) 并不可见。训练时手里只有有限样本，而没有“全体可能数据”的上帝视角。因此，期望风险通常不能被直接计算，只能被估计。

经验风险是用训练集对期望风险做出的现实近似。设训练集为 \(\mathcal{D}=\{(x_i,y_i)\}_{i=1}^{n}\)，则经验风险定义为：

它就是模型在当前这批已观测样本上的平均损失。工程上常见的 training loss，本质上反映的正是经验风险，或它的 mini-batch 近似。经验风险最小化（Empirical Risk Minimization, ERM）的训练逻辑也很朴素：既然期望风险不可直接计算，就先把训练集上的平均损失压低。

ERM 的关键前提是：训练集足够代表真实分布。当样本数量增加且采样足够合理时，经验风险通常会更接近期望风险；但在有限样本条件下，两者并不相等。二者之间的差距，本质上就是泛化误差（Generalization Gap）的来源。若模型只是把训练集中的偶然模式、局部噪声和标注误差也一并记住，那么 \(\hat R_n(f)\) 可以很低，而 \(R(f)\) 仍然很高，这正是过拟合（Overfitting）的典型形式。

结构风险（Structural Risk）是在经验风险之外，再把模型复杂度或假设空间规模纳入考虑的目标。它对应的思想是结构风险最小化（Structural Risk Minimization, SRM）：模型不仅要在训练集上拟合得好，还要避免复杂到足以随意记忆有限样本。

在统计学习理论的严格表述中，SRM 常写成在一族嵌套假设空间之间做选择；在工程实践里，它更常以“经验风险 + 复杂度惩罚”的形式出现，例如：

这里 \(\Omega(f)\) 是复杂度项（Complexity Penalty）， \(\lambda\) 控制数据拟合与复杂度约束之间的权衡。L2 正则化（L2 Regularization）、L1 正则化（L1 Regularization）、Weight Decay、早停（Early Stopping）以及对模型深度、宽度和树复杂度的限制，都可以看作结构风险最小化思想的具体实现。

因此，结构风险并不是对经验风险的否定，而是对 ERM 的补充：在有限样本条件下，仅仅把训练误差压到最低，并不能保证模型在真实分布上表现最好。模型必须同时控制复杂度，才能让“训练集上学到的规律”更有机会迁移到未见样本。

这三者共同构成了机器学习里最基本的张力。期望风险是理论上真正想优化的目标，但它不可直接见；经验风险是训练时可观测、可优化的替代量；结构风险则提醒我们，有限样本下不能把“训练集表现更好”直接等同于“真实世界表现更好”。换句话说，监督学习不仅是在找一个拟合训练集的函数，更是在有限数据和有限模型约束下，寻找一个最可能泛化的解释。

从这里继续往下，就会自然出现另一个问题：如果高维真实数据本身就带有强结构约束，那么经验风险为何常能在有限样本下逼近期望风险，模型又为何能够泛化到未见样本？流形假设（Manifold Hypothesis）正是对这个问题的一条几何回答：真实数据并不会任意填满整个高维空间，而是集中在某个低维、连续、受约束的结构附近。

流形假设（Manifold Hypothesis）给出了现代机器学习里一条极其重要的几何直觉：现实世界中有意义的数据，虽然表面上嵌在极高维空间里，但真正有效的变化自由度通常远低于表观维度。也就是说，高维观测往往不是填满整个空间，而是集中分布在一个低维流形（Low-dimensional Manifold）附近。

图像是最容易理解的例子。一个 \(1024\times 1024\) 的 RGB 图像在像素空间中维度极高，但自然图像并不会均匀占据这个巨大空间：物体形状、光照条件、视角变化、相机成像规律与纹理结构都受到强约束。因此，“像真实猫照片”的图像实际上只落在高维像素空间中的极小区域里。文本也类似。一个长度为 \(T\) 的 token 序列组合数极其巨大，但真正同时符合语法、语义和任务约束的文本，只占离散组合空间中很小的一部分。模型之所以能够泛化，一个重要原因正是：它并不需要学会覆盖整个高维空间，而只需要学会沿着这些低维结构建模。

流形（Manifold）首先是一个几何对象。它的关键性质不是“弯不弯”，而是局部上看起来像普通的低维欧几里得空间，整体上却可以弯曲、卷曲并嵌入到更高维空间中。更正式地说，若一个集合对其上每一点，都存在一个足够小的邻域，可以用 \(\mathbb{R}^d\) 中的局部坐标平滑描述，那么这个集合就可以看作一个 \(d\) 维流形。

地球表面是最直观的例子。站在操场或街道上时，局部地面几乎是平的，可以用二维坐标定位；但从整体看，地球表面显然不是二维平面，而是嵌入三维空间中的弯曲曲面。因此，地球表面就是一个嵌在三维空间里的二维流形。对只能沿地面运动的观察者而言，真正相关的不是三维空间全部坐标，而是地表上那两个局部自由度。

机器学习教材里常见的瑞士卷（Swiss Roll）把这个概念进一步可视化。可以先想象一张二维纸，再把它卷进三维空间。卷起来之后，样本点在外部看来落在三维空间里，但沿着纸面定位某一点时，真正需要的仍然只是二维坐标。外在维度变高了，内在结构却没有变。这正是流形概念在机器学习里最重要的几何直觉：数据的表观维度可以很高，但它的内在维度却可能很低。

这类卷曲结构还带来另一个机器学习里非常关键的后果：嵌入空间中的欧氏距离（Euclidean Distance）与流形上的测地距离（Geodesic Distance）并不一定一致。两点在外部空间里看起来可能很近，因为一条直线可以直接“穿过空气”连接它们；但若真实数据只能沿流形本身变化，那么真正相关的距离应当是沿曲面或曲线走过去的那条路径长度。流形学习（Manifold Learning）之所以强调邻域图、测地近似和局部结构，正是因为外部直线距离经常不能反映数据在内在结构上的真实远近关系。

放到高维数据上，这个判断尤其关键。一张 \(1000\times1000\) 的灰度图像在像素空间里有一百万维，但“真实人脸图像”显然不会填满整个一百万维空间。姿态、光照、表情、年龄、拍摄距离等因素彼此耦合，使真实样本只落在高维像素空间中一个极薄、极小、受连续约束的区域附近。文本也是同样的逻辑：虽然 token 组合空间极其巨大，但真正同时满足语法、语义、上下文与任务约束的句子，只会沿着某种低维结构变化，而不会任意填满整个离散组合空间。

因此，在机器学习语境中谈流形，真正想表达的并不是完整搬运微分几何的全部形式系统，而是一个更直接的判断：有意义的数据并不会随机散落在高维空间中，而是集中在某个低维、连续、受约束的结构附近。后面关于自由度、主成分、隐空间、低维近似以及 LoRA 任务子空间的讨论，都是围绕这个判断展开的不同形式化视角。

沿着前面“表观维度高、内在结构低”的判断继续往下走，就会自然落到自由度（Degrees of Freedom）这个概念上。表观维度说的是“数据在形式上有多少个坐标轴”；自由度说的是“这些数据实际上有多少种彼此独立的有效变化方式”。二者并不相同。一个对象可以嵌在极高维空间里，但真正能变化的自由度却很少。

例如，一张脸部图片在像素空间里有数百万维，但很多像素并不能独立随意变化：头部转向、光照强弱、表情变化、年龄纹理、拍摄距离这些因素彼此耦合，共同决定了大部分像素的联动变化。因此，“一张脸”看起来是高维数组，真正支配它变化的自由度却远小于像素总数。文本也一样。句子表面上由许多 token 组成，但语法结构、主题、语气、说话者意图与上下文约束，使它不可能在每个位置上完全独立自由地变化。

这也是流形假设真正重要的地方：它不是抽象地说“数据在低维流形上”，而是在说有效自由度远少于表观维度。一旦把这层理解清楚，后面关于主成分、隐空间、隐主题、低秩近似乃至 LoRA 的很多思想都会变得顺理成章，因为它们都在试图用更少的自由度，去抓住决定数据或参数变化的核心结构。

一旦接受了“高维数据实际靠近低维结构”这一点，后面许多术语就会自然连起来。主成分（Principal Components）强调几何视角：在一组高维数据里，哪些方向承载了最主要的变化。隐空间（Latent Space）强调表示视角：把原始高维观测压缩到一个更低维、但仍保留关键信息的内部空间。隐主题（Latent Topics）则更偏语义视角：在文本与文档分解里，低维方向常常可以被解释为若干潜在语义因素，例如“体育”“金融”“法律”这类人类能命名的主题轴。

这三个词并不完全同义，但常常指向同一个底层事实：高维观测可以通过少数主导方向或潜在因子来近似描述。主成分更强调方差最大的坐标轴；隐空间更强调模型内部那间低维“房间”；隐主题则是在某些任务里，对这些低维方向做出的语义解释。它们分别对应几何、表示与语义三种语言，但共享同一条低维结构主线。

PCA（Principal Component Analysis）是这条思路最经典、也最直接的算法形式。它在无监督条件下寻找方差最大的几个方向，并把数据投影到这些方向张成的低维子空间中。若数据矩阵为 \(X\)，PCA 本质上是在找一个低维线性子空间，使投影后的重建误差尽量小。在线性代数上，这与奇异值分解（SVD）直接对应：保留最大的前 \(r\) 个奇异值及其奇异向量，就得到最佳的 rank-\(r\) 近似。

这类思想并不只存在于经典降维里。自动编码器（Autoencoder）通过瓶颈层学习隐空间；潜在语义分析（Latent Semantic Analysis, LSA）和主题模型在文档-词矩阵里抽取潜在主题；词向量、句向量与深度表示模型把高维离散符号压缩到稠密向量空间。它们的目标函数和可解释性不同，但都默认：原始高维观测背后存在一个更低维、更有结构的变化空间。

LoRA（Low-Rank Adaptation）通过把参数更新 \(\Delta W\) 限制在一个低秩子空间中，实现对大模型的参数高效微调（PEFT）。它的核心做法不是直接改写原始权重矩阵的全部自由度，而是把更新写成两个低秩矩阵的乘积：

LoRA 应放在“低维结构”这条主线上理解，但不能把它与 PCA 直接等同。它的核心不是对输入数据做主成分分析，而是对模型参数更新施加低秩约束。

这个约束的含义是：模型不能在完整高维参数空间中任意改动，而只能在一个 rank-\(r\) 的低维更新子空间里移动。从思想上看，它确实与“只保留主导方向”高度相似；若事后对某个全量更新矩阵做 SVD，最佳低秩近似也会只保留最主要的奇异方向。但 LoRA 学到的并不是传统 PCA 意义上“数据方差最大”的主成分，而是对当前任务损失下降最有用的低维更新方向。前者是无监督的统计主轴，后者是由反向传播和任务目标共同决定的优化子空间。

因此，把 LoRA 理解为“逼迫模型只在少数主导方向上修改参数”是成立的；但这些方向更准确地说是任务相关的低维适配方向，而不是直接等同于原始数据的 PCA 主成分。也正因为如此，LoRA 与内在维度（Intrinsic Dimension）讨论天然相连：如果一个下游任务真正需要修改的有效自由度本来就不高，那么让模型只在一个低秩子空间里更新，不仅不会显著损失性能，反而会自动抑制大量无意义的噪声方向。

这里先按监督信号来源划分学习范式。监督学习（Supervised Learning）、无监督学习（Unsupervised Learning）、自监督学习（Self-supervised Learning）和强化学习（Reinforcement Learning）回答的是同一个问题：模型训练时的监督信号究竟来自哪里。它们属于同一分类标准，因此可以并列讨论。

监督学习（Supervised Learning）使用带标签的数据对 \((x,y)\) 训练模型：输入 \(x\) 是特征（Feature），输出 \(y\) 是目标或标签（Label）。模型学习的不是“记住答案”，而是学习一个映射 \(f_\theta:x\to y\)，使它对新样本也能给出合理预测。

但“学一个映射”还不够，训练时还必须回答另一个更具体的问题：怎样才算模型学得好。监督学习里最常见的回答，是在训练集上逐个比较预测与真实标签的差距，再把这些差距汇总成一个总体目标；这就导向经验风险最小化（Empirical Risk Minimization, ERM）。

经验风险最小化的典型目标写成：

这里 \(N\) 是样本数， \(f_\theta(x_i)\) 是模型预测， \(y_i\) 是真实标签， \(\ell\) 是损失函数（Loss Function）。这条式子的含义不是抽象求和，而是：逐个样本计算“预测错了多少”，再取平均，把平均错误压到尽可能小。

例：垃圾邮件分类里， \(x\) 可以是邮件文本特征， \(y\in\{0,1\}\) 表示“正常/垃圾”；房价预测里， \(x\) 可以是面积、地段、楼龄， \(y\) 是价格。前者是分类（Classification），后者是回归（Regression），但“有标签地学映射、再用损失函数衡量误差”这一训练逻辑完全一致。

分类任务（Classification）要预测的是离散类别，也就是样本属于哪一类。输出可以是一个类别 id，也可以是一组类别概率。例如二分类里常见输出 \(P(y=1|x)\)，表示“给定特征 \(x\) 时，样本属于正类的概率”。

垃圾邮件识别、肿瘤良恶性判断、情感分析、图像里的猫狗识别都属于分类任务。它更像“做选择题”：模型最终要在有限候选里做判断。训练时常配合交叉熵（Cross-Entropy）这类损失，因为模型不仅要选对类别，还要给正确类别足够高的置信度。

回归任务（Regression）要预测的是连续数值，也就是标签不是几个固定类别，而是在某个数值区间内连续变化。输出通常直接是一个实数，或一个多维连续向量。

房价预测、销量预测、温度预测、广告点击率中的停留时长估计都属于回归任务。它更像“做填空题”：模型不能只说“高”或“低”，而必须给出具体数值。训练时常配合均方误差（MSE）或平均绝对误差（MAE），因为关心的是预测值与真实值到底差了多少。

分类与回归都属于监督学习，因为它们都有标签；真正的区别在于标签空间的形状：分类的标签空间是离散集合，回归的标签空间是连续区间。这个区别会直接决定模型输出层形式、损失函数选择以及评估指标。

弱监督学习（Weakly Supervised Learning）仍然使用标签信号训练模型，但这些标签并不像标准监督学习那样完整、精确且逐样本对齐。它处理的核心情形是：标签存在，但监督结构不够理想，例如标签只存在于更粗粒度层面、标签本身含噪，或只有部分样本带标签。

从概念上看，弱监督并不是单一算法，而是一组监督不完备情形的总称。常见形式包括：标签不完整（incomplete supervision），即只有部分样本带标签；标签不精确（inexact supervision），即标签附着在聚合层级而不是实例层级；标签不准确（inaccurate supervision），即标签本身带噪或来自启发式规则、远程监督（Distant Supervision）与弱标注器。它与标准监督学习的边界在于：监督信号依然存在，但标签质量、粒度或覆盖度不足以直接当作“干净答案册”。

多实例学习（Multi-Instance Learning, MIL）是弱监督学习中的一个经典范式。它的关键设定是：标签不附着在单个实例（instance）上，而是附着在一个由多个实例组成的包（bag）上。设训练集由若干包 \(\{B_1,B_2,\dots,B_n\}\) 构成，其中第 \(i\) 个包可写成

这里 \(x_{ij}\) 是包内第 \(j\) 个实例， \(m_i\) 是该包包含的实例数， \(y_i\) 是包级标签。训练时只知道整个包的标签，不知道每个实例自己的标签。

MIL 最经典的标准假设（Standard MI Assumption）是：正包中至少存在一个正实例，负包中所有实例都为负。写成逻辑形式就是：

其中 \(z_{ij}\) 表示实例级未知标签。这个设定特别适合两类问题：第一，真正决定结果的证据只稀疏地存在于少数关键实例中，其余实例更像背景或噪声；第二，获取实例级标签成本高，只能拿到更粗粒度的聚合标签。

因此，MIL 的关键不只是“把很多实例放在一起”，而是要学习一条从实例集合到包级判断的聚合规则。早期方法常用最大池化、均值池化或手工设计的聚合函数；深度学习阶段则更常引入可学习聚合，例如注意力式 MIL（Attention-based MIL），用可训练权重自动决定哪些实例对最终包标签贡献更大。这使 MIL 不只具有表达能力，也更容易给出“模型主要关注了哪些实例”的解释线索。

MIL 的适用性可以用一个抽象例子来理解。若一条完整客服对话被视作一个包，其中每轮发言是实例，而整体满意度评分是包级标签，那么模型面对的就是“整体有标签、逐轮无标签”的典型结构。此时，MIL 的任务不是给每轮发言都强行分配人工标签，而是在只有整体评分的前提下，学习哪些局部发言更可能决定整段会话的最终判断。

无监督学习（Unsupervised Learning）只有输入 \(x\)，没有人工标签 \(y\)。它的目标不是拟合“标准答案”，而是从数据中发现结构（Structure），例如聚类（Clustering）、降维（Dimensionality Reduction）、密度估计（Density Estimation）与异常检测（Anomaly Detection）。

一个直观类比是：监督学习像“拿着答案册做题”，无监督学习像“没有答案册，只能自己把一堆材料按相似性归类”。例如电商用户没有现成“用户类型”标签，但可以根据浏览、购买、停留时间等行为聚成“价格敏感型”“冲动购买型”“高价值复购型”等群体，用于运营分层。

从任务形态上看，无监督学习通常沿三条主线展开。第一条是聚类分析，目标是把样本按几何接近性、密度连通性、层次结构或图上的社区结构自动分组，典型方法包括 K-Means、层次聚类、DBSCAN、HDBSCAN，以及基于图的 Leiden / Louvain；第二条是概率密度估计，目标是刻画数据在哪些区域更常出现，从而支持异常检测、生成建模与风险评分，常见路线包括 GMM、核密度估计、One-Class SVM，以及更现代的自编码器（Autoencoder, AE）、受限玻尔兹曼机（RBM）和对抗式路线；第三条是可视化与降维，目标是在压缩表示的同时尽量保留关键结构，典型方法包括 PCA、t-SNE 与 UMAP。

这三条路线并不是彼此割裂的。聚类往往依赖一个合适的低维表示；异常检测常常等价于“找低密度区域”；可视化又经常被用来检查聚类是否真的形成结构、异常样本是否落在边缘地带。因此无监督学习并不只是“没有标签时随便看看数据”，而是在没有人工答案的条件下，用几何、密度与表示结构去重建数据内部秩序。

自监督学习（Self-supervised Learning）介于监督与无监督之间：原始数据没有人工标签，但任务标签可以由数据本身自动构造出来。核心思想是从数据内部制造预测任务，让模型在完成这些任务的过程中学到可迁移表示（Representation）。

语言模型的下一个 token 预测就是最典型的自监督任务：前文是输入，后一个 token 是由原始文本自动给出的“监督信号”。图像领域里，旋转预测、遮挡恢复、不同增强视角匹配也属于同一路线。

掩码预测（Masked Prediction）把输入中的一部分信息故意遮住，再要求模型恢复。例如 BERT 会把句子中的部分 token 替换成特殊标记 \([MASK]\)，模型要根据上下文预测被遮住的词。

类比来看，这像完形填空：你不是死记整句，而是学会根据上下文推断缺失信息。它迫使模型同时利用左侧和右侧上下文，因此特别适合编码器（Encoder）型表示学习。

半监督学习（Semi-supervised Learning）位于监督学习与无监督学习之间：一小部分样本带标签，大量样本没有标签。它关心的核心问题是：如何利用未标注数据提供的结构信息，帮助少量标签发挥更大监督作用。与弱监督相比，半监督更强调“标签覆盖不足”，而不一定意味着标签本身粗糙或带噪。

经典路线包括 Self-Training、Co-Training、半监督 SVM、生成式方法和图半监督学习。Self-Training 会先用当前模型给未标注样本打伪标签，再把高置信样本并回训练集；Co-Training 要求样本存在两个相对独立但互补的视角，让两个模型彼此教对方；半监督 SVM 试图在利用标签的同时，把决策边界推向低密度区域；图半监督学习则利用样本相似图把少量标签沿图结构传播到邻近无标签样本。

主动学习（Active Learning）经常和半监督一起出现，但它的关注点略有不同：主动学习不是直接利用无标签样本训练，而是选择最值得标注的样本去获取人工标签。从数据效率角度看，半监督学习在“少标签 + 多无标签”条件下尤其重要，而主动学习解决的是“有限标注预算该花在哪些样本上”。

强化学习（Reinforcement Learning, RL）研究的是：智能体（Agent）在环境（Environment）中持续交互，根据奖励（Reward）学习策略（Policy），使长期累计回报（Cumulative Return）尽可能大。它关心的不是“单个输入该预测什么标签”，而是一串连续动作最终能否带来更高的长期收益。

强化学习的基本循环可以概括为：在时刻 \(t\)，智能体观察状态 \(s_t\)，选择动作 \(a_t\)，环境转移到新状态 \(s_{t+1}\)，并返回奖励 \(r_{t+1}\)。策略记为 \(\pi(a\mid s)\)，它回答的是“在当前状态下，动作应该怎样选”。

很多任务里，奖励并不会在正确动作发生的那一刻立刻显现。下棋时，一步好棋可能要十几步后才体现价值；推荐系统里，一次推荐是否合理，也要看后续点击、停留和转化。因此强化学习优化的不是单步得分，而是长期回报：

这里 \(\gamma\in[0,1)\) 是折扣因子（Discount Factor）。\(\gamma\) 越接近 1，策略越重视长期收益；越小，策略越偏向短期收益。这个目标函数的含义很直接：在所有可能的策略中，找到那个平均下来总分最高的行为规则。

监督学习通常基于带标签样本 \((x,y)\) 训练静态映射 \(x\mapsto y\)；强化学习面对的是动态环境中的序贯决策。监督学习收到的是“正确答案应当是什么”的指导性反馈，强化学习收到的是“这一步或这条轨迹好不好”的评估性反馈。前者的误差归因通常较直接，后者则需要把最终回报回溯到一串历史动作，这就是时间信用分配（Temporal Credit Assignment）的难点来源。

因此，强化学习的训练数据也不是静态不变的。当前策略会决定智能体之后访问哪些状态，于是数据分布本身会随着策略更新而改变。这一点使强化学习同时面对建模问题、探索问题和训练稳定性问题。

强化学习的标准数学框架是马尔可夫决策过程（Markov Decision Process, MDP）。一个 MDP 通常写成五元组 \((\mathcal{S},\mathcal{A},P,R,\gamma)\)，其中 \(\mathcal{S}\) 是状态空间， \(\mathcal{A}\) 是动作空间， \(P(s'|s,a)\) 是状态转移概率， \(R(s,a)\) 或 \(R(s,a,s')\) 是奖励函数， \(\gamma\) 是折扣因子。

“马尔可夫”这个词的核心含义是：如果当前状态已经把决策所需的信息概括完整，那么未来只取决于当前状态和当前动作。它并不要求系统真的没有历史，而是要求当前状态已经足够代表历史中与决策相关的部分。

强化学习里最重要的两个量是状态价值函数（State-value Function）和动作价值函数（Action-value Function）：

\(V^\pi(s)\) 描述“在状态 \(s\) 下，按策略 \(\pi\) 继续行动，长期回报大约是多少”；\(Q^\pi(s,a)\) 则更进一步，描述“在状态 \(s\) 下先做动作 \(a\)，再按策略 \(\pi\) 继续行动，长期回报大约是多少”。

Bellman 方程（Bellman Equation）把“长期回报”写成“即时奖励 + 下一步价值”的递归形式。对固定策略 \(\pi\)，状态价值满足：

这条式子的直觉非常重要：一个状态值多少钱，不需要把未来整条轨迹一口气全部展开，只要看“这一步先拿到多少，再加上下一状态值多少钱”。这就是动态规划思想在强化学习中的核心落点。

若目标是最优控制，则最优动作价值函数满足 Bellman 最优方程：

它表达的是：当前动作的最优价值，等于这一步的即时奖励，加上下一状态里最佳后续选择的折扣价值。价值型方法、时序差分学习（Temporal-Difference Learning, TD）以及 Q-Learning，都是围绕这个递归结构展开的。

价值型方法（Value-Based Methods）先估计“某个状态或状态-动作对值多少钱”，再根据价值做决策。最经典的做法是 Q-Learning。它不直接记住“这一步该做什么”，而是维护一个动作价值估计 \(Q(s,a)\)，让模型逐步学会哪些动作长期更划算。

Q-Learning 的标准更新写成：

这里 \(r+\gamma\max_{a'}Q(s',a')\) 是新的目标值（TD target），它把“这一步拿到的即时奖励”和“下一步开始最好还能拿到多少”拼接在一起；括号里的整体差值是 TD 误差（TD error），表示旧估计和新观察之间的偏差。Q-Learning 每见到一次新的转移样本，就用它修正一次账本。

当状态空间很小，例如离散网格迷宫，价值可以直接存成 Q 表；当状态变成图像、传感器序列或高维特征时，就需要用神经网络近似 \(Q(s,a)\)，这就是 DQN（Deep Q-Network）。它没有改变基本思想，只是把“查表记账”升级成“让网络来估值”。

SARSA（State-Action-Reward-State-Action）则代表另一种重要的 on-policy 时序差分路线。它把 Q-Learning 中的 \(\max_{a'}Q(s',a')\) 替换成策略实际下一步会采取的动作 \(a'\)，因此更新式写成

这一区别意味着：Q-Learning 更像“按最优后续动作记账”，SARSA 更像“按当前策略真实会怎么走来记账”。前者更激进，后者更保守；理解这一区别，有助于看清 on-policy 与 off-policy 方法的核心分野。

策略型方法（Policy-Based Methods）不先学一个价值表，而是直接参数化策略 \(\pi_\theta(a\mid s)\)。给定状态，模型直接输出动作概率分布或连续控制参数，再通过优化把高回报动作的概率提高、低回报动作的概率压低。它尤其适合连续动作空间，因为这类问题往往很难穷举所有动作再逐个估值。

策略梯度（Policy Gradient）的基本形式是：

它的含义可以概括成一句话：最终效果好的动作，以后更常做；最终效果差的动作，以后更少做。问题在于，直接用 \(G_t\) 更新通常方差很大，训练容易抖动。

于是就出现了 Actor-Critic。Actor 负责输出策略，也就是“怎么行动”；Critic 负责评估当前状态或动作值，也就是“这一步大概值多少”。Critic 提供更稳定的基线或优势估计，Actor 再沿着这个更平滑的信号更新策略。这样做的结果是：策略更新方向仍然由回报决定，但梯度噪声显著更可控。

PPO（Proximal Policy Optimization）可以看作一种工程上非常成功的 Actor-Critic 变体。它的核心思想不是改变优化方向，而是给策略更新加护栏，限制新旧策略之间的偏移幅度，避免一步改得过猛导致训练失稳。因此，PPO 在机器人控制、游戏智能体和大模型对齐里都很常见。

强化学习始终要面对探索与利用（Exploration vs. Exploitation）的权衡。利用意味着优先选择当前已知回报较高的动作；探索意味着尝试那些暂时不确定、但可能更优的动作。只利用，策略可能很快卡在局部最优；只探索，又会浪费大量样本在明显不好的选择上。

这个矛盾在强化学习里是结构性的，因为策略会影响后续看到的数据。常见做法包括 \(\epsilon\)-greedy、熵正则化（Entropy Regularization）、Boltzmann exploration、上置信界（UCB）等。它们形式不同，但共同目标一致：既让模型敢于试错，又不至于长期停留在无意义的随机行动里。

另一条常见划分标准是 model-based 与 model-free。二者的区别不在于是否使用神经网络，而在于是否显式学习或利用环境动力学。

价值型方法如 Q-Learning、DQN，策略型方法如 REINFORCE、PPO，多数都属于 model-free 路线；若先学习一个世界模型（World Model）或已知环境转移，再基于模型做搜索和规划，则属于 model-based 路线。实际系统也常把两者混合使用。