小熊的网站

LLM Agent 智能体底层原理

Sun, 16 Aug 2026 00:00:00 GMT

什么是 Agent#

LLM 本身只是一个”只会说话的模型”：你问它”帮我订个机票”，它只能回你一段话，不能真的去订。

Agent（智能体） = 大模型（大脑）+ 工具（手脚）+ 记忆（经验）+ 规划（策略）。

Agent 架构：大脑 + 工具 + 记忆 + 规划

它让大模型从”回答问题”升级为”完成任务”：自主决定下一步做什么、调用什么工具、根据结果调整计划，直到目标达成。

Agent 的核心四要素#

要素	作用	举例
大脑（LLM）	理解、推理、决策	GPT、Llama、Qwen
工具（Tools）	与外部世界交互	搜索、计算器、代码执行、API
记忆（Memory）	保存上下文与经验	对话历史、向量库、长期记忆
规划（Planning）	拆解任务、制定步骤	ReAct、CoT、Plan-and-Execute

一、工具调用（Function Calling / Tool Use）#

原理#

工具调用本质上还是文本生成，只不过模型输出的是结构化调用指令：

开发者把工具的描述（名称、参数、用途）以 JSON Schema 形式告诉模型（在 System Prompt 里）
模型判断”当前需要调用某个工具”，输出一个特殊的 JSON：
```
1
{
2
  "name": "get_weather",
3
  "arguments": {"city": "北京"}
4
}
```
应用层解析这个 JSON，执行真实函数，把结果作为一条新的消息回传给模型
模型基于工具返回结果继续推理，直至给出最终答案

工具描述的 Prompt 长什么样#

1
可用工具：
2
- search(query: string): 联网搜索，参数为查询关键词
3
- calculate(expr: string): 计算数学表达式
4
- get_weather(city: string): 查询城市天气
5

6
当需要调用工具时，只输出 JSON：{"name": "...", "arguments": {...}}

工具描述的质量直接影响调用成功率：描述要准确、参数要精简、说明要覆盖边界情况。

工具调用的关键工程点#

并行调用：模型一次可调用多个工具（现代 API 支持 tool_calls 数组）
失败重试：工具执行出错时，把错误信息回传给模型让它纠错
安全校验：工具是真实代码，必须做权限控制（不能把”删除数据库”暴露给任意 Agent）

二、ReAct 范式（推理 + 行动）#

ReAct（Reasoning + Acting）是 Agent 最经典的工作范式，由论文 ReAct: Synergizing Reasoning and Acting in Language Models（2022）提出。

核心思想：让模型交替输出思考（Thought）→ 行动（Action）→ 观察（Observation）：

1
Thought: 用户想知道北京天气，我需要查天气
2
Action: get_weather("北京")
3
Observation: 晴，26°C
4
Thought: 天气查询完成，可以回答用户了
5
Final Answer: 北京今天晴，气温 26°C

为什么 ReAct 有效#

思考让模型推理当前状态，决定下一步
行动让模型实际调用工具
观察把真实世界的结果反馈给模型，纠正推理偏差

思考-行动-观察循环可以执行多轮，模型可以自我纠错：如果第一次搜索没结果，它会换个关键词再搜。

实现方式#

在 API 时代，ReAct 循环由应用代码驱动：

1
while not finished:
2
    1. 把当前消息历史发给 LLM
3
    2. LLM 返回：要么是最终答案，要么是工具调用
4
    3. 若是工具调用：执行工具，把结果追加进消息历史
5
    4. 回到 1

模型本身不”运行循环”，循环是应用层的 while 循环，模型只是每轮输出”下一步干什么”。

三、规划（Planning）#

复杂任务需要拆解。常见规划策略：

1. CoT（思维链）#

让模型”一步步思考”再回答，本质是让模型在输出最终答案前先生成中间推理步骤。简单但有效。

2. Plan-and-Execute#

先让模型制定完整计划（步骤列表），再逐条执行，执行完一个步骤后可以修订后续计划：

1
Plan:
2
1. 搜索"AI Agent"定义
3
2. 整理核心概念
4
3. 生成大纲
5
4. 撰写文章

