企业官网建设流程全解析

1. 核心原理

模型到底是怎么生成回复的？

核心工作机制：预测下一个词

抛开复杂的算法，其底层运行机制极其简单：给定前文，计算下一个最可能出现的词是什么。

我们代入具体的案例看一下：

我们输入的内容就是大家经常听到的提示词（Prompt），预测出来的下一个词就是Token。

更准确地说：

大模型给定当前上下文，计算下一个 token 的概率分布，然后按某种策略选一个 token，把它接回上下文，再预测下一个，如此循环，直到生成结束符或达到长度限制。

完整工作过程

所以，下面我们看完整工作工程（逐字预测、文字接龙）：

大语言模型生成一个完整回答，本质上是自回归的逐 token 预测与接龙：它根据已有上下文，计算下一个 token 的概率分布，再按某种解码策略选一个 token 接上去，循环往复，直到生成结束符或达到停止条件。
举个例子
用户输入：“中国的首都是哪里？” 我们来看下模型怎么回复的？
模型内部大致会这样一步步生成：

可以看到每次LLM会预测出来下一个token，把下一个token拼接起来作为新的提示词喂给大模型，大
模型根据新的提示词预测出来下一个token。这样循环往复直到遇到结束符。
DeepSeek的默认的终止符是 <｜end▁of▁sentence｜> 。不同模型的终止符不一样。

如何决定下一个token

大语言模型（LLM）决定下一个 token 的核心机制是：

基于前文上下文，计算词表（词表——Vocabulary可以理解成就是大模型的“字典”，后面会单独介绍）中所有 token 的概率分布，再通过采样策略选出一个 token 输出，循环往复。
整个过程是自回归生成（Autoregressive Generation）。
自回归生成就是“用自己刚刚生成的结果，作为预测下一个结果的依据，像滚雪球一样，一步接一步地往外推”

Token选择策略（采样策略/解码策略）

一图总结：

Top-P 的思想是：我们只保留概率最高、加起来刚好能达到阈值 P（比如 90%）的那一小部分词。 这一小部分高概率词的集合，就被称为“核（Nucleus）”。

上面我们反复提到一个概念——token，那到底什么是token呢？

2. Token（词元）

概念

Token（词元）是大语言模型（LLM）理解和处理文本的最小基本单位（也是目前几乎所有大语言模型 API 的绝对计费单位）。
大语言模型不看完整的句子，而是把句子拆成一个个Token来“理解”和“生成”。
比如“我爱大模型开发”这样一句话；了解的人获得信息的断句是：我/爱/大模型/开发，依次送入到我们的大脑中去理解；
我们给大模型的输入，也是切分成一个个的token输入到模型中的
例如上例中：“我”是一个token，“爱”是第二个token，“大模型”和“开发”都是一个token。这个断句的过程在人工智能领域叫做分词（tokenization）。

当然，对于没有背景知识的人上例的断句也可能是：我/爱/大/模型/开发；对于一个小孩来说，断句可能是：我/爱/大/模/型/开/发。
不同的人断句的方式不同，与此相同，市面上的大模型厂商切词也会有细微的差别，不同切词的方式，同一句话切出来的token是不一样的。

常见形态

Token的常见的形态：

• 一个完整的单词： Hello 可能是 1 个Token。
•单词的一部分： unbelievable 可能会被拆成 un + believe + able （3个Token）。
•标点符号：逗号、句号、感叹号通常各占 1 个Token。
•中文情况：中文里，一个汉字通常占 1 到 2 个Token（视具体词汇频率而定），而不是一个字对应一个Token。

下图展示了ChatGPT 的 Token 估算工具对unbelievable这个单词的切分

可以看到这个单词被拆分成三个tokens，当然不同模型切分可能不同

为什么需要token

1. 数字化让机器能听懂

计算机本质上只能处理数字和数学运算，无法直接理解人类的文本。
通过将文本切分为 Token 并转换为向量，AI 才能在神经网络中进行矩阵运算，从而捕捉词语之间的语义关系。

