企业官网建设流程全解析

概念之间的因果链：从一个 Token 到一次 Agent 调用

大模型的术语不是孤立的词条。这一篇把一次请求从头走到尾：文字怎么变成 Token，Token 怎么被读成意思，一次回答怎么变成一次工具调用——搞清每一环为什么必须存在，以及它补上缺口之后又留下了什么新问题。

本文的关系图（读完全文再回来看这张图）：

【训练时·离线】 【推理时·在线】 文本语料 用户输入 ↓ ↓ 分词 Token ─────────────────────→ 分词 Token ↓ ↓ Embedding ─────────────────────→ Embedding ↓ ↓ 注意力 / Transformer ───────────→ 前向计算 → 采样 → 一个 Token ↓ ↓（循环） 预训练（学会世界知识） ┌──── 上下文窗口限制 ────┐ ↓ │ RAG / Chunk / Rerank │ SFT 指令微调（学会听话） │ 工具调用 Function Call│ ↓ │ ReAct 多步循环 │ 对齐 RLHF / DPO（学会答得好） │ 记忆机制 │ ↓ │ MCP 统一协议 │ ┌──────────────┐ └───────────┬───────────┘ │ 权重文件 │──────────────────────────────────────→ Agent 调用 └──────────────┘ （训练的全部产物，就是推理的全部输入）

一、为什么"背术语表"永远学不会

如果只是把"每个术语是什么意思"记下来，你多半还是会忘。

因为术语表是死的，因果链是活的。

• 静态视角：Token 是文本切分的最小单位，Embedding 是把 Token 映射成向量，注意力是加权求和的机制……
• 因果视角：Token 存在，是因为神经网络只吃数字；Embedding 存在，是因为 Token 的编号 1 和 2 之间没有"语义距离"，光有编号算不出"苹果"和"香蕉"比"苹果"和"汽车"更近；注意力存在，是因为同一个词在不同上下文里意思不同，必须看邻居。

一篇定义只能告诉你"它是什么"，因果链才能告诉你"它为什么必须在那儿"。后者一旦理解，你几乎不可能忘——因为忘掉其中一环，整条链就断了，你自己会发现不对。

这一篇要走的，就是这样一条链。它有两个分支：训练时（离线，一次性，塑造权重）和推理时（在线，每次请求，使用权重）。两个分支之间那条分界线，是后面所有"该用哪个技术"争论的判据。

二、类比：一个新人的成长史

把大模型想象成一个刚入职的新人。他的每一步成长，都对应链上的一环：

注意最后一行：Agent 不是一个新岗位，而是这个新人把上面所有能力都长齐之后，自然形成的状态。这一点是本文最重要的结论，后面会反复回到它。

三、第一条链：训练时——知识是怎么被塞进权重的

这条链离线跑一次，可能花几百万美元、几周时间。它的产物是一个权重文件。

第 1 环：文本 → Token

为什么必须存在：神经网络的输入必须是数字，但原文是字符串。

所以要做分词：把文本切成 Token，再查词表换成整数 ID。

"大模型的术语" → ["大", "模型", "的", "术语"] → [23391, 62028, 10483, 111783]

它留下的新问题：切法不唯一。同一句话，不同分词器切出的 Token 数可能差 30% 以上。这就是为什么"中文比英文贵"“用不同模型同样的文本价格不同”——问题不在模型，在第一环的切法。

第 2 环：Token ID → Embedding

为什么必须存在：ID 是离散编号，不是有距离的坐标。ID 23391 和 62028 之间的大小关系毫无意义，"苹果"的 ID 加"香蕉"的 ID 更没有任何含义。

所以要把每个 ID 映射成一个向量（比如 896 维），并且通过训练让语义相近的词在向量空间里靠得近。

"桃子" → [ 0.21, -0.34, 0.88, ... ] "苹果" → [ 0.19, -0.31, 0.85, ... ] ← 和桃子很近 "汽车" → [-0.77, 0.42, -0.11, ... ] ← 和苹果很远

这是大模型"理解语义"的全部秘密所在：不是它懂中文，而是它把词摆进了一个几何空间，而相似度变成了可计算的距离。

它留下的新问题：向量是高维的，几十万条向量做相似度检索很慢——这正是向量数据库和近似最近邻算法要解决的事。

第 3 环：Embedding → 注意力

为什么必须存在：光有词向量还不够，因为同一个词在不同上下文里意思不同。