好处：计划先行，减少长任务中的”走一步看一步”带来的发散。

3. Tree of Thoughts（思维树）#

每步探索多个候选思路，像搜索树一样评估分支。效果好但开销大，主要用于难题推理。

4. Multi-Agent（多智能体协作）#

多个 Agent 分工协作：规划者拆任务、执行者干活、评审者把关。典型框架如 AutoGen、CrewAI。协作的关键是消息协议——Agent 之间通过结构化消息传递任务与结果。

四、记忆系统（Memory）#

短期记忆 vs 长期记忆#

短期记忆：当前对话的上下文（直接放在 Prompt 里），受上下文窗口限制
长期记忆：跨会话保存的信息（用户偏好、历史结论、知识片段）

长期记忆的实现#

长期记忆的存储载体通常是向量数据库：

把重要信息（总结、事实、用户偏好）Embedding 后存入向量库
新对话开始时，检索与该用户相关的记忆片段
把检索到的记忆拼进 Prompt

这就是 RAG 技术在 Agent 记忆上的应用。更进一步的记忆管理：

记忆压缩：对话太长时让模型总结旧内容，替换掉原始消息
记忆遗忘：过时的记忆要能淘汰，否则会污染判断
分层记忆：工作记忆（当前任务）、情景记忆（最近经历）、语义记忆（长期知识）

五、Agent 的完整执行循环#

一个典型的单 Agent 系统运行时：

1
1. 接收用户目标
2
2. 读取相关记忆（检索向量库）
3
3. 循环：
4
   a. LLM 推理 → 决定行动
5
   b. 行动 = 工具调用 / 子任务 / 直接回答
6
   c. 工具结果写回上下文
7
   d. 判断是否完成
8
4. 输出结果，更新记忆

六、Agent 框架做了什么#

主流框架（LangChain、LangGraph、LlamaIndex、Dify、Coze）本质上提供了：

工具调用的统一抽象与解析
ReAct 循环的状态机（LangGraph 的图编排）
记忆/向量库的接入封装
多 Agent 的消息路由
Prompt 模板管理

框架解决的是工程复杂度，核心智能仍然来自模型本身。

七、Agent 的局限与风险#

幻觉累积：多轮推理中错误可能被放大
工具误用：模型可能调用错误工具或错误参数
长任务漂移：步骤越多越容易偏离原始目标
安全风险：Agent 能执行真实操作，越权、数据泄露是真实威胁
成本：每轮循环都是模型推理，多轮任务成本线性增长

工程上通过人类确认节点（关键操作需审批）、超时与步数上限、输出校验来兜底。

小结#

Agent 的本质公式：

1
Agent = LLM（推理决策） + Tools（行动能力） + Memory（经验） + Planning（策略）

理解 ReAct 循环、工具调用协议、记忆检索这三件事，你就掌握了 Agent 的底层骨架。再往上，所有的 Agent 框架和产品形态（编程助手、客服机器人、自动化工作流）都是在这个骨架上生长出来的。

知识库与 Embedding 底层原理

Sun, 16 Aug 2026 00:00:00 GMT

知识库解决什么问题#

企业里最常见的诉求：把公司的文档、手册、制度变成”能对话的 AI 问答系统”。

一条朴素的路线是微调：拿文档去继续训练模型。但微调成本高、周期长、知识更新就要重训，实际工程中 90% 的场景都不需要微调——用知识库 + RAG 就够了。

知识库系统 = 文档处理管线 + Embedding + 向量数据库 + 检索。这篇深入讲它最底层的两个引擎：Embedding 和向量检索。

一、Embedding 的底层原理#

从 one-hot 到稠密向量#

最早表示词的方法是 one-hot：每个词一个维度，向量长度为词表大小 V。问题很明显：

维度爆炸（V 可能几十万）
向量之间全是正交的，“猫”和”狗”没有任何相似度信息

Embedding 的做法是把词/句映射到低维稠密向量（几百到几千维），且语义相近的向量距离近。这背后的核心是**分布式表示（Distributed Representation）**思想：一个词的含义由它周围的词共同决定（“You shall know a word by the company it keeps”——Firth, 1957）。

上下文相关 vs 上下文无关#