第一步：切分编号（数字化输入）

文本不能一整坨丢给计算机，必须先拆成最小计算单元（Token），并给每个Token分配一个整数ID。
比如 unhappiness 切成子词[“un”, “happi”, “ness”] ，分别对应ID [432, 891, 256] 。
👉 此时计算机拿到了纯数字 [432, 891, 256] ，但注意：在模型里，数字891并不比432“更大”或“更开心”，它只是个冰冷的代号。如果直接拿这些ID做加减法（432+891），毫无意义。

第二步：

离散的ID无法表达语义，必须把每个ID映射成一串高维浮点数（向量）。
这些向量在训练中被不断调整，语义越近，对应的向量在空间里也离得越近。
比如模型为 “happy” 分配向量 [0.8, 0.9, -0.1,…] ，为 “glad” 分配向量 [0.79, 0.88, -0.09, …] ，两者距离很近（都表示开心）。
而 “un” 对应的向量带有“否定”方向，当它和 “happy” 组合时，合成向量会把空间坐标推向"sad" 所在的方向。

2. 解决“词汇爆炸”问题：

a.

如果按“字母”为单位（粒度太细）分词，词表很小，英文 unhappiness 会被拆成 11 个字符：
u n h a p p i n e s s ，每个字符几乎没有独立语义（比如 u 和 n 需要拼在一起才能表达“否定”），模型需要花大量计算去学习相邻字符的组合规律。而且对于长文本，序列会变得极长，计算量按平方增长，效率极低。

b.

如果按“单词”为单位（粒度太粗），词表会爆炸。
如果模型把所有可能出现的英文单词都放进词表，词表会大到无法训练（英语有几十万单词，还有各种各样的派生词如 unhappiness 、unhappily 等）。
遇到未登录词（如新造词 cryptocurrency ），模型只能当成“未知”而无法理解，语义表达能力受限。

主流 Tokenizer（分词器，如 BPE、SentencePiece）会把文本切分成介于字和词之间的子词单元。

输入token和输出token

输入token

你发送给模型的提示词所消耗的 token 数量。
包含内容：
用户输入的文本。
如果开启了联网搜索，搜索引擎返回的相关内容也会被计入输入 token。

但在真实场景中，输入 Token 往往比你想的要长得多，因为还包括诸如：

系统提示词（System Prompt）：
这是开发者预设的一段隐藏文本（比如“你是一个乐于助人的AI助手，回答要简洁……”）。每次你发消息，这段文字都会作为输入 Token 被发送，这也是为什么有时候你只发了一个“你好”，却消耗了几十个输入 Token 的原因。
历史对话记录（多轮对话）：
为了保持上下文，大模型是无状态的（后面会详细介绍）。每次你发起新提问，API 都会把之前所有的对话记录（包括你的提问和模型的回答）连同新问题一起打包作为输入发送。所以聊得越久，单次消耗的输入 Token 越多。

输出token

模型生成回答所消耗的 token 数量，包含模型返回的完整回复文本。

在推理模型（如 DeepSeek-R1、OpenAI o1）时代，输出 Token 多了一个巨大的消耗项：

思维链（Chain of Thought, CoT）：
现在的推理模型在给出最终回答前，会先进行一段长长的“内部思考”（比如 嗯，用户问的是…，我应该先算…）。这段思考过程通常也算作输出 Token！
很多时候，模型思考了几千个 Token，最终给你的答案可能只有几十个 Token。这会导致输出 Token 账单暴增。

为什么输出token贵？

致命伤一：算力闲置

输入阶段：
当你把一大段提示词发给模型，GPU 可以在一次矩阵计算中同时处理这所有的 Token（类似于多车道同时行驶），效率极高。
输出阶段：
AI只能一次生成一个token。每次为了算出这1个新token，它都要去翻看之前记住的1000个历史线索，并且算出一个 Token后，要拼接到上下文，再算下一个 Token。
计算器本身算得飞快，但95%的时间都在“等数据送过来”。GPU 的计算单元闲置了 95% 的时间，全在等“搬数据”。虽然每次算得极少，但生成1000 个输出 Token 需要串行跑 1000 步，总共耗时可能是输入阶段的 10 倍以上。