“苹果发布了新手机"和"苹果很甜”，这里的"苹果"必须是两个不同的表示。注意力机制的作用就是：让每个 Token 根据周围的 Token，动态地修正自己的表示——"发布了新手机"这些邻居会把"苹果"往科技公司方向推。

它留下的新问题：注意力要算每两个 Token 之间的关系，复杂度是 O(n²)。这就是上下文窗口不能无限大的根本原因——不是不想，是平方增长扛不住。

第 4 环：预训练——知识的来源

为什么必须存在：到这一步网络还是个随机初始化的空壳。

预训练做的事很简单：拿海量文本，遮住下一个词，让模型猜。猜错了就调参数。这个任务不需要人工标注（原文的下一个词天然就是答案），所以能用几万亿 Token 的数据。

为什么"猜下一个词"能学到知识：因为要猜准，模型被迫把世界的规律压缩进参数里。要猜准"中国的首都是___"，它必须真的记住这个事实；要猜准一段代码的下一个符号，它必须真的学会语法。预测能力是手段，知识压缩是结果。

第 5 环：SFT 指令微调——从"会说话"到"会听话"

为什么必须存在：预训练完的模型只会续写，不会回答。

你问它"法国首都？“，它可能续写成"法国首都是哪里？德国首都呢？”——因为它见过太多疑问句后面跟着另一个疑问句。它是个极其博学的续写机器，但不是个助手。

SFT 用大量(指令, 理想回答)配对数据教它：看到这种输入，应该停止续写，开始回答。

第 6 环：对齐（RLHF / DPO）——从"会听话"到"答得好"

为什么必须存在：SFT 只能模仿示范，它学会了"照着抄"，但学不会"哪个更好"。而示范数据质量参差，还往往互相矛盾。

对齐的做法是给模型看成对的好坏比较，教它"这两种回答里，人类更喜欢哪一种"。

它留下的新问题：对齐税。模型变得更安全、更礼貌的同时，也变得更啰嗦、更回避、更不敢给明确答案。你遇到的"车轱辘话"，很大一部分来自这一环。

训练链的收束

文本 → Token → Embedding → 注意力 → 预训练 → SFT → 对齐 → 【权重文件】

看清这条链的关键在于：每一环的输出都不能直接当成品用，必须再加工一次。Token 不能直接用，要嵌入；嵌入不能直接用，要过注意力；预训练模型不能直接用，要微调；微调完不能直接用，要对齐。

四、第二条链：推理时——一次请求的完整行程

现在权重文件有了。用户说了一句话，故事开始。

起点：一次自回归

用户输入 "帮我查一下上个月的销售额，做成图表发我邮箱" ↓ 分词 → Embedding → 过 Transformer → 得到一个 logits 向量（词表里每个词的得分） ↓ 采样（温度 / Top-p）→ 挑出 1 个 Token ↓ 把这个 Token 拼回输入末尾，整个再来一遍 ↓ 循环直到吐出结束符

注意这里：

• 它一次只产出一个 Token，且吐出去就收不回来（不能回头改）。
• 每一轮都要把前面全部内容重新算一遍——这正是"KV Cache"这类优化存在的理由。

到这里，模型能说话了。但只是个会说会道的文字机器。接下来的每一步，都是因为上一步暴露了一个缺口。

裂缝一：装不下

上下文窗口是有限的。一轮对话长了、或者你想塞一整份 PDF，就装不下了。而且就算塞得下，中间部分的信息也容易被模型忽略。

→补丁：RAG（检索增强生成）

思路很简单：既然塞不下全部，那就只塞最相关的那几段。

引入 RAG 之后，立刻长出一堆新问题，它们是同一层里的兄弟概念：

这里值得停一下：很多人以为 RAG 是"一个技术"，其实它是一个缺口炸出来的一整个技术簇。分不清 Chunk 和 Rerank 谁管什么，是因为没有先看到它们服务于同一个裂缝。

RAG 自己留下的新问题：检索错了比不检索更糟。模型会一本正经地基于错误材料作答——检索引入的幻觉，比模型自发的幻觉更难发现。

裂缝二：只会说，不会做

就算 RAG 把知识补齐了，模型仍然只能输出文字。它说"好的，我已经帮你查了销售额"——但它根本没查。

→补丁：Function Calling / Tool Use

做法是：给模型一份工具清单（函数名 + 参数说明）。模型判断需要调工具时，不再输出自然语言，而是输出一段结构化的调用意图，比如query_sales(month="2025-09")。真正执行的是外面的程序。