类型	代表	特点
上下文无关（静态）	Word2Vec、GloVe	一个词只有一个向量，“苹果”（水果/公司）无法区分
上下文相关（动态）	BERT、BGE、text2vec	同一个词在不同句子里向量不同，能区分多义词

现代知识库用的都是上下文相关的 Embedding：把整段文本（句子/段落）过一遍 Transformer 编码器，取输出的池化结果作为该文本的向量。

Embedding 是怎么训练出来的：对比学习#

训练目标非常直观：让语义相近的文本对向量靠近，语义无关的文本对向量远离。

构造训练样本：

正样本：问题-答案、原文-改写、标题-正文（语义相同）
负样本：随机配对（语义无关）

损失函数（InfoNCE）：

1
L = -log( e^(sim(q, pos)/τ) / Σ e^(sim(q, neg_i)/τ) )

sim 是余弦相似度
τ 是温度参数，控制分布的尖锐程度
分子拉近正样本，分母推远所有负样本

训练完成后，模型输出的向量就具有了”语义距离”性质——这正是检索的基础。

Embedding 的关键细节#

归一化：使用前对向量做 L2 归一化，这样余弦相似度 = 内积，检索实现更简单
同模型原则：入库和查询必须用同一个 Embedding 模型，否则向量空间不一致
维度选择：768/1024/1536 是常见选择；维度高精度好但存储大、检索慢
中文适配：中文分词与英文不同，务必选中文语料训练过的模型（BGE 系列、m3e、text2vec）

二、向量相似度计算#

三种度量#

余弦相似度：cos(θ) = (q·d) / (|q||d|)，只关心方向，最常用
内积：归一化后与余弦等价，实现最快
欧氏距离：越小越相似，适合绝对距离有意义的场景

为什么余弦相似度就够了#

向量检索不关心”向量多长”，只关心”方向是否一致”——语义相关性本质是方向上的接近。所以归一化 + 内积是工业界标准实现。

三、向量检索：从暴力到 ANN#

暴力检索#

数据量小时（万级以内），直接遍历计算所有相似度取 top-k。简单准确，但数据量大了以后每次查询都要扫全库，完全不可用。

ANN（近似最近邻）的三大流派#

百万级以上必须用索引加速，核心思想是牺牲一点精度换速度：

算法	原理	特点
HNSW	构建分层图，先粗粒度跳到大致区域再精细搜索	召回率高、速度快，内存占用大；最主流
IVF	先对全库聚类（K-Means），查询时只在最近的几个簇里搜	内存友好，配合 PQ 可大规模部署
PQ	把向量切块量化压缩，用查表代替距离计算	极致省内存，精度有损

HNSW 为什么快#

HNSW 的思想是”六度分隔”：构建多层图，上层图连接稀疏（跳得远），下层图连接密集（走得近）。查询时从顶层开始，逐层向下贪心搜索，很快就能收敛到目标附近。复杂度接近 O(log n)。

向量数据库产品#

Milvus / Zilliz：分布式、云原生，百万级起步
Qdrant / Weaviate：Rust/Go 实现，性能好
Chroma：轻量，适合原型
pgvector：PostgreSQL 插件，和现有业务库同栈，中小项目首选
Elasticsearch：自带 kNN 检索，与全文检索一体

选型的核心指标：数据量、查询 QPS、内存预算、是否需要混合检索、是否已有存储栈。

四、混合检索：为什么纯向量不够#

向量检索擅长”语义相关”，但对精确匹配不敏感：

用户搜”型号 A100”——向量可能匹配到”A100 和 H100 的对比”，但用户要的是 A100 的规格页
搜错误代码 “ERR_503”——语义向量毫无办法，关键词匹配秒杀

**BM25（关键词检索）**恰好擅长这个：基于词频-逆文档频率打分，精确命中权重高。

工业级方案 = 向量检索 + BM25 双路召回 + RRF 融合：

1
RRF 分数 = Σ 1 / (k + rank_i)

RRF 把两路的排序位置融合成一个分数（rank 越靠前分越高），无需调权重参数，简单有效。

五、知识库系统的完整架构#

一个生产级知识库问答系统的分层：