致命伤二：显存带宽被榨干

输出阶段瓶颈从“计算速度”变成了“显存搬运速度”
输入阶段：
消耗的是“计算能力”（算力），这是GPU的强项
输出阶段：
消耗的是“搬运能力”（带宽）。为了算1个新字，要把历史记录从显存“搬”到计算器里。显存带宽是 GPU 最稀缺、最贵的资源之一，输出阶段疯狂搬运海量数据，直接把带宽打满，导致其他运算都得排队。

致命伤三：KV Cache 占用显存

输入阶段：算完就释放显存，不占地方。
输出阶段：AI每吐出一个新字，就要把它的记忆写进KV Cache(键值缓存：AI为了记住上下文，把之前算过的历史线索存下来的“小本本”)里。生成过程中越写越厚，显存占用越来越大。直到整段对话结束，这块显存才会被释放。

对于云厂商来说，显存就是钱。一块A100只有80GB显存，如果给你一个人生成长文就占了40GB，那这张卡能同时服务的人就少了一大半。

3. Vocabulary（词表）

上面讲解原理的时候我们还提到一个概念——词表，那什么是词表呢？

概念

词表是模型预定义的一个映射字典。它包含了模型“认识”的所有词元（Token）。
•每个词元都有一个唯一的数字 ID（索引）。
•当输入文本时，分词器（Tokenizer）会查阅词表，将句子切割成词表中存在的片段，并转换为 ID列表输入模型；模型输出的 ID 再通过词表映射回文本。

在大型语言模型（LLM）的架构中，Vocabulary（词表） 是模型理解人类语言的“字典”。它定义了模型能“看见”和“写出”的所有基本单位。

作用：

由于大语言模型（LLM）本质上是数学函数（输入数字，输出数字），无法直接处理原始文本，因此词表就是连接“人类语言”和“模型数字世界”的桥梁。

常见大模型的词表大小

生成词范围

大模型不能生成不在词表（Vocabulary）里的“Token”，但可以组合出不在词表里的“词（Word）”。

比如大模型不认识unbelieveable ，但是可以通过 3个token un + believe + able 组词出来 unbelieveable ，理论上生成的所有的内容都必须来自token。
虽然模型可以拼凑出任何字符串，但它无法创造出词表索引之外的新编号。
如果模型的词表大小是50,257（GPT-2 的标准），它永远不可能输出编号为 50,258 的 Token。
如果真遇到了token没办法表示的单字符，比如某些Emoji 表情，就会触发字节级回退。

什么是字节级回退？

字节级回退

简单来说，由于字节级回退的存在

当模型遇到词表里完全没有的字符时，它不再摆烂说“我不认识”（输出未知符 ），而是直接把这个字符拆解成最底层的“字节（Byte）”，用字节级别的 Token 来拼凑它。

在早期的 NLP 模型中，如果词表是固定的 5 万个词

遇到一个没见过的生僻字（比如“龘”），分词器通常会直接把它替换成一个特殊的 （Unknown，未知词）Token。
后果：
模型直接丢失了这个字的信息，在输出时也无法生成它。如果一句话里有好几个 ，模型就彻底“看不懂”了。

为了解决这个问题

现代大模型（如 GPT-2、Llama、DeepSeek 等）引入了字节级回退机制，这是一个极其精妙的设计

为了让知识闭环更完整，我们可以用一个更具体的硬核拆解，来看看它在底层到底是怎么运作的：

