这一篇处理模型之外的系统层问题，包括上下文工程、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"在技术上是同一套系统提示和工具集，区别仅在于初始用户提示不同——这是一种提示策略，而非架构分离。

这种设计的关键，不是简单多了一个 shell 脚本，而是把“如何把项目跑起来”从高 token 成本的推断问题，转成低成本、可重复、可审计的脚本执行问题。后续每个 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 与大语言模型。

这一节处理的核心问题是：当面对搜索、更新、统计、调度、最短路径、依赖分析或训练流水线等任务时，数据应该怎样组织，操作应该怎样执行，才能既正确又高效。数据结构（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）描述的是假设空间的表达能力有多强，也就是模型能拟合多复杂规律。容量高，不代表一定更好；它只表示模型“有能力”表示复杂函数。是否真的学得好，还取决于数据量、正则化、优化过程和任务本身。

容量可以从多个角度理解。参数更多通常意味着容量更高，但这不是唯一标准；树的深度、核方法的核函数形式、特征维度、网络层数、隐藏维度、注意力头数，都会改变容量。工程上常用一个朴素判断：如果模型连训练集主要结构都拟合不了，容量偏低；如果训练集几乎完美、验证集却明显变差，容量往往偏高或约束不足。

容量与复杂度控制始终是一组平衡。表格数据上的浅层树模型可能已经足够；图像、语音、自然语言这类高度复杂任务，则通常需要更高容量的模型族。容量本身不是缺点，关键在于它是否与数据规模和任务难度匹配。

归纳偏置（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）。

一个直观类比是：监督学习像“拿着答案册做题”，无监督学习像“没有答案册，只能自己把一堆材料按相似性归类”。例如电商用户没有现成“用户类型”标签，但可以根据浏览、购买、停留时间等行为聚成“价格敏感型”“冲动购买型”“高价值复购型”等群体，用于运营分层。

自监督学习（Self-supervised Learning）介于监督与无监督之间：原始数据没有人工标签，但任务标签可以由数据本身自动构造出来。核心思想是从数据内部制造预测任务，让模型在完成这些任务的过程中学到可迁移表示（Representation）。

语言模型的下一个 token 预测就是最典型的自监督任务：前文是输入，后一个 token 是由原始文本自动给出的“监督信号”。图像领域里，旋转预测、遮挡恢复、不同增强视角匹配也属于同一路线。

掩码预测（Masked Prediction）把输入中的一部分信息故意遮住，再要求模型恢复。例如 BERT 会把句子中的部分 token 替换成特殊标记 \([MASK]\)，模型要根据上下文预测被遮住的词。

类比来看，这像完形填空：你不是死记整句，而是学会根据上下文推断缺失信息。它迫使模型同时利用左侧和右侧上下文，因此特别适合编码器（Encoder）型表示学习。

强化学习（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）。它没有改变基本思想，只是把“查表记账”升级成“让网络来估值”。

策略型方法（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 路线。实际系统也常把两者混合使用。

大模型时代出现的 RLHF、PPO-based alignment、GRPO 等方法，属于强化学习思想在语言模型上的应用层。它们沿用的仍然是策略、奖励、回报、优势函数和策略优化这些通用概念，只是把环境替换成“基于 prompt、回答和偏好反馈构成的交互过程”。因此，理解通用强化学习基础之后，再进入后文的强化学习对齐，会更容易看清哪些是 RL 本体，哪些是大模型场景下的特化设计。

统计学习（Statistical Learning）强调从数据由某种概率机制生成这一视角理解机器学习。前面的概率论与统计已经介绍了概率、似然、MLE、MAP、边缘化与随机过程；这里不重复纯数学定义，而是把这些概念收束成机器学习里的几条主线：模型究竟在建模什么分布，隐藏变量怎样进入问题，推断为什么会变难，以及“相关”与“因果”为什么不是同一件事。

从统计学习视角看，很多模型的区别首先不在神经网络层数或树的深度，而在于它们选择建模哪一种概率对象。判别式模型（Discriminative Model）直接学习 \(p(y\mid x)\) 或决策边界，关心“给定输入后标签怎么判”；生成式模型（Generative Model）则更关心 \(p(x,y)\)、\(p(x\mid y)\) 或带隐藏变量的联合分布，关心“数据是如何被生成出来的”。

这种划分并不等于“一个更先进、一个更落后”。判别式方法通常更直接服务于分类或回归目标；生成式方法则更容易表达不确定性、缺失变量和隐含结构。朴素贝叶斯、高斯混合模型（GMM）、隐马尔可夫模型（HMM）偏生成式；逻辑回归、支持向量机（SVM）、条件随机场（CRF）偏判别式。HMM 与 CRF 的细节放在后面的经典机器学习部分展开，这里只强调它们在统计建模立场上的差异。

概率图模型（Probabilistic Graphical Model, PGM）用图结构表达随机变量之间的条件独立关系，并把高维联合分布拆成较小的局部因子。它的核心价值不是“把概率画成图”，而是把哪些变量直接相互作用、哪些依赖可以被切断写成显式结构，从而让建模、推断和解释都更清晰。

贝叶斯网络适合表达“一个变量如何通过若干中间变量影响另一个变量”的有向依赖；因子图则更偏向把复杂联合分布拆成局部势函数（Factor）相乘的形式。若问题具有明显序列结构，HMM 和 CRF 就是最典型的链式概率图模型实例。它们之所以重要，不只是因为历史地位高，而是因为许多现代模型虽然实现方式更复杂，仍然在利用“局部分解 + 全局归一化/推断”这条思想主线。

统计学习里很多问题之所以变难，不是因为观测变量本身太复杂，而是因为模型里存在隐藏变量（Latent Variable）\(z\)。一旦联合分布写成 \(p(x,z)\)，训练或预测往往都要面对边缘化：

当这个求和或积分无法直接算清时，推断（Inference）就成为核心问题。EM（Expectation-Maximization）适合一类带潜变量的参数估计问题：E 步先根据当前参数估计隐藏变量的后验分布或其期望统计量，M 步再在这些期望量上更新参数。GMM 的训练、HMM 的 Baum-Welch 算法，都是这一路线的经典例子。

若后验分布本身也难以精确求解，就需要近似推断。变分推断（Variational Inference, VI）的思路是：不用直接算真实后验 \(p(z\mid x)\)，而是选一个可计算的近似分布 \(q(z)\) 去逼近它。于是问题从“直接求后验”转化为“在一个可处理的分布族里找最接近后验的那个近似”。这一思路后来也自然延伸到了现代深度生成模型，例如变分自编码器（VAE）的训练就建立在变分推断框架之上。

统计相关性回答的是“变量经常一起变化吗”，因果推断（Causal Inference）回答的则是“如果我主动干预一个变量，另一个变量会怎样变”。这两类问题在形式上很接近，但含义完全不同。观察性条件概率 \(p(y\mid x)\) 只说明在看到 \(x\) 时， \(y\) 通常是什么样；干预分布 \(p(y\mid \mathrm{do}(x))\) 讨论的是把 \(x\) 强行设定为某个值后， \(y\) 会怎样变化。

因果图（Causal Graph）通常也写成有向无环图，但它表达的不再只是统计依赖，而是因果生成结构。混杂因素（Confounder）、中介变量（Mediator）和碰撞点（Collider）之所以重要，正是因为它们决定了哪些相关性可以被解释为因果效应，哪些只是共同原因或选择偏差造成的表象相关。do-calculus 则是一套把干预分布改写成可识别表达式的规则系统，用来判断在给定图结构下，目标因果效应是否能够从可观测分布中恢复出来。

在这份速查里，因果推断只保留这一层定位：它是统计学习向更强解释目标的延伸。普通监督学习通常停在“预测得准”，统计学习进一步讨论“不确定性和隐藏结构怎么处理”，而因果学习则继续追问“如果系统被主动改变，结果会不会跟着改变”。三者不是互斥关系，而是建模目标逐步增强的不同层级。

与“学习范式”不同，下面这些概念不再按监督信号来源分类，而是分别回答另外几个问题：表示该怎样学、计算该怎样近似、已有知识该怎样迁移、在极少样本下又该怎样适配。因此它们更适合看成与学习范式并列的训练目标或训练策略。

表示学习（Representation Learning）讨论的是：如何把原始输入自动变换成更有用的特征表示，使后续任务更容易处理。它关心的不只是“最后预测对不对”，还关心模型内部是否学到了稳定、可迁移、对任务有判别力的中间表示。

传统特征工程（Feature Engineering）与表示学习处理的是同一个核心问题：如何把原始输入变成更适合下游任务的表示。但二者的方法论不同。特征工程主要依赖人工设计表示，例如词频、n-gram、统计量、规则特征与人工交叉特征；表示学习则强调由模型通过优化过程自动学出表示，例如 PCA、自编码器、词向量、上下文化表示以及深度网络中的隐藏状态。因此，传统手工特征本身通常不直接归入表示学习；只有当表示是通过训练自动获得时，它才更准确地属于表示学习范畴。

从 one-hot、BoW、词嵌入，到 BERT 的上下文化表示、Sentence-BERT 的句向量，主线始终一致：把原始符号或原始观测映射到更适合计算的表示空间。监督学习、自监督学习、对比学习都可以被用来学习表示；区别只在于监督信号来自哪里、训练目标如何设计。

对比学习（Contrastive Learning）通过“拉近正样本、推远负样本”学习表示。这里的关键不是类别标签本身，而是样本之间的相对关系：哪些应该相似，哪些必须区分。因此它特别适合表示学习、检索、多模态对齐和度量学习（Metric Learning）。

它的真正价值不只在于“学会匹配”，更在于学会区分性特征（Discriminative Features）。如果训练信号只告诉模型“这两个文本有关”，模型很容易停留在泛泛的共性描述上；而当训练持续提供“相似对”和“不相似对”，模型就被迫回答更尖锐的问题：究竟是什么让这两个文本属于同一语义区域，又是什么让它们必须分开。对比学习因此天然擅长抑制“表面上正确但没有区分度”的表示，转而强化真正决定语义边界的特征。

例如在商品评论表示学习里，句子“物流很快，包装也完整”和“物流很快，但东西是坏的”都包含“物流很快”这类高频表述。若模型只抓住表面词汇重叠，就可能把二者编码得非常接近；但在对比学习里，前者可能与“发货速度快、体验不错”构成正样本，后者则会与“收到商品后无法使用”“质量有问题”这类负面评价更接近。模型因此会逐步学会：真正决定语义边界的，不是共享的套话，而是“包装完整”“东西是坏的”这类改变整体语义走向的区分性片段。

从几何角度看，对比学习学到的是一个更有结构的向量空间。语义接近的文本会在局部形成簇（Cluster），语义无关或语义相反的文本则被推向更远位置。情感分析、语义检索、重复问句检测、意图聚类之所以能直接建立在 embedding 之上，本质上就是因为模型已经把“哪些内容应当靠近、哪些内容应当远离”编码进了空间结构，而不只是输出一个任务特定的分类分数。

在 NLP 中，这条路线并不是突然出现的。Word2Vec 已经体现了早期的对比式思想：真实共现词是正样本，随机采样词是负样本，模型通过区分“真实上下文”和“噪声配对”学习词向量。后来的句向量和文档向量模型，则把这种思想从词级扩展到句子级和文档级：正样本可以是复述句、问答配对、查询与相关文档，负样本则是不相关句子或困难反例（Hard Negatives）。

一个常见形式是 InfoNCE 损失：

其中 \(z_i\) 是当前样本表示， \(z_i^+\) 是与它匹配的正样本表示， \(\mathrm{sim}(\cdot,\cdot)\) 是相似度函数（常用余弦相似度）， \(\tau\) 是温度参数（Temperature），控制分布尖锐程度。这个目标的含义是：在一堆候选中，让正确配对拿到最高分，同时把不相关样本推远。

对比学习在句向量任务中的意义尤其大。交叉编码器（Cross-Encoder）把两个句子拼接后联合编码，能够做非常细的交互判断，但它直接输出的是“这一对句子有多像”，而不是可复用的独立句向量；一旦候选集合很大，计算量会迅速爆炸。双编码器（Bi-Encoder）路线则把两个文本分别编码成独立向量，再用余弦相似度或点积比较。SBERT 正是这一路线的经典代表：它通过孪生网络（Siamese Network）与对比式微调，把原本不适合作为通用句向量的 BERT 表示空间，改造成适合检索、聚类与语义匹配的 embedding 空间。

工程上，负样本既可以来自同一 batch 中的其他样本（In-batch Negatives），也可以来自专门构造的困难负样本（Hard Negatives）。所谓困难负样本，指的不是“完全无关”的反例，而是在表面上很像、但语义上不应被判为同一项的样本。例如检索里，与查询主题相近但并不真正回答问题的文档；句向量训练里，措辞高度相似却语义立场不同的句子；推荐里，风格相近但用户最终没有点击或转化的候选。它们之所以“困难”，正是因为模型若只依赖浅层词汇重叠、模板结构或主题相近性，很容易把这类负样本误判成正样本。

困难负样本的价值在于：它迫使模型放弃过于粗糙的匹配捷径，转而学习更细粒度的区分信号。随机负样本通常太容易分开，训练后期提供的梯度会迅速变弱；而困难负样本更接近真实决策边界，能持续推动表示空间学习“看起来相似但本质不同”的区别。不过它也有代价：若负样本挖掘质量不高，容易把本来就相关的样本错当成负例，形成假负样本（False Negatives），反而会伤害表示质量。因此，现代检索和 embedding 训练里，Hard Negatives 往往与 in-batch negatives、教师模型挖掘（teacher mining）或 reranker 筛选结合使用，而不是完全依赖人工拍脑袋构造。

CLIP、Sentence-BERT、现代检索 embedding、推荐召回模型，乃至许多 query-document dual encoder，本质上都在利用这种“正样本拉近、负样本推远”的训练逻辑。区别主要不在原理，而在样本如何构造、负样本如何选择，以及表示对象是词、句子、文档还是跨模态对。

负采样（Negative Sampling）是与对比学习和词向量训练密切相关的一类近似策略。它的核心动机是：当候选空间极大时，没有必要每次都与所有候选比较；只保留 1 个正样本和少量负样本，就能得到足够强的判别信号。换句话说，它把原本代价高昂的“大规模归一化选择问题”，近似成若干个“真配对还是噪声配对”的二分类判断。

在 Word2Vec 的 Skip-gram 中，若直接对全词表做 softmax，分母需要对 \(|{\cal V}|\) 个词求和，计算代价很高。负采样则对每个正样本对 \((w,c)\) 只保留少量噪声词 \(w_i\)，并最大化：

这里 \(\sigma\) 是 sigmoid 函数，第一项鼓励真实配对的内积更大，第二项鼓励噪声配对的内积更小。这样一来，计算量就从与词表大小同阶，降到与 \(1+k\) 个样本同阶。负样本也不一定完全随机：Word2Vec 常按词频的 \(0.75\) 次方采样；现代对比学习则常用 in-batch negatives 或 hard negative mining。推荐系统召回、知识图谱嵌入、句向量训练等任务里，这种思想到今天仍然非常常见。

迁移学习（Transfer Learning）讨论的是：先在数据更丰富、任务更通用的源任务上学到参数或表示，再把这些知识迁移到目标任务。它不是按监督信号划分出来的独立“学习方式”，而是一种跨任务复用知识的训练策略。现代大模型先预训练、再微调，本质上就是迁移学习。

BERT 就是这一思路的典型例子。它通常先在大规模通用文本上做语言建模预训练，例如维基百科（Wikipedia）这类覆盖面很广的语料；模型先学到词法、句法、语义关系以及上下文表示能力。随后再把这一预训练模型迁移到具体任务上，例如情感分类、自然语言推断（NLI）、命名实体识别（NER）或文本匹配，只需接上任务头并用该任务的数据继续微调，就能把通用语言知识转化为面向目标任务的能力。

它与对比学习不在同一层面。对比学习回答的是“预训练阶段该用什么目标来学表示”；迁移学习回答的是“学到的表示如何迁到新任务”。两者经常配合出现：例如先在海量无标签图像上用对比学习预训练视觉编码器，再把该编码器迁移到医学影像分类、工业缺陷检测或小样本识别任务上。

少样本学习（Few-shot Learning）处理的是“每个任务只有极少标注样本”时如何仍然快速泛化。它通常建立在迁移学习或预训练模型之上：模型先学到一套通用表示，再在很少示例下快速适配新任务。困难不在于单个任务本身，而在于模型必须把以往经验迁移到新任务上。直觉上，它更像“学会如何快速学习”，而不是“把一个任务彻底学透”。

零样本（Zero-shot）指模型在目标任务上没有任何专门示例，也能凭借已有知识完成任务。大语言模型通过指令理解实现的很多能力都属于这一类。例：不给任何情感分类样例，只写“判断下面评论是正面还是负面”，模型仍可能完成分类。

单样本（One-shot）指只给 1 个示例。这个示例的价值不是提供统计规律，而是告诉模型“输出格式、任务边界和你想要的判别标准”。例如先给一条“商品评论 → 正面”的例子，再让模型判断下一条评论。

K 样本（K-shot）指给每类或每任务提供 \(K\) 个示例。随着 \(K\) 增大，模型更容易对任务意图和判别标准形成稳定估计。工程上，prompt 中的 few-shot 示例本质上就是在上下文窗口里做一种“临时任务适配”。

元学习（Meta-learning）研究“让模型更快适应新任务”。MAML（Model-Agnostic Meta-Learning）的核心不是直接学一个最终答案，而是学一个好的初始化参数 \(\theta\)，使模型只需少量梯度更新就能适配新任务。

MAML 的外层目标可概括为：

其中 \(\mathcal{T}\) 表示一个任务， \(\alpha\) 是内层更新步长。读法是：先用当前参数在某任务上走一步，再看更新后的参数在该任务上的表现好不好；如果“一步后就变好”，说明初始化是好的。类比来看，MAML 训练的不是“会做每道题的学生”，而是“只要老师讲一遍就能迅速举一反三的学生”。

原型网络（Prototypical Networks）把每个类别表示成嵌入空间中的一个“类中心（Prototype）”。对类别 \(k\)，其原型定义为该类支持集（Support Set）样本嵌入的平均：

这里 \(f_\theta(x_i)\) 是样本的向量表示， \(S_k\) 是类别 \(k\) 的支持样本集合。分类时，把新样本映射到嵌入空间，看它离哪个原型最近。直觉上，这像“每一类先算一个代表点，新样本按离哪个代表点最近来归类”。在 few-shot 图像分类中，这种方法往往比直接训练复杂分类头更稳。

池化（Pooling）可以先按一句人话来理解：把一组相邻或相关的特征，压缩成更短、更稳定、更容易继续处理的摘要。它不是重新发明新特征，而是对已有特征做聚合（Aggregation）或下采样（Downsampling）。这里的下采样指：沿某些维度减少位置数或采样点数，让表示尺寸变小、分辨率变粗。例如把 \(4\times 4\) 的特征图压成 \(2\times 2\)，或把一长段序列压成更短的摘要向量，都属于下采样。

若把一组输入特征记为 \(x_1,\dots,x_k\)，则池化可以抽象写成

这里 \(\mathrm{Pool}\) 可以是最大值（Max Pooling）、平均值（Average Pooling）、求和（Sum Pooling）或更复杂的加权聚合。它们做的事不同，但主线一致：把“多个位置/多个元素的表示”变成“更少的表示”。

池化之所以重要，是因为很多任务并不需要保留每个细节位置的完整分辨率。图像分类不一定关心边缘恰好落在第 17 个还是第 18 个像素；句子分类也不一定要求记住某个情绪词出现在第 6 个还是第 7 个 token。此时，把局部细节适度压缩，往往能提升稳定性、降低计算量，并让后续层更关注“有没有出现模式”，而不是“模式的坐标是否一模一样”。

最大池化（Max Pooling）保留一组特征里最强的那个响应。若某个窗口里有一个边缘、某个关键词或某个邻居信号特别强，最大池化会把它留下来。它更像在问：这一小块区域里，最显著的模式有没有出现。

平均池化（Average Pooling）对一组特征取平均，更强调整体趋势而不是最强局部点。它更像在问：这一块区域总体上激活强不强、语义平均水平如何。

求和池化（Sum Pooling）常见于图网络和集合建模，用于累积总量信息。若节点数量本身有意义，求和会把“有多少邻居/总共多强”也编码进去；平均池化则更强调归一化后的平均强度。

全局池化（Global Pooling）表示不再只看局部窗口，而是直接把整张特征图、整段序列或整个节点集合压成一个向量。例如全局平均池化（Global Average Pooling, GAP）会把一整个空间维度平均掉，得到“每个通道在全局上的平均响应”。自适应池化（Adaptive Pooling）则把输出尺寸预先固定，例如无论输入特征图多大，最终都压成 \(1\times 1\) 或 \(7\times 7\)。

在卷积神经网络（CNN）里，池化最经典的含义是沿空间维度做局部下采样。例如一张特征图经过 \(2\times 2\) 最大池化后，宽高会缩小，局部最强响应被保留下来。它的直接收益有三点：减小特征图尺寸、扩大后续层的感受野（Receptive Field）、并降低模型对小幅平移和局部扰动的敏感度。

在时序模型和文本模型里，池化更常表示沿时间或序列长度维度做聚合。例如把所有 token 表示做平均池化，得到整句向量；把一段音频帧表示做最大池化，得到“这一整段里最强的模式”。这里池化的重点不再是二维空间下采样，而是把变长序列压成固定长度表示，方便做分类、检索或相似度计算。

在图神经网络（GNN）里，池化有两层常见含义。第一层是邻域聚合（Neighborhood Aggregation）：一个节点把邻居表示做均值、求和或最大值，再更新自己；这可以理解为“节点级局部池化”。第二层是图级读出（Graph-level Readout）：把整张图的节点表示再做一次全局聚合，得到整个图的表示，用于图分类、图回归等任务。

在 Transformer 里，池化通常不再以“池化层”这一模块形式高频出现，但概念仍然存在。句子分类常取 \([\mathrm{CLS}]\) 位置表示，或对所有 token 做平均池化；Embedding 模型也常对最后一层隐藏状态做 mean pooling / max pooling 得到句向量。进一步看，注意力（Attention）本身也可以理解成一种带内容依赖的加权聚合：区别只在于普通池化的规则通常固定，而注意力的权重是由输入动态决定的。

池化保留的是摘要信息，丢掉的是更精细的位置细节。最大池化更偏向“是否出现过显著模式”，平均池化更偏向“整体平均状态如何”，求和池化则更偏向“总量有多大”。因此，池化总带有一种 trade-off：表示更紧凑、更稳、更省算力，但精确定位能力会下降。

这也是为什么不同任务会选择不同聚合方式。图像分类往往欢迎一定程度的位置不敏感，因此池化很自然；语义检索希望一整句压成一个句向量，因此句级池化很常见；但像语义分割、目标检测、序列标注这类任务，输出本身依赖逐位置判断，就不能过早把位置信息池掉，否则细粒度边界会被抹平。

若说下采样（Downsampling）是在压缩表示，那么上采样（Upsampling）就是反过来把较粗的表示扩展回更细的空间分辨率。它做的不是凭空创造新信息，而是把低分辨率特征重新铺回更高分辨率的位置网格中，方便恢复空间结构、边界或局部细节。

插值（Interpolation）是最直接的上采样方式。最邻近插值（Nearest Neighbor Interpolation）相当于把原像素或原特征直接复制到更密的网格里，速度快、实现简单，但边界可能显得生硬；双线性插值（Bilinear Interpolation）则按周围位置做平滑加权，结果更连续，但也更容易把边界抹平。它们的共同特点是：上采样规则是固定的，不需要学习参数。

转置卷积（Transposed Convolution）则是可学习的上采样。它不是“把普通卷积矩阵简单转置后就 magically 还原图像”，而是指：若把普通卷积看作一个线性算子，转置卷积对应的是这个线性算子的转置形式，因此能够把较小的特征图映射到较大的特征图。因为它带有可学习卷积核，所以模型可以学习“该怎样把粗特征展开成更适合任务的细特征”。

在视觉任务里，这三者的分工很常见。语义分割、图像生成、超分辨率、U-Net 解码器、扩散模型解码器都需要上采样：有时先用插值把尺寸放大，再接普通卷积细化；有时直接用转置卷积一步完成“放大 + 学习性重组”。前者通常更稳、更少棋盘格伪影（Checkerboard Artifacts），后者表达力更强，但更依赖实现细节与核大小、步幅（Stride）设置。

机器学习更关心模型离开训练集之后能否维持稳定表现。泛化（Generalization）、过拟合（Overfitting）、欠拟合（Underfitting）与偏差—方差权衡（Bias–Variance Tradeoff）描述的，就是这件事。

泛化（Generalization）指模型在未见样本上的表现。若训练数据与未来输入都来自同一数据分布 \(P(X,Y)\)，则模型的总体风险可写成：

这里 \(R(f)\) 是真实风险（Population Risk），表示模型 \(f\) 在整个真实分布上的平均损失； \(\ell(f(x),y)\) 是单样本损失；期望 \(\mathbb{E}\) 表示对所有可能样本做平均。训练时真正能看到的只有有限样本，因此优化的通常是经验风险 \(\hat R_n(f)\)，而不是这个理想化的总体风险。

训练误差与测试误差之间的差距，常称为泛化间隙（Generalization Gap）。间隙小说明模型在未见数据上比较稳定；间隙大则说明模型过度依赖训练样本中的偶然细节。

内插（Interpolation）与外推（Extrapolation）描述的是：模型面对未见样本时，究竟是在已观测范围之内补全规律，还是在已观测范围之外延伸规律。二者都属于预测，但难度和风险完全不同。

以一维回归为例，若训练样本的输入主要落在区间 \([a,b]\) 内，那么对 \(x\in[a,b]\) 附近新样本做预测，更接近内插；对明显落在这个范围之外的 \(x\) 做预测，则更接近外推。内插依赖的是“训练数据已经覆盖了这片区域”；外推依赖的是“模型学到的规律在未见区域仍然继续成立”。后者显然要求更强。

在机器学习里，大多数标准泛化讨论其实都更接近内插。只要训练集与测试集近似满足独立同分布（IID）假设，测试样本通常仍然落在训练分布支持集（Support）附近，模型主要是在已知数据流形附近做平滑补全。这也是为什么现代高容量模型即使参数极多，只要训练分布覆盖充分，仍然能在测试集上表现得相当稳定。

外推对应的则是更困难的分布外泛化（Out-of-Distribution Generalization, OOD Generalization）。此时，测试输入不再只是训练分布中的轻微变化，而是进入了训练时很少见、甚至从未见过的区域。自动驾驶模型若只在晴天高速公路上训练，却要在暴雪、泥地和夜间乡道上决策；医学模型若主要见过成人数据，却被要求用于儿童病例；金融模型若只在平稳市场阶段训练，却要应对极端波动期，这些都属于外推问题。

外推之所以困难，根源在于经验风险最小化并不自动保证“规律可被安全延伸到训练分布之外”。模型完全可能在训练分布内部拟合得很好，却在一旦离开这片区域后迅速失效。因此，外推能力往往比普通测试集精度更能检验模型究竟学到了稳定结构，还是只学会了训练分布内部的高质量插值。

大语言模型里有一种非常典型的外推形式：长度外推（Length Extrapolation）。若模型训练时主要见到 \(4\mathrm{K}\) 或 \(8\mathrm{K}\) 上下文，却在推理时被要求处理 \(128\mathrm{K}\) 甚至更长序列，那么它面对的就不再只是“在熟悉长度范围内继续理解”，而是在训练长度之外延伸位置建模规律。RoPE 缩放、NTK-aware 调整、YaRN 等方法，本质上都是在尽量让模型把短上下文中学到的位置规律外推到更长序列上。

因此，可以把两者压缩成一句话：内插更像在已知区域里补全空白，外推更像拿着已总结出的规律去穿越未知边界。前者是标准机器学习评测里的常态，后者则更接近真实系统进入新环境时会遭遇的硬问题。

过拟合（Overfitting）指模型在训练集上持续吸收局部细节、噪声与偶然模式，但这些信息不能稳定迁移到未见样本上。它的典型外观是：训练集表现继续改善，而验证集或测试集表现停止改善、开始恶化，二者之间的泛化间隙（Generalization Gap）不断扩大。

过拟合描述的是一种训练现象，本身并不自动等于“模型已经不可用”。更准确的分析方式，是区分模型到底过拟合了什么。分类任务里最常见的两类退化并不完全相同：一类是决策边界本身开始贴合训练集偶然性；另一类是分类边界大体没变，但模型对既有判断越来越极端，概率校准逐步恶化。

前一类退化直接伤害模型的判别泛化，后一类退化主要伤害概率校准（Calibration）。因此，若系统只需要固定阈值之后的硬标签，置信度过拟合通常是次一级问题；若系统依赖概率值本身做风险分层、阈值调度、排序融合或人工兜底，置信度过拟合就会立刻变成工程问题。

识别过拟合时，不能只盯着单一 loss，而要同时观察训练集指标、验证集指标、概率分布形状与误差结构。最典型的信号包括：

• 训练 loss 持续下降，但验证 loss 在某个阶段后停止下降，随后回升。
• 训练 Accuracy / F1 继续提高，而验证 Accuracy / F1 停滞甚至下滑。这通常提示决策边界开始贴近训练集特有模式。
• 验证 F1 基本稳定，但验证 loss 明显变差。这类“指标稳、loss 崩”的组合，更接近置信度过拟合而不是判别边界崩坏。
• logit 绝对值持续增大，softmax 或 sigmoid 输出更集中到接近 0 和 1 的两端，说明模型在继续放大自信度。
• 训练后期错误样本逐渐集中在少量硬样本，而 easy case 的置信度仍在继续极化，说明模型已经不再学新的判别规律，而是在强化已有判断的幅度。
• 不同随机种子、不同验证切分下的波动变大，说明模型开始依赖训练样本中的偶然结构。

过拟合并不只由“参数太多”导致。更常见的诱因包括：样本量不足、类别长尾、标签噪声、训练集与线上分布不一致、数据泄露、训练时间过长、正则化过弱、batch 过小导致梯度噪声放大，以及高重复语料让模型过度记忆头部模式。对深度模型而言，容量大只是风险放大器，真正决定是否过拟合的，通常是模型自由度与有效监督信号之间是否失衡。

欠拟合（Underfitting）指模型连训练数据中的主要结构都没有学出来，表现为训练集和验证集都做不好。它对应的是高偏差（High Bias）状态：模型的平均预测长期偏离真实目标，也就是模型拟合能力不够，或训练过程根本还没有进入足够低误差的区域。

与过拟合相比，欠拟合的特征通常不是“训练和验证拉开了差距”，而是两边都差，而且差得很一致。训练集上的 loss 仍然偏高，训练 Accuracy / F1 也上不去，说明模型尚未把任务主结构写进参数中。

• 训练 loss 和验证 loss 都较高，而且两者相差不大。
• 训练 Accuracy / F1 与验证 Accuracy / F1 同时偏低，没有形成明显的泛化间隙。
• 训练到后期时，两条曲线仍然一起缓慢下降，说明模型可能还没收敛；若提前停止训练，问题更接近“没训练够”。
• 即使继续训练较长时间，训练指标仍然明显低于任务应有上限，说明容量、特征或优化配置本身不足。
• 错误并不只集中在边界样本或少数难例，而是连大量 easy case 都无法稳定学会。

欠拟合常见于模型容量过小、特征表达弱、模型结构与任务不匹配、正则化过强、学习率设置不当、训练轮数不够、输入信息被过度截断，或任务本身需要非线性组合而模型只允许非常受限的线性表达。工程上，欠拟合也经常伪装成“模型很稳但一直不强”：曲线不震荡、训练不发散，却始终到不了可接受的性能区间。

一个实用判断准则是先看训练集是否已经被充分学会。若训练集指标本身就很差，优先考虑欠拟合；若训练集指标很好而验证集开始回落，优先考虑过拟合；若验证集分类指标基本不动，但验证 loss 与校准指标变差，则更接近置信度过拟合。把这三种状态区分清楚，后续的调参与正则化方向才不会混淆。

坍缩（Collapse）描述的是训练过程中的一种退化解（Degenerate Solution）：模型表面上仍在输出结果，但内部表示、预测分布或优化轨迹已经失去有效多样性，学习过程塌到某种简单、无用或几乎无信息的模式上。它和过拟合不同。过拟合仍然在“认真地区分训练样本”，只是把训练集细节学得过头；坍缩则意味着模型逐渐失去区分能力，或者训练目标退化为某种几乎不再提供有效学习信号的状态。

其中前两类最常见也最容易直观理解。Mode Collapse 强调输出空间的多样性消失；Representation Collapse 强调内部表示空间的多样性消失。第三类常被笼统地称作 loss collapse，但更准确的理解是“优化目标退化”或“训练目标坍缩”：loss 本身只是一个观测信号，真正的问题在于模型已经进入某种几乎不再产生有效学习内容的状态。

判断坍缩时，关键不是只看某一个时刻的平均 loss，而是看输出分布、表示分布与样本间差异是否还存在。若某个 epoch 中同时出现极低 loss 样本和极高 loss 样本，说明模型仍在把 easy case 与 hard case 区分开，训练信号仍有明显异质性；这更像正常训练中的难度分层，而不是已经坍缩。真正的坍缩通常会伴随更一致的退化迹象，例如预测类别快速单一化、embedding 方差急剧缩小、梯度长期接近 0，或者 loss 在大多数样本上收缩到近乎同一个无信息水平。

坍缩在不同任务中的诱因并不相同。对比学习（Contrastive Learning）里若缺少 stop-gradient、predictor、负样本或方差保持机制，表示空间很容易整体塌平；生成模型里，判别器与生成器失衡会诱发 mode collapse；分类任务里，极端类别不平衡、错误的损失实现、过强正则化或训练数据本身标签塌缩，都可能把模型推向低信息输出。工程上监控坍缩，通常需要同时看 loss、预测类别分布、embedding 方差、梯度范数与验证集指标，而不能只盯着单一数值曲线。

偏差（Bias）与方差（Variance）是分析泛化误差来源的经典视角。对平方损失（Squared Loss），常见分解写成：

左边的 \(\mathbb{E}[(Y-\hat f(X))^2]\) 是模型的平均平方误差； \(\mathrm{Bias}^2\) 表示模型平均预测与真实函数之间的系统性偏离； \(\mathrm{Variance}\) 表示模型对训练样本波动的敏感度； \(\sigma^2\) 是数据本身不可约的噪声（Irreducible Noise），即使模型和训练过程都完美，也无法完全消除。

更直白地说，偏差看的是“模型平均预测离真实值有多远”，代表模型的拟合能力；方差看的是“换一份训练集后模型预测会抖动多大”，代表模型的稳定性。偏差高通常对应欠拟合，因为模型学不到足够有效的数据规律；方差高通常对应过拟合，因为模型过度依赖某一份训练集的细节，离开训练集后泛化能力变差。

工程上，降低偏差常靠更强模型、更好特征和更充分训练；降低方差常靠更多数据、正则化、数据增强、早停（Early Stopping）和集成学习（Ensemble Learning）。很多建模决策，本质上都是在“预测还不够准”和“预测太不稳定”之间做权衡。下表用几类典型树模型把这种权衡具体化。

因此，偏差与方差不是抽象口号，而是在解释不同模型为什么会“学不动”或“学过头”。看树模型尤其直观：单树的问题是两头都可能出错；随机森林主要靠并行平均压方差；Boosting 家族主要靠串行纠错压偏差，再用浅树和正则化把方差稳住。

大部分监督学习训练都可以概括成同一条主线：先定义单样本损失，再在训练集上取平均形成经验风险，最后通过优化算法把它压低。正则化（Regularization）是在这条主线之上加入额外约束，用来控制复杂度并改善泛化。

经验风险最小化（Empirical Risk Minimization, ERM）是统计学习的基本训练原则。设训练集为 \(\mathcal{D}=\{(x_i,y_i)\}_{i=1}^{n}\)，则经验风险定义为：

这里 \(n\) 是样本数， \(f(x_i)\) 是模型对第 \(i\) 个样本的预测， \(y_i\) 是真实标签， \(\ell\) 是损失函数。经验风险最小化就是在假设空间 \(\mathcal{H}\) 中寻找让这条平均损失最小的函数：

这条原则覆盖范围极广。线性回归最小化的是平方误差经验风险，逻辑回归和多分类神经网络最小化的是交叉熵经验风险，序列标注模型最小化的是序列级条件对数似然。算法形式不同，骨架是一致的。

正则化（Regularization）是在经验风险之外，再加入一个偏好“更简单、更平滑、更稳定”解的约束项。常见写法是：

这里 \(\Omega(f)\) 是正则项（Regularizer），刻画模型复杂度； \(\lambda\) 是正则化强度，决定“拟合训练集”和“控制复杂度”之间的权衡。 \(\lambda\) 越大，模型越保守；越小，模型越自由。

L2 正则（L2 Regularization）偏好较小权重，常写成 \(\Omega(f)=\|\mathbf{w}\|_2^2\)；L1 正则（L1 Regularization）偏好稀疏解，常写成 \(\Omega(f)=\|\mathbf{w}\|_1\)。更广义地看，早停、Dropout、数据增强、权重共享、标签平滑、参数冻结、低秩适配，都是在不同层面对模型自由度施加约束，因此都可以看作正则化思想的工程实现。

机器学习中的很多训练与评估结论，都建立在一个默认前提上：训练样本与未来样本来自同一统计机制。这个前提通常写成 IID（Independent and Identically Distributed，独立同分布）假设。只要这个前提破坏，训练集表现与线上表现之间就可能出现明显断裂。

设样本对 \((x_i,y_i)\) 来自某个联合分布 \(P(X,Y)\)，IID 假设写成：

这里“独立（Independent）”表示一个样本是否出现，不影响另一个样本的生成；“同分布（Identically Distributed）”表示所有样本都来自同一个联合分布 \(P(X,Y)\)。这个假设让训练集平均损失能够作为总体风险的近似，也让交叉验证、置信区间和很多泛化理论成立。

IID 是理想化近似，而不是自然界的铁律。时间序列、推荐系统、金融交易、医疗数据、A/B 实验日志、用户行为数据，常常都存在相关性、群组效应、时间漂移或采样偏差，因此不能机械套用 IID 设定。

当训练分布与测试分布不一致时，就发生了分布偏移（Distribution Shift）：

分布偏移有几种常见形式。协变量偏移（Covariate Shift）指 \(P(X)\) 变化，而 \(P(Y|X)\) 基本稳定；例如线上用户年龄结构变了，但“给定用户画像时是否点击”的规律没明显变。标签偏移（Label Shift）指 \(P(Y)\) 变化，例如欺诈率在促销期突然上升。概念漂移（Concept Drift / Concept Shift）指 \(P(Y|X)\) 本身发生变化，例如垃圾邮件发送策略升级后，原来有效的文本模式不再可靠。

因此，训练集、验证集与测试集的切分不能只追求随机均匀，还必须尽量模拟未来部署环境。若线上是时间推进场景，测试集就应按时间后移；若线上按用户或设备泛化，切分就应按实体隔离；若业务分布持续漂移，还需要做持续监控、重训和再校准。分布偏移不是评估里的边角问题，而是机器学习系统走向生产后的主要失效来源之一。

OOD 是 Out-of-Distribution 的缩写，意为分布外（Out-of-Distribution）。它强调的是：当前输入已经落到训练分布覆盖较弱、甚至根本没有覆盖的区域。与一般意义上的“有点噪声”不同，OOD 更像是模型被带到了一个不熟悉的世界里。

例如，一个文本分类模型训练时主要见到的是规范书面语，部署后却大量遇到拼写错误、口语、英文混杂、模板化投诉和新产品名称；一个视觉模型训练时主要见到晴天白昼图像，线上却开始接收夜间、雨雪和红外图像。这类输入即使形式上仍然属于同一任务，也可能已经超出训练分布支持范围。OOD 检测与分布外泛化因此成为真实系统里的关键问题：模型不只要尽量判对，还要在“不熟悉”时知道自己不熟悉。

数据漂移（Data Drift）强调的是线上数据分布会随着时间持续变化。它和 OOD 高度相关，但语境更偏工程系统：不是某一个样本偶然跑出了训练分布，而是整体数据来源、用户群体、业务流程或采集方式正在逐步改变。

若输入分布 \(P(X)\) 发生变化，常称为数据漂移或协变量漂移；若标签分布 \(P(Y)\) 变化，常表现为类别比例变化；若 \(P(Y|X)\) 也改变，则更接近概念漂移。现实系统里，这些变化往往同时发生。例如促销活动带来全新的用户结构，新功能改变用户行为路径，标注口径调整导致同类样本的标签规则也跟着变化。数据漂移的工程含义很直接：离线验证通过，并不意味着模型可以长期稳定在线上工作，监控、告警、回灌和重训机制必须跟上。

鲁棒性（Robustness）指模型在噪声、扰动、输入变形和分布变化下，性能是否仍能维持稳定。它关心的不只是“在标准测试集上最高能到多少分”，更关心输入一旦变脏、变偏、变怪，模型会不会立刻失效。

鲁棒性与 OOD、数据漂移不是同一概念，但三者紧密相关。OOD 和数据漂移描述的是输入环境发生了什么变化；鲁棒性描述的是模型面对这些变化时的承受能力。一个鲁棒性差的模型，可能在干净样本上分数很高，却会被轻微拼写错误、格式扰动、图像模糊、特征缺失或采样偏移迅速击穿。真实生产系统里，鲁棒性通常比单次 benchmark 分数更接近“模型能否长期可用”这个问题。

数据集工程（Dataset Engineering）决定了模型看到什么、以什么尺度看到、又会被哪些偏差误导。很多所谓“模型问题”，根源其实是数据问题：标签噪声、分布漂移、类别极不均衡或特征泄漏，都会直接扭曲训练结果。

数据集工程里常见一个实用分层：黄金数据集（Gold Dataset）与白银数据集（Silver Dataset）。黄金数据集通常指由高质量人工标注、规则严格审核或专家确认得到的小而精数据，标签噪声低，适合做最终评测、关键验证集或高价值监督信号；白银数据集则通常来自启发式规则、弱监督（Weak Supervision）、模型打标、日志回收或大规模自动清洗，规模更大、成本更低，但噪声也更高。实际工程中，常见策略不是二选一，而是用白银数据集提供覆盖面和规模，用黄金数据集提供校准、纠偏与最终可信评估。

数据划分的目标，是把学参数、做模型选择、汇报最终结果这三件事严格隔离开。若同一批数据既用来训练参数，又用来调超参数，最后还拿来汇报效果，评估结果通常会乐观得不真实，因为模型已经间接“看过”了答案。

从统计学习角度看，这三类数据分别承担三种不同职责：训练集负责让模型学习参数；验证集负责帮助人或训练流程做工程决策；测试集负责模拟真正的未知数据，给出最后一次、尽量无偏的泛化评估。三者分工清楚，模型评估才有可信度。

训练集（Training Set）用于更新模型参数。监督学习中，训练集包含输入 \(x\) 与标签 \(y\)；模型在这批样本上计算损失（Loss）、反向传播梯度（Gradient）并更新参数，因此训练集直接决定“模型学到了什么”。它回答的问题是：在已观测样本上，模型有没有学会输入与输出之间的对应关系。

训练集通常应占数据的大头，因为参数学习需要足够多的样本来稳定估计模式。实践中常见比例是 70% 到 80%，但这不是固定规则：若数据总量非常大，训练集比例可以更高；若数据本来就少，则往往需要把更多精力放在交叉验证（Cross Validation）而不是死守固定比例。

训练集上的误差通常是三者里最低的，这并不说明模型已经具有泛化能力。一个模型完全可能在训练集上表现极好，却只是记住了样本中的噪声与偶然性。训练集成绩更多反映“拟合能力”，而不是“真实上线表现”。

验证集（Validation Set）用于模型选择（Model Selection）和超参数调优（Hyperparameter Tuning）。它不直接参与参数更新，但会影响训练流程中的关键决策，例如学习率（Learning Rate）、正则化强度、模型深度、树的数量、batch size、阈值选择，以及是否执行 Early Stopping。

验证集回答的问题不是“模型能不能学会”，而是：在若干候选配置里，哪一个更可能在新数据上表现最好。因此，验证集像训练过程中的“模拟考试”：它不是最终成绩单，但会决定你在训练期间如何改模型、如何调参数、何时停止训练。

验证集通常占总数据的 10% 到 15% 左右。若数据量很小，单独留出一份验证集的代价会较高，此时更常见的做法是使用 \(K\) 折交叉验证，让每个样本轮流充当验证数据，以减少一次随机划分带来的偶然性。交叉验证的细节放在后面的“模型评估”部分展开。

测试集（Test Set）用于最终评估模型的泛化能力（Generalization）。它应尽量只在方案冻结之后使用：模型结构、超参数、训练策略、阈值和后处理规则都不再修改时，才在测试集上做一次最终评估。它回答的问题是：如果把模型部署到真实世界，它在新样本上的表现大致会怎样。

测试集通常占总数据的 10% 到 15%。它的重要性不在于比例有多大，而在于它必须保持“未参与决策”。如果开发过程中反复查看测试集结果，并据此继续改模型，那么测试集就已经被污染，不再是独立评测，而变成了另一个隐性的验证集。

因此，测试集更像真正的“高考卷”或“盲测集”：它的价值在于最后一次、尽量无偏的评估，而不是参与训练流程本身。

最常见的简单划分是训练集 / 验证集 / 测试集 = 70% / 15% / 15%，或 80% / 10% / 10%。这种划分适合样本量较大、类别分布较稳定的任务，因为单次随机切分已经足以给出相对稳定的训练与评估结果。

当数据量较小、类别极不平衡、或者不同子群体差异明显时，划分策略就必须更谨慎。分类任务常采用分层抽样（Stratified Split），确保训练、验证、测试三部分的类别比例大致一致；时间序列任务则必须按时间顺序切分，避免未来信息泄漏到过去；用户级、设备级、病人级任务常需要按实体分组切分，防止同一实体的样本同时出现在训练集和测试集中，造成过于乐观的结果。

因此，“如何划分”本身就是建模的一部分。划分方式若与真实部署场景不一致，即使指标很好，也可能只是评估设定过于宽松，而不是真正泛化能力强。

数据泄露（Data Leakage）指测试集或验证集中的信息以直接或间接方式进入训练过程，从而导致模型评估结果虚高。它的危险不在于“代码报错”，而在于模型会表现得看似极好，却无法在真实新数据上复现。

最常见的数据泄露有几类。第一类是先对全量数据做预处理，再切分数据，例如先用全量数据计算标准化均值和方差，再划分训练 / 测试集；这样测试集的信息已经进入了训练流程。第二类是用测试集反复调参，例如每改一次模型就看一次测试集成绩，直到测试集最好看为止。第三类是特征中混入未来或标签信息，例如用预测时不可能知道的字段做输入，或把目标变量的某种变形偷偷带进特征。

避免数据泄露的原则只有一句：任何依赖数据分布统计量、特征构造规则、模型选择决策或阈值选择的步骤，都只能在训练集内部完成，再把同样的变换应用到验证集和测试集。标准化、特征选择、缺失值填补、目标编码（Target Encoding）、降维（PCA）和重采样（Resampling）都要遵守这一原则。

因此，数据集划分不只是“把数据分三份”这么简单，而是整个实验设计（Experimental Design）的一部分。只有训练集、验证集、测试集的职责边界清晰，交叉验证使用得当，且数据泄露被严格控制，模型指标才具有解释价值和可复现实验意义。

归一化（Normalization）与标准化（Standardization）都在解决“不同特征量纲和尺度差异过大”问题，但含义不同。最常见的最小-最大归一化把数据映射到固定区间：

它把特征压到 \([0,1]\)，适合像像素值、比例值这类天然有上下界的量。标准化则是减去均值、再除以标准差：

标准化后的特征均值为 0、标准差为 1，更适合线性模型、距离模型和很多神经网络优化过程。类比来看，归一化像“把不同长度的尺子都缩到同一长度区间”；标准化像“先平移到共同中心，再按波动尺度统一单位”。

特征工程（Feature Engineering）是把原始数据加工成更利于模型学习的表示。它不是“多造点列”这么简单，而是在把领域知识编码进输入空间。例：时间戳可以拆成小时、星期、是否节假日；用户行为日志可以构造近 7 天点击次数、转化率、时间衰减统计；文本可以做 TF-IDF、n-gram 或实体抽取。

类比来看，特征工程像做菜前的备料：同样的原料，如果已经切片、去骨、配好比例，后续烹饪会顺畅得多。经典机器学习对特征工程高度依赖；深度学习则把一部分特征学习自动化了，但在表格数据、推荐、广告和风控里，特征工程仍然决定上限。

类别不平衡（Class Imbalance）指某些类别样本远多于另一些类别。欺诈检测、故障检测、医学筛查里最典型：正类往往极少。如果不处理，模型可能通过“永远预测多数类”获得看似不错的 Accuracy，却在关键少数类上彻底失效。

常见处理方法包括：重采样（过采样少数类、欠采样多数类）、类别加权（Class Weighting）、阈值调整（Threshold Tuning）和使用更合适的指标（如 Precision、Recall、PR-AUC）。例如在信用卡欺诈场景中，正类只占 0.1%，此时“全判正常”会有 99.9% Accuracy，但业务价值几乎为 0。

超参数（Hyperparameters）是训练开始前由人或外部搜索过程设定的配置变量。它们与模型参数（Parameters）不同：模型参数如线性回归的权重、神经网络的矩阵和偏置，是通过训练数据学出来的；超参数则决定模型该以什么结构、什么训练节奏、什么正则化强度去学习。学习率、batch size、树深、dropout、LoRA rank 都属于超参数，而不是训练过程中直接被梯度更新出来的参数。

从作用层面看，超参数大致分成三类。第一类决定模型结构，例如树的最大深度、神经网络层数、隐藏维度、注意力头数；第二类决定优化过程，例如学习率、batch size、训练轮数、warmup 步数；第三类决定复杂度控制，例如正则化强度、dropout、weight decay、早停耐心值。它们共同定义了“模型允许学成什么样、以及训练过程会沿哪条轨迹逼近这个结果”。

因此，超参数优化并不是在调模型已经学到的权重，而是在搜索哪一套训练配置更可能在验证集上泛化得最好。这也是为什么超参数搜索天然依赖验证集，而不能依赖测试集。

有些超参数跨很多模型家族都反复出现，它们更像训练流程级控制杆，而不是某个算法私有旋钮。最常见的一组可概括如下：

另一类超参数只在特定模型家族里出现。它们往往直接对应某个算法的结构假设，因此不能简单迁移到别的模型上。

这也是为什么“超参数”不能被理解成一张固定清单。不同模型真正敏感的旋钮并不相同。对树模型，max depth 和叶节点约束常是核心；对 Transformer，学习率、warmup、weight decay、batch 与上下文长度往往更关键；对 LoRA，rank 与挂载模块会直接决定可写入容量。

超参数搜索（Hyperparameter Search）指用验证集表现，在若干候选配置中选择更优组合。它本质上不是训练参数，而是在搜索哪套训练配方更值得被固定下来。搜索空间越大，找到更优组合的机会通常越高，但实验成本、验证集过拟合风险和复现难度也会同步上升。

贪婪串行登山（Greedy Sequential Hill Climbing）是一种非常实用的超参数搜索策略。它的核心规则是：每次只调整一个超参数，在当前其余超参数固定不变的条件下，选择验证集上更优的方向走一步；确定后先固定该值，再去调下一个超参数。在离散候选集上，它可以看作一种坐标式局部搜索。

例如先固定 dropout 和 batch size，只比较若干学习率；一旦找到当前最优学习率，就暂时锁定它，再去比较 dropout；然后再固定前两者去比较 batch size。这样做的优点是实验次数通常近似线性增长，适合“训练一次代价不低、超参数数量又不算很多”的场景。

贪婪串行登山常伴随一种棘轮式锁定（Ratchet-style Fixing）：某一轮一旦选定一个更优取值，就先不回头重开这个维度。这样做能显著缩小后续搜索空间，但代价也很明确：较早做出的局部最优决策，会限制后面组合空间的探索。

它最容易出问题的地方，是参数交互（Hyperparameter Interaction）。若两个超参数彼此强相关，例如学习率和 batch size、学习率和 warmup、LoRA rank 和 target modules，那么“在当前默认值下看起来更优”的选择，未必能和后续维度组成真正最优的整体组合。棘轮式锁定会把这类交互提前屏蔽掉。

因此，何时使用哪种策略，取决于训练代价与搜索空间形状。若一次训练就要数十分钟甚至数小时，且可调超参数并不多，贪婪串行登山往往已经足够作为第一轮工程方案；若参数交互明显、预算允许，随机搜索或贝叶斯优化通常更稳。无论使用哪一种方法，最关键的前提都不变：搜索必须由验证集驱动，而测试集必须保持未参与决策。

模型评估（Model Evaluation）回答的不是“模型能不能在训练集上做对”，而是“模型在新数据上是否可靠，以及错误代价如何”。不同任务对应的指标重点不同：分类关心类别区分，回归关心数值偏差，排序关心相对顺序。

交叉验证（Cross Validation）在数据较少时特别重要。最常见的 \(K\) 折交叉验证把数据分成 \(K\) 份：每次用其中 1 份做验证、其余 \(K-1\) 份训练，循环 \(K\) 次，最后对 \(K\) 个验证结果取平均。

它的作用像“轮流把不同一份数据拿出来当模拟考试卷”，从而降低一次随机划分带来的偶然性。对小数据集而言，单次划分可能刚好“运气好或坏”；交叉验证则给出更稳定的泛化估计。

校准（Calibration）讨论的是：模型给出的概率值，是否真的能当概率解释。分类模型不只输出“判成哪一类”，还常输出一个置信分数，例如 \(0.9\)。若一个模型在所有“预测概率约为 0.9”的样本子集上，最终真的有约 90% 预测正确，那么它就是校准良好的；若它经常把只有 60% 把握的样本说成 90%，就属于过度自信（Overconfident）。

二分类中，若模型输出正类概率 \(\hat p(x)\in[0,1]\)，理想校准条件可写成：

这里左边表示：在所有预测概率等于 \(p\) 的样本中，真实为正类的条件概率；右边的 \(p\) 是模型自己报出的概率。两者相等时，概率输出就与真实频率一致。多分类场景下，常把模型最大类别概率当作置信度，并检验“报 80% 置信度的样本，是否真的大约 80% 正确”。

校准与准确率不是同一件事。一个模型可以分类很准，但概率不可靠；也可以概率尺度较准，但分类边界并不最优。前者常见于深层神经网络：argmax 分类结果不错，但 softmax 概率偏尖，置信度系统性偏高。涉及风险控制、医学筛查、自动驾驶、检索重排、多阶段决策时，概率是否可信往往和“分对多少”同样重要，因为阈值决策、人工复核和代价加权都依赖这个概率尺度。

校准的可视化工具通常是可靠性图（Reliability Diagram）。做法是把预测置信度分成若干区间，例如 \([0.0,0.1),[0.1,0.2),\dots\)，然后对每个区间分别计算平均置信度与真实准确率。若图上的点接近对角线 \(y=x\)，说明校准较好；若点普遍落在对角线下方，说明模型报得比实际更自信；若点在对角线上方，则说明模型偏保守。

常用数值指标是期望校准误差（Expected Calibration Error, ECE）：

这里 \(M\) 是置信度分箱数， \(B_m\) 是第 \(m\) 个置信度区间中的样本集合， \(|B_m|\) 是该区间样本数， \(n\) 是总样本数， \(\mathrm{acc}(B_m)\) 是该区间的实际准确率， \(\mathrm{conf}(B_m)\) 是该区间的平均预测置信度。ECE 的含义很直接：把每个置信区间里“说得多准”和“实际多准”的差值取绝对值，再按样本占比加权平均。ECE 越小，表示整体校准越好。

另一类常见指标是 Brier Score。对二分类，它定义为：

这里 \(\hat p_i\) 是第 \(i\) 个样本的预测正类概率， \(y_i\in\{0,1\}\) 是真实标签。它既惩罚分类错误，也惩罚概率刻度不准，因此兼顾区分能力与概率质量。与单纯 Accuracy 不同，Brier Score 会区分“错得有多离谱”：把一个负样本报成 \(0.51\) 和报成 \(0.99\)，代价并不相同。

工程上最常见的后处理方法是温度缩放（Temperature Scaling）。设原始 logits 为 \(z_i\)，则缩放后的 softmax 概率写成：

这里 \(T>0\) 是温度参数。 \(T>1\) 会把分布拉平，降低过度自信； \(T<1\) 会把分布压尖，提高置信度。温度参数通常在验证集上通过最小化负对数似然（Negative Log-Likelihood, NLL）来拟合，然后固定用于测试或部署阶段。它不会改变类别排序，因此常能在几乎不影响 Accuracy 的前提下改善概率校准。

分类指标通常从混淆矩阵（Confusion Matrix）出发。设正类预测结果统计为真阳性 \(TP\)、假阳性 \(FP\)、真阴性 \(TN\)、假阴性 \(FN\)。不同指标本质上是在回答不同问题：是看“总共判对多少”，还是看“判成正类时有多准”，还是看“真实正类抓到了多少”。

准确率（Accuracy）定义为

它衡量“总体上判对了多少比例”，适合类别相对平衡、不同错误代价接近的场景。但在类别极不平衡时会误导：例如癌症筛查里，99% 都是阴性时，模型全判阴性也可能有 99% Accuracy，却毫无检测价值。

精确率（Precision）定义为

它回答的是：“所有被模型判成正类的样本里，有多少真的为正。”当误报成本很高时，Precision 特别重要。例：垃圾邮件过滤里，如果把正常邮件误判成垃圾邮件代价很高，就要关心 Precision。

召回率（Recall）定义为

它回答的是：“所有真实正类里，有多少被模型找出来了。”当漏报成本很高时，Recall 更关键。例：医学筛查里漏掉患者可能比多做一次复检更危险，因此 Recall 往往比 Precision 更重要。

F1 值（F1 Score）是 Precision 与 Recall 的调和平均：

之所以用调和平均而不是普通平均，是因为它会惩罚“一高一低”的不平衡情况。若一个模型 Precision 极高但 Recall 很低，它并不能拿到高 F1。F1 适合正负样本不平衡、且希望兼顾漏报与误报的场景。

AUC-ROC 衡量模型在不同分类阈值下区分正负样本的整体能力。ROC 曲线横轴是假阳性率（False Positive Rate），纵轴是真阳性率（True Positive Rate）。AUC 是曲线下面积，范围在 \([0,1]\)；越接近 1，说明模型越能把正样本排在负样本前面。

它不依赖某一个固定阈值，因此适合比较“排序能力”。但在极端不平衡数据上，PR 曲线（Precision-Recall Curve）常更敏感，因为 ROC 容易被大量真阴性“冲淡”。

回归指标（Regression Metrics）衡量预测值与真实值之间的数值偏差。它们关注的不是“判对类别”，而是“偏差有多大、对大误差是否敏感、模型解释了多少波动”。以房价预测为例，预测 300 万和真实 320 万之间的差距，就是典型回归误差。

平均绝对误差（Mean Absolute Error, MAE）定义为

它直接度量“平均差了多少个原始单位”，解释最直观。若房价单位是万元，MAE=12 就表示平均误差约 12 万元。由于使用绝对值，MAE 对离群点没有 MSE 那么敏感。

均方误差（Mean Squared Error, MSE）定义为

平方会放大大误差，因此 MSE 对离群点更敏感。它常用于你希望“大错要被重罚”的场景。高斯噪声假设下，最小化 MSE 还对应最大似然估计，因此它不仅是工程指标，也是概率建模结果。

均方根误差（Root Mean Squared Error, RMSE）是

它保留了 MSE 对大误差更敏感的性质，同时把单位拉回原始量纲，因此更易解释。若房价 RMSE 为 20 万元，可以直接理解为“典型误差量级约 20 万元”。

\[R^2\]（决定系数，Coefficient of Determination）回答的是：相比于最朴素的瞎猜基线，你的回归模型到底把预测提升了多少。要理解它，只需要在脑子里放两条线：一条是“什么都不知道时只能猜平均值”的水平线，另一条是模型给出的预测曲线。

先看最朴素的基线。假设你要预测一批房子的价格，但你手里没有面积、地段、楼龄这些特征，别人却逼着你给出预测。此时最不容易挨打的办法，不是胡乱报一个数字，而是对所有房子都猜样本平均价 \(\bar y\)。在散点图上，这对应一条横向的水平线。

真实房价 \(y_i\) 会散落在这条平均线的上下。每个点到平均线的垂直距离 \(y_i-\bar y\)，就是“瞎蒙平均值”时犯下的误差。把这些误差平方后全部加起来，就得到

这就是公式里的分母。它衡量的不是模型误差，而是这批数据本身原来就有多分散、多混乱。也可以把它理解为目标变量的总波动、总混沌程度，或者说“在完全不用特征时，世界原本有多少东西解释不了”。

现在再看你的模型。你训练出一个回归模型，它根据输入特征给出预测 \(\hat y_i\)。在图上，这不再是那条死板的水平线，而是一条试图穿过散点云中心的预测曲线。模型当然不可能完美，所以每个真实值 \(y_i\) 与预测值 \(\hat y_i\) 之间仍会有垂直误差，这个误差就是残差（Residual）。

把这些模型仍然没解释掉的误差平方后加起来，就得到

这就是公式里的分子，也叫残差平方和（Residual Sum of Squares, RSS）。它代表模型已经尽力之后，世界上依然残存的混沌。分子越小，说明模型越贴近真实数据；分子越大，说明模型虽然复杂，但其实没把问题解释清楚。

于是

这条式子就可以直接读成一句大白话：先看模型还剩下多少解释不了的波动，再除以最开始总共有多少波动，得到“模型搞不定的比例”；最后用 1 减掉它，剩下的就是模型成功解释掉的波动比例。

因此，若 \(R^2=0.8\)，意思不是“正确率 80%”，而是目标变量原本有 100 份波动，模型大约解释掉了其中 80 份，只剩 20 份还没解释；若 \(R^2=0\)，说明你的模型折腾半天，效果和“永远预测平均值”完全一样；若 \(R^2<0\)，则表示模型比这个最朴素基线还差，常见原因是模型设错了、特征没信息，或实现上有 bug。

从老板视角看， \(R^2\) 的灵魂拷问其实只有一句：相比直接拿平均值糊弄事，你这个复杂回归模型到底多解释了多少真实波动。这也是为什么 \(R^2\) 特别适合回答“模型有没有真正利用特征学到东西”，但它不能替代 MAE、RMSE——因为 \(R^2\) 讲的是解释比例，而不是误差到底有多少个原始单位。

优化算法（Optimization Algorithms）解决的问题非常朴素：模型参数该往哪个方向改，才能让损失函数持续下降。只要训练目标能写成“最小化某个损失函数”，背后就需要一套更新参数的规则。线性回归、逻辑回归、神经网络、大语言模型训练，本质上都绕不开这个问题。

这里要先分清两件事。优化（Optimization）关心的是“训练损失能不能降下来”；泛化（Generalization）关心的是“模型在新样本上好不好”。一个优化器可能把训练集拟合得很好，但泛化依然一般；反过来，一个优化器如果连训练损失都压不下去，模型通常也谈不上有效。因此优化算法决定的是你如何走向一个解，而不是直接保证这个解一定最好。

梯度下降（Gradient Descent）是最核心的一阶优化思想。设损失函数为 \(L(\theta)\)，参数为 \(\theta\)，则梯度 \(\nabla_\theta L(\theta)\) 给出“损失上升最快的方向”。既然梯度指向上坡，那么要让损失下降，就应沿着它的反方向更新参数：

这里 \(\theta_t\) 是第 \(t\) 步的参数， \(\eta\) 是学习率（Learning Rate），决定每一步走多大； \(\nabla_\theta L(\theta_t)\) 是当前位置的斜率信息。学习率太大，容易一步跨过谷底甚至震荡发散；学习率太小，又会下降得极慢。它像蒙着雾下山：梯度告诉你脚下哪边更陡，学习率决定你每次迈多大步。

为什么很多模型不直接“解公式”，而要反复迭代？因为在深度学习里，参数维度极高，损失面又往往非凸（Non-convex），通常没有漂亮的闭式解（Closed-form Solution）。这时最现实的办法不是一次算出全局最优，而是利用局部斜率，一步一步把损失往下压。

当总损失是逐样本损失的平均时，梯度下降还可以写得更具体：

这也回答了“为什么可以批量喂输入”：梯度对求和是线性的，整体梯度等于逐样本梯度的平均，所以可以并行算每个样本的梯度，再求平均后统一更新参数。

满足这种“逐样本求和/求平均”结构的损失函数其实非常多。典型例子包括：线性回归里的均方误差（MSE）、平均绝对误差（MAE），二分类里的 logistic loss / binary cross-entropy，多分类里的交叉熵（Cross-Entropy），语言模型训练里的负对数似然（Negative Log-Likelihood, NLL）。它们都可以写成“每个样本先各自算一份损失，再在整个数据集上取平均”的形式，因此天然适合 mini-batch 训练。

但并不是所有目标都能严格写成这种完全独立的逐样本平均。若损失显式依赖样本之间的相对关系，情况就会复杂一些。例如排序学习里的 pairwise/listwise loss、度量学习中的 triplet loss，以及对比学习里的 InfoNCE，都会让一个样本的损失依赖同一个 batch 中的其他样本。此时虽然仍然可以按 batch 计算梯度，但它已经不是“每个样本各算各的、最后简单平均”那么干净的分解了。

工程上还常见另一种情况：目标函数可以写成“逐样本平均损失 + 正则项（Regularization）”。例如

其中 \(\Omega(\theta)\) 可以是 \(\|\theta\|_2^2\) 这类参数惩罚项。前半部分仍然按样本分解，后半部分则是直接作用于参数本身，而不对应某一个单独样本。很多现代训练目标，本质上都是这两部分的组合。

几个常用训练量需要先分清：

• 批大小（Batch Size）：一次更新使用多少个样本。
• 步（Step / Iteration）：一次参数更新。
• 轮（Epoch）：完整遍历一次训练集。

若训练集大小为 \(N\)，batch size 为 \(B\)，则每个 epoch 的步数约为 \(\lceil N/B\rceil\)。工程里经常会说“训练了多少 step”，因为真正发生参数变化的是 step，而不是 epoch 这个更粗的计数单位。

批量梯度下降（Batch Gradient Descent, BGD）每次都用整个训练集来计算一次精确梯度，再更新参数。这里的 batch 指的不是现代深度学习里常说的一个 mini-batch，而是“整批训练数据”。它的优点是方向最稳定、梯度方差最小；缺点是每一步都很贵，数据一大就几乎不可用。它更适合小数据集、凸优化问题，或教材里说明“梯度下降原理”时使用。

随机梯度下降（Stochastic Gradient Descent, SGD）每次只用一个样本的梯度做更新。它的方向噪声很大，看起来像“跌跌撞撞地下山”，但每一步极便宜、更新极频繁，因此在数据流式到来或样本极多时很有价值。

• 优点：更新快、内存开销小、天然适合在线学习（Online Learning）与流式数据（Streaming Data）。
• 优点：梯度噪声有时反而是好事，更容易离开鞍点（Saddle Point）和较差的局部极小。
• 缺点：轨迹抖动大，若学习率控制不好，训练容易不稳定。

它像店长根据每一位新顾客的反馈立刻调价：反应很快，但也容易被个别顾客带偏。

适用场景：当你需要用最新样本尽快产生参数更新时，SGD（batch size=1）是最直接的选择，典型包括：

• 在线学习（Online Learning）/流式数据（Streaming Data）：样本持续到来，要求增量更新，而不是离线反复扫全量数据。
• 分布漂移（Distribution Shift）与非平稳（Non-stationary）环境：用户偏好、市场、策略对抗等持续变化，需要快速跟踪新分布。
• 低延迟更新需求：例如广告/推荐/风控的在线校准，需要“见到一条新反馈就更新一点”。
• 资源受限或样本极大：内存无法容纳大 batch 或无法频繁计算全量梯度时，用单样本更新换取更低的每步计算与存储成本。

在现代深度学习里，若使用 GPU/TPU 训练，大多数时候会用小批量梯度下降来兼顾吞吐与稳定性；纯 SGD 更常出现在在线/增量训练与部分强化学习（Reinforcement Learning, RL）设置中。

小批量梯度下降（Mini-batch SGD）是在 BGD 与 SGD 之间折中：每次用一个 batch 的平均梯度更新。它既能利用 GPU 的并行算力，又保留一定梯度噪声，因此现代深度学习几乎都在这个范式下训练。

batch 太小，梯度估计噪声会很大；batch 太大，虽然每步更稳定，但显存压力更高、更新频率更低，有时还会让优化和泛化都变钝。因此 batch size 不是“越大越好”，而是吞吐、稳定性、显存和泛化之间的折中。

单纯的梯度下降在“峡谷形”损失面里很容易左右来回震荡：沿陡峭方向上下摆动，沿真正有用的谷底方向前进却很慢。动量法（Momentum）的直觉是：不要只看当前这一脚的斜率，而要把过去几步的方向累积成一种“惯性”。

其中 \(g_t\) 是当前梯度， \(v_t\) 是累计出来的速度， \(\beta\in[0,1)\) 控制“记住过去多少信息”。 \(\beta\) 越大，方向越平滑、惯性越强；越小，则越接近普通梯度下降。类比来看，它像推一个有重量的小球下山：不会因为脚下的微小凸凹就频繁改道，而会沿长期更一致的下降方向滚动。

AdaGrad 与 RMSProp 属于自适应学习率（Adaptive Learning Rate）方法。它们的核心思想是：不同参数的梯度尺度不同，不应该所有维度都用同一个固定步长。历史上梯度很大的维度，后续步子要缩小；梯度稀疏或很小的维度，则可以走得更积极。

AdaGrad 累积历史平方梯度：

其中 \(g_t\odot g_t\) 表示逐元素平方， \(\epsilon\) 是数值稳定项。这样一来，历史上梯度一直很大的维度会被自动缩小学习率。AdaGrad 在稀疏特征（Sparse Features）任务里很有效，例如早期的文本与推荐场景；但它的问题是 \(s_t\) 只增不减，训练到后期学习率可能衰减得过头，参数几乎不再动。

RMSProp 用指数滑动平均替代“无限累积”，缓解这个问题：

这样历史信息会逐步“遗忘”，使学习率缩放更关注近期梯度尺度。可以把 AdaGrad 理解成“终身记账”，而 RMSProp 更像“滚动记账”。

Adam（Adaptive Moment Estimation）把动量法（Momentum）的一阶矩估计与 RMSProp 的二阶矩估计结合起来，因此它同时解决优化中的两个核心痛点：方向感（往哪走）与节奏感（每步走多大）。直觉上，可以把它理解为“带惯性的方向盘 + 自动变速箱”：方向由平均梯度决定，步长由梯度的尺度自动缩放。

• 索引约定：第 \(t\) 次更新先在 \(\theta_t\) 处计算 \(g_t\)，再把它并入动量得到 \(m_{t+1}\)；下标 \(t+1\) 表示“更新后状态”，不是未来信息。
• \(m_{t+1}\)：并入 \(g_t\) 后的一阶矩（动量）估计。
• 右边第一项 \(\beta_1 m_t\)：把历史动量按系数 \(\beta_1\) 保留下来，表示“历史方向对新方向的贡献”。
• 右边第二项 \((1-\beta_1)g_t\)：把当前梯度按系数 \(1-\beta_1\) 注入动量，表示“当前观测对新方向的贡献”。
• \(g_t\)：第 \(t\) 步的梯度，通常由当前 mini-batch 估计得到（\(g_t=\nabla_\theta L(\theta_t)\)）。
• \(m_t\)：一阶矩估计的滑动平均（动量项），可理解为“平均梯度方向”。
• \(\beta_1\in[0,1)\)：动量衰减系数，越大表示记忆越长、方向越平滑。

两项系数满足 \(\beta_1+(1-\beta_1)=1\)，因此这是指数滑动平均（Exponential Moving Average, EMA，越近发生的事情，参考价值越大；越久远的事情，参考价值越小）。当 \(m_0=0\) 时，可把它展开为：

上式说明：越久远的梯度 \(g_k\) 权重按 \(\beta_1^{t-k}\) 指数衰减；经验上可把有效记忆长度理解为 \(O\!\left(\frac{1}{1-\beta_1}\right)\)。因此 \(\beta_1\) 越大，平均窗口越长，方向越平滑但响应越慢；\(\beta_1\) 越小，平均窗口越短，方向更敏捷但更易受噪声影响。

RMSProp（Root Mean Square Propagation）用梯度平方的指数滑动平均（Exponential Moving Average, EMA）来估计每个参数维度的“尺度”，再用该尺度对当前梯度做逐元素归一化，从而把更新步伐控制在更稳定的量级。

• 索引约定：第 \(t\) 次更新先在 \(\theta_t\) 处计算 \(g_t\)，再用它更新得到 \(v_{t+1}\)；用 \(v_{t+1}\) 缩放 \(g_t\) 表示“用本次更新后的尺度估计做归一化”，不涉及未来信息。
• \(v_t\)：上一轮更新结束后的二阶原点矩估计（EMA 状态，“更新前的尺度缓存”）。
• \(v_{t+1}\)：梯度的二阶原点矩（Second Raw Moment）估计，逐（梯度）维近似 \(\mathbb{E}[g^2]\)，刻画“历史梯度大小”的典型尺度。
• \(g_t\odot g_t\)：当前梯度的逐元素平方（\(\odot\) 为 Hadamard 乘积），只保留幅度信息。
• \(\sqrt{v_{t+1}}\)：均方根（Root Mean Square, RMS）尺度；平方使量纲变为 \(g^2\)，开方把量纲还原到 \(g\)，从而可与 \(g_t\) 相除。
• \(\tilde g_t\)：按 RMS 尺度归一化后的梯度；分式表示逐元素相除（每个参数维度各自缩放）。
• \(\beta_2\in[0,1)\)：衰减系数，控制尺度估计的记忆长度；越大表示对历史尺度更“长记忆”。
• \(\epsilon\)：数值稳定项，避免分母为 0 或过小。

该缩放把“方向”和“尺度”解耦：方向仍由 \(g_t\) 给出；步长由 \(\sqrt{v_{t+1}}\) 自适应调节。若某维长期梯度偏大，则 \(\sqrt{v_{t+1}}\) 变大、该维更新被压小；若某维长期梯度偏小，则分母较小、该维相对步子更大。

若把 RMSProp 作为独立优化器使用，参数更新可写为 \(\theta_{t+1}=\theta_t-\eta\,\tilde g_t\)。在 Adam 中，同样的 RMS 缩放作用在一阶矩估计上：用 \(\hat m_{t+1}\) 替代 \(g_t\) 作为分子，并在下一节通过偏置修正得到 \(\hat v_{t+1}\) 作为分母。

因为 \(m_0=v_0=0\)，训练初期的滑动平均会系统性偏小（“没热起来”）。Adam 用偏置修正把它拉回合理尺度：

• \(\hat m_{t+1},\hat v_{t+1}\)：偏置修正后的估计，用来抵消初始化为 0 导致的早期偏小。
• 分母 \(1-\beta^{t+1}\)：校正“冷启动偏小”的缩放因子。由于初始化为 0，指数滑动平均在经历 \(t+1\) 次更新时只积累了约 \(1-\beta^{t+1}\) 的有效权重，因此会偏小；除以它相当于把估计值按同样比例放大回去。

更严格地说：若假设 \(\mathbb{E}[g_t]=\mu\) 近似稳定，则由递推可得 \(\mathbb{E}[m_{t+1}]=(1-\beta_1^{t+1})\mu\)，因此 \(\hat m_{t+1}=\frac{m_{t+1}}{1-\beta_1^{t+1}}\) 是把它改成近似无偏估计。同理可得 \(\hat v_{t+1}\) 的修正。

• \(\theta_t\)：第 \(t\) 步参数（权重向量/张量）。
• \(\eta\)：学习率（全局步长系数）。
• \(\sqrt{\hat v_{t+1}}\)：逐元素开方；整项 \(\frac{\hat m_{t+1}}{\sqrt{\hat v_{t+1}}+\epsilon}\) 表示逐元素相除。
• \(\epsilon\)：数值稳定项，避免除以 0 或极小数。

分子给方向，分母给节奏。一个极端例子能看出为什么 Adam 用 \(\mathbb{E}[g^2]\) 而不是方差：若某维梯度连续很多步都是 \(g_t=10\)，方差为 0 会导致除法不稳定；但 \(\mathbb{E}[g^2]\approx 100\) 给出稳定尺度，最终更新量级约为 \(10/\sqrt{100}=1\)（再加 \(\epsilon\) 保底）。

Adam 往往更易调参、早期收敛更快，因此在 Transformer、扩散模型和很多深度网络里是默认起点。但它并不是无条件最好：有些任务上，最终泛化仍可能不如精心调过的 SGD。实践中，配合权重衰减（Weight Decay）时，通常会使用 AdamW，把权重衰减从梯度自适应缩放里解耦出来，效果更稳。

AdamW（Adam with Decoupled Weight Decay）把权重衰减（Weight Decay）从 Adam 的自适应梯度缩放里解耦出来。原因是：在 Adam 这类自适应方法里，如果你把 L2 正则化写进损失（等价于把 \(\lambda\theta\) 加到梯度里），这个正则项也会被二阶矩 \(\hat v_t\) 的缩放影响，从而导致不同参数维度的“衰减强度”不再可控。

正则化本来应该是一个可控的、与梯度尺度无关的收缩力度；解耦后 \(\lambda\) 的含义更稳定。

对比两种写法会更清楚：

• 把 L2 正则化并入目标（常被口语化地称为“weight decay”，但在自适应优化器里并不等价）：先算 \(g_t=\nabla_\theta L(\theta_t)+\lambda\theta_t\)，再把这个 \(g_t\) 送入 Adam 的 \(m_t,v_t\) 与自适应步长。
• AdamW（解耦权重衰减）：先算纯数据梯度 \(g_t=\nabla_\theta L(\theta_t)\) 并完成 Adam 的自适应更新，然后单独对参数做一次权重衰减。

AdamW 的参数更新可写成：

• 前半段 \(-\eta\,\frac{\hat m}{\sqrt{\hat v}+\epsilon}\)：Adam 的自适应梯度更新（由数据损失驱动）。
• 后半段 \(-\eta\,\lambda\,\theta_t\)：解耦的 weight decay（参数按比例收缩），其中 \(\lambda\) 是衰减强度。

其中第一项是 Adam 的自适应更新，第二项是独立的权重衰减（等价于每步把权重按比例拉向 0）。这种分离让 \(\lambda\) 更像一个真正可解释的“收缩强度”，在 Transformer 等模型上通常更稳定、更好调。工程实现里常见做法是：对 bias 与归一化层参数（如 LayerNorm 的 \(\gamma,\beta\)）不做 weight decay，以免对尺度/偏置项造成不必要的收缩。

Muon 是一种面向神经网络隐藏层（Hidden Layer）权重矩阵（Weight Matrix）的优化器。它与 Adam/AdamW 的根本差异在于：AdamW 会为每个参数维度单独估计更新尺度，并对梯度/更新量做逐元素（Element-wise）归一化；Muon 则把一个二维权重张量视为一个整体，直接利用矩阵结构来塑造更新方向。因此，Muon 更像一种矩阵感知（Matrix-aware）的优化器。

它的核心做法不是改变“沿梯度下降”这个大方向，而是改变“更新张量应该具有什么几何形状”。典型写法可以概括为：先对梯度做动量（Momentum）累积，再把这个矩阵更新做一次正交化（Orthogonalization）后处理，然后才真正更新参数：

这里 \(G_t\) 是当前梯度矩阵， \(M_t\) 是动量缓冲， \(\mathrm{Orth}(\cdot)\) 表示把更新矩阵变换到更“接近正交（Orthogonal）”的形状。工程实现里，这一步通常用 Newton-Schulz 迭代（Newton-Schulz Iteration）高效近似完成，因此 Muon 常被概括为“对动量更新做正交化”。

• 优势：对线性层/MLP/注意力里的二维权重矩阵，Muon 往往能给出更结构化的更新方向；在一些大模型训练设定下，它的训练效率与收敛速度优于 AdamW。
• 边界：Muon 不是全参数通吃的默认方案。它通常只用于隐藏层的二维参数；embedding、bias、归一化参数、输出层等非二维或语义不同的参数，实践中常继续交给 AdamW。
• 工程特征：它强调更新矩阵的谱结构（Spectral Structure），而不是单个坐标的独立缩放；因此超参数分组与参数类型划分比 AdamW 更重要。

可以把 AdamW 与 Muon 的差别记成一句话：AdamW 解决“每个参数该走多大步”，Muon 进一步关心“整个矩阵应该以什么形状移动”。因此 Muon 更像是隐藏层矩阵优化的专用工具，而不是对所有参数一视同仁的通用默认项。

学习率（Learning Rate）往往是最敏感的超参数之一。即使优化器相同，只要学习率设错，训练就可能完全失败。学习率调度（Learning Rate Scheduling）/退火（Annealing）的核心思想是：前期用相对大的步长快速下降，后期逐渐减小步长做精细收敛。

常见调度方式包括：

• Step decay：按 epoch 或 step 乘以固定因子衰减，简单直接。
• Linear decay：线性下降到较小值或 0，常用于大模型训练后段。
• Warmup + decay：先小步热身，再进入正常学习率，最后逐步衰减；对 Transformer 和大 batch 训练尤其常见。
• 余弦退火（Cosine Annealing）：将学习率从较大值逐步衰减到较小值，把优化从“高温探索”过渡到“低温收敛”，在训练后期降低梯度噪声（gradient noise）与过冲（overshoot）风险，使参数能在极小值附近稳定细化。余弦曲线在起点与终点的一阶导数为 0，避免阶梯式衰减的突变，因而衰减更平滑、后期更柔和。

Warmup 为什么有用？因为训练刚开始时，参数还处在一个非常“生”的区域，梯度统计不稳定，若一上来就用很大学习率，模型容易发散。先用较小步长热身几百或几千步，再拉到目标学习率，通常更稳。

余弦退火的典型写法（从 \(\eta_{\max}\) 衰减到 \(\eta_{\min}\)）为：

• \(\eta(t)\)：第 \(t\) 步使用的学习率。
• \(\eta_{\max}\) / \(\eta_{\min}\)：一个退火周期内的最大学习率与最小学习率。
• \(t\)：当前步数（通常从 0 开始计），\(T\)：该周期的总步数。

这个公式可以直接做两次代入来验证边界：当 \(t=0\) 时，\(\cos(0)=1\)，所以 \(\eta(0)=\eta_{\max}\)；当 \(t=T\) 时，\(\cos(\pi)=-1\)，所以 \(\eta(T)=\eta_{\min}\)。中间学习率按半个余弦周期平滑下降。

通过余弦（Cosine）提供了一个非常干净的端点平滑（smooth endpoints）性质：在起点和终点处变化率为 0。对上式求导可得

因此 \(\sin(0)=\sin(\pi)=0\)，学习率在周期开始与结束都不会出现突兀的“拐点”。相比之下，step decay 有不连续跳变，linear decay 在末端通常会突然到达下限并停止变化（出现不光滑的折点）。在非凸深度网络里，这种平滑退火往往更稳：前期保持较大步长便于探索，后期自然减小步长便于精细收敛。

工程上常见扩展是余弦重启（Cosine Annealing with Warm Restarts, SGDR）：把训练过程切成多个周期，每个周期把 \(t\) 重新从 0 开始计（并可逐周期拉长 \(T\)）。在标准 SGDR 中，学习率在周期边界是不连续的：它会在一个周期末端衰减到 \(\eta_{\min}\)，并在下一个周期起点从 \(\eta_{\max}\) 重新开始（参数 \(\theta\) 不会重置）。

这种“重启”的作用不是为了制造噪声，而是把优化过程从“后期小步精修”短暂切回“较大步长探索”，以应对非凸问题中的平台区（plateau）与次优盆地（suboptimal basin）。学习率拉高会增大每步更新幅度与梯度噪声（gradient noise）的有效影响，帮助轨迹跳出当前区域并探索新的吸引域；而如果当前区域确实是更稳健的平坦极小值（flat minimal），后续退火通常会把参数再次拉回并在附近更精细地收敛。工程上常见做法是把 \(\eta_{\max}\) 设在“不会破坏稳定性”的范围内；若重启瞬间仍担心不稳定，也可以在每次重启后加一个很短的 warmup，让学习率在少量步数内从较小值爬升到 \(\eta_{\max}\)。

没有一种调度策略对所有任务都最好。真正有效的做法是结合损失曲线、梯度稳定性、验证集表现和训练预算一起看：如果前期降不动，往往学习率偏小；如果剧烈震荡甚至发散，往往学习率偏大；如果后期长期卡在平台区，通常需要更细的衰减策略。

集成学习（Ensemble Learning）的核心思想是：不要把预测完全押在一个模型上，而是让多个模型以某种组织方式共同决定结果。它背后的统计直觉并不神秘：如果多个模型的误差来源不完全相同，那么组合后的总误差通常会更小、更稳、更抗偶然扰动。

从误差分解视角看，集成学习最常见的两条路线分别在处理两种不同问题。Bagging 更擅长压低方差（Variance），适合“单个模型很容易被训练集波动带偏”的情形；Boosting 更擅长逐步降低偏差（Bias），适合“单个弱学习器表达力不够，但可以通过连续修正变强”的情形。树模型恰好非常适合这两条路线：单棵深树高方差，适合拿去做 Bagging；浅层回归树可作为局部纠错器，适合拿去做 Boosting。

Bagging（Bootstrap Aggregating）的核心做法是对训练集进行多次自助采样（bootstrap sampling），即反复执行有放回采样（sampling with replacement）生成多个训练子集，并在这些子集上分别训练基模型，以降低方差（Variance）。由于每个模型见到的数据子集略有差异，学到的决策边界不会完全一致；最后对预测结果做平均或多数投票，可抵消一部分过拟合噪声。

Bagging 的关键不在“模型一定很多”，而在人为制造模型之间的差异性。如果每个基模型看到的训练数据完全相同、特征也完全相同、优化过程也完全相同，那么把它们重复训练很多次并不会带来真正互补的信息。bootstrap 采样、特征子采样、不同随机初始化，本质上都在做同一件事：让多个模型不要犯完全一样的错。

例：如果单棵决策树很容易被训练集中的偶然样本带偏，那么训练 100 棵在不同 bootstrap 样本上的树，再投票，通常会比只用 1 棵树稳定得多。这也是随机森林的核心直觉。

Boosting 的思路与 Bagging 相反：它不是“并行训练很多彼此独立的模型”，而是“串行训练一串弱学习器（Weak Learners），让后一个模型专门修正前一个模型没做好的部分”。因此它更像“老师批改作业”：每一轮都盯着上轮最容易出错的题继续强化。

以加法模型视角看，Boosting 逐步构造

其中 \(h_m(x)\) 是第 \(m\) 个弱学习器， \(\alpha_m\) 是它的权重。公式不是为了堆符号，而是在表达：最终模型是“很多个简单模型的加权和”，每一轮都往当前模型上加一小块“修正项”。

这类“接力纠错”最直观的理解，是把当前模型与真实目标之间的差距看成下一轮的新任务。回归里，这个差距常直接表现为残差；更一般地，在可微损失下，它表现为损失对当前预测的负梯度。于是每一轮不再去重学整个标签，而是只学“接下来该往哪里补”。这就是 GBDT 家族能持续逼近目标函数的根本原因。

这里还可以再区分两种常见实现。较早的 Boosting，如 AdaBoost，更强调把之前分错的样本权重调高，让后续弱学习器更多关注难样本；GBDT 这一支则更强调直接拟合当前损失的残差或负梯度。两者都属于“串行纠错”，只是把“错误信息”传给下一轮的方式不同。

Boosting 也解释了为什么这类模型通常使用较浅的小树作为基学习器。因为每一棵树的职责不是独立解决全问题，而是在当前模型基础上补一个局部修正。如果每棵树都长得很深、很强，单轮就可能把训练集吃得过满，后续串行叠加更容易过拟合；若每棵树只做小而稳的修正，再配合学习率与早停，整体通常更可控。

Stacking（堆叠集成）不只是平均多个模型输出，而是再训练一个元学习器（Meta-Learner）去学习“什么时候该信哪个模型”。例如一个基模型擅长处理稀疏文本特征，另一个擅长处理数值特征，Stacking 可以学会在不同样本上动态加权它们。

它像“专家会诊 + 总负责人”：若文本模型和表格模型各有专长，元模型就负责综合判断谁在当前病例上更可信。

机器学习编程（Machine Learning Programming）处理的核心问题是：当一个模型被写成代码并真正运行起来时，谁负责组织训练流程，谁负责表达数学操作，谁又负责在具体硬件上把这些操作算快。这三层通常分别对应编程框架（Framework）、算子（Operator）和内核（Kernel）。理解这三个层次，有助于把“模型公式”与“工程实现”连接起来。

它们不是彼此独立的三个名词，而是一条自上而下的执行链。研究者或工程师先在框架里定义模型结构与训练流程；框架再把模型拆成一系列算子，例如矩阵乘法、卷积、归一化、激活、softmax；每个算子最终还需要落到某个硬件相关的内核实现上，才能在 CPU、GPU、TPU 或其他加速器上真正执行。因此，框架决定开发体验，算子决定计算图语义，内核决定实际运行效率。

框架（Framework）并不是单一层次的概念。在现代机器学习工程里，至少要区分两层：一层是基础框架（Foundational Framework），负责张量（Tensor）、自动求导（Automatic Differentiation）、算子调度与底层执行；另一层是高层框架（High-level Framework），负责把某一类模型、某一类训练范式或某一类工程流程封装成更直接的接口。前者提供“地基”，后者提供“脚手架”和“现成结构”。

因此，PyTorch、TensorFlow、JAX 这类系统更适合放在基础框架层；而 Transformers、DeepSpeed、ModelScope、Lightning 这类工具，则更适合放在高层框架层。它们之间不是替代关系，而是典型的上下层关系：高层框架通常建立在基础框架之上，用更强的任务抽象、更少的模板代码和更完整的工程能力，把常见训练与推理流程直接组织起来。

从工程使用频率看，开发者最常接触的是一组已经按职责分层的常见框架：高层框架负责组织训练与推理流程，基础框架负责真正执行张量计算，某些系统还进一步偏向执行优化与部署。把这些名字放回分层结构里理解，比孤立记忆框架名称更清楚。

高层框架的核心价值在于，它们不重新发明张量计算和自动求导，而是在基础框架之上增加更强的任务语义、训练编排、模型生态或分布式能力。很多工程里，开发者日常接触最多的其实是这一层。

这一层最容易让人产生“它自己就能训练模型”的直觉，但从执行链条看，它们大多只是把训练过程组织得更高级。以 Transformers 为例，Trainer 可以发起训练，但底层的张量、梯度、优化器、自动求导与设备执行，通常仍然由 PyTorch 负责；Lightning、Accelerate、DeepSpeed 也是同样的逻辑，只是它们封装的侧重点不同。

Unsloth 最适合放在高层框架这一层理解。它并不重新定义 Tensor、自动求导（Autograd）或底层计算图，而是在 PyTorch、Transformers、PEFT、TRL 这一整套既有生态之上，把大语言模型（Large Language Model, LLM）的高频训练流程重新组织成更偏性能导向的开发体验。它解决的核心问题不是“怎样从零实现神经网络”，而是怎样在尽可能小的显存和尽可能少的工程样板下，把 LLM 微调、对齐、导出与部署这条链路跑通。

从开发者视角看，Unsloth 的典型工作流通常仍然是“加载 Hugging Face 模型 → 挂接 PEFT 适配器 → 用监督微调（SFT）或强化学习（RL）训练 → 导出到下游推理栈”。它的价值在于把这条链上几个最痛的环节一起压平：第一，量化微调（如 LoRA / QLoRA）与长上下文训练更容易直接落地；第二，针对 GRPO 等对齐训练给出更直接的入口；第三，把训练后的模型或适配器导出到 GGUF、Ollama、vLLM、SGLang、Hugging Face 等下游环境的路径做得更短。换言之，Unsloth 不是另起炉灶，而是把已有生态串得更紧，并对其中最贵的显存、最长的上下文和最复杂的导出环节做专项优化。

它与其他高层框架的边界也需要分清。Transformers 的优势在于模型家族与任务头生态最通用；Accelerate 更像多设备执行抽象；DeepSpeed 更偏分布式训练、参数分片与大规模集群优化；Unsloth 则把重心压在“单机到小规模多卡场景下，如何更快、更省显存地完成 LLM 微调与对齐”。因此，它尤其适合消费级 GPU、本地实验、小团队快速验证、Notebook 驱动的训练流程，以及以 LoRA / QLoRA / RL 为主的大模型增量训练。若任务是超大规模集群预训练或需要复杂的跨机并行策略，DeepSpeed / Megatron 一类系统通常仍然更中心；若任务是通用模型调用与标准微调，Transformers 仍然是最基础的入口。

工程上可以把 Unsloth 看成“面向 LLM 微调的高性能工作台”。它一端连接 Hugging Face 模型与适配器生态，另一端连接本地推理、GGUF、Ollama、vLLM、SGLang 等部署路径，中间则用一套更偏性能调优的训练封装把它们粘起来。对初学者，它降低的是上手门槛：少改几处配置就能跑通量化微调或 RL；对熟悉生态的工程师，它降低的是试验成本：同样的显存预算下，能尝试更长上下文、更复杂的对齐流程，或更快地把训练结果导出到不同推理栈。它的本质依然是高层工程抽象，而不是底层深度学习框架的替代品。

基础框架直接定义张量运算、计算图、自动求导、优化器、算子调度与设备执行能力。它们离硬件更近，也离“神经网络真正怎样被算出来”更近。高层框架能否存在，首先取决于这一层是否提供了足够稳定和强大的底座。

nn.Module

如果把机器学习工程比作建楼，那么基础框架提供的是钢筋、水泥、电路和承重结构。高层框架之所以能让开发速度显著提升，正是因为底层这些张量、梯度和算子能力已经由基础框架稳定提供。

除了高层框架和基础框架，还存在一类经常与“框架”混称、但职责不同的系统：执行与部署系统。它们的核心目标不是让用户更方便地写模型，而是让已经定义好的模型在特定硬件上更快、更省、更稳定地运行。

因此，讨论“框架”时最好先分清是哪一层：高层框架负责把任务和流程组织起来，基础框架负责把张量与梯度真正算出来，执行与部署系统负责把已经定义好的模型在目标硬件上跑到更优。这三层一旦混在一起，很多看似相近的名词就会失去边界。

算子（Operator）是计算图（Computation Graph）的基本运算单元。它定义一个明确的数学变换：输入什么张量（Tensor）、输出什么张量、张量的形状（Shape）和数据类型（Data Type）如何变化，以及反向传播时梯度如何计算。框架层写出的模块、层、网络块，最终都会被拆解成一串更细粒度的算子。

从工程实现上看，算子这一层负责表达“数学语义”。例如一个线性层（Linear Layer）会被拆成 MatMul 与 Bias Add；一个自注意力（Self-Attention）模块会被拆成 Q/K/V 投影、MatMul、Scale、Mask、Softmax、再一次 MatMul、Dropout、LayerNorm 等。高层模块能否被编译优化，本质上取决于这些算子能否被识别、融合与高效执行。

常用算子可以分成四大类：线性代数与张量形状类、神经网络前向计算类、序列与索引操作类、训练与优化类。下面的表格按这一方式展开。

因此，算子层是连接“模型定义”和“底层执行”的语义中枢。看懂模型实际调用了哪些算子，基本就等于看懂了它在做哪些数学步骤，以及这些步骤能否被进一步融合和加速。

内核（Kernel）是算子的底层实现。它规定了某个算子如何映射到具体硬件：线程如何组织、数据如何分块、是否使用共享内存（Shared Memory）、是否调用向量化指令、是否走 Tensor Core、是否把多个小算子融合成一次执行。若说算子定义的是“做什么”，那么内核定义的就是“怎样在这台机器上把它做快”。

从性能工程角度看，内核层回答的是：同一个数学算子，针对不同硬件、数据形状、精度格式和访存模式，哪种实现最优。这也是为什么表面上同样是 MatMul、LayerNorm 或 Attention，不同框架和后端的速度会相差很大。

常见内核或内核族可以按下表理解：

理解内核时最重要的一点是：一个算子并不对应唯一实现。同样是卷积，可以选 direct convolution、Winograd 或 FFT；同样是 attention，可以选普通分步实现、FlashAttention 或推理场景下的 paged attention。真正的差异往往不在数学定义，而在访存方式、融合策略、并行粒度和硬件利用率上。

因此，内核并不是建模阶段最先暴露给用户的对象，却往往决定模型最终的吞吐、时延、显存占用、能耗和成本。模型结构决定“上限在哪里”，内核质量决定“这个上限能兑现多少”。

把三者串起来看，一个卷积层或注意力层的执行路径通常是这样的：开发者先在 PyTorch 或 JAX 中写出一个模块；框架把它拆成若干算子，例如 MatMul、Softmax、LayerNorm 或 Convolution；运行时再为每个算子选择对应硬件上的 kernel，例如 cuBLAS 的 GEMM kernel、cuDNN 的 convolution kernel，或 Triton 写成的自定义 fused kernel。整个训练与推理过程由框架负责调度，算子负责表达数学语义，内核负责把语义变成高性能机器代码。

可以用一个具体例子来理解。若在 PyTorch 中定义一个卷积层，那么：

1. PyTorch 作为框架负责接收模块定义、组织张量、记录梯度关系并调度执行。
2. 卷积（Convolution）作为算子表示“输入特征图与卷积核做局部加权求和”这一数学操作。
3. 底层可能调用 cuDNN 提供的卷积 kernel，在 GPU 上以高度优化的方式完成真正计算。

同样地，在 Transformer 中写一层自注意力时，框架会组织前向与反向图；MatMul、Softmax、Mask、LayerNorm 等作为算子组成计算链；而 FlashAttention、fused LayerNorm、paged attention 这类高性能实现，则属于内核或 kernel-level optimization 的范畴。

因此，这三个层次的关系可以概括为：框架管理整个建模与执行流程，算子定义模型中的数学步骤，内核负责把这些步骤在具体硬件上高效落地。从研究到工程落地的能力鸿沟，往往正体现在能否同时理解这三层。

经典机器学习的模型选择，本质上是在任务形式、数据规模、特征形态、可解释性要求、训练与推断成本之间做匹配。只要先判断“有没有标签”“输出是什么类型”“样本量有多大”“特征是不是稀疏或非线性”“是否需要概率或规则解释”，大多数任务都可以迅速缩小到少数几个候选模型。

本章中的模型并不是按“先进程度”排序，而是按建模假设来区分。线性模型假设边界或关系接近线性；树模型更擅长表格数据中的非线性交互；概率模型更强调分布解释；近邻模型依赖局部相似性；聚类与降维模型关注无监督结构；HMM（Hidden Markov Model, HMM）和条件随机场（Conditional Random Field, CRF）则处理序列标签之间存在依赖的结构化预测问题。

下面的表格不是概览式罗列，而是直接服务于选型。每一行都回答五个问题：什么情况下优先选它、它最依赖什么数据条件、它能解决什么核心诉求、为什么它在该场景里合适、以及什么情况下应当换模型。在大多数工程场景里，先按这些表格缩小范围，再进入具体模型细节，效率最高。

若只是要一个工程上可执行的默认起点，可以进一步压缩成如下规则：表格分类与回归优先从随机森林、GBDT、XGBoost、LightGBM 和线性模型里选；文本高维稀疏分类优先看逻辑回归和朴素贝叶斯；无监督分群先看 K-Means，再根据簇形状和噪声情况转向 DBSCAN、HDBSCAN 或 GMM；需要可视化时先区分是要线性压缩还是只要展示结构，再在 PCA、LDA、t-SNE、UMAP 中选择；涉及标签序列依赖时再进入 HMM 与 CRF。

线性模型（Linear Models）的核心不是“世界一定是线性的”，而是先用一个可解释、可优化、常常足够强的基线去刻画输入与输出的关系。很多复杂模型也可以看作“在线性读出层之前先做更强的特征变换”。

线性回归（Linear Regression）在回归任务中建模“输入特征的加权求和如何产生连续输出”。它的价值在于：可解释（权重直接对应特征影响）与可优化（凸问题，训练稳定）。

给定训练集 \(\{(\mathbf{x}_i,y_i)\}_{i=1}^{N}\)，其中 \(\mathbf{x}_i\in\mathbb{R}^d\) 是第 \(i\) 个样本的特征向量， \(y_i\in\mathbb{R}\) 是对应标签。线性回归假设单样本预测为：

• \(\hat y_i\)：对 \(y_i\) 的预测。
• \(\mathbf{w}\in\mathbb{R}^d\)：权重向量（每个维度对应一个特征）。
• \(b\in\mathbb{R}\)：偏置（Bias），用于整体平移。
• \(\mathbf{w}^\top \mathbf{x}_i\)：内积（Dot Product），表示“按特征加权求和”。

把全部样本写成矩阵形式。令设计矩阵（Design Matrix）\(\mathbf{X}\in\mathbb{R}^{N\times d}\) 的第 \(i\) 行为 \(\mathbf{x}_i^\top\)，标签向量 \(\mathbf{y}\in\mathbb{R}^{N}\) 的第 \(i\) 个分量为 \(y_i\)，全 1 向量 \(\mathbf{1}\in\mathbb{R}^{N}\)。则：

直觉类比：它像“按因素打分再加总”。例如房价预测里，面积、地段评分、楼龄都可作为特征；权重正负决定影响方向，绝对值大小决定影响强弱。

最常见的训练目标是最小化均方误差（Mean Squared Error, MSE）的总和（或平均）：

这个目标可以拆成三部分理解：第一项 \(\frac{1}{N}\|\mathbf{y}-\mathbf{X}\mathbf{w}-b\mathbf{1}\|_2^2\) 是数据拟合误差，其中 \(\mathbf{y}-\mathbf{X}\mathbf{w}-b\mathbf{1}\) 是所有样本的残差向量；第二项 \(\lambda_1\|\mathbf{w}\|_1\) 倾向把一部分权重直接压到 0；第三项 \(\lambda_2\|\mathbf{w}\|_2^2\) 倾向把权重整体缩小得更平滑。这里 \(N\) 是样本数， \(\lambda_1,\lambda_2\) 是正则化强度。若两者都取 0，就退化为普通最小二乘。

• \(J(\mathbf{w},b)\)：目标函数（Objective）。
• \(\|\cdot\|_2\)：二范数（Euclidean Norm），向量的长度。

平方项会对大残差施加更大惩罚，因此训练会优先修正“偏得很离谱”的样本。并且在高斯噪声假设下，最小二乘等价于最大似然估计（Maximum Likelihood Estimation, MLE）导出的解。

把偏置吸收到特征中更方便：定义增广特征 \(\tilde{\mathbf{x}}_i=[\mathbf{x}_i;1]\in\mathbb{R}^{d+1}\)，增广参数 \(\tilde{\mathbf{w}}=[\mathbf{w};b]\in\mathbb{R}^{d+1}\)，增广矩阵 \(\tilde{\mathbf{X}}=[\mathbf{X},\mathbf{1}]\in\mathbb{R}^{N\times(d+1)}\)。则 \(\hat{\mathbf{y}}=\tilde{\mathbf{X}}\tilde{\mathbf{w}}\)，目标为 \(\min_{\tilde{\mathbf{w}}}\|\mathbf{y}-\tilde{\mathbf{X}}\tilde{\mathbf{w}}\|_2^2\)。若 \(\tilde{\mathbf{X}}^\top\tilde{\mathbf{X}}\) 可逆，则正规方程（Normal Equation）给出闭式解：

这里 \(\tilde{\mathbf{w}}^*\) 表示最优增广参数，前 \(d\) 维对应原权重 \(\mathbf{w}\)，最后一维对应偏置 \(b\)。 \(\tilde{\mathbf{X}}^\top\tilde{\mathbf{X}}\) 汇总了特征之间的相关结构， \(\tilde{\mathbf{X}}^\top\mathbf{y}\) 汇总了特征与标签之间的相关程度，因此这个闭式解本质上是在“用整体相关关系一次性解出最优线性系数”。

• \(\tilde{\mathbf{X}}^\top\tilde{\mathbf{X}}\in\mathbb{R}^{(d+1)\times(d+1)}\)：Gram 矩阵，度量特征之间的相关性。
• \((\cdot)^{-1}\)：矩阵逆；不可逆时通常用伪逆（Pseudo-inverse）或加正则化处理。

工程实现中，直接求逆并不推荐；更稳定的做法是解线性方程组或用 QR/SVD 分解。

用一维数据拟合 \(y\approx wx+b\)。给定三点 \((x,y)\in\{(0,1),(1,3),(2,5)\}\)。构造增广矩阵与标签：

这个增广矩阵的每一行对应一个样本；第一列是原始特征 \(x\)，第二列固定为 1，用来把偏置 \(b\) 并入矩阵乘法。标签向量 \(\mathbf{y}\) 则把三个样本的真实输出按顺序堆叠起来。

计算：

左边的矩阵可以看成所有样本在“特征与偏置”两个方向上的二阶统计量： \(5\) 来自 \(0^2+1^2+2^2\)， \(3\) 来自 \(0+1+2\)，右边向量 \(\tilde{\mathbf{X}}^\top\mathbf{y}\) 则分别对应 \(\sum_i x_i y_i\) 与 \(\sum_i y_i\)。这正是正规方程所需要的汇总量。

解线性方程 \(\left(\tilde{\mathbf{X}}^\top\tilde{\mathbf{X}}\right)\tilde{\mathbf{w}}=\tilde{\mathbf{X}}^\top\mathbf{y}\)，即：

这组方程的未知量只有两个：斜率 \(w\) 和偏置 \(b\)。解出 \(w=2\) 表示特征每增加 1，预测值增加 2；解出 \(b=1\) 表示当 \(x=0\) 时，模型基线输出为 1。

因此预测为 \(\hat y=2x+1\)，恰好穿过三点。这个例子展示了：正规方程把“最小化平方误差”的优化问题，转换成一个线性方程组。

• 需要可解释的特征贡献（权重）与可校验的线性关系。
• 表格数据（Tabular）中，关系接近线性或可通过特征变换/交互项线性化。
• 作为强基线：先用线性模型定位数据问题、特征质量与噪声水平，再决定是否需要更复杂模型。
• 高维稀疏特征（如 one-hot、文本 bag-of-words）下，配合正则化可获得稳定解。

当特征很多、共线性（Collinearity）强或数据量相对不足时，普通最小二乘（Ordinary Least Squares, OLS）会出现高方差：训练集拟合很好、验证集误差上升。正则化（Regularization）通过惩罚参数规模，把“拟合训练误差”与“控制模型复杂度”写进同一个目标函数。

Lasso 把参数惩罚写成一范数（\(L_1\) Norm）：

这个式子里，前半部分仍然是拟合误差，衡量预测和真实标签之间差多少；后半部分 \(\lambda\|\mathbf{w}\|_1\) 是稀疏惩罚，其中 \(\|\mathbf{w}\|_1=\sum_j |w_j|\) 会优先把不重要的权重压成 0。于是 Lasso 不只是“把权重变小”，而是经常顺带完成特征选择。

• \(\lambda\ge 0\)：正则化强度（Regularization Strength）。越大表示越强的收缩。
• \(\|\mathbf{w}\|_1=\sum_{j=1}^{d}|w_j|\)：一范数，鼓励稀疏（Sparsity）。
• 通常不惩罚偏置 \(b\)；否则会把整体均值也一起往 0 拉。
• Lasso 由于 \(|\cdot|\) 在 0 点不可导，一般没有像岭回归那样简洁的闭式解；常用坐标下降（Coordinate Descent）、近端梯度（Proximal Gradient）或 LARS 等算法求解。

Lasso 的关键作用是让一部分权重被压到精确 0，而不是均匀缩小全部权重。它更像给参数设置了一个阈值：弱相关、贡献不足以抵消惩罚的特征，会被直接剔除。因此 Lasso 同时完成复杂度控制与特征选择（Feature Selection）。

几何上，在相同训练误差轮廓线下， \(L_1\) 约束对应菱形/正八面体；这些尖角更容易与最优点相交在坐标轴上，因此常出现某些 \(w_j=0\) 的解。

• 适合高维稀疏特征、希望自动筛特征的场景，例如广告、推荐、文本 one-hot 特征。
• 当特征高度相关时，Lasso 往往只保留其中少数几个，因此解的稳定性通常弱于岭回归。

岭回归把参数惩罚写成二范数平方（\(L_2\) Norm Squared）：

岭回归的结构与普通线性回归相同，只是在误差项之外额外加入了 \(\lambda\|\mathbf{w}\|_2^2\)。这里 \(\|\mathbf{w}\|_2^2=\sum_j w_j^2\) 会连续惩罚过大的权重，因此它更擅长缓解共线性和过拟合，而不是像 Lasso 那样主动做稀疏选择。

• \(\lambda\ge 0\)：正则化强度。越大表示越强的收缩。
• \(\|\mathbf{w}\|_2^2=\sum_{j=1}^{d}w_j^2\)：二范数平方，连续惩罚大权重。
• 通常不惩罚偏置 \(b\)；否则会把整体均值也一起往 0 拉。

从梯度角度看，惩罚项 \(\lambda\|\mathbf{w}\|_2^2\) 对单个参数 \(w_j\) 的梯度贡献是 \(2\lambda w_j\)。这就是 \(L_2\) 正则化在深度学习中被称为权重衰减（Weight Decay）的原因：它持续把权重按比例拉回 0。若取 \(\lambda=1\)，当 \(w_j=10\) 时，梯度为 \(20\)；优化器会施加强烈收缩，把这个大权重猛拉回去。当 \(w_j=0.1\) 时，梯度只有 \(0.2\)；往 0 拉的力量就很弱。也就是说，参数一旦变大， \(L_2\) 惩罚立刻增强；参数已经很小时，它几乎不再干预。

岭回归仍是凸二次问题，并有闭式解（忽略/已中心化处理 \(b\) 的情况）：

与普通最小二乘相比，这里多出来的 \(N\lambda\mathbf{I}\) 是沿对角线加入的一项稳定化修正。 \(\mathbf{I}\) 是单位矩阵，它不会改变特征之间的相对结构，但会让矩阵更容易求逆，因此在特征高度相关时更稳定。

• \(\mathbf{I}\in\mathbb{R}^{d\times d}\)：单位矩阵（Identity Matrix）。
• \(\mathbf{X}^\top\mathbf{X}+N\lambda\mathbf{I}\)：对角线上加了 \(N\lambda\) 的稳定项，缓解共线性导致的病态（Ill-conditioning）。

用一个最小可算的例子说明 \(\lambda\) 如何改变解。考虑无偏置的一维回归 \(\hat y=wx\)，目标为：

这是单变量岭回归的简化形式。前一项把所有样本的平方误差加总，后一项 \(\lambda w^2\) 惩罚过大的斜率。它清楚展示了岭回归的核心：既要求拟合数据，又限制参数不要长得太大。

对 \(w\) 求导并令其为 0 得：

这个结果说明岭回归解和普通最小二乘解非常接近，只是分母里多了一个 \(\lambda\)。它会把估计值往 0 方向收缩： \(\lambda\) 越大，分母越大，得到的 \(w^*\) 就越保守。

可见 \(\lambda\) 直接进入分母，把 \(w^*\) 持续拉向 0。岭回归不会像 Lasso 那样大量制造精确 0，而是把所有权重更平滑地压小，因此更像“把所有旋钮都往小一点拧”，让模型整体更保守、更稳健。

• 适合特征高度相关、希望保留全部特征但降低方差的场景；常见于经济学、医学和一般表格数据。
• 当既希望稀疏，又希望在强相关特征间保持稳定时，Elastic Net（\(L_1+L_2\)）通常比纯 Lasso 更稳。

Elastic Net 把 \(L_1\) 与 \(L_2\) 惩罚合并到同一个目标中：

它同时保留两类效应： \(L_1\) 项负责产生稀疏性（Sparsity），把一部分弱特征压到 0； \(L_2\) 项负责平滑收缩，在特征高度相关时提高解的稳定性。因此 Elastic Net 通常用于“既希望自动做特征选择，又不希望在强相关特征之间选得过于激进”的场景。

• 当 \(\lambda_2=0\) 时，退化为 Lasso。
• 当 \(\lambda_1=0\) 时，退化为岭回归（Ridge Regression）。
• 当特征高度相关且维度很高时，Elastic Net 往往比纯 Lasso 更稳，也比纯岭回归更稀疏。

逻辑回归（Logistic Regression）是二分类的标准基线：它先用线性函数产生打分，再把该打分通过 sigmoid（Logistic Function）映射到 \((0,1)\)，从而得到条件概率模型。

对二分类，令标签随机变量（Random Variable）\(Y\in\{0,1\}\)，其中 \(1\) 表示正类， \(0\) 表示负类。给定输入 \(\mathbf{x}\) 后，先定义线性打分：

再定义 sigmoid 函数：

于是，在给定输入 \(\mathbf{x}\) 的条件下，标签取正类的条件概率写成：

这里 \(\mid\) 表示“在给定……条件下”；左侧 \(Y=1\) 表示事件“标签随机变量取值为正类 1”。因此这个式子表示：在输入 \(\mathbf{x}\) 已知时，事件 \(Y=1\) 发生的概率。

相应地，负类概率为：

• \(\mathbf{x}\in\mathbb{R}^d\)：特征向量。
• \(\mathbf{w}\in\mathbb{R}^d\)：权重向量（Weight Vector）。
• \(b\in\mathbb{R}\)：偏置（Bias）。
• \(z\in\mathbb{R}\)：线性打分；它也是 logit（对数几率，log-odds）。
• \(\sigma(\cdot)\)：把任意实数映射到 \((0,1)\) 的非线性函数。

logit 的含义来自恒等式：

这里的 \(\frac{p(Y=1\mid \mathbf{x})}{1-p(Y=1\mid \mathbf{x})}\) 称为几率（Odds），表示“正类概率与负类概率之比”；再对它取对数，就得到 logit（对数几率，log-odds）：\(\log\frac{p}{1-p}\)。因此上式的含义不是再引入一个无关的新量，而是说明：逻辑回归把正类概率的对数几率建模为输入特征的线性函数。

换言之，在二分类逻辑回归里， \(z=\mathbf{w}^\top\mathbf{x}+b\) 就是线性部分的原始输出值，而这个原始输出值恰好等于 logit。它本身不是概率，可以取任意实数；经过 sigmoid 之后才变成 \((0,1)\) 内的概率。多分类情形中，softmax 之前那一组线性输出通常统称为 logits。

因此 \(w_j\) 可以被解释为：特征 \(x_j\) 增加一个单位，会把对数几率增加 \(w_j\)（在其他特征不变时）。这就是逻辑回归的核心可解释性。

给定训练集 \(\{(\mathbf{x}_i,y_i)\}_{i=1}^{N}\)，记 \(p_i=\sigma(\mathbf{w}^\top\mathbf{x}_i+b)\)。逻辑回归通过最大化似然（Likelihood）训练；等价地，它最小化负对数似然（Negative Log-Likelihood, NLL），也即二分类交叉熵（Binary Cross-Entropy）：

• \(\log p_i\)：当 \(y_i=1\) 时，鼓励 \(p_i\) 变大。
• \(\log(1-p_i)\)：当 \(y_i=0\) 时，鼓励 \(p_i\) 变小。

加入 \(L_2\) 正则化时，常见形式为 \(L(\mathbf{w},b)+\lambda\|\mathbf{w}\|_2^2\)（通常不惩罚 \(b\)）。该目标是凸的，因此不存在“坏局部最优”的训练不稳定问题。

把样本堆叠成矩阵 \(\mathbf{X}\)、标签向量 \(\mathbf{y}\)，预测概率向量 \(\mathbf{p}\)（第 \(i\) 个分量为 \(p_i\)）。则无正则项时梯度为：

这两个梯度式子都围绕同一个误差向量 \(\mathbf{p}-\mathbf{y}\) 展开：它表示“模型给出的正类概率”和“真实标签”之间的偏差。 \(\mathbf{X}^\top(\mathbf{p}-\mathbf{y})\) 表示把这种偏差按特征方向汇总起来，从而告诉每个权重该往哪个方向改； \(\mathbf{1}^\top(\mathbf{p}-\mathbf{y})\) 则把所有偏差直接相加，用来更新偏置。

这两个式子揭示了训练机制：如果某个样本真实标签是 1 但模型给出小概率（\(p_i-y_i<0\)），则梯度会推动 \(\mathbf{w}\) 朝着增加该样本 logit 的方向更新；反之亦然。

考虑一维特征 \(x=2\)，参数 \(w=1,b=-1\)，则 \(z=wx+b=1\)，概率：

若真实标签 \(y=1\)，该样本的负对数似然为：

该样本对 \(w\) 的梯度为（单样本形式）：

用学习率 \(\eta\) 做一次梯度下降： \(w\leftarrow w-\eta\frac{\partial\ell}{\partial w}\)。由于梯度为负，更新会把 \(w\) 增大，从而增大 \(z\)、提升 \(p\)，使模型更倾向把该样本判为正类。

• 二分类且需要概率输出/可校准阈值（例如欺诈检测、流失预测、医学风险评分）。
• 高维稀疏特征（如 one-hot、文本 bag-of-words），逻辑回归常是强基线。
• 对可解释性、训练稳定性要求高的工程场景（可用权重做审计/特征诊断）。
• 当决策边界高度非线性且特征工程不足时，需要树模型或神经网络补上非线性。

支持向量机（Support Vector Machine, SVM）是一类以最大间隔分类为核心原则的判别模型。对线性可分的二分类问题，它要寻找一个超平面（Hyperplane），使两类样本被正确分开，同时边界到两侧样本的最小距离尽可能大。这个最小距离对应的缓冲区称为间隔（Margin）。

也正因为优化目标是最大间隔，SVM 并不是“随便找一条能分开两类样本的直线/超平面”，而是要找那条对两类样本都留出最大安全缓冲区的边界。边界离两类样本都越远，模型对噪声、标注扰动与局部数据波动通常越稳。

从数学形式看，SVM 最终会落到二次规划（Quadratic Programming, QP）。所谓二次规划，就是：目标函数是变量的二次函数，约束是线性等式或线性不等式。SVM 的目标是最小化 \(\frac{1}{2}\|\mathbf{w}\|_2^2\)，约束则是每个样本都必须被放到正确一侧并留出至少 1 的函数间隔，因此它正好属于这一类优化问题。

从结构上看，SVM 把三件事连在一起：

1. 几何：先定义“什么叫分得开”，以及“什么叫分得最稳”。
2. 优化：把“最稳的边界”写成一个可求解的凸二次规划。
3. 对偶：把问题改写成只依赖样本内积的形式，从而自然导出核技巧（Kernel Trick）。

对二分类任务，设标签 \(y_i\in\{-1,+1\}\)。线性分类器先计算一个打分函数（Score Function）：

这里最好先把“函数写法”和“几何边界写法”区分清楚。像 \(y=x\) 这样的形式，强调的是“给定自变量（Independent Variable） \(x\)，应变量（Dependent Variable） \(y\) 如何变化”；但对分类器来说，更关键的问题不是“谁依赖谁”，而是哪些点恰好落在边界上，以及点位于边界哪一侧。因此同一条直线在几何里通常改写成隐式形式（Implicit Form） \(x-y=0\)。

一旦写成 \(x-y=0\)，就能直接看成二维超平面方程 \(\mathbf{w}^\top\mathbf{x}+b=0\)：令 \(\mathbf{x}=(x,y)^\top\)、\(\mathbf{w}=(1,-1)^\top\)、\(b=0\)，便有 \(\mathbf{w}^\top\mathbf{x}+b=x-y\)。此时直线方向向量（Direction Vector）可以取 \(\mathbf{v}=(1,1)^\top\)，因为沿这条线移动时 \(y\) 与 \(x\) 同时增加；而 \(\mathbf{w}^\top\mathbf{v}=1\cdot 1+(-1)\cdot 1=0\)，说明 \(\mathbf{w}\) 与直线切向方向正交，所以它正是这条直线的法向量（Normal Vector）。更一般地，对任意边界 \(\mathbf{w}^\top\mathbf{x}+b=0\)，系数向量 \(\mathbf{w}\) 都垂直于边界，因此天然决定“正侧、负侧”和距离的度量方向。

再用它的符号做判别：

这里 \(\mathbf{w}\) 是超平面的法向量（Normal Vector）。沿 \(\mathbf{w}\) 方向移动， \(f(\mathbf{x})\) 会增大；沿反方向移动， \(f(\mathbf{x})\) 会减小。因此：

• \(f(\mathbf{x})=0\)：点就在分类超平面上。
• \(f(\mathbf{x})>0\)：点落在法向量 \(\mathbf{w}\) 指向的那一侧。
• \(f(\mathbf{x})<0\)：点落在另一侧。

超平面把空间分成正半空间（Positive Half-space）与负半空间（Negative Half-space）；分数的正负号直接给出样本位于哪一侧。

令 \(\mathcal{H}=\{\mathbf{x}:\mathbf{w}^\top\mathbf{x}+b=0\}\) 表示超平面，令单位法向量（Unit Normal Vector）为 \(\mathbf{n}=\mathbf{w}/\|\mathbf{w}\|_2\)。对样本 \(\mathbf{x}_i\)，记 \(\mathbf{x}_{\Pi,i}\) 为它在超平面 \(\mathcal{H}\) 上的正交投影点（Orthogonal Projection），因此 \(\mathbf{w}^\top\mathbf{x}_{\Pi,i}+b=0\)，且 \(\mathbf{x}_i-\mathbf{x}_{\Pi,i}\) 与 \(\mathbf{w}\) 平行。点 \(\mathbf{x}_i\) 到超平面的带符号距离（Signed Distance）定义为该位移在单位法向量方向上的投影长度：

分子 \(\mathbf{w}^\top\mathbf{x}_i+b\) 衡量点在法向量方向上偏离超平面的代数量；分母 \(\|\mathbf{w}\|_2\) 对法向量做归一化，去掉“同一个超平面可写成不同倍数方程”的尺度影响；符号保留样本位于超平面哪一侧的信息。

带符号距离区分了超平面的两侧，但正类样本与负类样本的正确侧相反。将标签 \(y_i\in\{-1,+1\}\) 乘入后，得到几何间隔（Geometric Margin）：

几何间隔是用标签修正后的带符号距离。因此：

• \(\gamma_i>0\)：样本在正确一侧，被正确分类。
• \(\gamma_i=0\)：样本正好压在边界上。
• \(\gamma_i<0\)：样本落到错误一侧，被误分类。

SVM 的目标是让所有训练样本中最小的那个 \(\gamma_i\) 尽可能大，即最大化“最坏样本到边界的正确方向距离”：

这就是最大间隔（Maximum Margin）的含义：不是让“平均样本”离边界远，而是让最危险、最靠近边界的样本也尽量安全。

先看线性可分（Linearly Separable）的情形。所谓线性可分，就是存在某个 \((\mathbf{w},b)\)，使每个样本都在与自己标签一致的一侧。这件事可以统一写成：

为什么这里是 \(>0\)？因为它等价于“符号一致”：当 \(y_i=+1\) 时，要求 \(\mathbf{w}^\top\mathbf{x}_i+b>0\)，即正类样本必须落在正半空间；当 \(y_i=-1\) 时，要求 \(\mathbf{w}^\top\mathbf{x}_i+b<0\)，即负类样本必须落在负半空间。若只等于 0，则样本恰好压在分类边界上，不属于严格可分，因为此时它没有任何安全间隔，符号判别也处在临界点。

不过， \(y_i(\mathbf{w}^\top\mathbf{x}_i+b)\) 还不是几何距离，因为把 \((\mathbf{w},b)\) 同时乘以任意正常数 \(t>0\)，超平面 \(\mathbf{w}^\top\mathbf{x}+b=0\) 完全不变，但这个量会整体乘上 \(t\)。因此它只是一个未归一化的间隔量，通常称为函数间隔（Functional Margin）。

为了消掉这个缩放自由度，SVM 采用一个标准定标：强制所有样本的最小函数间隔等于 1，也就是要求

这条约束把两类样本同时编码进来：当 \(y_i=+1\) 时，它变成 \(\mathbf{w}^\top\mathbf{x}_i+b\ge 1\)；当 \(y_i=-1\) 时，它变成 \(\mathbf{w}^\top\mathbf{x}_i+b\le -1\)。于是分类边界两侧又出现两条平行的“间隔边界”（Margin Boundaries）：

因为平行超平面 \(\mathbf{w}^\top\mathbf{x}+b=c_1\) 与 \(\mathbf{w}^\top\mathbf{x}+b=c_2\) 之间的距离是 \(|c_1-c_2|/\|\mathbf{w}\|_2\)，所以这两条间隔边界之间的宽度为

在这个定标下，离分类边界最近的样本几何间隔恰好是

因此，最大化几何间隔就等价于最小化 \(\|\mathbf{w}\|_2\)；为了得到标准的凸二次目标，通常写成：

这就是硬间隔 SVM 的原始问题（Primal Problem）。现在“二次规划”这个术语也具体了：目标函数 \(\frac{1}{2}\|\mathbf{w}\|_2^2\) 是关于参数的凸二次函数，而约束 \(y_i(\mathbf{w}^\top \mathbf{x}_i+b)\ge 1\) 对 \((\mathbf{w},b)\) 是线性的，所以这是一个凸二次规划，并且可以求到全局最优解。

这一段只回答一个问题：训练集中明明有很多样本，为什么最后真正决定分类边界的，往往只有少数几个点。这个结论的严格来源是 KKT 条件，但它的直观含义并不抽象：只有那些真正把最大间隔边界“卡住”的样本，才会在最优解里留下非零权重。

硬间隔 SVM 的原始问题是：

这里目标函数 \(\frac{1}{2}\|\boldsymbol{w}\|_2^2\) 想把边界做得尽量“简单”，也就是让法向量尽量短，从而把间隔做大；而每个训练样本都在提出自己的硬约束：它不仅要被分对，还必须距离边界至少有 1 个单位的函数间隔。把这两股力量写到同一个式子里，就得到拉格朗日函数（Lagrangian）：

其中 \(\alpha_i\) 是第 \(i\) 个样本对应的拉格朗日乘子（Lagrange Multiplier）。在 SVM 里，可以把它直接理解为“第 \(i\) 个样本对当前分类边界施加了多大压力”。压力越大，说明这个样本越在真正影响边界的位置；压力为 0，说明这个样本虽然在训练集里，但最优边界并不需要它来支撑。

这个问题的读法可以想成一个“边界往外推、样本往回顶”的平衡过程：

• 模型一侧 想让 \(\|\boldsymbol{w}\|_2\) 尽量小，从而把间隔尽量做大。
• 约束一侧 则由每个样本通过 \(\alpha_i\) 施加压力：谁越接近边界、越可能破坏间隔，谁就越值得保留权重。

于是，离边界很远的样本会发生什么，就变得非常直观。若某个样本满足

说明它不仅分对了，而且还有额外安全余量。这个点对“边界能否继续外推”没有形成真正阻碍，因此最优时它对应的 \(\alpha_i\) 会被压到 0。相反，若某个样本恰好满足

它就正贴在间隔边界上，是“再往外推一点就会出问题”的临界点。这样的样本才有资格在最优解中保留非零权重。

KKT 条件（Karush–Kuhn–Tucker Conditions）把这个直觉写成严格公式。第一条来自驻点条件（Stationarity）：

这条式子的含义非常重要。它说明最终的法向量 \(\boldsymbol{w}\) 并不是由全部样本平均决定的，而是由训练样本的加权和决定的。这里：

• \(\boldsymbol{x}_i\) 是第 \(i\) 个训练样本；
• \(y_i\alpha_i\) 是它的“带符号权重”；
• 若 \(\alpha_i=0\)，该样本就完全不会出现在 \(\boldsymbol{w}\) 的表达式里。

第二条关键条件是互补松弛（Complementary Slackness）：

这条式子可以直接逐项阅读：

• \(\alpha_i\) 是第 \(i\) 个样本对边界施加的压力；
• \(y_i(\boldsymbol{w}^\top \boldsymbol{x}_i+b)-1\) 是该样本相对于间隔边界的“松弛量”；当它大于 0 时，说明样本在安全区里；当它等于 0 时，说明样本正好贴边。

由于这两个量的乘积必须等于 0，所以只可能出现两种情况：

• 若 \(y_i(\boldsymbol{w}^\top \boldsymbol{x}_i+b)-1>0\)，说明该样本有安全余量，那么必须有 \(\alpha_i=0\)。
• 若 \(\alpha_i>0\)，说明该样本仍在对边界施压，那么必须有 \(y_i(\boldsymbol{w}^\top \boldsymbol{x}_i+b)=1\)。

这就是支持向量（Support Vector）的严格定义来源：在硬间隔 SVM 中，只有恰好贴在间隔边界上的样本，才可能对应非零 \(\alpha_i\)；这些样本共同决定最终超平面的位置。其余样本虽然被正确分类，但因为离边界还有余量，所以在最优解里不再起作用。

如果继续沿着这个结论往下看，就会发现 SVM 的稀疏性完全不是偶然现象，而是 KKT 的直接产物。训练集里可以有大量“安全样本”，但最优边界只需要被少数临界样本支撑起来。名字“支持向量”说的正是这件事：这些点不是普通数据点，而是真正在几何上把边界撑住的点。

前面已经看到：KKT 让 \(\alpha_i\) 变成了“谁在真正顶住边界”的刻度。但如果这里只停在 KKT，还是会留下一个疑问：对偶问题到底是怎么从原始问题里长出来的？关键动作只有一步：先把 \(\alpha_i\) 固定住，把拉格朗日函数当成关于 \(\mathbf{w},b\) 的函数来最小化；然后再回过头，只对 \(\alpha\) 做最大化。

也就是说，原始问题里我们直接求“哪条边界最好”：

而引入拉格朗日乘子之后，可以先看下面这个函数：

对固定的 \(\alpha\)，它就是一个关于 \(\mathbf{w},b\) 的凸函数。于是我们先做内层最小化：

这里的 \(g(\alpha)\) 就叫对偶函数（Dual Function）。它表示：假设每个样本的施压强度已经给定，边界那一侧最好的回应会是什么。

这一步的好处是， \(\mathbf{w},b\) 可以被显式消掉。对 \(\mathbf{w}\) 和 \(b\) 求驻点条件，有：

这两条式子非常关键：第一条说明法向量 \(\mathbf{w}\) 完全由训练样本线性组合出来；第二条说明正负两类样本的“总施压”必须平衡。把它们代回去，原来依赖 \(\mathbf{w},b\) 的问题就变成只依赖 \(\alpha\) 的问题：

这就是 SVM 的对偶问题（Dual Problem）。现在可以看出它为什么叫“对偶”：它没有再直接问“\(\mathbf{w},b\) 应该是多少”，而是改问“每个样本应该分到多大的权重 \(\alpha_i\)，才能共同把最优边界顶出来”。

这样改写有两个直接收益。第一，支持向量为什么稀疏会变得一眼可见：若某个样本最终 \(\alpha_i^*=0\)，它就自动从 \(\mathbf{w}=\sum_i \alpha_i y_i\mathbf{x}_i\) 里消失。第二，对偶目标里出现的样本方式只剩内积 \(\mathbf{x}_i^\top\mathbf{x}_j\)，这正是后面引入核函数（Kernel）的入口。

把最优权重 \(\alpha_i^*\) 求出来后，分类器可以直接写成：

这个式子的含义很具体：新样本 \(\mathbf{x}\) 会与训练样本做内积（Inner Product），也就是计算相似度；每个训练样本按自己的类别符号 \(y_i\) 和影响系数 \(\alpha_i^*\) 投一票；最后把这些票加总，再加上偏置 \(b^*\)，看结果落在哪一侧。

由于绝大多数样本的 \(\alpha_i^*=0\)，真正参与这次投票的通常只有支持向量。因此 SVM 的预测阶段常带有一个很强的稀疏性（Sparsity）：不是所有训练样本都在持续发声，真正起作用的只是边界附近那一小部分点。

偏置 \(b^*\) 可以用任一支持向量恢复。若 \(\mathbf{x}_k\) 是一个支持向量，则它满足 \(y_k(\mathbf{w}^{*\top}\mathbf{x}_k+b^*)=1\)，因此

对偶问题真正重要的地方，不只是“把变量从 \(\mathbf{w},b\) 换成了 \(\alpha_i\)”，而是它把 SVM 的全部数据依赖压缩成了样本之间的内积（Inner Product）：

这一步非常关键，因为它说明：SVM 在对偶形式里并不需要直接看到样本坐标本身，它只需要知道样本彼此有多相似。只要这种“相似度”还能写成某个空间里的内积，SVM 的训练与预测公式就都可以照搬。

于是核技巧（Kernel Trick）的引入就变得自然了。设有一个特征映射（Feature Map）\(\phi(\mathbf{x})\)，它把原始样本送到更高维、甚至无限维的特征空间（Feature Space）。如果我们真的显式去算这个高维向量，代价往往很大；但对偶形式只关心内积，因此只要能直接计算

就等价于“隐式地”在特征空间里做线性 SVM，而不必真的把 \(\phi(\mathbf{x})\) 写出来。这个直接在原空间里计算特征空间内积的技巧，就叫核函数（Kernel Function）或核技巧（Kernel Trick）。

这也解释了为什么 kernel 是从 dual 里长出来的，而不是额外拼上去的：若你还停留在原始问题里，眼前看到的仍是显式参数 \(\mathbf{w}\)；而一旦进入对偶形式，表达式里只剩 \(\mathbf{x}_i^\top\mathbf{x}_j\)，把它替换成别的“合法相似度”就成了最自然的一步。

于是决策函数从

变成

要点是：特征空间里仍然是线性超平面；只是映回原空间后，边界看起来变成了弯的。因此 kernel 不是“把线性 SVM 换成非线性模型”，而是“先把数据换到更容易线性可分的表示里，再继续做线性 SVM”。

从直觉上看，核函数本质上是在重新定义“两个样本像不像”。线性核（Linear Kernel）比较原始方向是否一致；多项式核（Polynomial Kernel）强调特征之间的组合关系；RBF / Gaussian 核更强调局部邻近性，因此很容易形成局部、弯曲的决策边界。

• 线性核（Linear Kernel）：\(K(\mathbf{x},\mathbf{z})=\mathbf{x}^\top\mathbf{z}\)。
• 多项式核（Polynomial Kernel）：\(K(\mathbf{x},\mathbf{z})=(\mathbf{x}^\top\mathbf{z}+c)^d\)。
• RBF / Gaussian 核：\(K(\mathbf{x},\mathbf{z})=\exp(-\gamma\|\mathbf{x}-\mathbf{z}\|_2^2)\)。

一个典型例子是“同心圆”二分类：在二维平面里，内圈和外圈无法用一条直线分开；但如果映射到包含半径平方等特征的空间，类别就可能被一个超平面分开。核方法的价值就在这里：原空间里看到的是弯曲边界，特征空间里做的仍然是线性分类。

现实数据通常含噪声、离群点（Outlier）或类别重叠。若仍然要求“所有点都必须在间隔之外”，硬间隔 SVM 很可能根本无解，或者被少数异常点强行拉歪。软间隔 SVM（Soft-margin SVM）因此引入松弛变量（Slack Variable）\(\xi_i\ge 0\)，允许个别样本违反间隔约束：

这个式子只表达一件事：边界仍然希望尽量大，但违约要交罚款，罚款强度由 \(C\) 决定。对单个样本， \(\xi_i\) 的含义可以直接按大小来读：

• \(\xi_i=0\)：样本分类正确，且在间隔边界上或之外。
• \(0<\xi_i\le 1\)：样本仍在正确一侧，但已经挤进了间隔内部。
• \(\xi_i>1\)：样本跨过了分类边界，已经被误分。

\(C\) 控制的是“对违约有多敏感”：

• \(C\) 大：更重视把训练集分对，边界更硬，对噪声也更敏感。
• \(C\) 小：更重视大间隔和整体稳定性，允许少量训练误差。

软间隔下，支持向量的范围也更宽：不仅贴着间隔边界的点重要，落在间隔内部甚至被误分的点也会直接影响最优解。对应到对偶变量，常见情形是 \(0<\alpha_i<C\) 的点贴在间隔上，而 \(\alpha_i=C\) 的点往往是间隔内样本或误分类样本。

把松弛变量消去后，软间隔 SVM 还可以写成更常见的合页损失（Hinge Loss）形式：

第一项限制模型复杂度，第二项惩罚分类违约。SVM 因此可以被看作“大间隔 + 违约惩罚”的组合，而支持向量则是这两股力量平衡后仍然留在最前线的样本。

这一类方法处理的核心问题是：当输入与输出之间存在明显非线性、阈值效应与高阶特征交互时，线性模型往往表达力不足，但工程上仍然希望模型具备较强可解释性、对表格数据友好、并且训练稳定。树模型通过递归切分（Recursive Partitioning）把输入空间划成若干局部区域；集成方法则进一步通过 Bagging 或 Boosting 提升泛化能力与精度。

这张表背后的逻辑可以压缩成一句话：决策树是基础，随机森林主要靠并行平均降低方差，GBDT 家族主要靠串行纠错降低偏差，而 XGBoost、LightGBM、CatBoost 则是在 GBDT 主线上的工业级强化。因此它们虽然都属于“树模型”，训练逻辑、误差控制方式和工程侧优势并不相同。

决策树（Decision Tree）把预测过程写成一串逐层切分的规则：内部节点负责提问，边负责根据答案分流，叶节点负责输出最终结果。它的优势不在于公式复杂，而在于模型结构与业务规则天然同构：每一条从根到叶的路径，都对应一条可读的判断链。

决策树是总称；分类树（Classification Tree）与回归树（Regression Tree）是它在两类监督学习任务上的具体形式。三者共享同一种树结构，但目标变量、切分准则与叶子输出不同。

因此不要把“决策树”和“分类树”当成并列概念。更准确的表述是：分类树与回归树都是决策树；前者预测类别，后者预测数值。

设某个节点上落入的样本集合为 \(S\)，大小为 \(|S|\)。对某个候选切分（Split）\(\phi\)，例如“第 \(j\) 个特征 \(x_j\le t\)”，样本会被分成左右两个子节点：

其中 \(S_L\) 是满足切分条件的样本集合，\(S_R\) 是剩余样本集合。树在每个节点都会尝试多个候选切分 \(\phi\)，并保留收益最大的那个。

为了避免分别记忆分类树与回归树的训练目标，可以先写成统一形式。设 \(I(S)\) 表示“节点 \(S\) 当前有多乱”或“在该节点上预测误差有多大”，则一次切分的收益可统一写成：

这条式子的含义非常直接：

• \(I(S)\)：切分前，这个节点有多混乱。
• \(I(S_L),I(S_R)\)：切分后，左右子节点各自还有多混乱。
• \(\frac{|S_L|}{|S|},\frac{|S_R|}{|S|}\)：左右子节点占父节点样本的比例。要乘这个比例，是因为大子节点对总体误差的影响更大，小子节点不能和大子节点拥有同样权重。
• \(\mathrm{Gain}(S,\phi)\) 越大，说明这次切分越有效。

分类树与回归树的差别，正体现在 \(I(S)\) 具体取什么。

在贷款审批（Loan Approval）场景中，决策树可以直接写成规则链。根节点先按负债收入比（Debt-to-Income Ratio）切分；若负债收入比过高，再看是否有逾期记录；若负债收入比正常，再看信用评分（Credit Score）与近 6 个月收入稳定性。最终某个叶节点可能对应“直接通过”，另一个叶节点对应“人工复核”，再另一个叶节点对应“拒绝”。这就是决策树最重要的工程价值：它不只是给出一个分数，还给出一条可追溯的判断路径。

分类树的目标是让每个叶节点里的标签尽量单一。若一个节点里几乎都是同一类样本，这个节点就“纯”；若各类样本混在一起，这个节点就“不纯”。

设类别集合为 \(\mathcal{K}\)，类别 \(k\) 在节点 \(S\) 中的占比记为：

常用的不纯度（Impurity）有两种。

基尼不纯度（Gini Impurity）：

它可以读成“随机抽两个样本时，标签不一致的倾向有多强”。若节点里全是同一类，则某个 \(p_k=1\)、其余为 0，此时 \(G(S)=0\)，说明节点已经纯净；若二分类里两类各占一半，则 \(G(S)=1-(0.5^2+0.5^2)=0.5\)，说明混杂程度较高。

熵（Entropy）：

熵衡量的是“不确定性”。若节点里全是同一类，则不需要再猜，熵为 0；若各类比例接近，说明不确定性高，熵也更大。

信息增益（Information Gain）就是“切分前的不确定性”减去“切分后的加权不确定性”：

这条公式的每一部分都对应一个明确动作：

• 第一项 \(H(S)\) 是切分前的混乱程度。
• 后两项是切分后左右子节点各自的混乱程度，并按样本占比加权求和。
• 两者相减，就是这次切分让节点“变纯”了多少。

有些实现使用基尼下降而不是信息增益，本质上是同一件事：选择那个能让子节点更纯、让标签更集中的切分。

设任务是预测“一个用户未来 30 天是否流失”。标签只有两类：流失 / 未流失，因此这是典型分类树问题。候选特征可以包括：最近 7 天登录次数、最近 30 天是否投诉、是否还有未使用优惠券、最近一次下单距今天数。

假设根节点先尝试切分“最近 7 天登录次数 < 2”。这次切分后，左子节点里的用户大多已经很久不活跃，且流失比例显著升高；右子节点里的用户则活跃度更高、留存率更好。此时无论用基尼还是熵计算，左右节点的加权不纯度都会明显低于父节点，因此这会成为一个高质量切分。

继续往下，左子节点还可以再按“最近 30 天是否投诉”切分：低活跃且有投诉的用户，叶节点里可能出现“82% 最终流失”；低活跃但无投诉的用户，叶节点里可能是“61% 流失”。此时叶子不只给出类别，还可给出经验概率。工程上，这样的输出就能直接用于运营动作：高风险叶子推召回优惠券，中风险叶子推客服回访，低风险叶子不干预。

回归树处理的是连续数值目标，例如价格、时长、销量、能耗。它不追求“类别更纯”，而追求“同一个叶节点里的数值尽量接近”。

若某个叶节点 \(S\) 最终只输出一个常数 \(c\)，那么在平方误差（Squared Error）下，最优输出不是中位数，而是均值：

之所以是均值，是因为平方误差会把所有偏差向两边拉平，而均值正是使平方偏差和最小的那个常数。

在这个叶节点上，最小平方误差和（Sum of Squared Errors, SSE）为：

它表示节点里所有样本值围绕叶子预测值 \(c^*(S)\) 的总波动。SSE 越大，说明这个节点里的样本值越分散，单用一个常数代表它们的效果越差。

因此一次切分的目标是让切分后的总误差尽量小，也可写成误差下降尽量大：

若更喜欢看平均误差，也可以把它写成 MSE（Mean Squared Error）形式：

等价地，也可以最小化切分后的加权平均误差：\[\frac{|S_L|}{|S|}\mathrm{MSE}(S_L)+\frac{|S_R|}{|S|}\mathrm{MSE}(S_R)\]

两种写法完全等价：SSE 强调总误差，MSE 强调平均误差；本质都是寻找让子节点内部数值更集中的切分。

设任务是预测一笔订单从接单到送达需要多少分钟。这是连续数值目标，因此属于回归树。候选特征可以包括：配送距离、是否下雨、是否晚高峰、商家出餐速度、骑手当前手中订单数。

根节点可能先按“配送距离是否大于 3 公里”切分。因为近距离订单与远距离订单的时长分布差异很大，这一步通常能显著降低节点内部方差。对远距离子节点，再按“是否下雨”切分；下雨天路况更慢、波动更大。对近距离子节点，则可能按“是否处于午晚高峰”切分。

假设某个叶节点对应“距离 > 3 公里、下雨、晚高峰”这类订单，这个叶节点里的训练样本平均送达时长是 47 分钟，那么该叶子的预测值就是 47。另一个叶节点若对应“距离 < 2 公里、不下雨、非高峰”，其平均时长可能只有 18 分钟。回归树的预测逻辑不是拟合一条全局直线，而是把不同业务情境分段，再在每段内给出一个局部平均值。

• 需要把模型输出翻译成可审计规则，例如风控、审批、运营分层、客服分流。
• 数据以表格（Tabular）为主，且存在显著非线性、阈值效应或特征交互。
• 希望同时处理连续特征与离散特征，并保留较强可解释性。
• 注意：单棵树方差高、容易过拟合，通常需要限制最大深度、最小叶子样本数或配合集成方法。

随机森林（Random Forest）是 Bagging（Bootstrap Aggregating）在树模型上的经典实现：用 bootstrap 采样生成多份训练子集，训练多棵通常偏差较低、但对训练数据扰动高度敏感（高方差）的决策树，再把它们的输出聚合，以显著降低整体方差并提升鲁棒性。

这里的“高方差（High Variance）”指模型的估计方差（Estimator Variance）或预测方差（Prediction Variance）：如果训练集稍有变化，单棵树学到的分裂结构与最终预测就可能明显变化。随机森林利用多棵树的平均/投票，把这种由数据扰动带来的波动相互抵消。

随机森林并不是“很多棵树简单叠起来”这么粗糙。单棵树的主要问题，是一旦在上层节点做出某个早期切分，后面的整条子树都会被这个局部选择锁定，因此对数据扰动极敏感。随机森林通过 bootstrap 采样与特征子采样，让每棵树在“数据视角”和“可用特征视角”上都略有不同，再把这些不同视角的判断平均起来，从而大幅削弱某一棵树早期错误切分的破坏力。

给定训练集 \(D=\{(\mathbf{x}_i,y_i)\}_{i=1}^{N}\)。对 \(m=1,\dots,M\)：

1. bootstrap 采样：从 \(D\) 有放回采样 \(N\) 次得到 \(D_m\)。所谓“有放回（Sampling with Replacement）”，是指每次抽到一个样本后，都先把它放回原数据集，再进行下一次抽样；因此同一个样本可能被重复抽中，而有些样本在这一轮里一次也没有被抽到。
2. 训练一棵树 \(T_m\)：每个节点分裂时，只在随机选取的 \(d'\) 个特征上搜索最优切分（特征子采样，feature subsampling）。

预测时，回归取平均，分类取多数投票：

这里 \(T_m(\mathbf{x})\) 表示第 \(m\) 棵树对样本 \(\mathbf{x}\) 的预测。回归任务把所有树的输出做平均，以减少波动；分类任务取众数 \(\mathrm{mode}(\cdot)\)，也就是票数最多的类别。随机森林的稳定性正来自这种“多棵树共同决定”的聚合机制。

• \(M\)：树的数量。
• \(d'\)：每次分裂考虑的特征数（常见经验：分类用 \(\sqrt{d}\)，回归用 \(d/3\)）。

若单棵树预测的方差为 \(\sigma^2\)，不同树之间的相关系数近似为 \(\rho\)（\(0\le\rho\le 1\)），则平均后的方差近似为：

这个近似式子把随机森林为什么有效说得很清楚： \(\sigma^2\) 是单棵树自身的预测波动， \(\rho\) 是树与树之间的相关性， \(M\) 是树数。树越多， \(\frac{1-\rho}{M}\) 越小；树之间越不相似， \(\rho\) 越低，最终平均后的波动就越小。

因此随机森林有两条主线：

• 增加 \(M\) 降低 \((1-\rho)/M\) 项。
• 通过 bootstrap + 特征子采样降低相关性 \(\rho\)，让集成真正“互补”。

bootstrap 采样会重复抽到某些样本。对固定样本 \(i\)，一次采样中没被抽到的概率为 \((1-\frac{1}{N})^N\approx e^{-1}\approx 0.368\)。因此每棵树大约有 36.8% 的样本是袋外（Out-of-Bag, OOB）样本，可用它们评估该树对未见数据的表现，并对全森林给出近似验证误差。

这里 \((1-\frac{1}{N})\) 表示“一次抽样没抽到某个固定样本”的概率，连续做 \(N\) 次后得到 \((1-\frac{1}{N})^N\)。当 \(N\) 足够大时，它逼近 \(e^{-1}\)，也就是约 36.8%。这就是为什么随机森林天然拥有一批“没参与这棵树训练”的 OOB 样本。

• 表格数据（Tabular）的强默认基线：非线性、特征交互、缺失值与尺度不一致都较鲁棒。
• 对超参数不敏感、训练稳定；可用特征重要性（Feature Importance）做解释与特征筛查。
• 当需要极致精度时，GBDT 家族往往更强；当需要更快推理/更小模型时，线性/浅层模型更合适。

梯度提升树（Gradient Boosting Decision Tree, GBDT）是一类按序叠加回归树的加法模型（Additive Model）。模型从简单的初始预测 \(F_0\) 出发，在每一轮加入一棵新树，用于修正当前模型尚未拟合好的部分，从而逐步降低训练集上的经验风险（Empirical Risk）。

每一轮新增的树都对应一个修正函数（Correction Function）。它不直接重新学习标签 \(y\)，而是拟合当前模型输出与目标之间尚未被解释的差异。多轮修正连续叠加后，模型会从粗糙预测逐步逼近目标函数。

一个直观比喻是：GBDT 像一组按顺序接手的阅卷老师。第一位老师先给出一个粗略分数，后面的每一位老师都不重做整张卷子，只专门检查前面模型错得最明显的地方，并在这些地方补上修正意见。树一棵接一棵叠加后，最终预测会越来越接近真实值。

这里每棵小树都不是独立完成任务的“大模型”，而是一个局部纠错器。它关心的是当前模型还没解释好的误差：哪些样本被高估了，哪些被低估了，以及这些误差集中出现在哪些特征区域。“梯度”对应当前损失下降最快的修正方向，“提升”则表示把这些小修正持续累加成一个更强的整体模型。

GBDT 背后的目标非常直接：寻找一个函数 \(F\)，使训练集上的总损失最小：

这里 \(\ell(y,F(\mathbf{x}))\) 是单样本损失函数，平方损失、对数损失等都可以放进来。难点在于：函数 \(F\) 不是一个普通标量参数，而是一个复杂的预测函数；如果一次性同时优化所有树的结构和叶子输出，组合空间过大，几乎不可直接求解。

因此 GBDT 采用前向分步加法（Forward Stagewise Additive Modeling）：不一次求整个 \(F\)，而是把它写成逐步累加的形式，只在第 \(m\) 轮新增一个修正函数 \(f_m\)：

这里 \(F_M(\mathbf{x})\) 表示：模型经过总共 \(M\) 轮提升后，对输入样本 \(\mathbf{x}\) 输出的最终预测值。下标 \(M\) 表示“已经累计做了 \(M\) 次修正”，不是幂次，也不是某一棵单独的树。GBDT 的最终模型是许多轮小修正叠加后的总结果。

• \(\mathbf{x}\)：一个输入样本的特征向量。
• \(F_0(\mathbf{x})\)：初始模型对样本 \(\mathbf{x}\) 的预测，常取常数 \(c\) 使 \(\sum_i \ell(y_i,c)\) 最小。它可以理解为模型在还没有长出任何树之前给出的第一版粗略判断。
• \(f_m(\mathbf{x})\)：第 \(m\) 轮新增的回归树在样本 \(\mathbf{x}\) 上给出的修正值，负责弥补当前模型尚未拟合好的部分。
• \(\sum_{m=1}^{M}f_m(\mathbf{x})\)：把前 \(M\) 轮所有修正树的输出加起来，得到总修正量。
• \(\nu\in(0,1]\)：学习率（Shrinkage），控制每一步修正只走多大。它的作用不是改变方向，而是缩小步长，使训练更稳定、泛化更好。

这个公式也可以按“底稿 + 反复批改”来理解： \(F_0(\mathbf{x})\) 是第一版预测，后面的每个 \(f_m(\mathbf{x})\) 都是在已有结果上补一小笔修正，最终的 \(F_M(\mathbf{x})\) 就是经历 \(M\) 次修正后的版本。

这条式子表示：在第 \(m\) 轮，模型要寻找一个新的修正函数 \(f_m\)，使它加到旧模型 \(F_{m-1}\) 上之后，训练集的总损失尽可能小。这里的 \(\arg\min_f\) 可以读作“在所有候选函数 \(f\) 里，找出那个能让目标最小的函数”。因此，求出来的不是一个数，而是当前这一轮最合适的新树。

• \(F_{m-1}(\mathbf{x}_i)\)：前 \(m-1\) 轮模型在第 \(i\) 个样本上的当前预测值。
• \(f(\mathbf{x}_i)\)：候选新树在第 \(i\) 个样本上的修正值。
• \(F_{m-1}(\mathbf{x}_i)+f(\mathbf{x}_i)\)：把新树加进去之后，这个样本的新预测值。
• \(\ell\big(y_i,F_{m-1}(\mathbf{x}_i)+f(\mathbf{x}_i)\big)\)：该样本在新预测下的损失。
• \(\sum_{i=1}^{N}\ell(\cdot)\)：把所有样本的损失加总，得到这一轮希望尽量压低的整体目标。

这一轮之所以写成 \(F_{m-1}+f\)，而不是重新求一个全新的 \(F_m\)，原因在于 GBDT 采用的是逐步修正策略：旧模型已经学到的部分先保留，新树只负责补上当前还没有拟合好的误差。这样每一轮只解决一个更小的局部问题，计算上更可行，也更符合“不断纠错”的直觉。

第 \(m\) 轮只优化新增的修正函数 \(f_m\)，而把已有模型 \(F_{m-1}\) 视为固定量。这样做把原本难以整体求解的函数优化问题，拆成了一系列可逐步求解的局部优化问题。

上面的子问题仍然不容易直接做，因为“最佳新树”本身还是一个复杂的函数搜索问题。GBDT 的关键近似是：在当前模型 \(F_{m-1}\) 附近，对损失做一阶展开，只看局部下降方向。

对单个样本 \(i\)，把新增修正记为 \(f(\mathbf{x}_i)\)，则有：

一阶展开表明，新增函数 \(f\) 的最优局部方向由损失对模型输出的负梯度决定。因此第 \(m\) 轮的伪残差（Pseudo-residual）定义为：

接下来的动作就自然了：不用树直接拟合标签 \(y_i\)，而是用一棵回归树去拟合这些伪残差 \(r_i^{(m)}\)。这棵树学到的，就是“当前模型在输入空间不同区域里，应该往哪个方向、修正多大”的分段常数近似。

模型更新写成：

“梯度提升”这一名称对应的正是上述更新方式：优化对象不是有限维参数向量，而是预测函数本身；每一轮更新都沿着损失在函数空间中的负梯度方向加入一个新的修正函数。

若损失取平方损失

则对模型输出求导：

因此第 \(m\) 轮的负梯度为：

这正是当前预测与真实值之间的残差（Residual）。所以在回归任务里，人们常把 GBDT 说成“不断拟合残差”；这并不是另一套经验规则，而是平方损失下负梯度公式的直接结果。

“每轮拟合残差”只在平方损失下最直观。更一般地，GBDT 拟合的是当前损失对模型输出的负梯度，因此不同任务下，每轮新树学到的对象并不完全相同。

因此，GBDT 不是被固定死在“回归残差拟合”这一种形式上，而是一套更一般的函数优化框架。平方损失下它表现为残差学习；分类任务下，它表现为不断修正当前概率估计。

因为树天然产生分段常数（Piecewise Constant）的局部修正。若某一轮中，一棵树把样本空间切成若干区域 \(R_1,\dots,R_J\)，那么它输出的是：

这意味着：模型不是对整个输入空间统一加一个修正，而是在每个局部区域里分别加一个常数修正 \(\gamma_j\)。这正适合处理表格数据里的阈值效应、非线性和特征交互。

在平方损失下，若某个叶子覆盖的样本集合为 \(S\)，并用常数 \(\gamma\) 拟合这一叶内的残差 \(r_i\)，则该叶子的局部目标是：

对 \(\gamma\) 求导并令其为 0：

因此叶子输出之所以是均值，不是经验设定，而是平方损失下这个局部最小二乘问题的解析解。每一轮加入一棵树，本质上是在每个局部区域里补上一段“平均残差修正”。

1. 初始化 \(F_0\)，通常取使总体损失最小的常数模型。
2. 对第 \(m\) 轮，计算所有样本的伪残差 \(r_i^{(m)}\)。
3. 训练一棵回归树 \(f_m\) 去拟合 \((\mathbf{x}_i,r_i^{(m)})\)。
4. 把这棵树按学习率 \(\nu\) 缩小后加到当前模型上。
5. 重复多轮，直到验证集误差不再下降，或达到预设树数。

GBDT 的本质，是把复杂的函数优化问题拆成许多轮局部修正，并在每一轮用一棵小树逼近当前损失下降最快的方向。

• 结构化表格任务中的强模型：广告、推荐、风控、运营排序、传统特征工程场景。
• 对特征尺度、非线性、缺失值较鲁棒；能自动学习高阶交互。
• 注意：对超参数更敏感（树深、学习率、树数、采样比例）；需要用验证集早停（Early Stopping）防止过拟合。

GBDT 家族在表格数据上长期强势，并不是偶然。表格任务里常见的模式，本来就很适合树模型表达：阈值效应、离散规则、局部非线性、特征交互、缺失值路径、不同子群体的分段行为。树的分裂结构天然能把“收入高且近期投诉过的老用户”和“收入低但活跃度高的新用户”这类组合规则直接切出来，而不需要像线性模型那样依赖大量手工交叉特征。

但同样的归纳偏置，在高维稀疏文本、图像、语音这类输入上就未必占优。因为这些任务的有效模式通常不是少数几个阈值切分，而是分布在海量维度上的连续结构、局部平滑模式或长程依赖。此时树模型虽然能做基线，但往往不如专门面向非结构化数据的线性稀疏模型、卷积网络或 Transformer。

XGBoost（Extreme Gradient Boosting）是在梯度提升树（Gradient Boosting Decision Tree, GBDT）基础上的工程化强化版本。它关注的是：在保持高表达能力的同时，让树的生长过程更稳定、目标函数更明确、复杂度控制更系统。

XGBoost 仍然采用加法模型（Additive Model）：当前模型由多棵树的输出求和得到，第 \(t\) 轮只学习一棵新树 \(f_t\) 作为修正项。它的关键强化点有两条：第一，把新增树的学习写成显式的带正则优化问题；第二，对该目标做二阶近似，同时利用梯度（Gradient）和海森（Hessian）信息计算叶子输出与分裂增益。

设第 \(t\) 轮预测为 \(\tilde y_i^{(t)}=\tilde y_i^{(t-1)}+f_t(\boldsymbol{x}_i)\)。XGBoost 在第 \(t\) 轮优化的目标可写为：

在这个目标里， \(\ell(y_i,\tilde y_i^{(t)})\) 衡量第 \(i\) 个样本在第 \(t\) 轮更新后的预测误差， \(\Omega(f_t)\) 惩罚新树本身的复杂度， \(\text{const}\) 则表示与当前轮新树无关的常数项。也就是说，XGBoost 每一轮都在平衡“把误差降下去”和“不要把树长得太复杂”。

其中正则项通常取：

这里 \(T\) 是叶子数， \(\gamma T\) 惩罚“树长出太多叶子”， \(\frac{\lambda}{2}\sum_j w_j^2\) 惩罚“每个叶子的输出值过大”。前者控制结构复杂度，后者控制数值幅度，两者合起来让模型更稳。

对损失在当前预测附近做二阶泰勒展开，定义：

\(g_i\) 是一阶导数，表示“当前这个样本朝哪个方向改，损失下降最快”； \(h_i\) 是二阶导数，表示“这个方向有多陡、多稳定”。XGBoost 同时使用这两项信息，所以比只用一阶梯度的做法更精细。

则近似目标为：

这条近似目标里， \(f_t(\boldsymbol{x}_i)\) 是新树在样本 \(i\) 上给出的修正值。线性项 \(g_i f_t(\boldsymbol{x}_i)\) 反映“沿当前方向修正是否有利”，二次项 \(\frac{1}{2}h_i f_t(\boldsymbol{x}_i)^2\) 反映“修正过大时会不会带来额外代价”。

若固定树结构，记落在叶子 \(j\) 的样本集合为 \(I_j\)，并定义 \(G_j=\sum_{i\in I_j}g_i\)、\(H_j=\sum_{i\in I_j}h_i\)，则该叶子的最优输出为：

这里 \(G_j\) 是第 \(j\) 个叶子里所有样本一阶梯度的总和， \(H_j\) 是二阶梯度总和。分子告诉模型这个叶子整体应该往哪个方向修正，分母则用二阶信息和正则项 \(\lambda\) 把修正幅度稳住。

某次分裂把父叶拆成左右两叶后的增益（Gain）为：

这个增益式子比较的是“父叶不分裂”和“分成左右两叶”谁更划算。 \(G_L,H_L\) 与 \(G_R,H_R\) 分别是左右子叶的梯度统计量， \(G,H\) 是父叶统计量；最后减去 \(\gamma\)，表示每多长一个叶子都要付复杂度代价。

这说明 XGBoost 的分裂同时考虑“收益”和“复杂度惩罚”，并以此控制结构扩张。

XGBoost 的工程优势并不只来自“实现更快”。它把几项在工业界非常关键的能力同时做扎实了：显式复杂度正则化、二阶梯度优化、行采样与列采样、对稀疏特征的处理、缓存友好的分裂搜索，以及成熟的早停和监控接口。也正因为如此，它长期被视作结构化数据建模的稳健默认选项。

• 正则化更明确：通过叶子数惩罚与叶子权重 L2 正则显式控制树复杂度。
• 分裂选择更精细：同时使用一阶梯度与二阶梯度，不只看“该往哪边改”，还看“这一步有多稳”。
• 随机化更充分：支持样本子采样 \(\text{subsample}\) 和列采样 \(\text{colsample\_bytree}\)，既降计算量也降过拟合。
• 工程实现更成熟：对稀疏输入、缓存访问和大规模数据训练都做了专门优化。

1. 用当前模型计算每个样本的一阶梯度 \(g_i\) 与二阶梯度 \(h_i\)。
2. 在候选特征与候选阈值上搜索分裂增益最大的切分。
3. 固定树结构后，利用 \(w_j^*\) 计算每个叶子的最优输出。
4. 把新树加入现有模型，继续下一轮迭代。
5. 预测时把所有树的输出累加，再映射到分类或回归结果。

XGBoost 在工程实践里常配合较大的树数上限和验证集早停一起使用。做法通常不是先死板地决定“到底训 300 棵还是 800 棵树”，而是给一个偏大的上限，再观察验证集误差或任务指标何时不再提升。这样，树数不再是拍脑袋设定的固定值，而变成由验证集驱动的可学习训练预算。

这对 Boosting 家族尤其重要，因为学习率较小时，往往需要更多轮小步修正；若学习率较大，又更容易在后期进入过拟合区域。早停在这里的作用，是把“拟合能力很强”与“不要无限继续纠错”之间的边界交给验证集来判定。

在点击率预估（CTR Prediction）中，用户、广告和上下文之间往往存在复杂交互。XGBoost 可以通过逐轮加树自动学习“什么样的用户在什么时间、看到什么样的广告更容易点击”这类组合规则，因此在工业级表格任务中长期保持强竞争力。

• 优点：表格数据表现强，目标函数清晰，正则化明确，工程生态成熟。
• 局限：超参数较多；树深、学习率、树数、采样比例之间存在明显耦合。
• 适用场景：风控、广告、推荐、排序与一般结构化表格建模。

LightGBM 是面向大规模数据与高维稀疏特征优化的 GBDT 实现。它关注的核心问题是：当样本量和特征维度都很大时，如何降低分裂搜索的时间与内存成本，同时尽量不牺牲精度。

LightGBM 的两个关键设计是直方图分桶（Histogram Binning）和叶子优先生长（Leaf-wise Growth）。前者把连续特征离散到有限个桶上，后者每一步都继续分裂当前收益最大的叶子，从而在相同叶子预算下更快降低训练误差。

在优化目标上，LightGBM 与 GBDT / XGBoost 一致，仍然是逐轮加入树来降低损失。它的区别主要体现在计算方式：若某个连续特征被离散到 \(B\) 个桶，则算法只需在桶边界上搜索分裂点，而不必在所有实数取值上逐一枚举。这样，每个节点维护的是桶级梯度统计量，而非逐样本的原始实数值。

叶子优先生长意味着：算法始终选择当前分裂增益最大的叶子继续向下扩展。它通常比按层生长（Level-wise）更激进，因而在同样叶子数限制下更容易得到较低训练误差，但也更容易在局部区域长出很深的树。

LightGBM 的“快”并不是单一技巧带来的，而是多项近似与工程策略叠加的结果。

• 直方图分桶：把连续特征先离散到有限个桶，例如默认 255 或 256 个桶。这样找切分点时，复杂度从“遍历大量原始取值”变成“遍历固定桶边界”。
• Leaf-wise 生长：每一轮只扩展当前最值得继续分裂的叶子，在相同叶子预算下往往比 level-wise 更快压低误差。
• GOSS（Gradient-based One-Side Sampling）：优先保留梯度较大的样本，因为这些样本更能代表当前模型最需要修正的区域；对梯度较小的样本只随机保留一部分，以减少计算量。
• EFB（Exclusive Feature Bundling）：把互斥的稀疏特征打包到同一组表示里，降低高维稀疏输入的有效维度。

其中 GOSS 和 EFB 的意义非常工程化。前者服务于“大样本下不必每轮都看全量样本”，后者服务于“高维稀疏特征下不必把所有稀疏列都单独维护”。也正因为如此，LightGBM 尤其适合推荐、广告、风控这类既大规模又高度稀疏的表格任务。

LightGBM 也因此更依赖约束配套。leaf-wise 生长虽然更激进，但如果不同时限制

max_depth

num_leaves

min_data_in_leaf

1. 将连续特征离散到有限个桶，并统计桶级梯度信息。
2. 在每个节点上基于桶统计量搜索最优切分。
3. 选择全局增益最大的叶子继续分裂。
4. 使用最大深度、最大叶子数、最小叶子样本数等约束抑制过拟合。
5. 预测时沿树路径到达叶子并累加所有树的输出。

在大规模推荐粗排任务中，输入特征通常极高维且高度稀疏。LightGBM 能在保留较强拟合能力的同时显著缩短训练时间，因此非常适合需要频繁重训的工业流水线。

• 优点：训练快、内存占用低，对大规模稀疏特征友好。
• 局限：叶子优先策略若约束不足，局部树会过深，过拟合风险更高。
• 适用场景：超大规模表格数据、稀疏特征建模、追求训练效率的工业场景。

CatBoost 是另一条非常重要的 Boosting 工业路线。它关注的核心问题不是“比 XGBoost 更通用”或“比 LightGBM 更快”，而是：当数据里有大量高基数类别特征时，如何在不引入严重数据泄露和预测偏移的前提下，把这些特征真正用好。广告、推荐、电商、用户画像、商品属性等任务里，这个问题尤其关键。

CatBoost 的两项代表性设计是有序目标统计（Ordered Target Statistics）与有序提升（Ordered Boosting）。前者处理类别特征，后者处理训练偏移。它们共同服务于同一个目标：不要让模型在训练时偷看到本不该知道的目标信息。

对树模型而言，类别特征的难点不只是“字符串不能直接喂进去”，更在于很多类别列的取值空间极大，例如用户 ID、商品 ID、城市、品牌、广告位、渠道来源。若简单做 one-hot 编码，维度会迅速膨胀；若直接用目标均值编码，又很容易把标签信息泄露进训练过程，导致离线效果虚高、线上泛化变差。

CatBoost 的思路是：用类别对应的目标统计量来表示类别，但计算某个样本的统计量时，只允许使用它之前样本的信息，而不允许看见它自己以及它之后的样本标签。这样得到的类别表示虽然仍然利用了监督信号，却显著降低了数据泄露与目标泄露风险。

设某个类别值为 \(c\)，其编码值可以理解为“在训练顺序中，当前位置之前出现过的同类样本的目标统计量，再配合一个全局先验做平滑”。这样一来，模型在看到当前样本时，只能利用“过去”信息，不能直接偷看当前标签。

同样的思路也延伸到 Boosting 训练本身。传统目标编码或普通 Boosting 在训练时，常会让同一批样本之间发生微妙的信息穿透，形成预测偏移（Prediction Shift）。CatBoost 通过 ordered boosting 尽量让每一步的残差估计更接近“真正未见样本上的估计误差”，从而让训练分布和推理分布更一致。

CatBoost 还大量使用对称树（Symmetric Tree，也常称 Oblivious Tree）：同一层的所有节点共享同一个切分规则。这种树结构比一般决策树更受约束，表达上没那么自由，但推理路径规整、计算高效，也更利于工程实现和高吞吐推断。

从工程角度看，CatBoost 的价值就在于把“类别特征处理”从手工特征工程里拿回模型内部。很多场景里，团队不再需要先在外部纠结 one-hot、频次编码、目标编码、平滑规则和泄露控制，而是可以把类别列直接交给模型，让训练流程自己处理这套问题。

• 优点：对类别特征支持最好，默认配置往往更稳，推理效率高。
• 局限：当类别特征优势不明显时，未必总能胜过 XGBoost 或 LightGBM；训练生态也没有前两者那么普遍。
• 适用场景：类别特征很多、ID 类特征很多、需要尽量减少手工编码工作的表格任务。

这一类方法处理的核心问题是：模型不仅要给出“预测是什么”，还要明确回答“这个结果有多可信、数据是如何生成的、隐藏结构是什么”。因此它们直接建模概率分布（Probability Distribution）、隐变量（Latent Variables）或序列依赖关系，在分类、密度估计、软聚类、序列推断与不确定性表达中具有统一优势。

朴素贝叶斯（Naive Bayes）用于分类问题。给定特征 \(\boldsymbol{x}\)，它要估计样本属于每个类别 \(y\) 的后验概率 \(p(y|\boldsymbol{x})\)。该方法尤其适合高维稀疏、小样本或需要快速概率基线的任务。

朴素贝叶斯的核心假设是：在给定类别 \(y\) 的条件下，各个特征条件独立（Conditional Independence）。这个假设通常并不严格成立，但它把高维联合分布的估计问题，转化为多个一维条件分布的估计问题。

由贝叶斯公式：

这个贝叶斯公式把后验概率拆成三部分： \(p(y|\boldsymbol{x})\) 是看到特征后属于类别 \(y\) 的概率； \(p(\boldsymbol{x}|y)\) 是该类别生成这组特征的可能性； \(p(y)\) 是类别先验； \(p(\boldsymbol{x})\) 则是对所有类别做归一化的总证据。

由于 \(p(\boldsymbol{x})\) 对所有类别相同，分类时只需比较：

这里的 \(\propto\) 表示“成正比”。因为对同一个样本来说，分母 \(p(\boldsymbol{x})\) 对所有类别都相同，所以比较类别大小时只需看右边：先验 \(p(y)\) 乘上每个特征条件概率 \(p(x_j|y)\) 的连乘积。

其中 \(p(y)\) 是先验概率（Prior）， \(p(x_j|y)\) 是条件似然（Likelihood）。根据特征类型不同，可以得到高斯朴素贝叶斯、伯努利朴素贝叶斯、多项式朴素贝叶斯等变体。

1. 从训练集统计每个类别的先验概率 \(p(y)\)。
2. 估计每个类别下各特征的条件分布 \(p(x_j|y)\)。
3. 推断时计算各类别的对数后验分数 \(\log p(y)+\sum_j \log p(x_j|y)\)。
4. 选择分数最大的类别作为预测输出。

在垃圾邮件检测中，若某些词在垃圾邮件中显著更常见，那么这些词对应的条件概率会被估得更大，从而把包含这些词的邮件判到垃圾类别。

• 优点：训练快、推断快、对高维稀疏特征友好。
• 局限：条件独立假设常被破坏；概率校准有时较弱。
• 适用场景：文本分类、垃圾邮件过滤、简单可靠的概率基线。

高斯混合模型（Gaussian Mixture Model, GMM）处理的是“数据由多个潜在高斯成分混合生成”的建模问题。与 K-Means 只输出硬划分不同，GMM 希望估计每个样本属于各个簇的概率，并允许不同簇有不同的协方差结构。

GMM 引入潜变量 \(z\) 表示样本来自哪一个高斯成分。整体分布由多个高斯分布按混合系数加权得到，因此每个样本对各个簇的归属是软的（Soft Assignment），并以概率形式表达。

一个直观比喻是：把数据想成混在一起的几类人群，只能看到每个人的外在特征，却看不到他原本属于哪一类。每一类人群都有自己的“中心位置”和“分散形状”，对应一个高斯成分；整个数据集则像这些人群按不同比例叠在一起形成的总体分布。与 K-Means 把每个样本硬塞进某一个簇不同，GMM 会给出“这个样本更像第 1 类，也有一部分像第 2 类”这样的软归属结果。

因此，混合系数 \(\pi_k\) 可以理解为各类人群在总体中的占比，均值 \(\boldsymbol{\mu}_k\) 是每类人群的中心，协方差 \(\boldsymbol{\Sigma}_k\) 描述该群体沿不同方向的扩散方式，而责任度 \(\gamma_{ik}\) 则表示“样本 \(i\) 有多大程度属于第 \(k\) 类”。这也是 GMM 比 K-Means 更灵活的原因：它允许边界模糊，也允许簇具有不同大小、方向和椭球形状。

对样本 \(\boldsymbol{x}\)，GMM 的概率密度写为：

这条式子说明 GMM 的整体密度不是由单个高斯给出，而是 \(K\) 个高斯成分的加权和。 \(\pi_k\) 决定第 \(k\) 个成分在总体中的占比， \(\mathcal{N}(\boldsymbol{x}\mid \boldsymbol{\mu}_k,\boldsymbol{\Sigma}_k)\) 描述样本 \(\boldsymbol{x}\) 在该成分下有多典型。

其中 \(\pi_k\) 是混合系数，满足 \(\pi_k\ge 0\) 且 \(\sum_k \pi_k=1\)。给定样本后，其属于第 \(k\) 个成分的责任度（Responsibility）为：

责任度 \(\gamma_{ik}\) 是“样本 \(i\) 属于成分 \(k\) 的后验概率”。分子表示“成分 \(k\) 解释这个样本的能力”，分母则把所有成分对该样本的解释能力加总起来做归一化，因此所有 \(\gamma_{ik}\) 加起来等于 1。

GMM 的参数通常通过期望最大化（Expectation-Maximization, EM）求解。E 步计算责任度，M 步更新参数：

这里 \(N_k\) 不是成分 \(k\) 的硬计数，而是软计数：每个样本只按自己的责任度贡献一部分。于是混合系数更新为 \(\pi_k=\frac{N_k}{N}\)，表示第 \(k\) 个成分在总体中的相对权重。

均值更新式说明：每个样本按责任度大小对中心 \(\boldsymbol{\mu}_k\) 做加权贡献；协方差更新式则是在该加权中心周围统计离散程度。责任度越大，样本对该成分的中心和形状影响越大。

1. 初始化混合系数、均值和协方差。
2. E 步：计算每个样本对各高斯成分的责任度。
3. M 步：根据责任度更新参数。
4. 重复 E / M，直到对数似然收敛。

在用户分群中，若人群天然分成多个椭球状子群体，那么 GMM 不仅能给出簇划分，还能输出“某个用户属于每个群体的概率”，这比 K-Means 的硬分配更细致。

• 优点：软聚类、概率解释清晰、能建模不同协方差形状。
• 局限：对初始化敏感；高维时协方差估计代价高。
• 适用场景：软聚类、密度估计、带概率解释的聚类分析。

隐马尔可夫模型（Hidden Markov Model, HMM）用于序列建模，尤其适合处理序列标注（Sequence Labeling）问题。序列标注的任务形式是：给定一个按时间或位置排列的输入序列，为序列中的每个位置分配一个标签。例如，在词性标注中，句子“我爱北京天安门”的每个词或字都需要对应一个词性标签；在语音识别中，一段连续声学信号需要对应到一串离散文字或音素标签。

HMM 是序列模型中的经典早期方法，在语音识别等领域长期具有重要地位。它的优势在于结构清晰、推断高效，能够以较低的计算成本处理序列决策；与此同时，它主要依赖局部状态转移和局部发射关系，所使用的上下文信息相对有限。

HMM 的建模方式是：观测序列 \(\boldsymbol{x}_{1:T}\) 可以看到，但生成这些观测的状态序列 \(\boldsymbol{z}_{1:T}\) 看不到。这里的隐藏状态通常对应词性、命名实体类别或发音状态等潜在标签。围绕这一模型，核心问题通常包括计算某段观测序列的概率、恢复最可能的隐藏状态路径，以及估计模型参数。

HMM 假设隐藏状态满足一阶马尔可夫性（First-order Markov Property）：当前状态只依赖前一个状态；同时每个观测只依赖当前状态。一个直接的比喻是：无法直接看到远方朋友每天所处的天气，但可以持续看到他发布的活动，例如“去游泳”“去逛街”或“在家睡觉”。在这个比喻里，天气是隐藏状态 \(z_t\)，活动是观测 \(x_t\)。HMM 的生成逻辑正是先生成隐藏状态序列，再由每个状态发射对应观测。

如果今天是晴天，明天仍然晴天的概率通常较高；如果今天下雨，朋友在家休息的概率通常高于去游泳。这分别对应 HMM 中的状态转移概率 \(p(z_t|z_{t-1})\) 和发射概率 \(p(x_t|z_t)\)。因此，HMM 把序列建模为一个“剧本模拟器”：先按转移规律生成一条看不见的天气轨迹，再按照每一天的天气生成看得见的活动记录。

这个比喻也解释了 HMM 的优势与局限。它简单、快速、可解释，因为联合概率能够拆成局部转移和局部发射的乘积，并可用动态规划高效推断。但它的条件独立假设也很强：某一天的活动只由当天的天气决定，不直接依赖前后活动。在词性标注等任务中，一个词的标签往往同时受左右上下文影响，这种假设就会限制表达能力。

HMM 的联合分布写为：

这条联合分布把一整条序列拆成三部分： \(p(z_1)\) 是初始状态概率， \(\prod_{t=2}^{T}p(z_t|z_{t-1})\) 是状态转移链， \(\prod_{t=1}^{T}p(x_t|z_t)\) 是每个状态发射观测的概率。正因为有这种乘积分解，HMM 才能用动态规划高效求解。

若记初始分布为 \(\pi\)，转移矩阵为 \(A\)，发射分布为 \(B\)，则前向算法（Forward Algorithm）的核心量为：

\(\alpha_t(j)\) 的含义是：看到前 \(t\) 个观测，同时当前时刻状态恰好是第 \(j\) 个状态的联合概率。它把“历史观测信息”和“当前落在哪个状态”压缩成一个可递推的中间量。

其递推为：

递推式可以分成两步看：先对所有上一步状态 \(i\) 求和，用 \(A_{ij}\) 累积“从 \(i\) 转到 \(j\) 的可能性”；再乘上 \(B_j(x_t)\)，表示当前状态 \(j\) 发射出观测 \(x_t\) 的概率。

最可能状态路径可由维特比算法（Viterbi Algorithm）求解；参数估计通常采用 Baum-Welch 算法，即 HMM 上的 EM。

1. 定义状态空间、转移概率和发射概率。
2. 若参数已知，用前向 / 后向算法做概率计算，用维特比算法做解码。
3. 若参数未知，用 Baum-Welch 在训练集上迭代估计参数。
4. 根据任务输出状态路径、序列概率或边缘状态分布。

在词性标注中，观测是单词序列，隐藏状态是词性标签。HMM 会同时利用“某个词在某种词性下更常见”的发射规律和“词性之间如何转移”的序列规律完成整体解码。

例如，对序列“我 / 爱 / 北京 / 天安门”，模型看到的是词本身，看不到的是背后的标签序列。HMM 会比较多种候选路径，如“代词（Pronoun）→ 动词（Verb）→ 专有名词（Proper Noun）→ 专有名词（Proper Noun）”与其他不合理组合的概率。由于“我”更容易由代词状态发射，“爱”更容易由动词状态发射，而“代词后接动词、动词后接名词性成分”又符合常见转移规律，这条标签路径就会获得更高概率。这个过程可以理解为：模型一边根据词本身猜标签，一边检查整条词性路径是否顺畅。

• 优点：序列结构清晰，动态规划推断高效，可解释性强。
• 局限：一阶马尔可夫假设较强，表达能力有限。
• 适用场景：基础序列标注、时间状态切换建模、中小规模序列任务。

条件随机场（Conditional Random Field, CRF）主要用于结构化预测（Structured Prediction），尤其是序列标注。它处理的问题是：在给定输入序列 \(\boldsymbol{x}\) 的条件下，如何联合预测输出标签序列 \(\boldsymbol{y}\)，并显式建模标签之间的依赖关系。

CRF 可以看作对 HMM 的进一步发展：它不再试图解释输入序列如何被生成，而是直接在给定输入的条件下预测最合理的标签结构。通过引入全局特征和更灵活的上下文依赖，CRF 缓解了 HMM 仅依赖局部独立假设所带来的信息不足。在深度学习广泛进入 NLP 之前，CRF 长期是各类标注任务中的核心方法。

CRF 的核心是在给定观测序列的条件下，对整条标签序列进行全局评分，而不是显式描述数据生成过程。仍以天气和活动的比喻来理解：已知一整周的活动记录后，CRF 会把各种可能的天气序列都拿来比较，判断哪一种与这组活动整体最一致。它建模的是条件分布 \(p(\boldsymbol{y}|\boldsymbol{x})\)，而不是 HMM 那样的联合分布 \(p(\boldsymbol{x},\boldsymbol{y})\)。

这种“全局把控”体现在两个层面。第一，CRF 的打分对象是完整的标签路径，而不是每个位置互相独立的局部决策；第二，打分依据可以是灵活定义的特征函数（Feature Function）。例如，若连续三天都出现“游泳”，对应“连续晴天”的标签组合就应得到更高分；若一周中出现“滑雪”这类活动，与“夏天”一致的天气标签组合就应被显著压低。特征函数可以同时利用当前位置、前后邻域以及相邻标签之间的组合关系。

因此，CRF 可以视为一个面向整条序列的打分系统：输入固定，模型比较不同标签序列的相对合理性，并选择得分最高的一条。它的优势是能够充分利用复杂上下文和标签依赖，在序列标注任务中通常比 HMM 更准确；代价是训练和推断都更重，需要计算整条序列上的归一化与动态规划。

线性链 CRF 的条件分布通常写为：

这个式子最好分三层看。先看最里面的 \(\sum_{t=1}^{T}\sum_k \lambda_k f_k(y_{t-1},y_t,\boldsymbol{x},t)\)：它表示对整条标签序列逐位置累积特征得分。再看外面的指数 \(\exp(\cdot)\)：它把“总得分”变成一个始终为正的数，而且总得分越大，这个数就越大。最后再除以 \(Z(\boldsymbol{x})\)，把这些正数正规化成概率。因此，CRF 的计算顺序可以理解为：先打分，再变成正权重，最后归一化成概率。

为了看清楚 \(Z(\boldsymbol{x})\) 在做什么，可以先临时把分子记成一个“未归一化分数”：

这里特意加波浪号，是为了强调它还不是概率。原因很简单：把所有可能标签序列的 \(\tilde{p}(\boldsymbol{y}|\boldsymbol{x})\) 加起来，结果一般不会恰好等于 1。它只是每条路径的相对权重，表达“这条标签路径有多合理”。

这时配分函数（Partition Function）就出现了：

之所以你会觉得它“和上面那个公式一样”，是因为它确实就是把上式分子对所有可能的标签序列整体求和。上面的 \(p(\boldsymbol{y}|\boldsymbol{x})\) 针对的是某一条固定标签序列 \(\boldsymbol{y}\)；而这里的 \(Z(\boldsymbol{x})\) 不是看某一条路径，而是把所有可能路径都算一遍，再全部加起来。所以它不是“另一条几乎一样的公式”，而是“分子在全标签空间上的总和”。

于是条件概率就变成：

现在这个式子就容易理解了：某条路径的概率，等于“这条路径自己的权重”除以“所有路径权重的总和”。这和 softmax 的归一化逻辑完全一致，只不过 softmax 是在有限个类别上归一化，而 CRF 是在所有可能的标签序列上归一化。

配分函数这个名字来自统计物理，但在这里不需要物理背景也能理解：它本质上就是一个归一化常数。没有它，模型只能说“路径 A 比路径 B 更合理”；有了它，模型才能进一步说“路径 A 的概率是多少”。也正因为 \(Z(\boldsymbol{x})\) 需要把所有可能标签路径都考虑进去，CRF 训练时才必须借助动态规划，而不能暴力枚举。

• \(f_k(y_{t-1},y_t,\boldsymbol{x},t)\)：第 \(k\) 个特征函数，描述当前位置、相邻标签和输入之间的某种局部模式。
• \(\lambda_k\)：该特征的权重；越大表示模型越重视这个模式。
• \(\boldsymbol{x}\)：固定输入序列；在讨论 \(Z(\boldsymbol{x})\) 时，它不变。
• \(\boldsymbol{y}\)：某一条候选标签序列；计算 \(Z(\boldsymbol{x})\) 时要对所有可能的 \(\boldsymbol{y}\) 求和。
• \(\sum_{t=1}^{T}\sum_k \lambda_k f_k(\cdot)\)：整条标签序列的总得分。
• \(\exp(\cdot)\)：把总得分映射成正权重，并放大高分路径与低分路径之间的差异。
• \(Z(\boldsymbol{x})\)：所有候选标签路径未归一化权重的总和，用于把相对权重变成概率。

训练时最大化条件对数似然，解码时用维特比算法寻找最优标签序列。

1. 定义特征函数，描述输入与标签、标签与标签之间的关系。
2. 用前向后向算法计算配分函数与梯度。
3. 通过梯度法优化参数 \(\lambda_k\)。
4. 推断时用维特比算法输出最优标签序列。

在命名实体识别（NER）中，局部分类器可能会把某个词单独判成人名，但 CRF 会进一步考虑相邻标签是否合法，从而减少孤立的局部误判。这里“是否合法”指的不是语法合法，而是标签序列是否符合该任务定义下允许出现的邻接模式。例如，在常见的 BIO 标注体系中， \(B\) 表示 Begin，即实体开始； \(I\) 表示 Inside，即实体内部； \(O\) 表示 Outside，即不属于任何实体。也有一些任务使用 BIOES 标注体系，其中 \(E\) 表示 End， \(S\) 表示 Single。与 BIO 相比，BIOES 会把实体结束位置和单字实体显式标出来，因此边界信息更细。于是，标签 \(B\text{-}PER\) 表示一个人名实体的开始， \(I\text{-}PER\) 表示该人名实体的内部， \(O\) 表示不属于任何实体。于是， \(B\text{-}PER\rightarrow I\text{-}PER\) 是常见且合法的相邻转移， \(O\rightarrow B\text{-}PER\) 也合法；但 \(O\rightarrow I\text{-}PER\) 通常不合法，因为一个实体内部标签不能无缘无故直接开始，前面必须先有对应的开始标签。同样， \(B\text{-}LOC\rightarrow I\text{-}PER\) 这类“实体类型突然不一致”的连接也通常应被压低分数。

例如，在句子“张三 在 北京 工作”中，若任务要识别人名（PER）和地点（LOC），一个合理的 BIO 标注序列可能是“张三 / 在 / 北京 / 工作”对应 \(B\text{-}PER, O, B\text{-}LOC, O\)。这里首先需要区分两件事：某个位置更像哪一种实体类型，以及这些局部判断连起来是否构成一条合理的标签序列。前者主要来自输入本身提供的证据，例如“张三”在词形上很像中文人名，“北京”本身强烈像地点名词，而“在 北京 工作”这种上下文也会继续加强“北京是地点”的判断。传统 CRF 会把这些信息写成特征函数，例如“当前词是否常见于人名词表”“当前词是否带有地名后缀”“左邻词是否是介词‘在’”“右邻词是否是动作词‘工作’”等；每个特征都会给某个候选标签加分或减分。

CRF 的作用是在这些局部类型证据之上，再做一次全局一致性的联合解码。换言之，实体类型 A 还是 B，并不是和 CRF 完全无关；但也不是由 CRF 凭空决定的。更准确地说，实体类型的语义判断主要来自输入特征，CRF 负责把这些局部判断放到整条序列里统一协调。例如，如果“北京”这个位置单看局部证据时，对 LOC 的分数高于 PER，那么 CRF 会倾向保留“地点”这一判断；但它还会进一步检查，当前位置前后的标签连接是否自然。如果某条候选路径把“张三”切成 \(B\text{-}PER, O\)，或者把“北京”接成 \(B\text{-}PER\rightarrow I\text{-}LOC\)，即使某个局部位置的分数不低，整条路径仍会因为边界断裂或类型转移不一致而被整体压低。于是 CRF 做的不是单点分类，而是“局部类型打分 + 全局路径约束”的联合决策。

从工程实现上看，这个分工在不同年代的模型里表现形式不同。在传统 CRF 中，“局部类型打分”通常来自人工设计的特征模板，例如当前词、前后词、词性、字形、是否出现在人名词典或地名词典中；CRF 再把这些手工特征组合成整条序列的全局分数。在 BiLSTM-CRF 或 BERT-CRF 这类现代模型中，局部证据不再主要依赖手工模板，而是先由 BiLSTM 或 BERT 生成上下文化表示（Contextual Representation），再由线性层给出每个位置对各标签的局部分数，最后仍由 CRF 层负责建模标签转移和整条路径解码。也就是说，上游编码器主要回答“这个位置像什么类型”，CRF 层主要回答“这些位置判断拼在一起是否构成一条最合理的标签序列”。

类似的全局打分思想也可以推广到依存句法分析（Dependency Parsing, DEP）这类结构化任务。句子中的每个词都需要找到自己的中心词（head），模型的目标不是孤立地决定“这个词连向谁”，而是评估整棵依存树是否合理。例如，在“她 喜欢 自然语言处理”中，“喜欢”通常更可能作为中心谓词，“她”依附到“喜欢”形成主谓关系，“自然语言处理”整体依附到“喜欢”形成宾语关系。若某个局部决策把“她”错误地连到“自然语言处理”，单看两个词的局部相似度未必很低，但放到整棵树的全局结构中就会显得不协调。CRF 的价值正体现在这里：它通过全局归一化和结构约束，偏好整体验证一致的输出结构，而不是一组彼此冲突的局部最优决策。

• 优点：适合结构化输出，能显式编码标签依赖。
• 局限：训练与推断成本高于普通独立分类器。
• 适用场景：序列标注、分词、命名实体识别等条件结构化预测任务。

这一类方法处理的核心问题是：在缺少可靠全局函数形式时，是否可以直接依赖“局部相似样本通常有相似输出”这一假设完成预测。近邻模型不急于学习一个显式参数化函数，而是把相似性度量（Similarity Metric）本身作为建模中心：先找邻居，再由邻居投票、平均或加权得到结果。

K 近邻（K-Nearest Neighbors, KNN）用于分类与回归。给定一个待预测样本 \(\boldsymbol{x}\)，它要根据训练集中与其最相似的样本来决定输出。

KNN 的基本假设是局部平滑性（Local Smoothness）：在特征空间中彼此接近的样本，往往具有相近的标签或数值。它不显式学习参数化模型，训练集本身就是局部比较的参照集。

给定距离函数 \(d(\boldsymbol{x},\boldsymbol{x}')\) 与邻居数 \(K\)，若 \(N_K(\boldsymbol{x})\) 表示 \(\boldsymbol{x}\) 的 \(K\) 个最近邻，则分类时可写为：

这里 \(N_K(\boldsymbol{x})\) 是样本 \(\boldsymbol{x}\) 的 \(K\) 个最近邻集合，花括号中收集的是这些邻居的标签， \(\mathrm{mode}(\cdot)\) 则返回出现次数最多的类别。也就是说，KNN 分类本质上就是“看最近的邻居们大多数是谁”。

回归时常取邻居标签平均：

回归版 KNN 只是把“多数投票”换成“数值平均”。 \(\frac{1}{K}\sum\) 表示把最近 \(K\) 个邻居的输出做均值，因此预测值会受到局部邻域中所有数值样本的共同影响。

若距离使用欧氏距离，则默认所有特征尺度可比，因此标准化（Standardization）通常是必要前处理。

1. 训练阶段几乎不做参数学习，只保存全部训练样本。
2. 推断时计算待测样本到训练样本的距离。
3. 选出最近的 \(K\) 个样本。
4. 分类取多数投票，回归取平均或距离加权平均。

在简单的手写数字识别中，如果一张新图片与训练集中大量“3”的图像都很接近，而与“8”的图像明显更远，那么 KNN 会依据局部邻域投票把它判为 3。

• 优点：概念简单、无需复杂训练、局部非线性表达能力强。
• 局限：推断成本高；对特征尺度和无关特征敏感；维度灾难会削弱距离判别力。
• 适用场景：中小规模数据、快速基线、基于相似度的简单分类与回归。

聚类处理的核心问题是：在没有标签的前提下，如何仅根据样本之间的几何关系、密度结构或层次关系，把数据自动分成若干组。这里不存在唯一正确的“簇”定义：K-Means 假设簇围绕中心分布，层次聚类强调多粒度组织结构，DBSCAN / HDBSCAN 则把簇理解为高密度连通区域。因此，聚类算法的选择本质上是在选择“什么样的结构应被视为同一类”。

K-Means 处理的是无监督聚类问题：给定一组没有标签的样本，希望把它们分成 \(K\) 个簇，使同一簇内样本尽量接近，不同簇之间尽量分开。

K-Means 用“每个簇由一个中心点代表”的方式近似数据分布。算法不断重复两件事：把样本分配给最近的中心；再用簇内样本均值更新中心。它本质上是在最小化簇内平方误差。

目标函数为：

这个目标里， \(c_k\) 是第 \(k\) 个簇中心， \(z_i\) 表示样本 \(i\) 被分到哪个簇， \(\|\boldsymbol{x}_i-c_{z_i}\|_2^2\) 是样本到所属簇中心的平方距离。K-Means 想做的，就是让所有样本离各自中心都尽可能近。

其中 \(c_k\) 是第 \(k\) 个簇中心， \(z_i\in\{1,\dots,K\}\) 表示样本 \(\boldsymbol{x}_i\) 属于哪个簇。固定簇分配时，最优中心是该簇样本均值：

这里 \(S_k\) 是第 \(k\) 个簇里所有样本的集合， \(|S_k|\) 是该簇样本数。这个更新式说明簇中心就是簇内样本的算术平均，因此 K-Means 的“中心”确实是均值意义上的代表点。

1. 初始化 \(K\) 个簇中心。
2. 分配步骤：把每个样本分到最近中心。
3. 更新步骤：用各簇样本均值更新中心。
4. 重复迭代直到簇分配稳定或目标下降很小。

在用户分群中，若特征是消费频次与客单价，K-Means 往往会自动形成“高频低客单”“低频高客单”“中频中客单”等若干均值中心明确的群体。

• 优点：实现简单、可扩展、训练速度快。
• 局限：需要预先指定 \(K\)；对初始化与离群点敏感；不适合非凸簇。
• 适用场景：簇近似球形、需要快速聚类或作为预处理的任务。

层次聚类（Hierarchical Clustering）输出的是一个由粗到细的聚类层次结构，因此簇数可以在观察树状图后再决定。它适合需要观察“簇是如何逐步合并或拆分”的任务。

凝聚式层次聚类（Agglomerative Clustering）从每个样本单独成簇开始，每一步合并当前最相近的两个簇；分裂式层次聚类则从一个大簇开始不断拆分。实践中更常见的是凝聚式版本。

关键在于定义簇间距离。常见联接准则（Linkage Criteria）包括：

单链距离只看两簇之间最近的那一对点，因此它很容易把“靠得最近的局部桥梁”连起来，适合发现链式结构，但也更容易被噪声点串联。

完全链距离只看两簇之间最远的那一对点，因此它会避免把跨度过大的簇合并到一起，更偏好紧凑、直径较小的簇。

平均链则对两簇之间所有点对的距离取平均。这里 \(|A||B|\) 是点对总数，因此它不只看最近点或最远点，而是综合考虑两簇整体的平均接近程度。

不同联接方式对应不同簇形偏好：单链更容易形成链式簇，完全链更偏向紧凑簇，平均链则居中。

1. 初始化每个样本为单独一个簇。
2. 计算簇间距离矩阵。
3. 反复合并距离最近的两个簇，并更新距离矩阵。
4. 得到树状图（Dendrogram）后，在某个高度切开即可获得聚类结果。

在文档聚类中，层次聚类不仅能区分“体育”“财经”“科技”等大类，还能进一步展示每一大类内部的细粒度层级关系。

• 优点：无需预先指定簇数；可以输出多层次聚类结构。
• 局限：计算与存储成本较高；早期合并错误通常无法回退。
• 适用场景：中小规模数据、需要树状关系解释的聚类分析。

DBSCAN（Density-Based Spatial Clustering of Applications with Noise）用于识别任意形状的高密度簇，并显式发现噪声点。它尤其适合处理非球形簇与含离群点数据。

DBSCAN 通过局部密度定义簇。若一个点周围半径 \(\epsilon\) 内有足够多的邻居，则它是核心点（Core Point）；核心点可以把周围密度可达（Density-Reachable）的样本不断扩展成一个簇。既不够密、又不属于任何核心点邻域的样本被视为噪声。

记 \(N_{\epsilon}(\boldsymbol{x})\) 为点 \(\boldsymbol{x}\) 的 \(\epsilon\) 邻域。若：

判断核心点只需看两件事： \(N_{\epsilon}(\boldsymbol{x})\) 是点 \(\boldsymbol{x}\) 在半径 \(\epsilon\) 内的邻域集合， \(|N_{\epsilon}(\boldsymbol{x})|\) 是邻域里有多少点。只要这个数量不小于 \(\text{minPts}\)，就说明该点周围密度足够高，可以作为簇扩张的核心。

则 \(\boldsymbol{x}\) 是核心点。若某点落在某个核心点邻域中但自身并非核心点，则为边界点（Border Point）；不属于任何簇的点为噪声（Noise）。

1. 遍历未访问样本，计算其 \(\epsilon\) 邻域。
2. 若邻居数少于 \(\text{minPts}\)，则暂记为噪声或边界候选。
3. 若为核心点，则以它为起点递归扩展所有密度可达的点。
4. 重复直到所有样本都被标记。

在地理位置聚类中，餐馆、商圈、交通枢纽附近的点位通常形成形状复杂的密集区域。DBSCAN 可以识别这些非凸热点，同时把零散孤立点保留为噪声。

• 优点：无需预设簇数；可识别任意形状簇；对离群点鲁棒。
• 局限：对 \(\epsilon\) 和 \(\text{minPts}\) 敏感；难以同时适配不同密度簇。
• 适用场景：空间聚类、热点区域发现、非凸簇与带噪声数据。

HDBSCAN（Hierarchical DBSCAN）用于缓解 DBSCAN 的单一密度阈值问题。它面对的核心困难是：真实数据中的簇密度常常并不一致，用一组固定的 \(\epsilon\) 和 \(\text{minPts}\) 很难同时兼顾所有簇。

HDBSCAN 会在多个密度尺度上构建层次结构，再从中选出稳定簇（Stable Clusters）作为结果。这让它比 DBSCAN 更适合处理密度差异显著的数据。

给定参数 \(k\)，先定义核心距离（Core Distance）为点到其第 \(k\) 近邻的距离，再定义互可达距离（Mutual Reachability Distance）：

互可达距离把三个量取最大值：点 \(\boldsymbol{x}\) 的核心距离、点 \(\boldsymbol{y}\) 的核心距离，以及它们之间的原始距离。这样做的效果是：低密度区域的点会被“拉远”，从而更清楚地暴露不同密度簇之间的结构边界。

随后算法在互可达图上构建最小生成树（Minimum Spanning Tree），再转成聚类层次，并依据簇稳定性选择最终输出。

1. 计算所有点的核心距离。
2. 基于互可达距离构造图并求最小生成树。
3. 从图中得到随密度变化的层次聚类结构。
4. 在压缩树（Condensed Tree）上选择稳定簇作为结果。

在用户行为嵌入空间中，有些兴趣群体很紧密，有些较松散。HDBSCAN 可以同时保留这两类簇，而不需要强行用同一个密度阈值描述它们。

• 优点：对多密度簇更稳健，仍保留噪声识别能力。
• 局限：实现更复杂，计算与内存开销通常高于 DBSCAN。
• 适用场景：嵌入聚类、用户分群、不同密度簇共存的数据。

升维（Feature Expansion / Lifting）处理的问题，与降维正好互补。降维试图把高维表示压缩到更低维空间，以减少冗余、噪声与计算量；升维则试图把原始特征映射到一个更高维的表示空间，使原本难以表达、难以分离或难以拟合的结构，在新空间里变得更容易处理。它的目标不是“把维度变大本身”，而是通过增加表示自由度，把非线性关系改写为更容易由简单模型处理的形式。

许多经典机器学习模型本体是线性的，例如线性回归、逻辑回归、线性支持向量机（Support Vector Machine, SVM）。它们直接在原始输入空间中学习一个线性决策函数或线性预测函数。若数据关系本身高度非线性，那么模型能力可能不足。升维的思路因此是：先把输入映射为一个更高维的新表示，再在新表示上使用线性模型。模型形式仍然简单，但由于工作空间改变了，整体表达能力会显著提升。

更一般地，若原始输入为 \(\boldsymbol{x}\in \mathbb{R}^d\)，则升维映射可写成：

这里 \(\boldsymbol{x}\) 是原始输入； \(\tilde{\boldsymbol{x}}\) 是升维后的新特征； \(\phi(\boldsymbol{x})\) 是特征映射； \(D>d\) 表示新的表示空间维度高于原空间维度。若后续模型写成 \(f(\boldsymbol{x})=\boldsymbol{w}^\top \tilde{\boldsymbol{x}}+b\)，那么它虽然在新空间中仍然是线性的，但在原始输入 \(\boldsymbol{x}\) 上通常已经对应一个非线性函数。

升维的直观含义，是把原来“纠缠在一起”的关系展开。例如在二维平面里，某些数据可能无法被一条直线分开；但若把 \((x_1,x_2)\) 映射成 \((x_1,x_2,x_1^2,x_2^2,x_1x_2)\) 这样的更高维特征，原本的弯曲边界就可能对应高维空间中的一个超平面。于是复杂性并没有消失，而是被转移到了特征映射 \(\tilde{\boldsymbol{x}}=\phi(\boldsymbol{x})\) 上。

这也是经典机器学习里一个非常常见的套路：先做特征构造或特征展开，再用结构简单、优化稳定的线性模型。因此，升维常常并不以“升维”这个名字出现，而是以多项式特征、基函数展开、核方法、one-hot 编码、N-gram 稀疏特征、随机特征等形式出现。

升维后的线性模型通常写成：

这里 \(\tilde{\boldsymbol{x}}\) 是由原始输入 \(\boldsymbol{x}\) 构造出来的高维特征向量； \(\boldsymbol{w}\in \mathbb{R}^D\) 是新空间中的参数； \(b\) 是偏置。关键点在于：模型在 \(\tilde{\boldsymbol{x}}\) 空间里仍然是线性的，但如果 \(\phi(\boldsymbol{x})\) 含有平方项、交叉项、基函数或核映射，那么 \(f(\boldsymbol{x})\) 相对于原始输入 \(\boldsymbol{x}\) 就会表现出非线性。

以二次多项式特征为例，若原始输入为 \(\boldsymbol{x}=(x_1,x_2)\)，则可构造：

此时线性模型

在参数上仍然是线性的，但在输入上已经能够表达二次曲面或二次决策边界。这正是升维最核心的数学作用：把原空间中的非线性关系，改写成高维空间中的线性关系。

其中，核方法是经典机器学习里最有代表性的升维思想。以 SVM 为例，若定义特征映射 \(\tilde{\boldsymbol{x}}=\phi(\boldsymbol{x})\)，则线性分类器可写成 \(f(\boldsymbol{x})=\boldsymbol{w}^\top \tilde{\boldsymbol{x}}+b\)。核技巧（Kernel Trick）并不显式构造 \(\tilde{\boldsymbol{x}}\)，而是直接通过核函数

计算升维后特征空间中的内积。这样既保留了高维映射的表达力，又避免了显式展开到巨大维度的代价。也正因为如此，SVM 是很多人最先感受到“升维威力”的经典模型。

在圆形可分但线性不可分的数据中，原始二维平面上一条直线无法把内圈与外圈分开；但若加入半径相关的二次特征，例如 \(x_1^2+x_2^2\)，则问题可以转写为更高维空间中的线性分离。文本任务里，N-gram 稀疏特征同样是一种典型升维：原始句子是离散序列，经过词袋或 N-gram 展开后，就变成了数万维甚至更高维的稀疏向量，随后再交给逻辑回归、朴素贝叶斯或线性 SVM 处理。

表格任务中的类别变量处理也体现了同样思想。一个城市字段看起来只是一个离散取值，但 one-hot 编码后，它会被展开成一个高维稀疏向量，使模型能够为每个类别学习独立参数。推荐系统、广告点击率预估、工业风控中的大规模离散特征，长期都高度依赖这种升维方式。

经典机器学习也会使用升维，但通常更谨慎。原因在于，维度一旦上去，过拟合风险、存储开销与计算开销都会迅速增加，这就是维度灾难（Curse of Dimensionality）的典型体现。于是经典方法常把“升维”与“控制复杂度”配套使用：一边通过特征展开提升表达能力，一边用正则化（Regularization）、特征选择（Feature Selection）或后续降维来抑制过拟合。

因此，在经典机器学习里，常见工作流并不是“只升维”或“只降维”，而是两者交替配合：先做有针对性的特征展开，让结构变得更容易表达；再通过正则化、筛选或压缩保留真正有效的部分。升维是在展开表达能力，降维是在压缩冗余信息，它们并不是对立操作，而是围绕表示空间做的两种互补控制。

维度灾难（Curse of Dimensionality）指的是：当特征维度不断升高时，许多在低维空间中直观、有效的统计与几何规律会迅速恶化，导致数据需求、计算成本与建模难度同时上升。它不是某一个单独问题，而是一组高维效应的统称，包括样本空间体积指数级膨胀、样本变得极其稀疏、局部邻域难以稳定估计、距离与密度统计的判别力下降，以及模型更容易用复杂边界去记忆训练集。

其中一个最重要的现象确实是：高维里距离往往会变得不再像低维那样有区分力。直观地说，当维度很多时，样本之间的最近距离和最远距离可能越来越接近，导致“谁是真正近邻”这件事变得没那么清晰。依赖距离或局部邻域的方法，例如 KNN、聚类、核密度估计、局部异常检测等，往往会因此退化。这也是为什么高维数据上，距离度量、标准化、特征筛选和嵌入学习会变得格外重要。

但“高维更容易过拟合”并不只因为距离失去意义。更根本的原因是：当维度升高后，表示空间的自由度与可容纳的划分方式急剧增加，而训练样本相对于整个空间显得越来越稀疏。模型于是更容易找到一些只对训练集成立、却不能推广到新样本的偶然边界或偶然相关性。换句话说，距离退化主要伤害的是邻域、相似度与密度估计；过拟合风险上升则更直接地来自空间稀疏化、参数自由度增加和有效样本覆盖不足。

这也是为什么经典机器学习在做升维时往往必须同步引入约束：一方面用特征展开提升表达能力，另一方面通过正则化（Regularization）、特征选择（Feature Selection）、降维（Dimensionality Reduction）或更强的数据先验，限制模型不要把高维空间当成“背题空间”。因此，维度灾难并不是在说“高维一定不好”，而是在提醒：维度每增加一层，模型就需要更多数据、更强归纳偏置和更谨慎的复杂度控制，才能让新增维度真正转化为有效表达能力。

深度学习中的很多操作，本质上也在做升维。Transformer 的前馈网络（Feed-Forward Network, FFN / MLP）常把 \(d_{\text{model}}\) 升到更大的 \(d_{\text{ff}}\)，再降回原维度；这与经典机器学习里“先展开、再用简单变换处理”的思想是一脉相承的。差别在于，经典方法里的升维往往是人工设计或固定形式的，而深度学习中的升维通常是可学习的线性投影与非线性组合。

因此，若从表示学习角度看，升维在机器学习中并不罕见。SVM 的核空间、逻辑回归的多项式特征、文本的 N-gram 稀疏向量、推荐系统的 one-hot 离散展开，以及 Transformer MLP 中的中间维度扩张，本质上都属于同一条主线：把原本难以处理的关系，展开到一个更容易表达与分离的表示空间里。

降维处理的核心问题是：高维数据往往包含冗余、相关性与噪声，既增加计算成本，也削弱可视化与建模稳定性。目标不是简单“删维度”，而是在压缩表示的同时尽量保留有用结构——这个“有用”可以是方差、类别可分性、局部邻域、全局流形，具体取决于所采用的方法。

主成分分析（Principal Component Analysis, PCA）处理的是线性降维问题：在尽量保留数据主要变化信息的前提下，把高维样本映射到更低维空间。它常用于压缩维度、去相关、可视化与噪声抑制。

PCA 用方差（Variance）近似衡量信息量。若数据在某个方向上的投影变化很大，说明该方向承载了更多结构；于是 PCA 选择能最大化投影方差的一组正交方向作为新的表示基底。

给定中心化后的数据矩阵 \(\boldsymbol{X}_c\in\mathbb{R}^{N\times d}\)，协方差矩阵为：

这里 \(\boldsymbol{X}_c\) 是已经减去均值后的数据矩阵， \(\boldsymbol{X}_c^\top \boldsymbol{X}_c\) 汇总了各个特征之间如何共同变化；再除以 \(N\)，就得到平均意义下的协方差矩阵 \(\boldsymbol{\Sigma}\)。PCA 正是从这个矩阵里找“变化最大的方向”。

第一主成分对应的优化问题为：

\(\boldsymbol{u}\) 是候选投影方向， \(\boldsymbol{u}^\top \boldsymbol{\Sigma}\boldsymbol{u}\) 表示数据投影到该方向后的方差，约束 \(\|\boldsymbol{u}\|_2=1\) 则防止通过把向量无限放大来虚增方差。于是这个优化问题真正寻找的是“单位长度下最能保留变化信息的方向”。

其解是协方差矩阵最大特征值对应的特征向量。取前 \(k\) 个主成分组成矩阵 \(\boldsymbol{U}_k\) 后，样本 \(\boldsymbol{x}\) 的低维表示为：

这里 \(\boldsymbol{\mu}\) 是原始数据均值， \(\boldsymbol{x}-\boldsymbol{\mu}\) 先把样本中心化， \(\boldsymbol{U}_k\) 由前 \(k\) 个主成分方向组成，最终 \(\boldsymbol{z}\) 就是样本在这组主方向上的低维坐标。

1. 对数据做中心化，必要时再做标准化。
2. 计算协方差矩阵或直接对数据矩阵做奇异值分解（SVD）。
3. 取前 \(k\) 个主成分方向。
4. 把数据投影到这些方向上得到低维表示。

在人脸图像压缩中，大量像素变化往往由少数全局因素驱动。PCA 可以用少量主成分保留大部分有效变化，从而显著降低特征维度。

• 优点：线性、稳定、可解释，常用作预处理和可视化。
• 局限：只能捕捉线性结构；对异常值敏感。
• 适用场景：线性降维、特征压缩、去相关与噪声过滤。

线性判别分析（Linear Discriminant Analysis, LDA）用于监督降维与分类。与 PCA 只看输入分布不同，LDA 利用类别标签寻找一个投影空间，使同类样本尽量聚集、异类样本尽量分开。

LDA 同时考虑类内散度（Within-class Scatter）和类间散度（Between-class Scatter）。好的投影方向应当让类间距离大、类内波动小，因此它优化的核心是判别性。

定义类内散度矩阵：

类内散度矩阵 \(\boldsymbol{S}_W\) 统计的是“同一类内部有多分散”。 \(\mathcal{C}_k\) 是第 \(k\) 类的样本集合， \(\boldsymbol{\mu}_k\) 是该类均值。若类内样本围绕各自均值分布得很紧， \(\boldsymbol{S}_W\) 就会较小。

类间散度矩阵：

类间散度矩阵 \(\boldsymbol{S}_B\) 统计的是“各类中心彼此有多分开”。其中 \(\boldsymbol{\mu}\) 是全局均值， \(N_k\) 是第 \(k\) 类样本数，因此样本多的大类会对类间结构贡献更大权重。

LDA 寻找投影向量 \(\boldsymbol{w}\) 使 Fisher 判别准则最大：

Fisher 准则的分子衡量“投影后类间有多分开”，分母衡量“投影后类内有多混在一起”。因此 \(J(\boldsymbol{w})\) 越大，说明方向 \(\boldsymbol{w}\) 越有助于把不同类别拉开、同时保持同类紧凑。

该问题可转化为广义特征值问题 \(\boldsymbol{S}_B\boldsymbol{w}=\lambda \boldsymbol{S}_W\boldsymbol{w}\)。对 \(C\) 类问题，最多能得到 \(C-1\) 个有效判别方向。

1. 根据标签统计每一类的均值与全局均值。
2. 构造类内散度矩阵和类间散度矩阵。
3. 求解广义特征值问题，选择主要判别方向。
4. 将样本投影到低维判别子空间中做分类或可视化。

在手写数字分类中，LDA 关注的是“哪些方向最有助于把不同数字分开”，因此在有标签监督时，它往往比只最大化总体方差的 PCA 更适合分类前降维。

• 优点：利用标签信息，投影方向更有判别性。
• 局限：线性假设较强；类内散度矩阵可能奇异。
• 适用场景：有标签监督的降维、分类前特征压缩、判别性可视化。

t-SNE（t-distributed Stochastic Neighbor Embedding）主要用于二维或三维可视化。它主要关注如何在低维图上尽量保留高维空间中的局部邻域关系。

t-SNE 把“样本彼此接近”转写为概率相似度：在高维空间中，接近的样本应当有较大概率互为邻居；在低维嵌入中，也希望这种邻近关系继续成立。优化的目标是让两种邻域概率分布尽可能接近。

在高维空间中，先定义邻域概率 \(p_{ij}\)；在低维空间中，对嵌入点 \(\boldsymbol{y}_i\) 定义：

这里 \(\boldsymbol{y}_i\) 和 \(\boldsymbol{y}_j\) 是低维嵌入坐标，分子把距离越近的点赋予越大的相似度，分母则把所有点对的相似度加总起来做归一化，因此 \(q_{ij}\) 可以被解释成低维空间里的邻域概率。

t-SNE 最小化高维邻域分布与低维邻域分布之间的 KL 散度：

KL 散度衡量的是“低维邻域分布 \(Q\) 与高维邻域分布 \(P\) 相差多少”。若某对样本在高维里很近，即 \(p_{ij}\) 很大，但在低维里被拉得太开， \(q_{ij}\) 就会过小，从而产生较大惩罚。

低维中采用重尾 Student-t 分布，主要是为了缓解拥挤问题（Crowding Problem），使远处点更容易被拉开。

1. 根据高维距离计算样本间的邻域概率。
2. 随机初始化低维坐标。
3. 计算低维相似度 \(q_{ij}\)。
4. 通过梯度下降最小化 KL 散度并更新低维坐标。

在词向量或图像嵌入可视化中，t-SNE 常把语义相近的样本压到局部团簇中，从而帮助研究者直观看到表示空间里是否出现了合理分群。

• 优点：二维可视化效果强，局部邻域保持能力好。
• 局限：全局距离与簇间相对位置不稳定；对超参数和随机初始化敏感。
• 适用场景：嵌入可视化、表示质量诊断、探索性数据分析。

UMAP（Uniform Manifold Approximation and Projection）同样用于低维可视化与非线性降维。它面对的任务与 t-SNE 类似，但更强调在保留局部结构的同时，尽量维持一定的全局几何关系，并提升速度与可扩展性。

UMAP 先在高维空间构建一个加权近邻图，把数据视为流形（Manifold）上的离散采样；随后在低维空间中寻找一张新图，使低维图与高维图的模糊连通结构尽量一致。它本质上是在匹配两张图的连通结构，而不只是在匹配两组欧氏距离。

这里的流形可以先从一个标准定义理解：设样本位于高维空间 \(\mathbb{R}^D\) 中，若它们实际上集中在某个低维集合 \(\mathcal{M}\subseteq\mathbb{R}^D\) 附近，并且对 \(\mathcal{M}\) 上任一点，都能在一个足够小的邻域内用 \(d\) 维坐标平滑描述，其中 \(d\ll D\)，那么这个集合就可以看作一个 \(d\) 维流形。流形的关键性质不是“它弯不弯”，而是它在局部看起来像低维欧氏空间，在全局上则可以嵌入到更高维空间并发生弯曲、卷曲或拉伸。

在数据分析里，这个概念表示：虽然原始特征有很多维，但样本并没有真正填满整个高维空间，而是分布在某种低维结构附近。例如一组人脸图像在像素空间里维度极高，但由姿态、光照、表情等少数潜在因素变化时，样本往往只覆盖其中一个低维子区域。UMAP 的出发点正是：若数据主要几何结构由这个低维流形决定，那么局部近邻关系比“全局欧氏直线距离”更能反映真实结构。

“离散采样”则表示：真实流形 \(\mathcal{M}\) 本身是连续对象，但我们手里只有有限个样本点 \(\{x_i\}_{i=1}^N\)。UMAP 通过近邻图近似这些点在流形上的局部连通关系，再在低维空间中寻找一组坐标 \(\{y_i\}_{i=1}^N\)，使这种局部连通关系尽量被保留下来。因此它不是直接恢复整张流形，而是在有限样本层面恢复流形的邻域结构。

与 t-SNE 相比，UMAP 更强调“样本来自某个低维流形，并且近邻图是在近似这个流形的局部连通结构”；t-SNE 的核心对象则更偏向“高维邻域概率分布与低维邻域概率分布的匹配”。两者都重视局部关系，但 UMAP 的表述更几何化，t-SNE 的表述更概率化。

若高维图边权为 \(p_{ij}\)，低维图边权常写为：

UMAP 用这个函数把低维距离转换成连通强度。 \(a\) 和 \(b\) 控制曲线形状：距离很近时 \(q_{ij}\) 接近 1，距离变远时迅速衰减到接近 0，因此它可以把“近邻关系”转写成平滑的图边权。

其中 \(a,b\) 决定低维距离与连接强度的映射形状。UMAP 的优化目标通常是高维图与低维图之间的交叉熵（Cross-Entropy）：既鼓励高维中相连的点在低维中也靠近，也鼓励高维中不相连的点在低维中适当分开。

1. 计算近邻图，并为边赋予模糊连通权重。
2. 初始化低维坐标。
3. 通过随机优化最小化高维图与低维图之间的交叉熵。
4. 得到二维或三维嵌入用于可视化或下游分析。

在单细胞测序、文本嵌入或推荐向量分析中，UMAP 常被用来把高维表示映射到二维平面，从而观察群体结构、类别分布与异常点。

• 优点：通常比 t-SNE 更快，较好兼顾局部与部分全局结构。
• 局限：嵌入结果仍依赖超参数与随机种子；二维距离不能机械等同于原空间距离。
• 适用场景：大规模嵌入可视化、非线性降维、聚类前的低维表示。

异常检测处理的核心问题是：正常样本通常大量存在，而异常样本稀少、形态多变、甚至在训练阶段根本拿不到完整标签。模型因此不再主要学习“类别之间如何区分”，而是学习“什么算正常”以及“偏离正常结构有多严重”。不同方法对“异常”的定义并不相同：有的依赖隔离难易度，有的依赖局部密度，有的学习正常区域边界。

在业务语境里，“异常”并不等于“数值特别大”或“离均值很远”。更准确地说，异常是相对于当前业务规则、历史模式或同类群体而言，不应当出现、很少出现、或者一旦出现就值得额外关注的样本。因此异常是一个“相对概念”，必须依赖参照系：相对于谁、在哪个时间段、在什么上下文里、以什么代价衡量。

例如，单笔消费 5000 元在全国范围内不一定异常，但若这位用户平时只在本地便利店做几十元交易，而这次交易突然发生在异地、高风险设备、深夜时段，并伴随支付习惯突变，那么它在风控上就可能是异常。类似地，服务器 CPU 使用率 85% 在大促期间可能是正常负载，在凌晨低峰却可能意味着任务堆积；工厂传感器温度轻微升高若同时伴随振动模式变化，也可能预示故障正在形成。

这说明业务上的异常通常至少包含三类含义。第一类是统计稀有：样本落在低概率区域。第二类是行为失配：它与该对象自己的历史模式不一致。第三类是群体失配：它在全局上不一定极端，但相对于同类群体显著不同。异常检测算法的差异，本质上就在于它们分别更擅长刻画哪一种“失配”。

因此，做异常检测时首先要回答的不是“用哪种模型”，而是“业务到底把什么视为异常”。若异常意味着“明显稀少且容易与大部队分开”，隔离式方法更合适；若异常意味着“在本地邻域里显得稀疏”，应优先考虑密度比较；若正常样本边界清楚、异常样本类型杂乱，则更适合只学习正常区域。算法不是在定义业务，而是在实现业务已经确定的异常标准。

孤立森林（Isolation Forest）用于无监督异常检测：在没有可靠异常标签时，仅根据数据分布本身识别“容易被孤立”的异常样本。它尤其适合高维表格数据与大规模检测场景。

孤立森林利用一个非常直接的直觉：异常点通常更稀少、更孤立，因此在随机切分下更容易被提早隔离。路径越短，越可能是异常；路径越长，越像处于正常群体内部。若把正常样本理解为“扎堆生活在高密度区域里的大群体”，那么它们往往需要经过很多次随机切割才会被单独分离出来；而那些落在边缘、稀疏区域、或与主体分布明显脱节的样本，只需少量切分就会被单独留在某个叶节点里。

这种思路和距离或密度方法非常不同。K 近邻（K-Nearest Neighbors, KNN）或局部异常因子（Local Outlier Factor, LOF）会显式比较“离别人有多远”或“局部密度有多低”；孤立森林则直接把异常检测改写成一个更具操作性的判据：一个样本在随机树里平均多快会被单独隔开。因此它并不先估计复杂的概率分布，也不依赖全局距离结构，而是用“隔离难易度”来近似刻画异常性。

图中的示意数据由两个主要正常簇和若干离散分布的异常点构成。背景等高线展示的是孤立森林学到的“异常分数地形”：颜色越深，表示该区域样本平均路径长度越长，更接近模型眼中的正常高密度区域；颜色越浅，表示样本更容易在随机切分中被提早隔离，因此更接近潜在异常区域。

图中圆形点对应被模型判为正常的样本，它们主要聚集在两个深色中心附近；叉号对应被模型判为异常的样本，它们更多分布在边缘、簇间空白带或浅色区域。这种可视化非常适合帮助理解孤立森林的工作方式：它并不是在画一条严格的几何边界，而是在表达“哪里更容易被随机树迅速切出来”。因此，等高线的深浅更接近一种“隔离难度地图”，而不是传统分类器意义上的硬分类边界。

隔离树（Isolation Tree, iTree）可以理解成一棵专门为了“把样本逐步切开”而构造的随机二叉树。它与决策树（Decision Tree）在外形上相似，但目标完全不同：决策树是在找最有区分力的切分规则，隔离树则故意随机选择一个特征，再在该特征当前取值范围内随机选择一个切分点，把样本递归分到左右子节点。

设当前节点包含样本集合 \(S\)，随机选到的特征为第 \(j\) 维，其切分阈值为 \(\tau\)，则一次切分可写成

递归继续进行，直到某个节点只剩下 1 个样本，或所有样本在当前节点上已经无法再被有效区分。对一个本来就远离主体、所在区域又很稀疏的样本而言，随机切分往往只需要很少几步就能把它单独留在某个叶节点中；而对处在高密度正常群体内部的样本，通常要经过更多次切分才能被单独隔离。隔离树因此并不显式估计概率密度，而是把“异常”转写为“被随机切分提早单独分离”的难易度。

对样本 \(\boldsymbol{x}\)，记它在一棵隔离树中的路径长度为 \(h(\boldsymbol{x})\)。在多棵树上取平均路径长度 \(\mathbb{E}[h(\boldsymbol{x})]\) 后，异常分数定义为：

这里 \(h(\boldsymbol{x})\) 是样本在一棵树里被隔离所需的路径长度， \(\mathbb{E}[h(\boldsymbol{x})]\) 是在整片森林中的平均值， \(c(n)\) 是针对样本规模 \(n\) 的归一化常数。路径越短，指数里的值越小，异常分数 \(s(\boldsymbol{x},n)\) 就越接近 1。

其中 \(c(n)\) 是平均路径长度的归一化常数，用来把不同样本规模下的路径长度放到可比较的尺度上。它常写为 \(c(n)=2H_{n-1}-2(n-1)/n\)，其中 \(H_{n-1}\) 是第 \(n-1\) 个调和数（Harmonic Number）。若某点明显比普通样本更早被切分隔离，则其平均路径长度更小，异常分数更接近 1。

1. 从训练集中随机抽取多个子样本。
2. 为每个子样本构建随机隔离树。
3. 对待测点计算其在所有树中的平均路径长度。
4. 将平均路径长度映射为异常分数。

在交易风控中，若某条交易在金额、时间、地点、设备等多个维度上都明显偏离正常模式，它往往能在随机切分下被较早隔离出来，因此会获得更高异常分数。

• 优点：无需显式估计密度，也不依赖两两距离矩阵；因此在大规模数据上通常比基于邻域或密度的方法更高效。
• 优点：对高维表格数据较友好，对随机噪声通常也有较强鲁棒性，因为最终判断来自多棵随机树上的平均隔离行为，而不是某一次局部切分。
• 局限：对特征编码和特征尺度的业务含义仍然敏感；若异常与正常高度混叠、或者异常本身并不更容易被切开，隔离优势会下降。
• 适用场景：风控、日志异常、设备故障、指标监控等无监督异常检测，尤其适合作为高维表格场景中的强基线。

局部异常因子（Local Outlier Factor, LOF）主要解决“全局上不远，但在局部邻域中显著稀疏”的异常检测问题。当数据不同区域密度差异很大时，只看全局距离通常不够稳定。

LOF 比较的是“这个点相对于其邻居是否更稀疏”。若一个点周围的局部密度显著低于邻居自己的局部密度，则它更像局部异常。它识别的不是“全局上最远的点”，而是相对于自己所在局部环境显得不协调的点。因此，当不同区域本来就有不同密度时，LOF 往往比只看全局距离的方法更稳。

图中的实心圆点表示样本点，围绕样本点的空心圆圈大小表示该点的 LOF 分数大小。圆圈越小，说明该点的局部密度与其邻居相近，更像正常簇中的内部样本；圆圈越大，说明该点所在位置相对于邻居显得更稀疏，因此更可能是局部异常点。

这张图直观展示了 LOF 的核心判断方式：它并不先问“这个点离全局中心有多远”，而是先问“这个点和自己周围那一圈邻居相比，是不是显得过于稀疏”。因此，大圆圈对应的未必是全局最远的点，而更可能是那些周围邻居仍然较密、但它自己明显脱离了局部密度水平的点。

若把这张示意图看作两个高密度簇与少量随机噪声点的组合，则邻居数 \(k\) 决定了算法观察“局部环境”的尺度。 \(k\) 较小时，模型更敏感于非常局部的扰动； \(k\) 较大时，密度比较更平滑，但也可能削弱对细粒度异常的敏感性。

给定邻居数 \(k\)，设 \(N_k(\boldsymbol{p})\) 表示点 \(\boldsymbol{p}\) 的 \(k\) 个最近邻集合。LOF 的计算可以拆成三层：先算可达距离（Reachability Distance），再算局部可达密度（Local Reachability Density, LRD），最后比较邻居密度与自身密度，得到局部异常因子（Local Outlier Factor, LOF）。

先定义可达距离（Reachability Distance）：

可达距离会把两个量取最大值：邻居点 \(\boldsymbol{o}\) 自己的第 \(k\) 邻距离，以及点对之间的真实距离。这样做可以防止极近的点对把局部密度估得过于夸张，使密度估计更稳。

再定义局部可达密度（Local Reachability Density, LRD）：

局部可达密度 \(\mathrm{lrd}_k(\boldsymbol{p})\) 本质上是“平均可达距离”的倒数：平均距离越小，周围越拥挤，密度越大；平均距离越大，周围越稀疏，密度越小。

最终的 LOF 分数为：

LOF 分数比较的是“邻居的局部密度”和“自己本身的局部密度”。若 \(\mathrm{lrd}_k(\boldsymbol{p})\) 明显小于邻居的密度，分数就会大于 1，说明该点相对周围环境显得更孤立。更具体地说，分子是邻居局部密度的平均水平，分母是点 \(\boldsymbol{p}\) 自己的局部密度，因此这个比值本质上是在问：你周围的人都很挤，而你自己是不是站得太空。

结果通常可以这样解读：

• \(\mathrm{LOF}_k(\boldsymbol{p})\approx 1\)：该点的局部密度与邻居相近，通常属于正常样本。
• \(\mathrm{LOF}_k(\boldsymbol{p})<1\)：该点甚至比邻居更密集，往往处于簇的核心区域。
• \(\mathrm{LOF}_k(\boldsymbol{p})>1\)：该点局部密度低于邻居，越大越像异常点。

因此，LOF 回答的是“这个点在自己的局部邻域里是不是显得过于稀疏”，而不是“这个点离全局中心远不远”。这也是它能识别局部异常、却对距离度量与邻居数 \(k\) 较敏感的根本原因。

1. 为每个样本找到 \(k\) 个近邻。
2. 计算可达距离与局部可达密度。
3. 比较样本与邻居的局部密度，得到 LOF 分数。
4. 按分数排序或设置阈值输出异常点。

在消费行为数据中，某一线城市用户的高消费在全国范围内未必异常，但在“同年龄、同区域、同收入”的邻域里可能明显偏离。LOF 正是通过这种局部密度比较识别这类异常。

• 优点：适合不同密度区域共存的数据，能识别“全局上不极端、但局部上明显失配”的异常。
• 优点：解释性较强，因为 LOF 分数直接来自“邻居密度 / 自身密度”的局部比较，便于回答异常是相对于谁显得异常。
• 局限：对距离度量、标准化和邻居数 \(k\) 很敏感； \(k\) 太小会放大噪声，太大又可能抹平真正的局部异常。
• 局限：大规模近邻搜索成本较高，因此在超大数据上常需要索引加速或近似近邻方法配合。
• 适用场景：局部离群检测、消费异常、群体内部行为异常、同类用户或设备群体中的行为失配识别。

单类支持向量机（One-Class Support Vector Machine, One-Class SVM）用于“只有正常样本、缺少可靠异常样本”的异常检测任务。它的目标是学习一个描述正常样本区域的边界。

One-Class SVM 通过核映射把样本送到高维特征空间，再寻找一个把大多数正常样本与原点分开的超平面。等价地看，它学习的是一个“包住正常样本”的高维边界，边界外的点更可能是异常。

一种标准形式为：

One-Class SVM 的目标由三部分组成： \(\frac{1}{2}\|\boldsymbol{w}\|_2^2\) 控制边界不要太复杂， \(\frac{1}{\nu N}\sum_i \xi_i\) 惩罚落在边界外或靠得太近的样本， \(-\rho\) 则鼓励把正常区域尽量向外推开。 \(\nu\) 越大，对违约样本的容忍度越高。

这些约束表示：样本映射到特征空间后，其投影值至少要达到阈值 \(\rho\)；若做不到，就用非负松弛变量 \(\xi_i\) 记录违约程度。于是模型允许少量样本越界，但必须为此付出代价。

其中 \(\boldsymbol{w}\) 是超平面法向量， \(\rho\) 是阈值， \(\xi_i\) 是松弛变量， \(\nu\in(0,1]\) 控制允许落在边界外的比例与支持向量比例。判别函数为：

判别函数先计算样本在特征空间里相对边界的位置：若 \(\boldsymbol{w}^\top \phi(\boldsymbol{x})-\rho\) 为正，说明样本位于学习到的正常区域一侧；若为负，则更可能落在边界之外，被视为异常。

若使用核函数 \(K(\boldsymbol{x},\boldsymbol{x}')\)，则该边界可以是非线性的，因此能表达复杂的正常区域。

1. 只用正常样本训练模型，选择核函数与超参数 \(\nu\)。
2. 在特征空间中学习分离超平面。
3. 对新样本计算判别函数值。
4. 若分数低于边界阈值，则判为异常。

在设备健康监控中，异常故障类型往往变化很大，难以完整收集，但正常运行数据很多。One-Class SVM 可以只基于正常样本学习边界，一旦新样本落出该区域，就触发异常告警。

• 优点：只依赖正常样本；核方法可表达复杂边界。
• 局限：对特征缩放和核参数敏感；大规模训练较重。
• 适用场景：设备监控、入侵检测、质量控制等“正常样本丰富、异常样本稀缺”的任务。

感知机（Perceptron）是最早的神经元模型之一，也是现代神经网络最基本的计算原型。无论是 MLP、CNN、RNN，还是 Transformer，本质上都由大量“线性变换 + 非线性变换”的单元堆叠而成；从这个意义上说，理解感知机，就是理解大型模型最小的功能部件。

最原始的感知机先做线性组合，再经过一个阈值函数给出二分类输出：

这里 \(\mathbf{x}\) 是输入特征， \(\mathbf{w}\) 是权重， \(b\) 是偏置。 \(\mathbf{w}^\top \mathbf{x}+b\) 的含义是“沿着权重指定的方向对输入做加权打分”，而 \(\mathrm{sign}(\cdot)\) 则把连续分数变成离散决策：高于阈值判为正类，低于阈值判为负类。

需要特别区分的是：最早的感知机确实直接做分类，但现代神经网络里的大多数“感知机式单元”并不直接输出最终类别。隐藏层单元更常见的形式是 \(h=\phi(\mathbf{w}^\top \mathbf{x}+b)\)，它们输出的是中间表示（Intermediate Representation），职责是检测局部模式、重组特征并为后续层提供更有用的表示；只有最后的任务头（Task Head）才把这些中间表示转成分类、回归或生成输出。

这里的中间表示（Intermediate Representation）本质上就是一组可被后续层继续计算的数值特征。它既可以是向量（Vector），也可以是矩阵（Matrix），更一般地说，它通常是张量（Tensor）。向量和矩阵都只是张量的特殊情形：若只看单个样本的 MLP 隐层输出，最常见的是向量 \(\boldsymbol{h}\in\mathbb{R}^{d}\)；若看 Transformer 对整段序列的隐藏状态，常写成矩阵 \(H\in\mathbb{R}^{L\times d}\)；若再把 batch 维也带上，则会变成三维张量 \(\mathcal{H}\in\mathbb{R}^{B\times L\times d}\)。在卷积网络（Convolutional Neural Network, CNN）里，中间表示则常是特征图张量（Feature Map Tensor） \(\mathcal{H}\in\mathbb{R}^{C\times H\times W}\)，或带 batch 的 \(\mathbb{R}^{B\times C\times H\times W}\)。

因此，“中间表示”不是某种神秘对象，它就是网络在某一层对输入所形成的内部编码。它不像最终标签那样直接面向人类语义，而是把输入重写成更适合下一层处理的坐标系。例如，文本模型中的某一层隐藏状态可能同时编码词义、上下文关系、句法位置和任务相关线索；图像模型中的某一层特征图则可能突出边缘、纹理、局部部件或更高层形状。后续层与任务头读到的，正是这些内部编码。

感知机的重要性不止在于历史地位，更在于今天大型模型中的知识，本质上仍然是通过这类权重结构逐层编码进去的。训练过程并不会把知识像数据库那样逐条写成显式记录，而是不断调整参数，使某些输入模式被放大、某些输入模式被抑制。于是，模型在数据中反复见到的统计规律——词与词的共现、图像局部纹理、特征之间的组合关系——都会被压缩进参数矩阵的数值结构中。

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

感知机能学会线性可分任务，但无法处理 XOR 这类线性不可分问题，这正是多层网络出现的动机：当一个超平面不够时，就需要通过多层组合把输入空间逐步重写成更容易分开的表示。

多层感知机（Multi-Layer Perceptron, MLP）处理的核心问题是：当输入与输出之间的关系不是一个超平面就能表达时，如何通过多层可学习变换，把原始特征逐步改写成更容易完成任务的表示。它由多层线性变换与逐元素非线性激活交替组成，是最基本也最通用的前馈网络结构。

单层可写成：

多层堆叠后，可写为：

这里 \(W^{(l)}\) 和 \(\mathbf{b}^{(l)}\) 是第 \(l\) 层参数， \(\mathbf{h}^{(l)}\) 是第 \(l\) 层隐藏表示。所谓“逐层重写表示”，就是每一层都在回答一个更具体的问题：哪些原始模式值得保留、哪些组合值得放大、哪些方向更利于后续任务。于是，早期层往往捕捉较局部、较简单的模式，后期层则把这些模式组合成更抽象的语义结构。

MLP 比单层感知机强，关键不在“层数更多”本身，而在于层与层之间插入了非线性激活函数 \(\phi\)。如果没有非线性，多层线性变换满足

最终仍然等价于一层线性变换，表达能力不会因为堆叠而提升。只有加入非线性后，网络才能把输入空间切分、折叠、拉伸并重新组合，形成复杂的分段线性或平滑非线性决策边界。

从几何角度看，单层模型像“用一个超平面切一次”；而多层 MLP 则是在表示空间中反复做坐标变换和非线性折叠，把原本难分的数据逐步变成线性头也能分开的形状。文中的激活函数对比图展示的正是这个过程：不同激活函数会把同一个三层网络变成完全不同的几何变换器。

在现代大模型中，MLP 的作用远不只是“附属模块”。在 Transformer 里，注意力层负责在 token 之间路由信息，而 MLP / Feed-Forward Network（FFN）则负责在每个位置上做通道维度的非线性特征变换，把路由来的信息重新编码进更强的表示。因此，很多语义模式、组合规则与任务相关知识，最终都会沉淀到这些大规模参数化的 MLP 权重中。

更进一步说，在 Transformer 的常见解释框架里，MLP / FFN 往往被看作事实性知识的重要载体之一。一个常见直觉是把 FFN 看成参数化的“键值存储器（Key-Value Memory）”：第一层线性变换更像在检测当前输入是否匹配某种模式或概念，第二层线性变换则把与该模式相关的语义方向重新写回残差流（Residual Stream）。这里的残差流，可以理解为 Transformer 里那条贯穿各层的主表示通道：每一层注意力与 MLP 的输出，都会通过残差相加的方式写回这条主通道，再交给后续层继续处理。因此，诸如“实体—属性”“术语—定义”“模式—响应”这类较稳定的关联，常常更容易在 MLP 权重里留下痕迹。

但这并不意味着“一个神经元就存一条事实”。更准确的描述是：知识通常以分布式方式存在于许多层、许多通道和许多参数方向里。单个神经元有时会对某种关系或概念特别敏感，因而出现所谓“知识神经元（Knowledge Neurons）”现象；但更稳定的事实表示，通常仍然依赖一组共同激活的单元和跨层传递的表示。可以把两类子层的分工概括为：注意力更擅长“去哪里找、和谁建立联系”，MLP 更擅长“把匹配到的模式变成可供后续层使用的语义内容”。因此，说 MLP 是知识的主要载体之一是合理的；说知识只存在于 MLP、完全不在注意力里，则过于简单。

激活函数（Activation Function）的作用是给线性层引入非线性。如果没有激活函数，多层线性层叠起来仍然等价于一层线性变换，深度就失去了意义。

先给出一个实用的选型总表。它不代替后文的机制分析，但可以先回答工程上最常见的问题：某个激活函数通常应该放在输出层、隐藏层，还是特定结构里。

Sigmoid 把实数压到 \((0,1)\)：

Sigmoid 的优势在于输出天然落在 \((0,1)\)，因此非常适合表示概率，尤其常用于二分类输出层或门控结构中。但它在隐藏层里的主要问题是饱和（saturation）：当输入绝对值较大时，函数会迅速贴近 0 或 1，此时导数接近 0，梯度在反向传播时会被不断压缩，深层网络因此容易出现梯度消失（Vanishing Gradient）。从优化角度看，这意味着前面层参数即使有误，也很难收到足够强的更新信号。

此外，sigmoid 的输出始终为正，不以 0 为中心，这会使后续层接收到带偏移的激活分布，通常不利于优化动态的稳定性。因此，sigmoid 今天更多保留在“需要概率解释”的输出层，或在 LSTM / GRU 等门控结构中充当开关函数，而不再是深层前馈隐藏层的默认选择。

Tanh 的输出范围是 \((-1,1)\)：

Tanh 可以看作“零中心版 sigmoid”：它同样会在大幅度输入时饱和，但输出分布位于 \((-1,1)\) 且以 0 为中心，这通常比 sigmoid 更利于优化，因为后续层接收到的激活不再整体偏向正侧。对于需要表达“正负方向”差异的隐藏表示，tanh 往往也比 sigmoid 更自然。

不过，tanh 并没有解决饱和带来的根本问题：当 \(|x|\) 很大时，导数仍接近 0，深层网络中的梯度传播依然会变弱。因此，在较深的前馈网络里，tanh 通常不如 ReLU 家族稳定；它更多出现在较浅网络、早期神经网络设计，或某些希望激活有界且零中心的结构中。

ReLU（Rectified Linear Unit）定义为

ReLU 看起来几乎“过于简单”，但它之所以长期有效，关键不在公式花哨，而在于它同时满足了深层优化最需要的几条性质。第一，ReLU 在正半轴不饱和（non-saturating）：当 \(x>0\) 时导数恒为 1，梯度穿过这一单元时不会像 sigmoid / tanh 那样被持续压小，因此更有利于深层网络中的梯度传播。第二，ReLU 保留了非线性，但正半轴仍是线性的，这使整个网络变成分段线性（piecewise linear）系统：表达能力足够强，同时局部优化形状又比高度弯曲的饱和函数更“规整”。第三，负半轴直接截断会带来自然的稀疏激活（sparse activation）：不是所有单元都会在每个样本上同时活跃，这通常有助于提升表示分解能力，并降低无效共适应（co-adaptation）。这里的共适应，指多个神经元在训练中形成了过强的相互依赖：某个单元之所以有效，不是因为它单独学到了稳定、可迁移的模式，而是因为它总是和另外几个特定单元“成套工作”。一旦输入分布变化，或其中某些单元没有按训练时那样响应，这种脆弱的协同关系就容易失效，从而削弱泛化能力。

从工程角度看，ReLU 的优势还包括计算代价极低，只需一次比较运算；这在大规模训练中会被成千上万层和数十亿次前向/反向传播放大。更深层的原因是：深度网络真正需要的不是“平滑得很漂亮”的激活函数，而是一个既能打破线性、又不会在大范围内把梯度压扁、还能让优化器容易工作的非线性。ReLU 恰好在这三点之间取得了非常实用的平衡，这就是为什么一个形式上极其朴素的函数，反而成为现代深度学习最成功的默认选择之一。它的代价也很明确：负区间梯度为 0，单元可能长期失活，这就是后面 Leaky ReLU、ELU、GELU 等变体继续改进的出发点。

Leaky ReLU 给负半轴保留一个很小的斜率：

这样做是为了缓解“死亡 ReLU（Dying ReLU）”问题：若某神经元长期落在负区间，普通 ReLU 的梯度可能一直为 0，而 Leaky ReLU 仍保留一点更新信号。

从机制上看，Leaky ReLU 的核心改动很小，但很有针对性：它保留了 ReLU 在正半轴的不饱和与分段线性优点，同时避免把负半轴完全切断。这样即使某个单元暂时落入负区间，参数仍有机会通过非零梯度被重新拉回活跃状态。因此，Leaky ReLU 可以看作对 ReLU 的保守修正：表达风格几乎不变，但训练风险更低。

ELU（Exponential Linear Unit）在负半轴使用指数平滑：

它的目标是兼顾 ReLU 的优化优势和负区间的平滑性，使激活均值更接近 0。

与 Leaky ReLU 相比，ELU 在负半轴不再是简单直线，而是用指数曲线平滑衰减到负饱和值。这带来两个效果：一是避免了 ReLU 在 0 点附近过于生硬的折线结构；二是允许激活出现稳定的负值，从而减轻隐藏表示整体偏正的问题。代价是计算比 ReLU 更重，且负区间在极小值处同样会逐渐饱和，因此它通常被视为“更平滑、更零中心”的 ReLU 变体，而不是彻底不同的一类激活。

GELU（Gaussian Error Linear Unit）可理解为“按输入大小平滑地决定保留多少信号”。它不像 ReLU 那样硬截断，而是对小正值和小负值做连续、概率化的保留，因此在 0 附近更平滑。

这种设计的价值在于：它仍然保留了 ReLU 家族的选择性——不是所有信号都被同等对待——但又避免了硬截断带来的尖锐折点和完全失活区。于是，GELU 往往能在“表达选择性”和“优化平滑性”之间取得更好的折中，这也是它在 Transformer、BERT 及其后续大量变体中被广泛采用的重要原因。

Swish / SiLU 定义为

它是平滑、非单调的激活函数，在某些深层网络里表现优于 ReLU。其结构可以直接读成“输入值 \(x\) 乘上一个 sigmoid 门控 \(\sigma(x)\)”：当 \(x\) 很大时， \(\sigma(x)\approx 1\)，信号几乎原样通过；当 \(x\) 很小时， \(\sigma(x)\approx 0\)，信号被显著压低；在 0 附近则是连续、平滑的软过渡。

这种形式的价值在于：它既不像 ReLU 那样做硬截断，也不像 sigmoid 那样把输出彻底压进固定区间，而是让网络学到一种“按输入强度自适应通过多少”的软门控机制。结果是，SiLU / Swish 往往能在保持优化平滑性的同时，保留较强的表达灵活性，因此在一些现代卷积网络与大模型变体中表现良好。它可以看作介于 ReLU 家族与门控激活之间的一种折中设计。

Softmax 把一组实数分数（scores）映射为概率分布（Probability Distribution）。在分类与语言模型里，这组分数通常称为 logit（Logits）：它们是 softmax 之前的未归一化输出。

logits 的两个关键性质：

• logits 不需要是概率，可以是任意实数；softmax 才把它变成 \([0,1]\) 且和为 1 的分布。
• softmax 对整体平移不敏感：对任意常数 \(c\)，有 \(\mathrm{softmax}(z)=\mathrm{softmax}(z+c\mathbf{1})\)。因此实现里常用 \(z\leftarrow z-\max_i z_i\) 做数值稳定（Numerical Stability）。

这说明 softmax 真正关心的是各个 logit 之间的相对差值，而不是某个 logit 的绝对数值。若把所有分数同时加 10，模型对“哪一类更占优”的判断不会改变，因为指数项会在分子和分母里同时乘上 \(e^{10}\)，最终完全约掉。改变 softmax 输出的，是某个类别相对其他类别高了多少，而不是整体抬高或压低所有分数。

也正因为如此，logit 更适合理解为“未归一化偏好分数（unnormalized preference scores）”，而不是“概率雏形”。例如两类 logits 从 \((1,2)\) 变成 \((101,102)\)，softmax 输出完全相同；但若从 \((1,2)\) 变成 \((1,5)\)，第二类相对第一类的优势被显著拉大，概率才会明显变化。

在语言模型（Language Model）中，给定最后一层隐藏状态 \(h\in\mathbb{R}^{d_{\text{model}}}\)，线性输出头产生词表大小 \(V\) 的 logits： \(z=hW_{\text{vocab}}+b\)，再经 softmax 得到下一个 token 的分布。若采用权重共享（Weight Tying），则输入嵌入表 \(E\in\mathbb{R}^{V\;\times d_{\text{model}}}\) 与输出头满足 \(W_{\text{vocab}}=E^\top\)，于是可直接写成 \(z=hE^\top+b\)。

在多分类任务里，这几个概念实际上是一条连续的计算链：任务头先输出 logits \(z\in\mathbb{R}^{C}\)，softmax 把它们变成条件概率 \(p(y=i|x)\)，再取真实类别 \(c\) 的负对数概率作为单样本损失，也就是负对数似然（Negative Log-Likelihood, NLL）。

把两步合起来，NLL 可以直接写成 logits 的函数：

这个式子把训练目标拆成了两部分：第一项 \(-z_c\) 要求真实类别的 logit 足够大；第二项 \(\log\sum_j e^{z_j}\) 是归一化项（log-sum-exp），它把所有类别的竞争都算进去。因此训练并不是单独把正确类别分数抬高，而是要让它相对其他类别更占优势。

softmax 的平移不变性（Translation Invariance）在这里也能直接看见。对任意常数 \(a\)，若把所有 logits 同时改为 \(z+a\mathbf{1}\)，则 softmax 概率不变，NLL 也不变：

因此 logits 的绝对零点没有意义，真正有意义的是类别之间的相对差值。工程实现里常把 \(z\) 先整体减去 \(\max_i z_i\)，再计算 softmax 或 log-sum-exp。这样不会改变概率与损失，但能显著降低指数溢出的风险。

术语区分：假设函数（Hypothesis Function）/模型 \(f_\theta\) 定义“模型在做什么映射”；样本损失（Loss Function）定义在单样本上；代价函数/成本函数（Cost Function）是把样本损失在全数据集上做平均或求和后的经验风险；目标函数（Objective Function）是优化器真正要优化的函数，最常见写法是 \(J(\theta)=L(\theta)+\lambda\Omega(\theta)\)。

均方误差（Mean Squared Error, MSE）定义为

平方的作用是让大误差被放大处罚。若一个样本错 10，另一个样本错 1，那么前者在 MSE 里不是“重 10 倍”，而是“重 100 倍”。因此 MSE 很适合你明确希望重罚大错的场景，也对应前面讲过的高斯噪声假设。

平均绝对误差（Mean Absolute Error, MAE）对应单样本形式

它直接度量偏差大小，对离群点更鲁棒，因为不会像平方那样把大误差急剧放大。若做房价预测，数据中存在一批价格远高于主体分布的豪宅样本时，MAE 往往比 MSE 更稳；这里的“主体分布”指的是样本中占大多数的普通住宅价格区间，而豪宅样本相对它明显偏高。这样一来，哪怕豪宅样本数量不多，它们也会在 MSE 下因为误差被平方而获得过大的影响力。

Huber Loss 结合了 MSE 与 MAE：误差小时像平方误差，误差大时像绝对误差。设阈值 \(\delta\)，则

这条式子的直觉是：小误差区间内保持平滑、便于优化；大误差区间内降低对离群点的过度敏感。它像“正常误差严肃处理，极端异常别让它一票否决整个模型”。

二分类交叉熵（Binary Cross-Entropy, BCE）用来训练输出概率 \(p\in(0,1)\) 的二分类器。这里 \(p\) 通常表示模型预测“正类”的概率， \(y\in\{0,1\}\) 是真实标签： \(y=1\) 表示正类， \(y=0\) 表示负类。

左边的 \(\ell_{\mathrm{BCE}}(y,p)\) 表示“单个样本在真实标签为 \(y\)、模型预测正类概率为 \(p\) 时的 BCE 损失值”。也就是说，这不是新的概率，而是一个标量惩罚：预测越符合真实标签，它越小；预测越违背真实标签，它越大。

这条公式会根据 \(y\) 的取值自动选择应当惩罚哪一项。当 \(y=1\) 时，式中的 \((1-y)=0\)，因此第二项消失，损失化简为 \(-\log p\)；当 \(y=0\) 时，第一项中的 \(y=0\)，因此第一项消失，损失化简为 \(-\log(1-p)\)。于是它惩罚的本质就是：让真实类别对应的概率尽可能高。

数值例子（自然对数）：若 \(y=1\) 且 \(p=0.9\)，则 \(\ell\approx 0.105\)；若 \(p=0.1\)，则 \(\ell\approx 2.303\)。正确但不自信会被罚，错误且自信会被重罚。

多分类交叉熵（Categorical Cross-Entropy, CE）与 softmax 通常配套使用。这里 \(y_i\) 是真实分布（Ground-Truth Distribution）在第 \(i\) 类上的概率质量， \(p_i\) 是模型预测分布（Predicted Distribution）在第 \(i\) 类上的概率。若类别总数为 \(C\)，则单样本损失写成：

左边的 \(\ell_{\mathrm{CE}}(y,p)\) 表示“当真实标签分布为 \(y\)、模型预测分布为 \(p\) 时，这个样本对应的交叉熵损失值”。其本质是：用真实标签分布 \(y\) 作为权重，对预测分布的负对数概率 \(-\log p_i\) 做加权平均。

当 \(y\) 是 one-hot 分布时，只有真实类别 \(c\) 那一维的权重为 1，其余维度权重都为 0，因此求和会自动塌缩成单项：

这正是分类任务里最常见的形式。它与最大似然估计（Maximum Likelihood Estimation, MLE）完全一致：最小化交叉熵等价于最大化真实类别的对数似然。

若 \(y\) 不再是 one-hot，而是一个在多个类别上分配了非零概率质量的分布，那么交叉熵就不再只读取单个类别 \(p_c\)，而是会对整条标签分布做加权。常见来源有两类。

第一类是软标签（Soft Label）。它指真实监督信号本身就是一个概率分布，而不是“只有一个绝对正确类别”的硬标签（Hard Label）。例如一张图像可能被标注为“70% 像猫、30% 像狐狸”，或一个样本本身就带有多标注者投票汇总后的类别分布。在这种情况下， \(y_i\) 直接表示第 \(i\) 类的目标概率，交叉熵自然要对所有类别一起计算。

第二类是教师分布蒸馏（Knowledge Distillation from Teacher Distribution）。知识蒸馏（Knowledge Distillation）的做法是：不用人工标签单独监督学生模型（Student Model），而是让学生去拟合教师模型（Teacher Model）给出的类别分布。若教师在某个样本上输出 \(q\)，学生输出 \(p\)，则训练目标常包含 \(-\sum_i q_i\log p_i\) 这样的交叉熵或等价的 KL 散度项。它传递的不只是“哪一类是对的”，还传递“其余类别分别有多像”，因此常被称为暗知识（Dark Knowledge）。

这两种情况的共同点是：标签本身已经不是单点答案，而是一条分布。于是交叉熵的计算对象就不再只是“真实类别那一项”，而是整个目标分布与预测分布之间的匹配程度。Label Smoothing 也会把 one-hot 改成软分布，但它承担的是训练目标修正的角色，因此放在后文“分类任务正则化”里更清晰。

从信息论角度看，交叉熵的标准定义是两个分布 \(P\) 与 \(Q\) 之间的

分类里的 \(\ell_{\mathrm{CE}}(y,p)\) 与这个定义并不矛盾，它只是把信息论中的 \(P\) 和 \(Q\) 分别具体化成了“单个样本对应的真实标签分布 \(y\)”与“模型在这个样本上的预测分布 \(p\)”。若标签是 one-hot，那么 \(P\) 退化成一个只在真实类别处取值为 1 的离散分布，于是信息论里的交叉熵自然退化成 \(-\log p_c\)。

进一步地，交叉熵与 KL 散度（Kullback–Leibler Divergence）的关系可以直接写成：

这里 \(H(P)=-\sum_x P(x)\log P(x)\) 是真实分布 \(P\) 自身的熵（Entropy），只由数据分布决定； \(D_{\mathrm{KL}}(P\|Q)=\sum_x P(x)\log\frac{P(x)}{Q(x)}\) 是 KL 散度，用来衡量预测分布 \(Q\) 相对真实分布 \(P\) 的偏离程度。于是，在训练数据固定时， \(H(P)\) 是常数，最小化交叉熵 \(H(P,Q)\) 就等价于最小化 \(D_{\mathrm{KL}}(P\|Q)\)。

因此，“最小化交叉熵就是最小化 KL 散度”这句话在监督学习里通常成立，但更准确的表述是：在真实分布固定不变时，最小化交叉熵与最小化预测分布对真实分布的 KL 偏离是等价的。KL 散度确实可以理解为“与真实分布的差异或偏离”，但它不是对称距离（Symmetric Distance）：一般有 \(D_{\mathrm{KL}}(P\|Q) \neq D_{\mathrm{KL}}(Q\|P)\)，也不满足严格距离函数的三角不等式，因此更准确的名称是分布失配（distribution mismatch）或相对熵（relative entropy）。

若进一步把 \(p\) 写成 softmax 作用在 logits \(z\) 上，则多分类交叉熵可直接写成：

这条式子把任务头和损失函数直接接起来：线性头先输出 logits，softmax 把它们归一化为概率，交叉熵再读取真实类别的负对数概率。由于 softmax 具有平移不变性，给所有 logits 同时加上同一个常数不会改变这个损失，因此实现中通常直接从 logits 计算交叉熵（log-sum-exp 形式），并先减去 \(\max_j z_j\) 做数值稳定，而不是显式先算 softmax 再取 log。

Focal Loss 常用于类别极不平衡的分类任务，尤其是目标检测（Object Detection）这类“负样本远多于正样本”的场景。它不是简单换掉交叉熵，而是在交叉熵前再乘一个与样本难度相关的调制因子，使已经分得很对的容易样本贡献变小，把梯度预算更多留给困难样本：

这里 \(p_t\) 表示“真实类别对应的预测概率”：若真实标签 \(y=1\)，则 \(p_t=p\)；若 \(y=0\)，则 \(p_t=1-p\)。因此 \(-\log p_t\) 就是普通交叉熵，而前面的 \((1-p_t)^\gamma\) 是额外加上的难度调制项。参数 \(\gamma\ge 0\) 控制聚焦强度： \(\gamma=0\) 时，Focal Loss 退化回普通交叉熵； \(\gamma\) 越大，对容易样本的压低越明显。

这个机制的关键在于样本难度如何反映到权重上。若某个样本已经分得很对，例如真实类别概率 \(p_t=0.99\)，则调制因子 \((1-p_t)^\gamma\) 会非常小；以 \(\gamma=2\) 为例，权重大约只有 \((0.01)^2=10^{-4}\)，这意味着它对总损失和梯度的影响被大幅削弱。相反，若某个样本很难，例如 \(p_t=0.2\)，则权重约为 \((0.8)^2=0.64\)，其损失会被较大程度保留。于是训练过程不再被海量“早就分对的简单样本”主导，而会持续关注误分样本、边界样本和少数类样本。

目标检测是最典型的应用例子。以单阶段检测器（One-stage Detector）为例，一张图像上往往有成千上万个候选框（Anchors），但真正包含目标的正样本只占极少数；绝大多数候选框都是背景。若直接使用普通交叉熵，训练会被这些“背景且容易判断”的负样本淹没：它们单个损失虽小，但数量太多，累积后仍然主导梯度。Focal Loss 的作用正是把这批容易背景样本的权重压下去，让模型把更多注意力放在少数正样本、遮挡目标、边界模糊目标，以及那些看起来像目标但其实是背景的困难负样本上。这样做通常会显著改善长尾检测与前景-背景极不平衡时的训练效果。

Hinge Loss 是 SVM 常用的分类损失：

其中 \(f\) 是模型分数而不是概率。当 \(yf\ge 1\) 时，说明不仅分类正确，而且留出了足够间隔，损失为 0；当 \(yf<1\) 时，就要受罚。它强调的不只是“分对”，而是“分对且留有安全距离”。

度量学习（Metric Learning）不直接预测类别，而是学习一个表示空间，让“应该相似的样本靠近，不该相似的样本拉远”。这类损失在检索、人脸识别、推荐召回和 embedding 学习中非常常见。

Contrastive Loss 处理样本对（pair）。若一对样本应相似，则拉近它们；若应不同，则至少推开到某个间隔 \(m\) 之外：

这里 \(d\) 是两者在嵌入空间中的距离， \(y=1\) 表示正对， \(y=0\) 表示负对。它像“朋友要坐得近，陌生人至少别挤在一起”。

Triplet Loss 使用三元组：锚点（Anchor）、正样本（Positive）、负样本（Negative）。目标是让锚点离正样本比离负样本更近至少一个 margin：

这条式子表达的是一种相对排序约束，而不是绝对相似度分数。它非常适合“谁比谁更像”的任务，例如人脸验证：同一个人的两张照片应比不同人的照片更近。

InfoNCE 是现代对比学习最常见的损失之一。对一个锚点来说，它把正样本放进一堆候选里，要求模型把正样本打分最高：

分子是正确配对，分母是所有候选。这个结构和 softmax 分类非常像，只不过类别不再是固定标签，而是“在一堆候选里，谁才是真正匹配的那个”。在大语言模型 embedding、图像表征学习和多模态对齐里，它几乎是标准配置。

任务头（Task Head）是把主干网络（Backbone）产出的隐藏表示（Hidden Representation）映射到具体任务输出空间的模块。主干负责抽取通用特征，任务头负责把特征“读出来”并对齐到目标形式（类别、数值、序列标签、跨度、关系等）。在工程上，绝大多数“用 Transformer 做下游任务”都可以写成：Transformer backbone + task head + task loss。

主干网络输出的隐藏表示（Hidden Representation）是任务头的输入，任务头则是把这种内部表示读成具体任务输出的最后一层或最后几层变换。若把主干输出记为 \(h\)、\(H\) 或更一般的张量 \(\mathcal{H}\)，则任务头通常先做一次线性读出（Linear Readout）得到分数，再视任务类型决定是否接 sigmoid、softmax、CRF 解码或直接保留实数输出。

logits 就是在这个读出阶段最常见的中间产物。它们是任务头输出、但尚未归一化或尚未解码的原始分数。例如，多分类头常先产生 \(z\in\mathbb{R}^{C}\)，这里 \(C\) 是类别数， \(z_c\) 表示模型对第 \(c\) 类的偏好分数；softmax 之后这些分数才变成概率。对 token 分类任务，task head 产生的不是单个向量，而是一整张 logits 矩阵 \(Z\in\mathbb{R}^{L\times C}\)；对语言模型，输出则是词表 logits \(Z\in\mathbb{R}^{L\times V}\)，其中 \(V\) 是词表大小。

因此，关系可以概括为：输入先被 backbone 编码成中间表示，中间表示再被 task head 读成 logits 或其他任务分数，最后再由概率映射、解码器或损失函数把这些分数变成最终预测。logits 不是所有中间表示的统称，而是“距离最终任务输出只差一步”的那类任务分数；它们通常由任务头生成，而不是由主干网络中间每一层都显式生成。

不同任务头的差异，最核心地体现在“直接输出什么张量、这些张量后面还要经过什么处理”这两个问题上。下面这张表把常见任务头的输入形状、直接输出和后续处理并列起来，便于从工程实现角度快速对照。

这张表的关键在于区分“任务头直接输出什么”和“用户最终看到什么”。很多任务头直接输出的并不是概率，也不是标签，而是 logits、边分数、起止位置分数或 embedding。概率、标签、生成 token、依存边、异常分数等最终结果，通常还需要经过归一化、解码、阈值化或搜索过程才能得到。

分类头（Classification Head）的核心职责，是把主干网络输出的表示 \(h\in\mathbb{R}^{d}\) 变成类别分数（Class Scores）或 logits。最常见的做法是一层线性映射：

这里 \(\mathbf{h}\in\mathbb{R}^{d}\) 是单个样本的隐藏表示， \(W\) 是任务头权重矩阵， \(\mathbf{b}\) 是偏置向量， \(\mathbf{z}\) 是未归一化类别分数。分类任务的关键区别不在于“有没有线性层”，而在于：输出空间是否互斥、每个样本允许几个标签成立、以及这些分数之后接什么归一化与损失。

直觉上，这个线性头就是一个“可学习的读出（Readout）”：在高维表示空间里用超平面（Hyperplane）切分区域，或用线性映射把表示投影到目标坐标系。这里的“读出”指的是：主干网络先把输入编码成内部表示，而任务头再把这种内部表示转换成模型真正需要输出的量，例如类别 logits、词表 logits、回归值、span 分数或关系分数。换言之，读出不是“再提特征”，而是把已经形成的表示翻译成任务空间中的可判定分数。

二分类（Binary Classification）要求每个样本只在两个互斥类别中选一个，例如“垃圾 / 非垃圾”“欺诈 / 正常”“阳性 / 阴性”。最常见的写法是输出一个标量 logit：

然后通过 sigmoid 得到正类概率：

这里 \(z\) 是模型对正类的原始偏好分数， \(p\) 是正类概率，负类概率则是 \(1-p\)。训练时通常配合二分类交叉熵（Binary Cross-Entropy, BCE）。工程上也可以输出二维 logits \(\mathbf{z}\in\mathbb{R}^{2}\)，再接 softmax；但若任务确实只有两个互斥类别，单 logit + sigmoid 更常见，也更经济。

多分类（Multi-class Classification）要求每个样本在 \(C\) 个互斥类别中恰好选一个类别，例如“猫 / 狗 / 鸟”“体育 / 财经 / 科技 / 娱乐”。此时任务头不会只输出一个标量，而是输出长度为 \(C\) 的 logits 向量：

其中第 \(c\) 维 \(z_c\) 表示模型对第 \(c\) 个类别的原始偏好分数。由于这些类别互斥，后续通常接 softmax，把整组分数归一化成概率分布：

这条式子的含义很直接：分子 \(e^{z_c}\) 是第 \(c\) 类的相对强度，分母 \(\sum_{j=1}^{C}e^{z_j}\) 把所有类别一起归一化，因此最终得到的 \(p(y=c\mid x)\) 落在 \((0,1)\) 之间，且所有类别概率和为 1。也正因为总和必须为 1，多分类头天然表达的是“类间竞争”：某一类概率上升，其他类的总概率就必须下降。

训练时通常直接把 logits \(\mathbf{z}\) 输入多分类交叉熵（Cross-Entropy）损失，而不是手动先算 softmax 再取对数。这样做的原因是数值稳定：损失函数内部会把 softmax 与对数合并成 log-sum-exp 形式，避免指数溢出。推理时若只关心类别标签，直接取 \(\arg\max_c z_c\) 或 \(\arg\max_c p(y=c\mid x)\) 即可；若需要概率、阈值或校准，再显式使用 softmax。

多标签分类（Multi-label Classification）与多分类名字相近，但任务结构完全不同。它不是“从多个类里选一个”，而是同一个样本可以同时拥有多个标签。例如一篇文章可以同时属于“AI、NLP、Transformer”，一张图片可以同时打上“室内、人物、宠物”三个标签。

这种任务里，标签之间不再互斥，因此不能使用 softmax。若仍用 softmax，所有标签概率会被强制归一化为和 1，相当于错误地假设“只能有一个标签成立”。多标签头通常输出 \(C\) 个 logits：

但后续不是做一次整体 softmax，而是对每一维独立做 sigmoid：

这里 \(p_i\) 表示“第 \(i\) 个标签是否成立”的独立概率。训练时通常使用逐维二分类交叉熵，即把每个标签都当作一个独立的二分类问题，再在标签维上求和或取平均：

因此，多标签头的关键不是“输出维度也叫 \(C\)”，而是这 \(C\) 维之间不竞争，每一维都在独立回答一个 yes/no 问题。推理时也不是取单个 argmax，而是对每一维做阈值判断，例如输出所有满足 \(p_i>0.5\) 的标签，或按业务分别设定不同标签阈值。

回归头（Regression Head）不负责在离散类别之间做判别，而是直接输出连续数值（Continuous Value）或连续向量。最常见的形式仍然是一层线性映射：

这里 \(m\) 是回归目标维度。若 \(m=1\)，就是标量回归，例如房价预测、评分预测、温度预测；若 \(m>1\)，则是多维回归，例如边界框坐标回归、姿态参数回归或多目标数值预测。

回归头通常不接 softmax，也不强制输出落在 \((0,1)\)。原因很简单：回归任务关心的是数值大小本身，而不是类别概率竞争。训练时常配合均方误差（MSE）、平均绝对误差（MAE）或 Huber Loss。只有当目标值本身有明确范围约束时，才会额外接 sigmoid、tanh 或其他变换，把输出压到指定区间。

语言模型头（Language Modeling Head, LM Head）是把隐藏表示映射回词表空间的输出头。只要任务目标是“在若干位置上对词表中的 token 做预测”，就会出现这一类头；因此它不只存在于 Decoder-only 大模型，也存在于 Encoder-only 的掩码语言模型（Masked Language Model, MLM）以及 Encoder-Decoder 的生成端。它读取主干网络在每个位置输出的隐藏状态 \(H\in\mathbb{R}^{L\;\times d_{\text{model}}}\)，并把每个位置的表示投影到整张词表空间，得到词表 logits：

这条式子先描述整体矩阵，再自然落到单个位置。这里 \(L\) 是序列长度，表示当前一共有多少个位置； \(d_{\text{model}}\) 是隐藏维度； \(V\) 是词表大小（Vocabulary Size）。因此，隐藏状态矩阵 \(H\in\mathbb{R}^{L\;\times d_{\text{model}}}\) 的每一行对应一个位置的表示，输出权重矩阵 \(W_{\text{vocab}}\in\mathbb{R}^{d_{\text{model}}\;\times {V}}\) 的每一列对应“词表中某个 token 作为候选答案时的读出方向”，最终得到的 \(Z\in\mathbb{R}^{L\;\times {V}}\) 就是一个“位置 \(\times\) 词表”的打分表：行表示位置，列表示候选 token。

把这张打分表聚焦到第 \(t\) 行，就得到 \(Z_{t,:}\in\mathbb{R}^{V}\)，也就是“第 \(t\) 个位置对整张词表所有 token 的一整行 logits”。这里 \(H_t\in\mathbb{R}^{d_{\text{model}}}\) 表示第 \(t\) 个位置的隐藏状态，冒号 \(:\) 表示该行的全部列；若写成 \(Z_{:,i}\)，则表示第 \(i\) 列，也就是“所有位置对第 \(i\) 个 token 的分数”。继续缩小到单个元素 \(Z_{t,i}\)，它表示“在第 \(t\) 个位置，把词表中第 \(i\) 个 token 作为下一个输出时的原始分数”。

把矩阵形式按单个位置、单个候选 token 展开后，打分可写成：

这里 \(W_{\text{vocab},:,i}\) 表示输出权重矩阵的第 \(i\) 列，也就是与词表第 \(i\) 个 token 对应的参数向量； \(b_i\) 是该 token 的偏置项。这个公式的读法是：拿第 \(t\) 个位置的隐藏表示 \(H_t\)，与“token \(i\) 的读出向量”做一次点积，再加偏置，就得到该 token 在该位置的 logit。

LM Head 与分类头的根本区别在于输出空间。普通分类头通常只需输出 \(C\) 个类别分数；LM Head 则要在每个位置输出 \(V\) 个分数，而 \(V\) 往往达到几万甚至几十万。因此，LM Head 本质上是“逐位置的大规模多分类器”：每一步都在问“下一个 token 应该是词表中的哪一个”。

同一个 LM Head 公式，在不同 Transformer 架构里的使用方式并不相同。对 Encoder-only 模型，LM Head 通常服务于掩码语言建模：模型先用双向注意力得到各位置隐藏状态，再只在被遮蔽的位置上读取 \(Z_{t,:}\) 来预测原 token；这一过程通常是一次性编码，不涉及自回归生成，也没有 KV Cache 逐步增长的问题。对 Decoder-only 模型，LM Head 用于 next-token 预测：第 \(t\) 个位置的隐藏状态对应预测 \(x_{t+1}\)，推理时会逐步生成，因此会配合因果注意力（Causal Self-Attention）和 KV Cache。对 Encoder-Decoder 模型，LM Head 位于解码器一侧：编码器先产出源序列表示，解码器再在因果自注意力与交叉注意力（Cross-Attention）的共同作用下生成目标侧隐藏状态，最后由 LM Head 映射到词表。

训练时，自回归语言模型（Autoregressive Language Model）通常采用 next-token 目标：第 \(t\) 个位置的隐藏状态 \(H_t\) 用来预测真实的下一个 token \(x_{t+1}\)。对应损失可写成：

这个损失公式也可以逐项拆开理解。左边的 \(\mathcal{L}_{\mathrm{LM}}\) 是整段序列的语言模型损失；求和下标 \(t=1,\dots,L-1\) 表示：前 \(L-1\) 个位置都要各自预测一次下一个 token。分子里的 \(\exp(Z_{t,x_{t+1}})\) 表示“真实下一个 token 在第 \(t\) 个位置对应的指数化分数”；这里 \(x_{t+1}\) 是真实的下一个 token id，所以 \(Z_{t,x_{t+1}}\) 表示在位置 \(t\) 对这个真实 token 的 logit。分母 \(\sum_{i=1}^{V}\exp(Z_{t,i})\) 则把整张词表所有候选 token 的分数全部加起来做归一化。因此整个分式就是“在位置 \(t\) 预测真实下一个 token 的概率”，外面的负对数再把它变成训练损失。

推理时则不是直接输出标签，而是先对 \(Z_{t,:}\) 做 softmax 得到下一个 token 的条件分布。这里的 \(Z_{t,:}\) 不是一个标量，而是长度为 \(V\) 的向量，包含位置 \(t\) 对整张词表每个 token 的分数。对这整行做 softmax 后，得到的是：

这条式子表示：在已经看到前缀 \(x_{\le t}\) 的条件下，下一个 token 取词表中第 \(i\) 个词的概率是多少。随后再配合贪心搜索（Greedy Decoding）、束搜索（Beam Search）、温度采样（Temperature Sampling）、top-k / top-p 等策略，从这组概率中选出真正生成的 token。也就是说，LM Head 负责把隐藏表示变成“词表级候选分数”，真正的文本生成还要再经过一层解码（Decoding）策略。

很多 LLM 还会使用权重共享（Weight Tying）：把输入嵌入表 \(E\in\mathbb{R}^{V\;\times d_{\text{model}}}\) 与输出头绑定，使 \(W_{\text{vocab}}=E^\top\)。这样一来，输入端“一个 token 的向量表示”与输出端“一个 token 作为候选答案时的原型向量”共用同一套参数空间。它通常既能减少参数量，也让输入和输出语义空间保持更强一致性。

从工程角度看，LM Head 往往比分类头更贵，因为它直接与词表大小 \(V\) 成正比：词表越大，最后一层的矩阵乘法、softmax 和采样都越重。因此，大模型的推理优化常会专门围绕 LM Head 展开，例如 fused softmax、采样优化、logits processor、词表裁剪或 speculative decoding 等。本质上，这些优化都在解决同一个问题：如何更高效地从词表 logits 走到最终生成 token。

序列标注（Sequence Labeling）/Token 分类（Token Classification）要求对每个 token 预测一个标签（例如 NER）。设主干输出 \(H\in\mathbb{R}^{L\times d}\)（长度 \(L\)，隐藏维 \(d\)），则逐 token 线性头为：

对第 \(t\) 个 token，用 softmax 得到 \(p(y_t|x)\) 并用逐 token 交叉熵训练。该做法把每个位置的标签看作条件独立，能工作，但会忽略标签之间的结构约束（例如 BIO 体系中不允许

I-ORG

O

例：对 “Apple Inc. is in California” 的 NER（Named Entity Recognition），合理标签序列可能是

B-ORG I-ORG O O B-LOC

线性链条件随机场（Linear-chain Conditional Random Field, CRF）在 token 分类头上增加一个转移矩阵（Transition Matrix）\(A\in\mathbb{R}^{C\times C}\)，对整段标签序列做归一化建模。令发射分数（Emission Score）为 \(s_t(y)=Z_{t,y}\)，则序列 \(y_{1:L}\) 的总分为：

并定义条件概率：

训练最小化负对数似然（Negative Log-Likelihood）；解码用 Viterbi 算法（动态规划）求 \(\arg\max_y \mathrm{score}(x,y)\)。CRF 的收益是把“标签合法性/连贯性”学进转移项，从而显著减少结构错误。

双仿射（Biaffine）任务头常用于“成对打分”（Pairwise Scoring），例如依存句法（Dependency Parsing）里的“当前词应依附到哪个词”，或关系抽取（Relation Extraction）里的“两个实体之间是否存在某种关系”。它的名字可以按层级直接理解：对一个变量， \(Wx\) 是线性， \(Wx+b\) 是仿射；对两个变量， \(h_i^\top U h_j\) 是双线性（Bilinear）；在这个双线性项之外再加上线性项和偏置项，就得到双仿射（Biaffine）。因此，双仿射的本质是：既建模两个表示之间的交互，又保留各自单独的角色偏好。

这条式子可以逐项拆开读。 \(h_i,h_j\in\mathbb{R}^{d}\) 是两个待配对对象的表示向量；在依存句法里，它们可分别表示“当前词”和“候选 head”；在关系抽取里，它们可分别表示“实体 1”和“实体 2”。 \(U\in\mathbb{R}^{d\times d}\) 是双线性参数矩阵，因此 \(h_i^\top U h_j\) 建模的是二者之间的交互强度：不是只看 \(h_i\) 自己，也不是只看 \(h_j\) 自己，而是看“这两个向量放在一起是否匹配”。把它展开后就是 \(\sum_{p=1}^{d}\sum_{q=1}^{d}(h_i)_p\,U_{pq}\,(h_j)_q\)，因此 \(U_{pq}\) 可以理解为“第 \(p\) 个 dependent 特征与第 \(q\) 个 head 特征同时出现时，该给多少分”。

若任务需要一次输出多类关系分数，工程实现通常会为每个类别各放一张矩阵 \(U^{(k)}\)，或直接使用三阶参数张量。这样不同关系类型就能拥有不同的交互模式，而不必共用同一套 \(U\)。

\([h_i;h_j]\in\mathbb{R}^{2d}\) 表示把两个向量直接拼接； \(w^\top [h_i;h_j]\) 是普通仿射项，可以进一步拆成“只依赖 \(h_i\) 的线性项 + 只依赖 \(h_j\) 的线性项”。它的作用是补充单边信息：即使暂时不看两者之间的乘性交互，某些 token 或实体本身也可能更像 head、更像 dependent，或更像某类关系的一端。最后的 \(b\) 是全局偏置，给整类配对提供一个基线分数。

具象地看， \(h_i^\top U h_j\) 像在问“这两个人之间是否搭得上”， \(w^\top [h_i;h_j]\) 像在问“这两个人各自单独看，是否本来就带某种角色倾向”。把两部分合起来，模型既能利用配对关系，也不会丢掉单个对象自身的类型线索。这正是双仿射通常比纯双线性更稳、更有表达力的原因。

把 \(s(i,j)\) 对所有 \((i,j)\) 组合都算出来，就能形成一个 \(L\times L\) 的分数矩阵；对每个位置 \(i\)，再在所有候选 \(j\) 上做 \(\arg\max\) 或 softmax 分类，就能得到“它最可能依附到谁”或“它与谁最可能存在某种关系”。这种头的关键点在于：任务监督信号作用在“对”的层面，而不是单点分类。

解析式 NLP（Analytical NLP）指一类“结构化输出”的语言任务：输出不是一段自由文本，而是标签序列、树或图。这类任务的工程难点通常不在 backbone，而在输出结构约束、标注成本、以及错误后果（例如信息抽取用于合规/风控）。

同一个 backbone 可以挂多个任务头（Multi-head / Multi-task）：共享表示学习带来数据效率，但不同任务的梯度可能冲突，需要权衡损失权重（Loss Weighting）与采样策略。工程上也常见“同任务多头”：例如同时输出 token 标签与 span 边界，或同时输出检索 embedding 与分类 logits，用不同头对齐不同指标。

反向传播（Backpropagation）描述的是训练阶段中“如何把损失函数对输出的误差信号传回网络内部，并进一步求出各层参数梯度”的过程。理解这一章时，可以把它拆成三件事：前向传播先把值算出来，反向传播再把梯度传回去，而链式法则与 Jacobian 则给出这件事的数学形式。

前向传播（Forward Propagation）是训练与推理中首先发生的计算过程：给定输入 \(x\) 和当前参数 \(\theta\)，按照网络定义从前到后依次计算各层输出、最终预测 \(\hat y\)，以及训练时对应的损失 \(L\)。若把网络写成函数复合

那么前向传播做的就是按 \(x\to h_1\to h_2\to \cdots \to h_L\to \hat y \to L\) 的顺序把这些值算出来。它回答的问题是：在当前参数下，这个样本会被模型算成什么结果，以及这个结果与真实标签相差多大。

前向传播的产物不仅是最终预测，还包括中间激活值（Activation）。这些中间量一方面构成模型当前这次推理的内部表示，另一方面也是后续反向传播计算梯度时必须依赖的节点。因此，训练过程总是先有前向传播，再有反向传播：前者负责算值，后者负责算这些值对参数的敏感度。

反向传播（Backpropagation）是深度学习里用于高效计算梯度（Gradient）的算法。训练神经网络的目标，是最小化损失函数（Loss Function）\(L(\theta)\)；而要用梯度下降（Gradient Descent）或 Adam 之类的优化器更新参数，就必须先知道每个参数对损失的影响，也就是 \(\frac{\partial L}{\partial \theta}\)。

这个需求在深层网络里会立刻变得庞大。一个模型往往包含从数万到数十亿个参数；如果对每个参数都单独做一次数值扰动，逐个估计“它变一点时损失会怎么变”，计算代价会高得无法训练。反向传播出现的直接原因，就是要把这个原本几乎不可做的问题，变成一次前向传播（Forward Pass）加一次反向传播（Backward Pass）即可完成的梯度计算流程。

它的来源并不神秘：神经网络本质上是许多简单函数的复合。线性层、激活函数、归一化、注意力、损失函数，都会把前一层输出当作后一层输入。只要这些局部变换可导（Differentiable）或几乎处处可导，就可以对整条复合链应用链式法则（Chain Rule）。反向传播就是把链式法则改写成一种适合计算图（Computational Graph）执行的程序：前向时保存必要的中间结果，反向时从最终损失出发，把局部导数一层层乘回去，并把梯度分发给每个中间变量和参数。

因此，反向传播不是另一条独立于微积分的“神经网络专用规则”，而是链式法则在复合函数上的工程化实现。它做的事情可以概括为两步：第一步，前向传播先算出各层激活值与最终损失；第二步，从 \(\frac{\partial L}{\partial L}=1\) 出发，把损失敏感度沿着依赖边反向传回去，依次得到 \(\frac{\partial L}{\partial h_l}\)、 \(\frac{\partial L}{\partial W_l}\)、 \(\frac{\partial L}{\partial b_l}\) 等量。到这一步为止，反向传播完成的是梯度计算；参数真正如何更新，则属于优化器（Optimizer）的职责。

最简单的梯度下降（Gradient Descent）更新写成

这里更适合写梯度符号 \(\nabla_{\theta}L\)，因为 \(\theta\) 往往是整个参数向量或参数集合，而不是单个标量。若只讨论某一个标量参数，才可写成 \(\theta \leftarrow \theta - \eta \frac{\partial L}{\partial \theta}\)。从计算方式看，反向传播对应自动微分（Automatic Differentiation）中的反向模式（Reverse Mode AD）。它特别适合“输入参数很多、输出损失很少”的场景；而神经网络训练恰好就是这种结构：参数维度极大，但最终通常只关心一个标量损失。因此，反向传播成为现代深度学习训练的标准机制。

先看一个只多加一层激活函数（Activation）的最小网络。设输入 \(x=2\)，参数为权重 \(w=1\) 与偏置 \(b=-1\)，先做仿射变换（Affine Transform）

再经过 ReLU 激活函数

把激活值当作最终预测，即 \(\hat y=a\)。若真实标签 \(y=0\)，损失取平方损失（Squared Loss）

前向传播链条现在是

反向传播先从损失对输出的导数开始：

由于这里 \(\hat y=a\)，所以

再经过激活函数这一层。因为当前 \(z=1>0\)，ReLU 的导数为

于是梯度传回仿射层输出：

最后再看仿射层对参数的局部导数：

因此

若学习率 \(\eta=0.1\)，梯度下降更新后

这个版本比纯线性例子多了一站 \(z\to a\)，因此链式法则也多乘了一个局部导数 \(\frac{\partial a}{\partial z}\)。这正是反向传播的一般形式：误差信号每穿过一层，就乘上这一层自己的局部导数。若这里的 \(z<0\)，则 ReLU 导数为 0，上游梯度也会在这一层被截断。

反向传播（Backpropagation）本质是链式法则（Chain Rule）在计算图（Computational Graph）上的系统化应用：把最终损失对中间变量的导数沿依赖关系向后传。

固定一个训练样本 \((x,y)\) 后，损失 \(L\) 最终当然可以看成参数 \(\theta\) 的函数；训练时真正要更新的也确实是权重（Weight）。但在计算图里， \(L(\theta)\) 并不是一步直接从 \(\theta\) 跳到损失，而是先经过各层线性变换、激活值（Activation）和输出再到损失。因此，反向传播会先求 \(\frac{\partial L}{\partial h_l}\) 这类“损失对中间激活值的敏感度”，再由这些中间梯度继续求出 \(\frac{\partial L}{\partial \theta_l}\)。

Jacobian 一节已经给出局部线性化：若 \(h_{l+1}=f_l(h_l)\)，则在当前点附近有 \(dh_{l+1}\approx J_l\,dh_l\)，其中 \(J_l=\frac{\partial h_{l+1}}{\partial h_l}\)。这条式子描述的是输入扰动如何向前传到输出扰动；反向传播关心的是相反方向的问题：输出端的损失敏感度如何传回输入端。

先看一层。由于损失 \(L\) 是标量，若采用与前文 Jacobian 一致的分子布局（Numerator Layout），把 \(\frac{\partial L}{\partial h_l}\) 记成 \(1\;\times d_l\) 的行向量，则向量链式法则写成：

这条式子最好按符号逐个读。先看 \(h_l\) 与 \(h_{l+1}\)：它们分别表示第 \(l\) 层的输入表示和该层输出表示。若 \(h_l\) 有 \(d_l\) 个分量， \(h_{l+1}\) 有 \(d_{l+1}\) 个分量，那么

它表示：损失 \(L\) 对第 \(l+1\) 层每个输出分量分别有多敏感。这里把它写成行向量，是因为前文采用的是分子布局（Numerator Layout）。

再看 Jacobian：

其中第 \((i,j)\) 个元素是

意思是：第 \(l\) 层第 \(j\) 个输入分量变化一点，会让第 \(l+1\) 层第 \(i\) 个输出分量变化多少。因此，Jacobian 记录的是“输入各分量 \(\to\) 输出各分量”的局部影响表。

现在看乘法

左边最终应该是一个关于 \(h_l\) 各分量的梯度，所以它必须有 \(d_l\) 个分量。维度上， \(\frac{\partial L}{\partial h_{l+1}}\) 是 \(1\;\times d_{l+1}\)， \(J_l\) 是 \(d_{l+1}\;\times d_l\)，两者相乘后确实得到 \(1\;\times d_l\)。

如果把第 \(j\) 个分量单独展开，这个乘法其实就是

这时含义就完全显出来了：第 \(l\) 层第 \(j\) 个输入分量，会通过第 \(l+1\) 层的所有输出分量共同影响损失；因此要把“损失对每个输出分量的敏感度”乘上“该输出分量对当前输入分量的局部导数”，再对所有输出分量求和。矩阵乘法只是把这组求和一次性写成了紧凑形式。

把这条一层公式沿网络递推展开，对深度网络 \(h_{l+1}=f_l(h_l)\) 可得：

这条公式的读法非常具体：前向传播按 \(h_0\to h_1\to\cdots\to h_L\) 计算；反向传播则从最终梯度 \(\frac{\partial L}{\partial h_L}\) 出发，依次乘上最后一层到第一层的 Jacobian，把敏感度一层层传回去。矩阵乘法满足结合律（Associativity），因此可以逐层累积；但不满足交换律，乘法顺序不能改，因为每个 Jacobian 都对应不同层的局部坐标变换。

一个最小可算例可以把这件事完全写开。设输入 \(x\) 是标量，第一层有两个参数 \(w_{11},w_{12}\)，输出二维隐藏表示：

第二层有两个参数 \(w_{21},w_{22}\)，把二维隐藏表示读成一个标量预测：

损失取最简单的平方损失（Squared Loss）：

这里总参数一共四个，但反向传播不会直接去“猜” \(\frac{\partial L}{\partial w_{11}}\)、 \(\frac{\partial L}{\partial w_{12}}\) 等结果，而是先沿着计算图写出中间量：

先看第二层的局部 Jacobian。因为 \(\hat y\) 是标量、 \(h_1\in\mathbb{R}^2\)，所以

再看第一层的局部 Jacobian。因为 \(h_1\in\mathbb{R}^2\)、 \(x\) 是标量，所以

损失对最终输出的导数最容易先算：

于是，损失对隐藏表示的梯度由链式法则得到：

这一步已经把“损失对输出的敏感度”传回到了中间激活值 \(h_1\)。继续往回乘第一层 Jacobian，就得到损失对输入的梯度：

对参数的梯度也是同样的思路。第二层参数直接作用在 \(\hat y\) 上，因此

第一层参数不直接连到损失，而是先影响 \(h_1\)，再影响 \(\hat y\) 和 \(L\)，所以必须经过中间激活值这一站：

若取一组具体数值 \(x=2\)、 \(y=1\)、 \(w_{11}=1\)、 \(w_{12}=-1\)、 \(w_{21}=0.5\)、 \(w_{22}=2\)，则前向传播先得到

于是反向传播依次得到

这个最小例子把反向传播的结构完整展示了出来：损失函数最终是参数的函数，但梯度并不是“绕开中间层直接对权重求”。它必须先通过 \(\frac{\partial L}{\partial \hat y}\)、 \(\frac{\partial L}{\partial h_1}\) 这样的中间敏感度逐步回传。激活值因此不是“额外引入的变量”，而是计算图中必经的节点。

若改用深度学习里更常见的列向量梯度记号 \(\nabla_{h_l}L\in\mathbb{R}^{d_l}\)，同一件事会写成

这与上面的公式没有本质区别，只是把“左乘 Jacobian 的行向量记号”改写成了“右侧乘 Jacobian 转置的列向量记号”。工程实现里常见的 Vector-Jacobian Product，本质上就是这一步。

对参数的梯度也是同一个模式。若第 \(l\) 层含参数 \(\theta_l\)，则

因此 backward 的核心不是“把前向再算一遍”，而是复用每一层的局部 Jacobian，把同一个上游梯度分别传给输入变量和参数。

梯度消失（Vanishing Gradients）与梯度爆炸（Exploding Gradients）通常来自连乘的数值尺度：若这些雅可比的有效增益（Effective Gain）的奇异值（Singular Values）长期小于 1，则梯度指数级衰减；长期大于 1 则指数级放大。

在 RNN 的 BPTT 中，这种现象尤其明显：同一递归矩阵在时间轴上重复相乘。粗略地看，若 \(W_{hh}\) 的谱半径（Spectral Radius）\(\rho(W_{hh})\) 明显大于 1，梯度更易爆炸；明显小于 1 更易消失。但这不是“只要 \(\lambda>1\) 就一定爆炸”的二选一结论，因为实际还受到激活函数导数、归一化、残差/门控结构、以及数据分布的共同影响。

“梯度随训练慢慢变小是否正常？”在接近最优点时，梯度范数下降是预期现象；需要警惕的是训练早期就出现系统性消失（例如大量饱和激活导致导数接近 0）或出现不稳定爆炸（loss/梯度频繁变成 NaN/Inf）。

常见应对：

• 梯度裁剪（Gradient Clipping）：抑制爆炸。
• 合理初始化（Xavier/He）、归一化（BatchNorm/LayerNorm）、残差连接（Residual）。
• 门控结构（Gated Units）：LSTM/GRU 通过门控缓解长程梯度问题。

权重初始化（Weight Initialization）的目标不是“随机给一个小数”，而是控制信号在层间传播的数值尺度。设第 \(l\) 层的线性部分为 \(z^{(l)}=W^{(l)}h^{(l-1)}+b^{(l)}\)。若 \(z^{(l)}\) 的二阶原点矩（Second Raw Moment）在层间持续放大，前向激活与反向梯度都会倾向爆炸；若持续衰减，则会出现梯度消失。

对单个神经元，写成 \(z=\sum_{i=1}^{n}w_i x_i+b\)。初始化分析里通常进一步假设 \(w_i\) 与 \(x_i\) 相互独立，且权重满足 \(\mathbb{E}[w_i]=0\)。这里的 \(\mathbb{E}[w_i]=0\) 不是在声称“训练后的权重天然应当均值为 0”，而是在分析初始化时，把权重看作从一个以 0 为中心的随机分布中抽样得到；这样做的目的，是避免网络在一开始就对某一方向产生系统性偏置，并让前向输出的均值计算更干净。基于这一初始化假设，在线性部分有

当输入也近似零均值时， \(\mathbb{E}[x^2]\approx \mathrm{Var}(x)\)，于是常写成 \(\mathrm{Var}(z)\approx n\,\mathrm{Var}(w)\,\mathrm{Var}(x)\)。这里 \(n\) 就是 fan_in。因此初始化的核心约束可以概括为：让 \(n\,\mathrm{Var}(w)\) 保持在 1 附近。

更严格地说，深度初始化分析常跟踪的是 \(\mathbb{E}[h^2]\)，而不是所有层都精确使用方差；因为经过 ReLU 之后，激活不再零均值，此时二阶原点矩与方差不再完全相同。但在线性层与零均值近似下，两者是一致的，因此“保持方差稳定”仍是准确的工程表述。

两种朴素做法都会失败：若所有权重都初始化为 0，则各神经元保持完全对称，反向传播得到相同更新，网络退化为“许多拷贝的同一个单元”；若直接令 \(\mathrm{Var}(w)=1\)，则线性输出的尺度会随层数按 fan_in 连乘，深层网络极易数值失稳。偏置（Bias）通常初始化为 0 或很小的常数；真正决定尺度的是权重矩阵的方差结构。

这里的 fan_in 与 fan_out 可以直接按“这层连接了多少路信号”来理解。对某个线性层中的一个输出神经元，fan_in 是流入它的输入通道数；输入通道越多，很多随机小贡献叠加后，输出就越容易变大。对某个输入神经元，fan_out 是它连接到下一层多少个输出通道；fan_out 越大，这个输入方向上的梯度在反向传播时就会被分发到更多支路。因此，fan_in 主要约束前向激活的放大量级，fan_out 主要约束反向梯度的放大量级。

具象地看，一个神经元像一个汇流节点：fan_in 决定有多少根水管把信号同时灌进来，fan_out 决定这股信号会被分流到多少个下游节点。初始化如果不考虑这两个连接数，网络就会在“汇流过猛”与“分流过弱”之间失衡。Xavier 正是在前向与反向之间做折中，He 则进一步把激活函数本身带来的能量损失也纳入补偿。

Xavier 初始化（Xavier Initialization）也称 Glorot 初始化（Glorot Initialization），针对近似线性的激活工作区间设计，例如 tanh 与 sigmoid 在原点附近的局部线性区域。它的目标是同时控制前向激活与反向梯度的尺度，使它们在穿过每一层时不发生系统性放大或衰减。

若暂时忽略激活函数对二阶原点矩的额外缩放，则前向保持尺度不变要求 \(\mathrm{Var}(w)\approx 1/\mathrm{fan\_in}\)；反向对应地要求 \(\mathrm{Var}(w)\approx 1/\mathrm{fan\_out}\)。Glorot 给出的折中形式因此写成：

常见实现包括正态版 \(w\sim\mathcal{N}\!\left(0,\frac{2}{\mathrm{fan\_in}+\mathrm{fan\_out}}\right)\)，以及均匀版 \(w\sim U\!\left[-\sqrt{\frac{6}{\mathrm{fan\_in}+\mathrm{fan\_out}}},\sqrt{\frac{6}{\mathrm{fan\_in}+\mathrm{fan\_out}}}\right]\)。

从直觉上看，Xavier 初始化像是在给每一层设置一个“不过度放大、也不过度压缩”的中性增益（neutral gain）。可以把一层线性变换想成一组并联的混音器：输入信号从上一层流入，经过许多权重通道混合后送到下一层。Xavier 的目标就是让这组混音器在初始状态下近似保持“总音量”不变，使信号既不会层层变得越来越吵，也不会层层变得越来越弱。

Xavier 的局限在于：它默认激活函数不会系统性丢失太多能量。对 ReLU 这类半波整流（Half-wave Rectification）激活，这个假设不再成立；即使线性层前后的尺度匹配，经过激活后信号的二阶原点矩仍会明显下降。

He 初始化（He Initialization）也称 Kaiming 初始化（Kaiming Initialization），专门处理 ReLU 家族的整流效应。若线性输出 \(z\) 近似关于 0 对称，经过 \(\mathrm{ReLU}(z)=\max(0,z)\) 后，大约一半的质量被截断为 0，并且

因此，若仍使用 Xavier 量级，信号的二阶原点矩会随层数持续衰减。He 初始化通过把权重方差提高到

来补偿这一半波损失。对应实现可写为正态版 \(w\sim\mathcal{N}\!\left(0,\frac{2}{\mathrm{fan\_in}}\right)\)，或均匀版 \(w\sim U\!\left[-\sqrt{\frac{6}{\mathrm{fan\_in}}},\sqrt{\frac{6}{\mathrm{fan\_in}}}\right]\)。

具象地看，ReLU 像一道只允许正值通过的闸门：一批近似对称分布的信号经过后，负半边会被直接截成 0，等于天然损失了一部分能量。He 初始化做的事情就是在闸门前把信号预先放大一些，使它通过这道“半波闸门”之后，整体尺度仍能维持在稳定区间。Xavier 假定通道基本不漏能量，He 则明确把 ReLU 的漏损补偿计入初始化方差。

对 Leaky ReLU/PReLU，补偿因子可推广为 \(\frac{2}{(1+a^2)\,\mathrm{fan\_in}}\)，其中 \(a\) 是负半轴斜率。实践上，ReLU 及其变体默认优先使用 He 初始化；tanh/sigmoid 更适合 Xavier。归一化层与残差连接可以进一步放宽初始化的容错区间，但不能替代合理的初始尺度控制。

Transformer / 大语言模型（Large Language Model, LLM）里的初始化通常不按“整模统一套 Xavier”或“整模统一套 He”来理解，而更像一套围绕残差流（Residual Stream）稳定性、归一化层和深度扩展设计的小方差初始化配方。原因在于：LLM 的主干不是简单的“线性层 + 单一激活函数”堆叠，而是由自注意力、残差连接、LayerNorm / RMSNorm、MLP / SwiGLU 等子结构共同组成；纯粹以某个激活函数为中心推导的 Xavier / He，只能覆盖其中一部分局部直觉。

工程上最常见的做法是：嵌入层与线性层权重用零均值的小方差正态分布初始化，偏置置零或省略；随后依靠 LayerNorm / RMSNorm 与残差结构维持训练初期的数值稳定。BERT、GPT-2 一类经典 Transformer 常见做法是使用标准差约为 \(0.02\) 的正态或截断正态初始化；很多更现代的 Decoder-only LLM 仍延续“小方差高斯初始化”这一主线，只是在具体投影层上再叠加按隐藏维度、层数或残差分支做缩放的配方。

从直觉上看，LLM 初始化更像是在给一条很深的多车道主干道设置初始车流密度。若注意力里的 \(Q/K/V/O\) 投影、FFN 的升维/降维投影以及其他会把结果写回残差流的线性层初始尺度过大，残差分支会把信号越叠越猛，训练初期容易震荡；若尺度过小，几十层上百层残差块叠起来后，真正进入有效学习区的信号又会太弱。因此，现代 LLM 初始化的重点往往不是“严格选 Xavier 还是 He”，而是让残差支路在深层网络中既能传递信息，又不会在训练一开始就把数值尺度推离稳定区。

具体到模块分工，也可以这样理解：MLP 内部若使用 ReLU 家族激活，He 的补偿思想仍然成立；若使用 GELU、SiLU、SwiGLU 这类更平滑或带门控的激活，则实现里往往直接采用统一的小方差正态初始化，再由归一化、残差和训练配方共同保证稳定性。换言之，LLM 并没有抛弃 Xavier / He 背后的“方差守恒”原则，而是把这套原则嵌入到了更完整的 Transformer 初始化策略里。

正则化（Regularization）在经验风险（Empirical Risk）上增加复杂度惩罚，缓解过拟合（Overfitting）。假设函数/模型 \(f_\theta\) 决定预测；样本损失 \(\ell\) 度量单样本误差；代价函数/成本函数 \(L(\theta)\) 汇总训练集误差；目标函数 \(J(\theta)\) 则是 \(L(\theta)\) 加上正则化项： \(J(\theta)=L(\theta)+\lambda\Omega(\theta)\)。

L1 正则化（L1 Regularization）使用 \(\Omega(\theta)=\|\theta\|_1\)。它倾向产生稀疏解（Sparsity），即一部分权重被直接压到 0，因此可同时做参数学习和特征选择（Feature Selection）。

从优化角度看，L1 的梯度是次梯度（Subgradient）：对单个参数 \(\theta_k\)，当 \(\theta_k\ne 0\) 时有 \(\frac{\partial}{\partial \theta_k}\|\theta\|_1=\mathrm{sign}(\theta_k)\)；在 0 点是一段区间 \([-1,1]\)。这使得优化过程更容易把小权重“推过 0”，形成精确稀疏。

在很多实现中，会用近端算子（Proximal Operator）给出更清晰的“压到 0”机制：对标量 \(w\)，软阈值化（Soft-Thresholding）是

当 \(|w|\le \alpha\) 时直接变为 0。

L2 正则化（L2 Regularization）使用 \(\Omega(\theta)=\|\theta\|_2^2\)。它倾向均匀缩小参数，但通常不会把参数精确压到 0。直观上，L1 在 0 点不可导，更容易触发“阈值化”解；L2 是光滑二次惩罚，更新更连续。

梯度层面，L2 会在原梯度上叠加一个“拉回原点”的项：若目标为 \(\ell(\theta)+\lambda\|\theta\|_2^2\)，则 \(\nabla_\theta=\nabla \ell(\theta)+2\lambda\theta\)。工程上常把这个效果称为权重衰减（Weight Decay）：每一步都把权重按比例缩小。

需要区分一个常见细节：在自适应优化器（如 Adam）里，“把 \(\lambda\|\theta\|_2^2\) 加到损失里”与“直接做 weight decay”在数值上并不完全等价；因此实践中常用解耦权重衰减（Decoupled Weight Decay，典型实现是 AdamW）来获得更可控的正则化行为。

把带惩罚的目标改写成约束形式后，几何差异会非常直观： \(\min_\theta L(\theta)\ \mathrm{s.t.}\ \|\theta\|_1\le t\) 的可行域在二维里是菱形， \(\min_\theta L(\theta)\ \mathrm{s.t.}\ \|\theta\|_2\le t\) 的可行域则是圆盘。损失等高线从外向内收缩时，第一次接触 \(L_1\) 边界，往往更容易落在角点；角点恰好对应某些坐标精确等于 0。 \(L_2\) 边界处处光滑，接触点通常只是把所有坐标一起缩小，而不是把其中一部分直接压成 0。

从一维更新机制看，这个差异也对应两种不同的收缩方式。 \(L_2\) 更像连续比例收缩：权重越大，拉回原点的力越强，但通常不会在有限步内变成精确 0。 \(L_1\) 则对应软阈值化（Soft-Thresholding）：一旦 \(|w|\) 小于阈值，就会被直接压成 0。因此， \(L_1\) 不只是“把权重变小”，而是会主动把一部分坐标从模型中删掉，这就是稀疏性（Sparsity）的来源。

Dropout 通过随机屏蔽部分神经元输出，减少共适应（Co-adaptation），等价于在训练时对网络做一种随机子网络集成（Ensemble）。这里的共适应，是指若干神经元彼此形成了固定搭配：模型过度依赖它们同时出现、按特定组合共同完成判断，而不是让每个单元都学到相对独立、稳健的特征。Dropout 随机拿掉其中一部分单元后，网络不能再把能力押注在某一组固定配合上，只能把有用模式分散到更稳健的表示里。令隐藏向量为 \(h\)，mask \(m_i\sim \mathrm{Bernoulli}(p)\)，常见的 inverted dropout 写法为：

其中 \(p\) 是保留概率（Keep Probability）。这样推理时可直接使用原网络（不再采样 mask），避免额外缩放。

Batch Normalization（BatchNorm）在训练时用 mini-batch 的均值/方差做归一化，并学习缩放/平移参数。对特征维上的某个分量 \(x\)，典型形式是：

推理阶段通常使用训练过程累积的运行均值（Running Mean）与运行方差（Running Variance），因此训练/推理行为不同。BatchNorm 在 CNN 中极常见，因为卷积特征图在同一通道上的空间位置具有较强同质性，跨样本统计量较容易稳定；但在 Transformer 中，主流做法并不是沿 batch 维做归一化，而是使用与 batch 统计无关的 LayerNorm 或 RMSNorm。

原因在于 Transformer 的基本计算单元是 token 表示。序列长度常常可变，batch size 在训练与推理中也经常变化，尤其大模型训练会受到显存限制而使用较小、波动甚至分布式切分后的 micro-batch。若使用 BatchNorm，某个 token 的归一化结果会显式依赖同一 batch 中其他样本与其他位置的统计量，这会引入跨样本耦合，使训练和推理的数值语义不一致，也不利于自回归解码阶段逐 token 稳定生成。

Layer Normalization（LayerNorm）对每个样本（或每个 token）的特征维做归一化，不依赖 batch 统计量，因此更适合变长序列与自回归推理。对向量 \(x\in\mathbb{R}^{d}\)：

这里的均值 \(\mu\) 与方差 \(\sigma^2\) 都只在当前样本、当前 token 的特征维内部计算，因此每个 token 都能独立完成归一化。这个性质与 Transformer 的残差流（Residual Stream）非常匹配：无论 batch 如何变化、序列如何裁剪、推理时是否一次只输入一个 token，归一化规则都保持一致。

当前主流的 Transformer 归一化实践可以概括为两类。Encoder-only 与很多 Vision Transformer（ViT）架构通常沿用 LayerNorm；Decoder-only 大语言模型（Large Language Model, LLM）则大量采用 Pre-Norm 残差块，并进一步把 LayerNorm 简化为 RMSNorm。前者保留去均值与方差缩放，后者只保留尺度归一化，计算更轻，也更适合超大规模训练。

Early Stopping 用验证集指标监控训练过程，在泛化性能不再提升时提前停止，从而避免在训练集上继续拟合噪声。工程上常用“耐心（Patience）”：若验证集指标连续 \(K\) 次评估都未改善，则停止训练并回滚到最佳 checkpoint。它属于训练流程级的隐式正则化（Implicit Regularization）。

分类任务正则化（Regularization for Classification Tasks）直接作用在分类训练的监督方式、样本混合方式或概率分布形状上。它的主要目标包括：缓解过度自信、减轻类别不平衡造成的梯度偏置、降低标签噪声影响，以及让决策边界在训练样本之间保持更平滑的过渡。

Label Smoothing（标签平滑）把 one-hot 标签从“真实类为 1、其余类为 0”改写成更平滑的目标分布。对 \(C\) 分类问题，常见写法是：

这里 \(c\) 是真实类别， \(\varepsilon\in(0,1)\) 是平滑系数。真实类别仍占最大权重，但其他类别也会分到一小部分概率质量。训练因此不再持续奖励模型把正确类别概率推到 1、把其余类别压到 0，输出分布通常会更平滑，概率校准（Calibration）也更稳定。

在固定阈值或直接取 \(\arg\max\) 的分类系统里，Label Smoothing 带来的收益往往更多体现在 loss 曲线与概率可信度上，而不是直接转化为同等幅度的 F1 提升。若模型输出概率还会进入阈值调优、排序、融合、拒识或风险控制，这种校准改进的价值会更明显。

类别重加权（Class Reweighting）与重采样（Resampling）主要处理类别不平衡（Class Imbalance）。其核心思想是让少数类样本在训练中获得更大的有效权重，避免优化过程被大量易分类的多数类样本主导。加权交叉熵的常见形式为：

这里 \(\alpha_i\) 是第 \(i\) 类的损失权重。若某类样本极少，可以给它更大的 \(\alpha_i\)，使模型在误分该类时承担更高代价。重采样则直接改变 mini-batch 的类别组成，例如过采样少数类、欠采样多数类，或用类别均衡采样器（Class-balanced Sampler）保证 batch 内标签分布更均衡。

这类方法的直接效果，是让决策边界不再默认偏向多数类。代价则是：过强的重加权会放大少数类中的噪声标签，过强的过采样会提高过拟合风险。因此它通常要与验证集上的 Precision / Recall / F1 一起调节，而不只盯着训练损失。

Mixup 与 CutMix 通过构造“介于两个训练样本之间”的新样本，显式约束分类器在样本间插值区域上的行为，从而平滑决策边界。Mixup 的典型形式是：

这里 \(\lambda\in[0,1]\) 通常从 Beta 分布采样。输入和标签都被线性混合，于是模型被要求在 \(x_i\) 与 \(x_j\) 之间给出相应的插值预测。CutMix 则不是对整张输入做加权平均，而是把一张图像中的局部区域替换为另一张图像的对应区域，同时按被替换面积比例混合标签。

这类方法对图像分类尤其有效，因为它们直接惩罚“决策边界贴着训练样本走”的过拟合行为。换一个视角看，Mixup / CutMix 并不是简单的数据增强，而是在告诉模型：输入空间里两点之间的过渡区域也应当保持语义上的平滑可解释。

置信度惩罚（Confidence Penalty）和熵正则（Entropy Regularization）直接约束输出分布不要过早塌缩到极端尖锐形状。一个常见做法是在交叉熵之外，再加入预测分布熵的奖励项：

这里 \(\beta>0\) 控制正则强度。由于熵越大表示分布越平滑，这一项会抑制模型过快形成极端概率。它和 Label Smoothing 的方向相近，但切入点不同：Label Smoothing 改的是监督目标分布，置信度惩罚改的是模型预测分布本身。

两者都常用于需要更好概率校准的分类系统。相比之下，Focal Loss 更强调“把梯度预算留给困难样本”，因此它在类别不平衡或难例挖掘场景更常见；Label Smoothing 与熵正则则更偏向控制过度自信与改善概率形状。

回归任务正则化（Regularization for Regression Tasks）除了常见的参数惩罚外，还经常直接约束预测函数 \(f(x)\) 的形状。回归目标是连续值，因此“曲线是否足够平滑、是否满足单调关系、是否具有合理曲率”往往和任务正确性本身直接相关。

平滑性正则化（Smoothness Regularization）要求回归函数不要在输入空间里出现不必要的高频震荡。最典型的形式是惩罚导数，尤其是二阶导数：

第二项就是经典的样条平滑惩罚（Smoothing Spline Penalty）。它惩罚曲率过大，相当于抑制函数频繁弯折。 \(\lambda\) 越大，拟合曲线越平滑； \(\lambda\) 越小，模型越愿意追随样本中的局部波动。很多非参数回归（Nonparametric Regression）与时间序列平滑，本质上都在做这种“数据拟合 + 曲率惩罚”的权衡。

Total Variation（TV）正则与 Fused Lasso 适合分段平滑（Piecewise Smooth）的回归目标。它们不强求函数处处光滑，而是允许少数突变点存在，同时惩罚过多的相邻跳变。离散形式的 TV 惩罚常写成：

若同时对参数本身加 \(L_1\) 惩罚，再对相邻参数差分加 \(L_1\) 惩罚，就得到 Fused Lasso：

这类方法非常适合信号去噪、时序回归、基因拷贝数分段估计，以及任何“整体大致平稳、局部允许少数结构突变”的问题。与样条惩罚相比，它更偏好形成平坦区段，而不是全局光滑弯曲曲线。

很多回归任务天然带有单调先验：广告出价上升，曝光概率通常不应系统性下降；贷款风险特征上升，违约风险不应系统性降低；药物剂量增加，效应在一定区间内通常应单调增强。单调性约束（Monotonicity Constraint）把这种领域知识直接写进模型：

这里 \(x_k\) 是某个具有明确方向含义的特征。在线性模型里，这等价于约束对应权重非负或非正；在树模型和神经网络里，则可以通过结构限制、投影步骤或软惩罚项来实现。单调约束的价值不只在提高泛化，还在于提升可解释性与业务一致性。

当回归函数预期具有凸性（Convexity）、凹性（Concavity）或有限曲率时，可以继续对二阶导数施加方向性约束。例如一维凸函数满足：

这类约束在成本函数建模、供需曲线估计、剂量反应建模和某些经济学回归问题里非常常见。即使不要求严格凸性，也常通过曲率上界控制函数不要弯折过猛，例如惩罚 Hessian 范数或二阶差分幅度。它们的作用与平滑惩罚相近，但强调的是“弯曲方向和弯曲强度应满足领域结构”，而不只是单纯地压低高频波动。

Lipschitz 约束（Lipschitz Constraint）控制的是输入微小变化会把输出放大多少。若存在常数 \(K\)，使得

则函数变化速度受到统一上界控制。对可导函数，一个常见做法是直接惩罚输入梯度范数：

这种正则化常用于需要鲁棒输出的回归系统，例如物理量估计、坐标回归和噪声敏感的传感器建模。它抑制模型对局部输入扰动过度敏感，也能缓解高维回归中出现的不稳定尖峰。

概率回归（Probabilistic Regression）不仅预测均值，还会预测方差、分位数或整个条件分布。此时正则化对象不再只有均值函数，还包括分布参数之间的结构关系。例如异方差回归（Heteroscedastic Regression）中，方差参数必须保持正值；分位数回归（Quantile Regression）中，不同分位点曲线应尽量避免交叉（Quantile Crossing）。

若模型同时预测多个分位点 \(\hat q_{\tau_1}(x),\hat q_{\tau_2}(x)\) 且 \(\tau_1<\tau_2\)，则理想上应满足：

工程上常通过排序约束、投影修正或惩罚项来维持这种分布一致性。对高斯 NLL、混合密度网络（Mixture Density Network）或生存分析模型，也会对尺度参数、危险率函数或累积分布形状加入额外约束，使预测分布既拟合数据，又保持统计上可解释、数值上稳定。

深度学习（Deep Learning）是以多层神经网络为核心、通过大规模数据和梯度优化自动学习表示的建模范式。若上一章讨论的是神经网络的基本部件，例如线性层、激活函数、损失函数、反向传播、初始化与正则化；这一章讨论的则是这些部件在更深层、更大规模、更强归纳偏置下，如何组合成现代模型家族，并在视觉、语音、语言、生成和图结构任务上形成方法论分水岭。

“深度”并不只是层数更多。更关键的变化是：模型开始把原始输入逐层改写成越来越抽象的中间表示，从边缘、纹理、局部模式，逐步组合到部件、对象、语义关系与任务决策。于是，模型能力的来源不再只是最后那一层分类器，而是整条表示变换链本身。

下文的卷积神经网络（CNN）、循环神经网络（RNN）、生成模型（Generative Model）、图神经网络（GNN）和 ONNX，分别对应深度学习里几条非常重要的主线：空间局部归纳偏置、时序递推建模、生成式分布学习、关系数据表示学习，以及模型部署交换格式。它们共同构成了大模型出现之前深度学习的主要版图，也为 Transformer 与现代多模态模型奠定了方法学基础。

在传统机器学习流程里，特征工程和预测器常常是分开的：先由人手设计特征，再把这些特征交给线性模型、树模型或核方法完成分类与回归。深度学习把这两步合并进同一个可微计算图。前面的层负责把原始输入转写为更有判别力、更有结构感的表示，后面的层负责完成具体任务，所有参数围绕同一个目标函数联合优化。这就是端到端学习（End-to-End Learning）的核心含义。

表示学习（Representation Learning）之所以重要，是因为感知任务真正困难的部分，往往不在“最后怎么分一下类”，而在“怎样把原始信号变成对任务友好的坐标系”。图像像素、语音波形、文本序列和图结构都高度高维、局部相关且语义分散。深度网络的价值，在于它能用层级结构自动提取适合当前任务的中间表示，而不再完全依赖人工定义纹理统计量、边界特征、语言规则或图特征模板。

这也解释了为什么深度学习会改变整个方法栈。过去很多系统的主要工作量放在“特征怎么造”；深度学习之后，工作重心逐渐转向“架构如何设计、数据如何构造、训练如何稳定、预训练如何迁移、部署如何落地”。从研究到工业实践，核心竞争力开始沿着表示学习能力重新分布。

多层神经网络并不是 2010 年代才出现的新概念。真正的转折点在于，一系列条件在同一时期同时成熟，使深网络第一次具备了大规模可训练、可迁移、可复用的现实基础。深度学习成为里程碑，靠的不是单一公式突破，而是数据、算力、优化、架构和软件工程几条线一起闭环。

从方法史角度看，深度学习真正改变的是“模型从何处获得有用表示”。经典机器学习更多依赖人工抽取特征，再用较浅模型做判别；深度学习则把表示构造本身纳入训练。这个变化一旦与数据和算力结合，就会呈现出非常强的规模效应。

AlexNet 是现代深度学习史上的标志性节点。它的意义不只是 ImageNet 分类精度显著提升，而是证明了一个足够深、足够宽、用 GPU 训练、配合 ReLU 和数据增强的卷积网络，能够系统性压过人工特征加浅层分类器的旧路线。视觉领域由此从“设计特征”转向“训练特征”。

这次转折的后果极其深远。分类只是起点，检测、分割、检索、视频理解和视觉问答很快都转向以深层 backbone 为中心的范式。很多后续工作不再从零设计整套视觉特征，而是围绕预训练卷积网络做迁移、微调和多任务扩展。

ResNet 的历史意义在于，它解决了“网络更深但反而更难优化”的退化问题。残差连接（Residual Connection）为信息和梯度提供了一条更稳定的主通路，使模型不必在每一层都重写完整映射，而可以学习对当前表示的局部修正。深层网络由此从几十层推进到上百层乃至更复杂的堆叠结构。

残差思想后来超出了视觉本身。Transformer、扩散模型和大量现代深层架构都把残差连接当作标准部件，因为它本质上解决的是深网络训练稳定性，而不是某一个特定任务的技巧。残差网络因此不仅是一类 CNN 结构，更是现代深度学习的通用工程原则。

在序列任务上，深度学习的关键进展并不只来自更强的 RNN / LSTM / GRU，还来自编码器-解码器（Encoder-Decoder）和注意力（Attention）机制。Seq2Seq 让模型能够把输入序列映射为输出序列，最早大规模改变了机器翻译、语音识别和摘要生成等任务；注意力则突破了“所有信息都必须挤进一个固定长度向量”的瓶颈，使解码器可以在生成每一步时，动态读取输入序列中最相关的部分。

这条技术线的重要性在于，它把序列建模从“单纯递推记忆”推进到“按需访问上下文”。Transformer 正是在这条线上进一步把注意力从辅助机制推到主干架构，因此 Seq2Seq 与 Attention 构成了通往下一篇 Transformer 主线的直接前史。

深度学习早期最强的成果主要集中在识别任务，而 GAN 把研究重点大幅推进到“高质量生成”本身。它展示了深网络不仅能判断图像属于什么类别，还能学习数据分布并生成逼真的新样本。这使图像合成、风格迁移、超分辨率、图像到图像翻译等方向迅速发展，也改变了人们对“模型能力边界”的直觉。

GAN 之后，生成式建模继续沿着 VAE、流模型、扩散模型等路线演进。它们关注的问题已经不只是判别准确率，而是样本质量、潜空间结构、可控生成和条件生成。生成模型因此成为深度学习内部一条独立而强势的方法线，后文会单独展开。

深度学习的另一个方法学跃迁，是从“每个任务都从随机初始化开始学”转向“先学通用表示，再迁移到具体任务”。在视觉里，这条线最初体现为 ImageNet 预训练 backbone；在语音和语言里，则逐步发展为更大规模的自监督预训练。迁移学习显著降低了下游任务对标注数据量的依赖，也让模型参数本身成为可复用资产。

这一变化与大模型时代直接相连。大语言模型并不是凭空冒出来的新物种，而是深度学习在预训练、表示共享和规模扩展三条线上持续推进后的自然结果。因此，把深度学习理解成“大模型之前的旧阶段”并不准确；更准确的说法是，大模型建立在深度学习已经完成的方法论基础之上。

深度学习之所以成为主流，不是因为它在论文基准上偶尔领先，而是因为它在大量真实任务上持续改写了系统能力边界。它最擅长的场景，通常具备三个特征：输入高维、原始信号结构复杂、手工特征难以穷尽。只要这三个条件同时出现，表示学习的优势就会迅速放大。

人脸识别本身毫无疑问属于深度学习的典型落地方向，而 Face ID 这类系统则更接近“深度学习模型 + 传感器 + 活体检测 + 安全芯片 + 阈值策略”的产品级集成。深度网络负责学习人脸表征与匹配规则，但真正可商用的身份认证系统，还必须处理深度信息、环境光变化、攻击对抗、设备端隐私隔离和误识率控制等工程问题。这类例子很能说明：模型往往是核心能力来源，但完整系统从来不只是一张网络结构图。

卷积（Convolution）在连续形式下定义为函数重叠积分：

在离散二维图像中常写为：

深度学习框架里多数“卷积层”实现的是互相关（Cross-Correlation）而非严格翻转核的数学卷积，但工程上沿用“卷积”命名。卷积核（Kernel）共享权重（Weight Sharing），天然利用局部性（Locality）与平移等变（Translation Equivariance）。

直观上，卷积层做的事情是：对每个位置取一个局部窗口，把窗口里的像素与卷积核做加权求和，得到该位置的响应。不同卷积核学习不同的局部模式（边缘、纹理、角点等）。

一维互相关示例：输入 \(x=[0,0,1,1,1,0,0]\)，核 \(w=[1,0,-1]\)，则在从左到右滑动时，核会对“上升沿/下降沿”给出大幅响应（本质上是比较左右两侧的差异）。这就是经典的边缘检测直觉在离散信号上的对应。

卷积的“系统视角”能统一理解 CNN 与信号处理：把卷积核看作响应函数（Response Kernel），输出就是对历史输入的加权累积。参见“微积分 ➡ 卷积（Convolution）”中的因果卷积与“打点滴累积药效”直觉例子。

LeNet 可以看作现代卷积神经网络（Convolutional Neural Network, CNN）的原型。它面对的是手写数字识别这类“局部笔画决定整体类别”的任务，因此核心思想很直接：先用卷积层提取局部边缘、角点和笔画，再用池化（Pooling）降低分辨率与局部扰动敏感性，最后把高层特征送入全连接层做分类。

经典 LeNet-5 的结构可以概括为“卷积 - 池化 - 卷积 - 池化 - 全连接”。前面的卷积层负责把原始像素变成越来越抽象的特征图（Feature Map），后面的全连接层负责把这些局部特征整合成类别判断。它的重要性不只是“识别数字有效”，更在于证明了三件事可以协同工作：局部感受野（Local Receptive Field）、权重共享（Weight Sharing）和层级特征提取（Hierarchical Feature Learning）。

卷积层里的一个典型计算是：

这里 \(x\) 是输入图像或上一层特征图， \(W^{(k)}\) 是第 \(k\) 个卷积核， \(c\) 是输入通道索引， \((i,j)\) 是空间位置， \(y_{i,j}^{(k)}\) 是输出特征图在该位置上的响应。这个公式表达的就是：用同一个卷积核在整张图上滑动，寻找“哪里出现了我关心的局部模式”。

训练上，LeNet 已经体现出现代深度学习的基本闭环：前向传播得到类别 logits，损失函数衡量预测与真实标签的差距，反向传播把梯度传回卷积核和全连接层参数，再用梯度下降更新权重。它最典型的应用是 MNIST 手写数字识别，也常被用作理解 CNN 的第一块教学样板，因为结构短、计算图清晰、局部模式学习的直觉非常强。

AlexNet 标志着深度卷积网络在大规模视觉识别上的突破。它面对的不是手写数字这种相对简单的灰度图，而是 ImageNet 级别的彩色自然图像，因此核心思想从“能提特征”进一步推进到“更深、更宽、更可训练”：增加网络容量，用 ReLU（Rectified Linear Unit）加快优化，用 Dropout 缓解过拟合，用数据增强提升泛化，再借助 GPU 让大模型真正训得动。

其典型结构是多层卷积堆叠后接全连接层，早期卷积核较大、步幅较大，用于迅速降采样并提取低层纹理；中后期卷积核变小，重点转向更细粒度的组合特征。AlexNet 还使用了局部响应归一化（Local Response Normalization, LRN）这一今天较少使用、但在当时有历史意义的设计。整体上，它把 CNN 从“可用于小型任务的模型”推向了“可以在大规模视觉基准上碾压传统方法的通用架构”。

它最有代表性的非线性是 ReLU：

其中 \(z\) 是线性层或卷积层的输出。与 sigmoid / tanh 相比，ReLU 在正半轴不饱和，梯度传播更直接，因此深层网络更容易优化。AlexNet 的历史意义之一，就是把“激活函数的选择会显著影响深网络可训练性”这件事变成了工程共识。

训练上，AlexNet 典型地结合随机裁剪、翻转、颜色扰动等数据增强，并在全连接层使用 Dropout。它的直接应用是大规模图像分类；更深远的影响则是推动了整个视觉领域转向“预训练 CNN + 迁移学习”的工作流。很多后续检测、分割与检索系统，都曾把 AlexNet 当作特征提取骨干网络（Backbone）。

VGG 的核心思想是：用结构极其规整的小卷积核反复堆叠，把网络做深。它放弃了早期“大卷积核 + 大步幅”的粗放设计，转而几乎全程使用 \(3\times 3\) 卷积，通过增加层数来扩大感受野、提高非线性表达能力，并让整套架构在工程上更统一、更易复用。

VGG 的典型结构非常整齐：若干个 \(3\times 3\) 卷积层组成一个 stage，stage 之间通过池化层下采样，最后再接全连接分类头。它的重要工程思想是“深度本身就是能力来源之一”。相较于更杂糅的早期网络，VGG 的层次感非常强：浅层提边缘和纹理，中层提局部部件，高层提更完整的语义结构。

为什么反复使用 \(3\times 3\) 卷积有效，可以从感受野和参数量两方面理解。两个连续的 \(3\times 3\) 卷积，其有效感受野接近一个 \(5\times 5\) 卷积，但中间多了一次非线性变换，参数量通常还更少。若忽略通道数变化，单层 \(5\times 5\) 卷积大约有 25 个核参数，而两层 \(3\times 3\) 卷积一共是 18 个核参数。

训练上，VGG 比 AlexNet 更依赖较好的初始化、较强的正则化和更大的算力预算，因为它的参数量尤其在全连接部分非常大。它的直接应用是图像分类，但工程上更著名的是作为“通用视觉特征提取器”：在风格迁移、感知损失（Perceptual Loss）、检测与分割早期系统中，VGG 特征长期是强基线。它的代价也很明显：参数多、推理重、显存占用高，这直接推动了后续更高效架构的出现。

ResNet（Residual Network）的关键突破不是再把卷积堆得更深，而是重新设计“深层网络应该学什么”。它提出残差学习（Residual Learning）：一层或一组层不必直接学习完整映射 \(H(x)\)，而是学习相对于输入的增量 \(F(x)=H(x)-x\)。这样网络输出就写成：

这里 \(x\) 是块输入， \(F(x)\) 是若干卷积层、归一化和激活组成的残差分支输出， \(y\) 是该残差块的最终输出。若最优映射本身就接近恒等映射（Identity Mapping），那么让网络学习“只改一点点”通常比“从零重建整个映射”更容易优化。

具象地看，普通深网络像要求每一层都重新写一遍完整答案；ResNet 则允许每一层在原答案旁边写批注：需要修改的地方补上增量，不需要改的地方直接走捷径。这个“捷径连接（Skip Connection）”让梯度能沿更短路径传播，因此网络深到几十层、上百层时仍可训练。ResNet 解决的核心不是表达能力不足，而是深层优化退化（Degradation）问题：层数增加后，训练误差反而上升。

训练上，ResNet 通常结合 BatchNorm、较深的 stage 结构和全局平均池化（Global Average Pooling）来替代庞大的全连接头。它在图像分类上大获成功后，很快成为检测、分割、关键点、视频理解等视觉任务的主流骨干网络。更深远的影响是：残差连接后来成为 Transformer、扩散模型和许多现代深网络的标准部件，因为它本质上是在为深层优化建立稳定的信息主通路。

循环神经网络（Recurrent Neural Network, RNN）按时间步（Time Step）处理序列。第 \(t\) 个时刻输入是 \(x_t\)，隐藏状态（Hidden State）递推为：

\(W_{xh}\)（输入到隐层）与 \(W_{hh}\)（隐层到隐层）在所有时刻共享，这是 RNN 能在变长序列上泛化的关键。

把它展开（Unroll）到时间轴上会更直观：同一套参数在每个时间步重复使用，形成一个深度为 \(T\) 的计算图。这也是 RNN 训练常说的“通过时间的反向传播（Backpropagation Through Time, BPTT）”。

RNN 的经典难点是梯度消失/爆炸（Vanishing/Exploding Gradients）：反向传播时会反复乘以 \(W_{hh}\) 的雅可比，从而导致梯度范数指数级衰减或增长。LSTM/GRU 通过门控（Gating）与更“线性”的记忆通道缓解这一问题。

Seq2Seq（Sequence-to-Sequence）是任务范式，不限定具体单元。早期 Seq2Seq 常由 RNN/LSTM/GRU 的编码器-解码器（Encoder-Decoder）实现；后续被 Transformer 大规模替代。

“乘法 + 加法 + 非线性”为何有效：线性变换负责特征重表达，非线性激活（Nonlinearity）提供函数逼近能力，时间递推提供记忆路径，三者叠加形成高表达力。

LSTM（Long Short-Term Memory）是为了解决普通 RNN 难以稳定保留长程信息的问题而设计的门控循环结构。它的核心思想不是简单把隐藏状态不断往前传，而是显式维护一个记忆单元（Cell State） \(c_t\)，并用门控决定“忘掉什么、写入什么、读出什么”。这使得序列中的关键信息可以沿着一条更接近线性的通道向后传播，而不必在每个时间步都被强非线性反复改写。

LSTM 的典型更新写成：

其中 \(x_t\) 是当前输入， \(h_{t-1}\) 是前一时刻隐藏状态， \(c_{t-1}\) 是前一时刻记忆单元； \(f_t\) 是遗忘门（Forget Gate），控制旧记忆保留多少； \(i_t\) 是输入门（Input Gate），控制当前候选记忆 \(\tilde c_t\) 写入多少； \(o_t\) 是输出门（Output Gate），控制当前记忆暴露给隐藏状态多少； \(\sigma\) 是 sigmoid，把门值压到 \((0,1)\) 区间； \(\odot\) 是逐元素乘法。

具象地看，LSTM 像一条带阀门的记忆水管。普通 RNN 每走一步都把旧信息和新输入一锅重拌，长距离信息容易被冲淡；LSTM 则允许旧记忆沿主管道直接往后流，同时用三个阀门分别控制“放掉旧水”“注入新水”“输出多少”。这正是它能比普通 RNN 更稳定地记住长距离依赖的原因。

训练上，LSTM 仍然通过时间反向传播（BPTT）学习参数，但门控结构显著改善了梯度流。它曾长期是机器翻译、语音识别、语言建模、时间序列预测和序列标注的主力模型。在 Transformer 出现之前，大量 Seq2Seq 系统都建立在双向 LSTM 或多层 LSTM 之上；在某些中小规模时序任务里，LSTM 今天仍然是强而稳的基线。

GRU（Gated Recurrent Unit）可以看作 LSTM 的简化版本。它保留了“用门控控制信息保留与更新”的核心思想，但把记忆单元与隐藏状态合并，不再单独维护 \(c_t\)，从而用更少参数换取更紧凑的结构与更快的训练速度。

GRU 的一组典型公式是：

这里 \(z_t\) 是更新门（Update Gate），决定旧状态保留多少、新候选状态写入多少； \(r_t\) 是重置门（Reset Gate），决定在构造候选状态 \(\tilde h_t\) 时，历史信息应当被参考到什么程度。若 \(z_t\) 很小，模型更倾向保留旧记忆；若很大，模型更倾向用新信息刷新状态。

从直觉上看，GRU 把 LSTM 的三道阀门压缩成两道更紧凑的控制逻辑：一方面决定“要不要更新”，另一方面决定“生成候选更新时要不要忘掉旧状态的一部分”。这让它在很多任务上能以更少参数达到与 LSTM 相近的效果，尤其适合数据量不极大、模型容量受限或推理效率敏感的场景。

训练上，GRU 与 LSTM 一样使用 BPTT。应用上，它常见于语音、时序预测、较轻量的编码器-解码器模型，以及很多工业界的表格时间序列任务。若需要更强的显式记忆控制，LSTM 往往更稳；若更看重结构简洁和训练效率，GRU 常是更自然的选择。

生成模型（Generative Model）关注的核心问题不是“这个样本属于哪一类”，而是“数据本身是如何产生出来的”。更形式化地说，它试图学习数据分布 \(p(x)\)，或条件分布 \(p(x|c)\)，从而能够采样、重建、补全、去噪或按条件生成新样本。不同生成模型的主要差别在于它们选择了不同的概率建模路径：有的学隐变量，有的学博弈过程，有的学逐步去噪，有的更偏重表示压缩。

自编码器（Autoencoder, AE）的核心思想是“先压缩，再重建”。它把输入 \(x\) 通过编码器（Encoder）映射到低维或受约束的隐表示（Latent Representation） \(z\)，再通过解码器（Decoder）把 \(z\) 重建回 \(\hat x\)。如果模型在受限瓶颈下仍能较好重建输入，就说明 \(z\) 抓住了数据中的关键结构。

其基本形式可以写成：

这里 \(f_{\theta}\) 是编码器， \(g_{\phi}\) 是解码器， \(z\) 是瓶颈表示， \(\hat x\) 是重建结果。若输入是连续值，常用均方误差；若输入近似二值或归一化到概率意义，常用逐维交叉熵。这个目标迫使模型学习“怎样用更紧凑的表示保存足够重建原样本的信息”。

自编码器本身并不天然是强生成模型，因为它主要学会的是“给定输入怎么重建自己”，而不是如何从一个规则、可采样的潜空间中稳定地产生新样本。它更适合理解为表示学习或降维模型。通过在结构或训练目标上增加限制，例如稀疏自编码器（Sparse AE）、去噪自编码器（Denoising AE）或收缩自编码器（Contractive AE），它可以学到更稳健的隐表示。

应用上，AE 常用于降维、异常检测、去噪、预训练和表征学习。例如在工业异常检测里，模型只用正常样本训练，推理时若某个输入无法被良好重建，重建误差就可能提示该样本偏离了正常分布。

变分自编码器（Variational Autoencoder, VAE）是在 AE 基础上把“隐空间可采样”这件事做成概率建模的方案。它不再把编码器输出一个确定的潜向量，而是输出一个潜变量分布 \(q_{\phi}(z|x)\)；同时假设存在生成分布 \(p_{\theta}(x|z)\)。这样，模型既能重建输入，又能从一个规则的潜空间里采样新样本。

VAE 的核心训练目标是证据下界（Evidence Lower Bound, ELBO）：

其中第一项是重建项，鼓励给定 \(z\) 时能把 \(x\) 生成回来；第二项是 KL 散度（Kullback-Leibler Divergence），把编码器输出的后验近似分布 \(q_{\phi}(z|x)\) 拉向先验分布 \(p(z)\)，通常取标准高斯 \(\mathcal{N}(0,I)\)。这一步的作用是把隐空间整理成“规则、连续、可插值、可采样”的形状。

训练上的关键技巧是重参数化（Reparameterization Trick）：若直接从 \(q_{\phi}(z|x)\) 采样，梯度难以回传；VAE 通常把采样写成 \(z=\mu+\sigma\odot \epsilon\)，其中 \(\epsilon\sim\mathcal{N}(0,I)\)，而 \(\mu,\sigma\) 由编码器输出。这样随机性被转移到与参数无关的 \(\epsilon\) 上，梯度就能顺利穿过 \(\mu,\sigma\) 回传。

应用上，VAE 特别适合做潜空间操作，例如插值生成、属性控制、缺失补全和概率建模。与 GAN 相比，VAE 生成结果往往更平滑、更稳定，但图像清晰度常较弱；与扩散模型相比，VAE 在采样效率上更高，但生成质量上通常不是最强路线。

生成对抗网络（Generative Adversarial Network, GAN）的核心思想是对抗式学习：让生成器（Generator）负责“伪造样本”，让判别器（Discriminator）负责“分辨真假”，两者在博弈中共同提高。生成器学会把随机噪声变成越来越像真实数据的样本，判别器则学会识别这些样本是否来自真实分布。

经典 GAN 的目标写成：

这里 \(z\) 是从先验分布中采样的随机噪声， \(G(z)\) 是生成器产生的假样本， \(D(x)\) 输出输入样本为真样本的概率。判别器希望让真实样本分数高、伪样本分数低；生成器则希望骗过判别器，让 \(G(z)\) 看起来足够真实。

具象地看，GAN 像“伪造者”和“鉴定师”的对抗升级。鉴定师越强，伪造者就被迫学会更精细的伪造技巧；伪造者越强，鉴定师也必须学会更细致的辨别规则。理论上，这种动态会把生成分布推向真实数据分布；工程上，它带来的最大问题是训练不稳定，常见现象包括模式崩塌（Mode Collapse）、震荡和判别器过强导致生成器梯度过弱。

GAN 在图像生成、图像翻译、超分辨率和风格迁移里曾经极其成功，因为它特别善于生成锐利、感知上真实的图像纹理。但它对训练技巧依赖很强，后来在大规模高保真图像生成上逐渐被扩散模型压过；即便如此，GAN 在需要低步数快速生成或特定视觉变换任务中仍然很有生命力。

扩散模型（Diffusion Model）的核心思想是：把“直接学会生成复杂数据”拆成“先逐步加噪，再逐步去噪”这条更稳定的路径。前向过程把真实样本一步步污染成近似高斯噪声，反向过程则训练一个神经网络学会在每一步去掉一小部分噪声。最终从纯噪声出发，经过多步反向去噪，就能逐步生成结构清晰的样本。

记号上，前向扩散链从真实样本 \(x_0\) 出发，依次得到 \(x_1,x_2,\dots,x_T\)。因此 \(x_0\) 表示原始数据样本， \(x_t\) 表示第 \(t\) 步加噪后的样本。

一个常见的前向加噪过程写成：

这里 \(\beta_t\) 是第 \(t\) 步的噪声强度：它控制从 \(x_{t-1}\) 走到 \(x_t\) 时，原信号衰减多少、随机噪声注入多少。训练时常把从 \(x_0\) 到 \(x_t\) 的若干步合并写成

这里 \(\bar\alpha_t\) 是由噪声日程（Noise Schedule）累乘得到的系数，控制到第 \(t\) 步时，原始信号保留了多少、噪声混入了多少。实际训练中，网络通常不直接预测 \(x_0\)，而是预测噪声 \(\epsilon\)，典型损失是：

这条路径之所以有效，在于“预测一步噪声”比“直接一次生成整张复杂图片”更容易优化。训练上，扩散模型相对稳定，较少出现 GAN 那种对抗不平衡；代价是采样通常需要多步迭代，推理速度较慢。应用上，扩散模型已经成为图像生成、文生图、图像编辑、超分辨率、视频生成和分子设计的重要主线。Stable Diffusion 一类系统，本质上就是把扩散过程放到了潜空间（Latent Space）里执行，以降低像素空间扩散的计算成本。

图神经网络（Graph Neural Network, GNN）处理的对象不是规则网格上的序列或图像，而是由节点（Node）和边（Edge）组成的图（Graph）。它的核心问题是：当样本之间存在不规则连接关系时，如何让一个节点的表示同时反映“自己的特征”和“邻居结构中的上下文”。因此，GNN 的基本直觉不是滑动卷积核，也不是按时间递推，而是让节点在图上传递消息、聚合邻居信息，再更新自身表示。

图卷积网络（Graph Convolutional Network, GCN）把卷积思想推广到图结构上。它的核心思想是：一个节点的新表示，不应只由自己决定，还应由其邻居节点的表示共同决定；但这种聚合不能简单相加，而需要根据图结构做适当归一化，否则高度节点会在信息聚合中占据过大权重。

GCN 的经典一层更新公式写成：

其中 \(H^{(l)}\) 是第 \(l\) 层所有节点的表示矩阵； \(W^{(l)}\) 是该层可学习权重； \(\tilde A=A+I\) 表示在原邻接矩阵 \(A\) 上加自环（Self-loop），让节点保留自己的信息； \(\tilde D\) 是 \(\tilde A\) 的度矩阵（Degree Matrix）； \(\sigma\) 是非线性激活。中间那项对邻居求和并按度做归一化，本质上是在做“平滑的邻居平均”。

具象地看，GCN 像在社交网络里更新一个人的画像：不仅看这个人自己填写的特征，还参考他一跳邻居的大致特征，再做归一化，避免“朋友特别多的人”把自己的表示稀释得过于严重。多层堆叠后，一个节点就能间接接触到两跳、三跳甚至更远范围的信息。

训练上，GCN 常用于节点分类、图分类和链路预测。它的经典应用包括引文网络分类、分子图预测和推荐系统图表示学习。局限也很典型：层数太深时，节点表示会越来越相似，出现过平滑（Oversmoothing）；大图上直接用全图邻接矩阵训练也会带来显存与计算压力。

图注意力网络（Graph Attention Network, GAT）在 GCN 的“统一归一化邻居平均”之上进一步提出：不同邻居的重要性不应被预先固定，而应由模型动态学习。它的核心思想是把注意力机制引入图结构，使每个节点在聚合邻居时，能够自适应决定“更该听谁的话”。

一层 GAT 的典型计算是：

这里 \(h_i\) 是节点 \(i\) 的输入表示， \(W\) 是线性变换矩阵， \(a(\cdot,\cdot)\) 是注意力打分函数， \(e_{ij}\) 是节点 \(j\) 对节点 \(i\) 的未归一化重要性分数， \(\alpha_{ij}\) 是在邻居集合 \(\mathcal{N}(i)\) 内 softmax 归一化后的注意力权重。

与 GCN 相比，GAT 的关键收益是更灵活：若某个邻居特别重要，模型可以给它更高权重；若某个邻居噪声较大，则可自动抑制。训练上，GAT 仍通过监督或自监督目标学习节点表示，常用多头注意力（Multi-head Attention）稳定训练。应用上，它常见于异质关系更复杂、邻居重要性差异显著的图任务，例如社交网络分析、知识图谱局部推断和分子性质预测。

GraphSAGE（Graph Sample and Aggregate）的核心思想是把 GNN 从“转导式（Transductive）图编码”推进到“归纳式（Inductive）图表示学习”。传统 GCN 常依赖整张训练图；GraphSAGE 则强调：即使测试时出现训练中未见过的新节点，只要能拿到它的邻居特征，也应能在线生成它的表示。

其典型更新形式是先采样邻居，再做聚合：

这里 \(h_v^{(k)}\) 是节点 \(v\) 在第 \(k\) 层的表示， \(\mathcal{N}(v)\) 是其邻居集合， \(\mathrm{AGG}\) 可以是均值、池化或 LSTM 聚合器， \([\cdot\|\cdot]\) 表示向量拼接。GraphSAGE 的关键工程点是“采样”，因为超大图中不可能每次把全部邻居完整展开。

具象地看，GraphSAGE 像为每个节点建立一套“从邻居摘要中构造自我画像”的规则。它不要求记住整张训练图中每个节点的专属嵌入，而是学会一套可迁移的邻域聚合函数。这正是它能处理新节点、动态图和大规模图数据的原因。

应用上，GraphSAGE 在推荐系统、社交网络、风控图谱和工业知识图谱中非常常见，因为这些场景经常不断出现新节点、新边，归纳式能力比单纯在固定图上做转导预测更重要。

消息传递（Message Passing）不是某一个具体模型，而是理解 GNN 的统一抽象框架。无论是 GCN、GAT 还是 GraphSAGE，本质上都可以拆成两步：第一步，节点从邻居那里接收消息；第二步，把这些消息与自己的旧表示结合，更新成新的节点表示。

这一抽象常写成：

其中 \(h_v^{(l)}\) 是节点 \(v\) 在第 \(l\) 层的表示， \(e_{uv}\) 是边特征， \(M^{(l)}\) 是消息函数，决定一条边上传递什么信息； \(\mathrm{AGG}\) 是聚合函数，如求和、均值、最大值或注意力加权和； \(U^{(l)}\) 是更新函数，把旧表示与聚合后的消息合成为新表示。

这个框架的重要性在于，它把看似不同的图模型放进了一套统一语言里：GCN 相当于使用归一化线性消息与均值式聚合，GAT 相当于把注意力权重写进聚合，GraphSAGE 相当于强调采样与归纳式聚合。理解了消息传递，就能把很多图模型看成“消息函数、聚合函数、更新函数”三处设计选择的不同组合。

训练上，消息传递式 GNN 常用于三类任务：节点级任务（例如节点分类）、边级任务（例如链路预测）、图级任务（例如分子性质预测）。它们的共同难点包括：过平滑、邻居爆炸（Neighborhood Explosion）、异质图关系复杂，以及深层堆叠后长程依赖难以稳定传播。很多现代 GNN 改进，本质上都在围绕这几个瓶颈重新设计消息传递规则。

ONNX（Open Neural Network Exchange，开放神经网络交换格式）是一种描述机器学习模型的开放标准。它的核心作用，不是训练模型，而是把已经定义并训练好的神经网络表示成一种可交换、可部署、跨框架可读的中间格式，使模型能够从训练环境转移到不同推理环境中运行。

训练阶段常用 PyTorch、TensorFlow、JAX 等框架；部署阶段则常落到 ONNX Runtime、TensorRT、OpenVINO、移动端推理引擎或嵌入式执行环境。问题在于，这些系统各自拥有不同的内部表示方式、图执行器和算子实现，原生模型格式并不天然互通。ONNX 解决的正是这条链路中的“中间表示”问题。

可以把 ONNX 理解为模型世界里的 PDF：训练框架先把网络导出为

.onnx

从结构上看，ONNX 文件本质上是一份静态计算图（Static Computation Graph）加权重参数的描述。其中通常包含四类核心信息：

• 计算图：模型由哪些算子组成，例如卷积（Conv）、矩阵乘法（MatMul）、归一化、激活、注意力等。
• 张量元信息：输入、输出与中间张量的形状（Shape）和数据类型（Data Type）。
• 参数权重：训练后得到的权重矩阵、偏置和其他可学习参数；大模型也可能采用外部权重文件。
• 算子版本信息：模型依赖的 ONNX opset 版本，以及每个算子的语义约定。

这种表示方式的关键价值，是把“Python 前向代码如何写”转写成“部署时应该执行哪条算子图”。一旦导出完成，部署系统通常不再依赖训练时的 Python 类定义，而是按 ONNX 图里的算子与依赖关系直接执行。

在 PyTorch 生态里，ONNX 最常见的入口是导出。开发者通常先在 PyTorch 中定义并训练模型，再用

torch.onnx.export(...)

导出之后，部署侧执行的已不再是原始 Python 前向代码，而是 ONNX 图中的算子序列。因此，依赖复杂动态控制流、框架私有算子或运行时分支逻辑的模型，在导出时往往需要额外改写、简化或替换成更可静态化的结构。

ONNX 的价值很大，但它并不是“只要导出就一定能无缝部署”的万能格式。第一，并非所有训练框架中的算子都存在完美的 ONNX 映射，复杂模型可能导出失败，或需要改写成等价但更标准的图结构。第二，不同推理引擎对 ONNX 的支持程度并不完全一致：即使同样读取 ONNX 文件，也可能只支持某些 opset 版本或某一部分算子子集。第三，ONNX 更适合表达相对稳定的前向计算图；当模型强依赖高度动态的运行逻辑时，静态导出路径会更受约束。

因此，ONNX 更准确的定位不是“另一种训练框架”，而是训练环境与部署环境之间的中间表示层。它的意义在于把模型从原始框架内部释放出来，交给更适合推理、优化和跨平台执行的后端系统。

The post 人工智能理论知识 - Transformers和大模型 appeared first on 绿色记忆.

这一篇从常用算法进入机器学习基础概念、经典机器学习与神经网络，重点讨论“模型如何被构造、训练、评估与正则化”。前一篇给出了数学语言，这一篇开始进入真正的建模问题：数据怎样表示，损失怎样定义，优化怎样推进，不同模型家族各自擅长什么；再往后才会过渡到 Transformer 与大语言模型。