知识库系统分层架构

1
┌──────────────────────────────────────────┐
2
│  接入层：Web / IM / API                   │
3
├──────────────────────────────────────────┤
4
│  编排层：Query 改写 → 检索 → Rerank → 生成 │
5
├──────────────────────────────────────────┤
6
│  检索层：向量库 + BM25 + 混合排序          │
7
├──────────────────────────────────────────┤
8
│  索引层：Chunking + Embedding + 元数据     │
9
├──────────────────────────────────────────┤
10
│  存储层：向量数据库 + 文档源 + 元数据库     │
11
└──────────────────────────────────────────┘

元数据（Metadata）的妙用#

每个 Chunk 不光存向量，还存元数据：来源文档、章节、更新时间、权限标签。作用：

过滤：只检索某部门/某时间段的文档（检索前先过滤，既快又准）
溯源：回答时能指出”依据来自《运维手册》第 3 章”
权限控制：不同用户只能检索到权限范围内的内容

文档更新与版本#

文档变了怎么办？

增量更新：只重新 Embedding 变化的 Chunk
版本管理：向量库中按文档版本打标，可回滚
定期全量重建：兜底方案，防止脏数据累积

六、常见误区#

误区	真相
”Embedding 模型越贵越好”	要匹配语言和数据域，中文场景用中文模型更稳
”向量维度越高越好”	高维度带来存储和检索开销，够用即可
”向量库能解决一切检索”	精确匹配场景必须混合 BM25
”数据入库就完事了”	数据质量、切分质量决定检索天花板
”RAG 能替代微调”	两者互补：知识用 RAG，风格/领域技能用微调

小结#

知识库的底层是两件事：

Embedding：用对比学习训练出的语义向量化能力，把文本变成可计算相似度的向量
向量检索（ANN）：用 HNSW/IVF/PQ 等索引结构，在百万级向量中毫秒级找出最相似的片段

上层再叠加 Chunking、混合检索、Rerank、元数据管理，就构成了完整的知识库问答系统。这也是 RAG 技术栈的基石——理解了这一层，任何知识库产品的原理在你眼里都是透明的。

RAG 检索增强生成原理与实践

Sun, 16 Aug 2026 00:00:00 GMT

为什么需要 RAG#

大语言模型有两个致命短板：

知识截止：训练数据是某个时间点之前抓取的，之后发生的事（新闻、新版本、公司内部文档）一概不知
幻觉：模型不知道答案时不会说”我不知道”，而是会一本正经地编造

RAG（Retrieval-Augmented Generation，检索增强生成）的思路很朴素：模型不知道，那就先查资料，把资料塞进上下文里，再让它基于资料回答。就像开卷考试——模型是考生，检索系统是它的笔记本。

RAG 整体流程#

一个标准的 RAG 系统分两个阶段：

RAG 完整流程：离线索引 + 在线查询

阶段一：离线索引（建库）#

收集文档（PDF、网页、Markdown、数据库记录……）
清洗文本（去页眉页脚、去重、格式统一）
切分（Chunking）：把长文档切成小块
向量化（Embedding）：每块文本转成一个向量
存入向量数据库，建立索引（便于 ANN 近似最近邻检索）

阶段二：在线查询（问答）#

用户提问
把问题向量化（用同一个 Embedding 模型）
在向量库里检索 top-k 最相似的文本块
把检索结果拼进 Prompt，与问题一起发给 LLM
LLM 基于检索内容生成回答

核心一：Embedding（文本向量化）#

什么是 Embedding#

Embedding 是把一段文本映射成一个固定维度的稠密向量（如 768 维、1536 维），使得语义相近的文本在向量空间里距离更近。

“猫”和”猫咪”的向量距离很近，“猫”和”汽车”的向量距离很远——这就是语义向量化的威力。

Embedding 模型怎么训练的#

常见的训练思路是对比学习（Contrastive Learning）：

构造正样本对（语义相同的文本，如问题和答案、原文和改写）
构造负样本对（语义无关的文本）
训练目标：拉近正样本对的向量距离，推远负样本对的向量距离

损失函数常用 InfoNCE 或 Triplet Loss。训练好的模型对任意输入文本输出一个向量。