关键认知：模型自己不执行任何操作，它只是"表达了想执行什么"。执行权永远在你手里。这是评估 Agent 风险时最重要的一条前提。

它留下的新问题：模型可能调错工具、传错参数，或者在不该调的时候乱调。

裂缝三：一步做不完

“查销售额 → 生成图表 → 发邮件”，这是三步，不是一步。而且第二步要等第一步的结果。

→补丁：ReAct 范式（思考—行动—观察）

ReAct 把推理变成一个循环：

思考：要查销售额，我需要调用 query_sales 行动：调用 query_sales(month="2025-09") 观察：返回 128 万 思考：现在要生成图表，我需要调用 make_chart 行动：调用 make_chart(data=...) 观察：图表已生成，地址是 ... 思考：最后要发邮件 ...

它留下的新问题：错误会累积，而且循环可能不收敛（模型绕圈出不来）。这正是"规划与任务分解"要处理的事，也是"Agent 的能力边界"讨论的核心。

裂缝四：干着干着忘了

循环十几轮之后，最早的对话被挤出了上下文窗口。模型忘了用户一开始说的"发给老板，语气正式一点"。

→补丁：记忆机制

短期记忆（本次会话的摘要压缩）+ 长期记忆（跨会话存进外部库，需要时检索回来）。

它留下的新问题：记什么、忘什么、什么时候取回来——这本质上又变成了一个 RAG 问题。

裂缝五：N × M 的适配地狱

假设你有 10 个模型、100 个工具。按老办法，每个模型要接每个工具，需要 1000 份适配代码。换一个模型，1000 份全部重写。

→补丁：MCP 协议

思路和 USB 一样：定一套统一接口。工具方按协议实现一次，模型方按协议接入一次，N × M 变成 N + M。

它留下的新问题：谁能接、能接多少、接了之后权限边界在哪——协议统一了接口，但没有统一信任。

收束：Agent 是长出来的，不是造出来的

把上面五步串起来：

一次模型调用 + RAG （补知识缺口） + 工具调用 （补行动缺口） + ReAct 循环 （补多步缺口） + 记忆 （补上下文缺口） + MCP （补接入缺口） = Agent

所以"Agent 是什么"这个问题，答案不在一句定义里，而在这一整条链上。它不是某个新模型架构，而是"模型 + 一串补丁"构成的运行时形态。

这也解释了一个常见困惑：为什么 Agent 产品效果差异那么大？因为模型只是其中一环，另外五环的工程质量同样决定上限。同一个模型，把 RAG 做扎实的和没做扎实的，体验会差一个数量级。

五、因果链总表

这张表是本文的核心资产。第三列——它又留下了什么新问题——是判断"这个概念为什么会有下一环"的关键。

读这张表的正确方式：不要横着读（背概念），要竖着读（追因果）。每一行的第二列来自上一行的第三列——这就是"链"的含义。

六、两条链在哪里交汇

这两条链的分界线，可以用一句话概括：训练时决定模型会什么，推理时决定这次要它做什么。现在把它落到具体位置：

【训练时】文本 → Token → Embedding → 注意力 → 预训练 → SFT → 对齐 ↓ ★ 权重文件 ★ ↓ 【推理时】用户输入 → 分词 → 嵌入 → 前向计算 → 采样 → 输出

权重文件是唯一的外交官。训练侧的一切努力，只有变成权重才能影响推理；推理侧的一切技巧，如果不动权重，就永远改变不了模型本身的能力。

这条分界线能一刀切开很多争论：

七、四个常见误区

误区一：把 RAG、微调、Prompt 当成三个可以互相替代的选项。
它们在链上的位置完全不同：Prompt 在推理侧的输入端，RAG 在推理侧的输入前，微调在训练侧。位置不同，就不是替代关系。正确的用法是组合，不是二选一。

误区二：以为 Agent 是一种新技术。
Agent = 模型 + RAG + 工具 + 循环 + 记忆 + 协议。如果你已经理解了这五块，你其实已经理解了 Agent，只差一个名字挂上去。

误区三：认为后面出现的概念"更高级"。
ReAct 不比 Function Calling 高级，Function Calling 不比 RAG 高级。它们是链上不同的环，各自解决各自那个裂缝。用高级/低级来看这条链，一定看不懂。

误区四：忽略"每个补丁都会带来新问题"。
这是本文最想传递的思维方式。RAG 引入检索错误，ReAct 引入循环失控，MCP 引入信任问题。理解了这一点，你看到任何一个新技术时，第一个该问的问题不是"它能干什么"，而是"它替谁擦了屁股，又留下了什么新屁股"。