假设我们要让大模型处理 😊 这个表情，而词表里恰好没有它
传统 Tokenizer 的绝路： 传统分词器一看词表里没有 😊 ，就会直接抛出一个未知字符标记——[UNK] （Unknown）。模型看到 [UNK] 就是两眼一抹黑，根本不知道这后面代表的是愤怒、悲伤还是微笑。
Byte-fallback 的拯救，有了字节级回退的存在，这时候就会触发回退，直接查 😊的UTF-8 编码编码：
😊 的 UTF-8 编码由 4 个字节组成： 0xF0 0x9F 0x98 0x8A 。
字节级切分：模型直接在词表的字节层，找到对应这 4 个字节的 Token，把😊变成了 4 个基础字节 Token 的拼接。
0xF0 →映射到词表里的专用 Token： <byte_0xF0>
0x9F →映射到词表里的专用 Token： <byte_0x9F>
0x98 →映射到词表里的专用 Token： <byte_0x98>
0x8A →映射到词表里的专用 Token： <byte_0x8A>
最后，这个表情就被切成了 4 个独立的字节 Token 送入模型。理解了这是一个整体，然后在输出时，再把这 4 个字节吐出来，解码后重新组合成😊（结构上的认识）

那这样模型就认识这个表情了吗？

在字节级回退发生后，模型并不是立刻就认识了这个表情，知道它代表微笑的意思。
它需要通过内部的计算机制，才能逐渐“领悟”这 4 个字节连在一起到底代表什么。

他真的理解微笑吗？

这是一个哲学问题。模型没有眼睛，看不到表情，也没有情绪。
它所谓的“认识”，本质上是统计关联：
它知道 <byte_0xF0> <byte_0x9F> <byte_0x98> <byte_0x8A> 这四个字节连在一起，在人类语境中通常表示“积极、开心”。
它知道如果你给它一个“悲伤”的语境，它不应该输出这 4 个字节。
它知道如果你让它“发个开心的表情”，它应该预测出这 4 个字节（以及可能的其他组合，比如 😄、😁 的字节序列）。

极其关键的区分：高频与低频

对于 😊 这样的高频 Emoji：模型在训练中见过无数次，这 4 个字节的向量已经被“训练”得极其精准，模型完全“认识”它。
对于极其罕见的 Emoji 或自造符号（比如某个偏僻的非洲部落文字）：如果训练数据里从来没有出现过，字节级回退虽然能让模型“不报错、不崩溃”地把它吞下去（变成 4 个字节 Token），但模型完全不知道它是什么意思。
此时模型的状态是：它“看到”了这 4 个字节，但脑子一片空白。
它可能会根据“这四个字节看起来像其他什么词”来瞎猜，或者完全忽略它们。

为什么说这是一个“极其精妙”的设计？

在 Byte-fallback 出现之前，为了不让模型遇到生僻字就变“瞎子”，早期的 GPT-2 采用了纯字节级BPE（Byte-level BPE）。
也就是说，它的词表干脆完全由最基础的 256 个字节组合而成。
但纯字节级有一个致命缺点：效率太低。
英文单词 apple （6字节）就要占 5 个 Token，中文 苹果 在 UTF-8下有 6 个字节，要占 6 个 Token。这会导致大模型的上下文窗口（Context Window）迅速被吃满。

而 Byte-fallback（字节级回退） 则是两者的完美结合（Best of Both Worlds）：

正常情况下：
词表里有高频的“苹果”、“apple”、“Hello”，那就直接用大 Token，保证效率。
极端情况下：
遇到冷门字、火星文、罕见 Emoji，不报错、不丢弃，而是降级回退到字节模式，保证鲁棒性。

字节级回退的代价

Token 数量爆炸：

如果一句话全是词表里的高频词，可能 10 个字只占 10 个 Token。
但如果一句话全是生僻字或者新造词或冷门表情，每个字/表情都被迫回退成字节数个 Token，占用的token数量大大增加推理速度自然也变慢。

对于词表里有的词，模型输出1 个 Token 即可；对于词表里没有的“新词”，模型可能需要输出 5-10 个 Token。

这也是为什么处理某些冷门专业术语或罕见语言时，LLM 的推理速度会变慢且更贵。