Embedding 的注意点#

查询和文档必须用同一个模型，否则向量空间不一致，检索失效
中文场景要选中文优化过的模型（如 BGE、text2vec、m3e），英文模型对中文效果差
向量维度越高，信息越丰富但存储和计算开销越大

核心二：Chunking（文本切分）#

切分质量直接影响检索效果。切太大，噪音多、浪费上下文；切太小，语义不完整。

常见策略：

策略	说明	适用场景
固定长度切分	按字符数硬切，可加重叠	通用兜底
按段落/标题切分	尊重文档结构	Markdown、结构化文档
语义切分	用模型判断语义边界	高质量索引
父子块（Parent-Child）	小块检索、大块喂给模型	平衡精度与上下文

工程上常用重叠窗口（overlap）避免把语义割裂在边界上。

核心三：向量检索#

相似度度量#

向量检索的本质是算相似度，常用三种：

余弦相似度：cos(q, d) = q·d / (|q|·|d|)，只关心方向，最常用
内积：q·d，未归一化，速度快
欧氏距离：越小越相似，与余弦在归一化后等价

精确检索 vs 近似检索#

暴力检索：和库里每个向量算相似度，取 top-k。数据量小（万级）没问题
ANN 近似检索：数据量百万级以上，用索引结构加速，牺牲少量精度换取速度

主流的 ANN 算法：

HNSW（分层可导航小世界图）：图结构，召回率高，内存占用大
IVF（倒排文件）：先聚类再在桶内检索
PQ（乘积量化）：把向量压缩存储

向量数据库（Milvus、Qdrant、Weaviate、Chroma、pgvector）就是把这些算法封装成可直接使用的服务。

混合检索#

纯向量检索对关键词精确匹配（如型号 “A100”、代码片段）不敏感。工程上常用混合检索：向量检索 + BM25 关键词检索，再用 RRF（Reciprocal Rank Fusion）融合排序。这是生产级 RAG 的标配。

核心四：重排序（Rerank）#

向量检索的第一轮召回是”粗筛”，top-k 里可能混入语义相似但不直接相关的段落。重排序模型（如 BGE-Reranker、Cohere Rerank）对”问题-段落”对做精细的相关性打分，重新排序后只保留前 3~5 条喂给 LLM。

流程：

1
问题 → 向量检索召回 50 条 → Rerank 重排 → 取前 5 条 → 拼 Prompt → LLM 生成

重排序能显著提升答案质量，代价是多一次模型推理。

核心五：Prompt 拼接与生成#

检索到的文本块要拼成结构化的上下文，示例：

1
你是一个严谨的助手，请仅根据以下参考资料回答问题。
2
如果参考资料中没有答案，请明确说"资料中未找到相关信息"。
3

4
参考资料：
5
[1] <chunk1>
6
[2] <chunk2>
7
[3] <chunk3>
8

9
问题：<user_question>
10
回答：

要点：

给资料编号，让模型在回答中引用来源
明确”没有就直说”，降低幻觉
控制总长度，避免超出模型上下文窗口
可加系统提示词约束回答风格

RAG 的进阶形态#

1. Query 改写（Query Rewriting）#

用户的原始问题往往检索效果差，先用 LLM 把问题改写得更适合检索：拆解多跳问题、补全指代、生成子问题。

2. 多路召回#

不同来源（向量库、SQL 数据库、API、搜索引擎）并行检索，结果融合。这就是 GraphRAG（结合知识图谱）的思想。

3. Agentic RAG#

检索不再是”一次性的”：让 Agent 判断是否需要检索、需要检索什么、检索结果不够就换个方式再查，甚至自主调用多个工具。这就是 RAG 与 Agent 的融合。

4. 评估与优化#

RAG 系统要用指标持续迭代：召回率（Recall）、精确率、忠实度（Faithfulness，回答是否忠于检索内容）、答案相关性（Answer Relevancy）。配合 RAGAS 等评估框架做回归测试。

RAG 的常见问题与排查#