八、代码：温度到底是什么

链上有一环特别容易被讲得玄乎——采样。我们用一段可以真跑起来的代码把它拆开。

采样 = 给候选词打分 → 按温度缩放 → softmax 变成概率 → 按概率抽签。

温度的作用就一个：把分数差距除以 T。T 小于 1，差距被放大，模型更保守；T 大于 1，差距被压平，模型更发散。

"""温度到底是什么：一段零依赖、可本地运行的演示。 模型每一步会为词表里每个 Token 打一个分（logits）， 温度就是"把这个分除以几，再 softmax"。 """importmath# 假设模型看完上文后，对 6 个候选词打了这样的分（真实模型里是几十万维）CANDIDATES=["销售","数据","报表","图表","报告","狗"]LOGITS=[8.0,7.0,6.0,5.0,4.0,1.0]defsoftmax(logits,temperature=1.0):"""温度 T：T<1 拉大差距（更保守），T>1 抹平差距（更发散）。"""scaled=[x/temperatureforxinlogits]m=max(scaled)# 减最大值，防止 exp 溢出exps=[math.exp(x-m)forxinscaled]total=sum(exps)return[e/totalforeinexps]fortin(0.1,0.5,1.0,2.0,5.0):p=softmax(LOGITS,t)print(f"T={t:<4}"," ".join(f"{w}:{x*100:8.6g}%"forw,xinzip(CANDIDATES,p)))

真实运行结果（本机实测。上面这段代码打印出的是一长串原始数字，下面是我把它排成表格、并做了精度处理后的版本，数值完全一致）：

温度 | 销售 | 数据 | 报表 | 图表 | 报告 | 狗 ---------------------------------------------------------------------------------- 0.1 | 99.9955% | 4.5e-03% | 2.1e-07% | 9.4e-12% | 4.2e-16% | 4.0e-29% 0.5 | 86.5% | 11.7% | 1.6% | 0.2% | 2.9e-02% | 7.2e-05% 1.0 | 63.6% | 23.4% | 8.6% | 3.2% | 1.2% | 5.8e-02% 2.0 | 42.3% | 25.7% | 15.6% | 9.4% | 5.7% | 1.3% 5.0 | 26.8% | 21.9% | 18.0% | 14.7% | 12.0% | 6.6%

几点值得注意：

1. T=0.1 时"销售"占 99.9955%——它几乎必然被选中，模型表现得很"确定"。这也是为什么调低温度能让输出更稳定、更适合做结构化抽取。
2. T=5.0 时"狗"涨到了 6.6%——注意它仍然不是最高的。"胡说"不是突然发生的，而是概率分布被逐渐压平的结果：低概率的荒谬选项从"不可能"变成了"有可能"。
3. 两次计算的输入完全一样。LOGITS一个字节都没变。温度改变的只是"这一次怎么挑"，它碰不到权重，因此永远改变不了"模型会什么"。

这是"训练时 / 推理时"这条分界线最直接的物理证据：采样参数是纯推理时的东西。把它和微调放在一起讨论，就像比较"今天点什么外卖"和"改造你的味觉"。

完整的可运行脚本我放在code/02-temperature-demo.py，零依赖，复制走就能跑。

九、把这条链接回整张图

把大模型的概念按依赖关系分成从下到上的几层——底层是算力和数据，往上依次是文字的表示、模型结构、训练、调用，最上面是增强和智能体——本篇走过的是这样一条纵向通路：

L6 智能体层 Agent / Function Calling / ReAct / 记忆 / MCP L5 增强层 RAG / 向量检索 / Rerank / GraphRAG / 微调 L4 调用层 Prompt / Few-shot / CoT / 温度 / Top-p L3 训练层 预训练 / SFT / RLHF / DPO / LoRA / Scaling Law L2 结构层 Transformer / 注意力 / 参数量 / 上下文窗口 L1 表示层 Token / 分词 / 词表 / Embedding L0 底座 算力 / 数据 / 成本

本篇点亮的是整条纵向的通路——每个概念在这条链上都有自己的位置，而不是一个孤立的词条。

三条可以带走的判断规则

1. 看到一个新概念，先问"它补的是哪个裂缝"，而不是"它是什么"。
2. 评估一个补丁，要看它留下的新问题，那里往往藏着下一个热点技术。
3. 区分它站在分界线的哪一侧（训练时 / 推理时），这决定了它能改什么、不能改什么。

《大模型概念地图》专栏 · 第 2 篇