症状	可能原因	排查方向
答非所问	检索结果与问题无关	检查 Embedding 模型、Chunk 质量
答案有幻觉	检索结果不够/Prompt 约束弱	加 Rerank、加”不知道就说不知道”
回答太泛	喂给模型的上下文太短	增大 top-k、用父子块
检索慢	数据量大	换 ANN 索引、加缓存
中文效果差	Embedding 模型不适配	换中文 Embedding 模型

小结#

RAG 的完整链路：

1
文档 → 切分 → Embedding → 向量库
2
问题 → Embedding → 检索 → Rerank → Prompt → LLM → 带引用的答案

它解决了大模型的知识时效性和幻觉两大问题，是落地知识库问答（企业文档、客服、法律、医疗）最主流的技术方案。掌握了 RAG，你就掌握了让大模型”用上你数据”的核心能力。

Transformer 架构底层原理详解

Sun, 16 Aug 2026 00:00:00 GMT

为什么需要 Transformer#

在 Transformer 出现之前，处理序列数据主要靠两类模型：

RNN / LSTM：按时间步逐个处理 token，第 t 个词的输出依赖前 t-1 个词的隐藏状态，天生无法并行，且长距离信息会随步数增长而衰减（梯度消失）
CNN：虽然可以并行，但感受野有限，捕捉长距离依赖需要堆叠很多层

2017 年 Google 发表《Attention Is All You Need》，提出 Transformer，核心思路是：抛弃循环结构，只用注意力机制（Attention）建模序列中任意两个位置之间的关系。任意两个 token 之间的距离都是 1，长距离依赖问题迎刃而解，而且可以完全并行计算。

模型总览#

一个标准的 Transformer 编码器层由以下几部分组成：

Transformer 架构图（Encoder-Decoder 结构）

输入嵌入（Embedding）：把 token 映射为向量
位置编码（Positional Encoding）：注入位置信息
多头自注意力（Multi-Head Self-Attention）：建模 token 间关系
前馈网络（Feed-Forward Network）：逐位置的非线性变换
残差连接与层归一化（Residual + LayerNorm）：稳定训练

下面逐层拆解。

输入嵌入与位置编码#

Token 嵌入#

词表大小为 V，每个 token 通过查表得到一个 d 维向量（d 通常为 512~4096+）。嵌入矩阵是一个 V × d 的可学习参数矩阵。

为什么需要位置编码#

注意力机制本身是置换不变的：把”我打你”换成”你打我”，如果不加位置信息，模型看到的两组向量完全相同，无法区分语序。因此必须把位置信息加进去。

原始的 Transformer 使用正弦/余弦函数生成位置编码：

1
PE(pos, 2i)   = sin(pos / 10000^(2i/d))
2
PE(pos, 2i+1) = cos(pos / 10000^(2i/d))

其中 pos 是位置，i 是维度下标。这种编码有几个好处：

每个位置的编码唯一
任意两个位置的相对距离可以通过线性变换表达（因为 sin(a+b) 可以展开）
不需要学习，长度外推性较好（现代模型多用可学习的绝对位置编码或 RoPE 旋转位置编码，各有取舍）

自注意力机制（Self-Attention）#

从查询-键-值说起#

自注意力的灵感来自检索系统：想象你在图书馆查资料，你手里有一个查询（Query），书架上每本书都有一个键（Key），你通过”查询和键的相似度”找到最相关的书，然后取走这本书的**值（Value）**内容。

对输入序列的每个 token，模型学习三个矩阵 W_Q、W_K、W_V，把嵌入向量 x 投影成三个向量：

1
q = x · W_Q
2
k = x · W_K
3
v = x · W_V

注意力分数的计算#

对于第 i 个 token，它要决定”我该关注序列里哪些 token”：

计算它自己的 q_i 与所有 token 的 k_j 的点积，得到相似度
除以 √d_k 做缩放（防止点积过大导致 softmax 梯度消失）
过 softmax 归一化成权重
用权重加权求和所有 v_j，得到输出

公式如下：

1
Attention(Q, K, V) = softmax(QKᵀ / √d_k) · V

为什么除以 √d_k#

当维度 d_k 较大时，点积的方差会随之增大，导致 softmax 输出接近 one-hot，梯度极小。除以 √d_k 可以把方差拉回到 1 附近，保持梯度稳定。

缩放点积注意力的计算复杂度#

注意力矩阵是 n×n（n 为序列长度），因此计算和显存开销都是 O(n²)。这就是为什么长上下文模型需要 FlashAttention、稀疏注意力、滑动窗口注意力等优化手段——它们本质上都是在降低这个 n² 的代价。

多头注意力（Multi-Head Attention）#

单头注意力只能捕捉一种”关系模式”。多头注意力把 d 维空间切成 h 个头，每个头在各自的子空间里独立做注意力，最后拼接：

1
MultiHead(Q, K, V) = Concat(head₁, ..., head_h) · W_O
2
head_i = Attention(Q·W_Qᵢ, K·W_Kᵢ, V·W_Vᵢ)

h 通常取 8~32，每个头的维度 d_k = d / h，总计算量不变。

多头带来的好处：

多角度建模：不同的头可以分别关注语法关系、指代关系、语义相似性等
集成效应：多个头相当于多个”专家”投票，鲁棒性更好
并行计算：各个头互不依赖，可以并行

前馈网络（FFN）#

每个 token 经过注意力后，还要过一个逐位置（position-wise）的两层 MLP：

1
FFN(x) = max(0, x·W₁ + b₁)·W₂ + b₂

中间用 ReLU（现代模型常用 GELU / SwiGLU）激活，中间维度通常是 d 的 4 倍左右。注意这个 FFN 对每个位置独立作用，不跨 token 共享信息——跨 token 的信息交换全靠注意力层完成。

为什么要 FFN？注意力是线性的加权求和（权重非负且和为 1），线性组合无法表达复杂的非线性映射。FFN 提供非线性变换能力，让模型能学到更复杂的特征。

残差连接与层归一化#

残差连接#

每一层子层（注意力、FFN）都套上残差：

1
x' = x + Sublayer(x)

好处：

梯度可以直接从输出流回输入，缓解深层网络的梯度消失
即使某层学不到东西，也至少可以退化成恒等映射

层归一化（LayerNorm）#

对每个 token 的 d 维向量做归一化：

1
LayerNorm(x) = (x - μ) / √(σ² + ε) · γ + β

μ 和 σ 是该 token 自己那一维向量的均值和标准差。γ、β 是可学习的缩放和平移参数。LayerNorm 让每层输入的分布稳定，训练更快更稳。

现代模型（如 GPT、Llama）普遍采用 Pre-Norm 结构，即先归一化再进子层，这样更深层也能稳定训练。

从编码器到解码器#

Transformer 原始论文是 Encoder-Decoder 架构：

编码器：双向注意力（每个 token 能看到全序列），适合理解任务（BERT 就是纯编码器）
解码器：带掩码的因果注意力（只能看到自己及之前的 token），适合生成任务（GPT 就是纯解码器）

因果注意力的实现很简单：在算完 QKᵀ 后，把上三角部分置为 -∞，softmax 后这些位置的权重就变成 0，模型便”看不到未来”。

交叉注意力#

解码器除了自注意力，还有一层交叉注意力（Cross-Attention）：Q 来自解码器，K、V 来自编码器输出。这让解码器在生成时能”查阅”编码器理解过的完整输入。

训练目标与损失#

语言模型（GPT 类）用自回归方式训练：给定前文，预测下一个 token，用交叉熵损失
掩码语言模型（BERT 类）随机遮住 15% 的 token 让模型预测

为什么 Transformer 能”理解”语言#

严格说，Transformer 并不”理解”语言，它学到的是 token 之间的统计规律和分布式表示。但正因为注意力机制能让每个词充分参考上下文，加上足够多的数据和参数，模型涌现出语法、常识、推理等能力——这就是大模型”智能”的底层来源。

小结#

组件	作用
嵌入 + 位置编码	把 token 变成带位置信息的向量
多头自注意力	建模任意 token 之间的关系（O(n²)）
前馈网络	逐位置非线性变换
残差 + LayerNorm	稳定深层网络训练
因果掩码	让解码器只能看过去

理解了这一层，再去看 RAG、Agent、知识库这些上层应用，你会发现它们都建立在”Transformer 能高效处理海量文本”这个地基之上。