第三层：模型如何把输入变成输出？

核心问题：用户输入一句话后，模型内部发生了什么？

主要概念：Prompt、Chat Template、Tokenizer、Token、Embedding、Position、Attention、Forward Pass、Logits、Sampling、Context Window、Autoregressive Generation。

流程

以用户输入：“介绍下 LLM”，模型处理的完整过程如下：

两个阶段：

1. 输入处理：把人类输入转换成模型能够计算的数字；
2. 自回归生成：一次预测一个 Token，不断形成最终输出。

1. Prompt

提示词或提示，用户提供给模型的输入。通常译为：提示词或提示。是交给模型处理的输入内容，但在聊天模型中，模型真正接收到的通常不只是用户输入的一句话。比如：

System：你是一个专业的技术助手。
User：介绍下 LLM。
Assistant：

Chat Template：聊天应用中保存的消息可能是结构化数据：

[
  {
    "role": "system",
    "content": "你是一个专业的技术助手。"
  },
  {
    "role": "user",
    "content": "介绍下 LLM"
  }
]

2. Chat Template

Chat Template 将其拼接成模型训练时熟悉的输入格式，例如概念上可能类似：

<|im_start|>system
你是一个专业的技术助手。
<|im_end|>
<|im_start|>user
介绍下 LLM
<|im_end|>
<|im_start|>assistant

• Chat Template 不负责理解问题，也不负责生成答案；它负责按照模型要求组织 system、user、assistant 等消息。

• 不同模型可能使用不同的特殊 Token 和消息格式。如果格式不正确，模型仍然可能运行，但回答质量、角色识别和工具调用能力可能受到影响。

3.Tokenizer：把文本转换成 Token

模型不能直接处理文字，它只能处理数字。Tokenizer 的作用是：按照模型预先定义的规则，把文本切分成 Token，并将每个 Token 转换为一个整数 ID。比如：

介绍下 LLM
 
可能被切分为：
 
["介绍", "下", "LLM"]
 
再转换为：
 
[1045, 6821, 2379, 9134]

Token

模型处理文本的基本单位。

一个 Token 可能是：

• 一个汉字；
• 一个词；
• 一个词的一部分；
• 标点符号；
• 空格；
• 换行；
• 特殊控制标记。

英文示例：unbelievable

可能被拆成：["un", "believ", "able"]

不同 Tokenizer 的切分结果可能不同。Token 不等于汉字，也不等于单词，而是由当前模型的 Tokenizer 规则决定的文本单位。

Token ID

模型真正接收的不是 "介绍" 这个字符串，而是在词表中的整数编号：Token → Token ID。

Tokenizer 通常依赖一个 Vocabulary：

Vocabulary
├── Token A → ID 0
├── Token B → ID 1
├── Token C → ID 2
└── ...
 
以 Qwen3.8 vocab.json 为例，可以看到：
 
"@": 31,
"A": 32,
"B": 33,
"C": 34,
"D": 35,
"E": 36,
"F": 37,
"G": 38,
"H": 39,
"I": 40,
"J": 41,
"K": 42,
"L": 43,
"M": 44,
"N": 45,
"O": 46,
"P": 47,
"Q": 48,

再看 Qwen 仓库里的这些文件，就能明确其作用：

• tokenizer.json：Tokenizer 的完整定义；
• vocab.json：Token 与 ID 的对应关系；
• merges.txt：BPE Token 的合并规则；
• tokenizer_config.json：Tokenizer 类型和特殊 Token 等配置。

4. Embedding：把 Token ID 转换成向量

Token ID 只是一个编号，本身没有可计算的语义关系。比如：LLM -> 9134，介绍 -> 2841。

不会因为 9134 > 2841，就认为 LLM 在某种意义上“大于”介绍。

模型会通过 Embedding Table，把每个 Token ID 映射为一组浮点数：

Token ID
→ 查找 Embedding Table
→ Embedding Vector
 
"LLM"
→ Token ID：9134
→ [0.18, -0.42, 0.07, 0.91, ...]

这组数称为：

• Embedding；
• Embedding Vector；
• Token Embedding；
• 嵌入向量。

不是人为编写的，而是通过训练学习得到的。

Tokenizer 把文字转换成编号，Embedding 再把编号转换成模型可以进行数学运算的向量。

Position

只有 Token Embedding 还不够，因为下面两句话包含相似的 Token，但含义不同：

小猫追小狗
小狗追小猫

模型还需要知道每个 Token 在序列中的位置，因此，模型会加入位置信息。

Token 的向量表示
=
Token Embedding
+
Position Information

现代 Transformer 可能使用：

• Positional Encoding；
• Positional Embedding；
• RoPE（Rotary Position Embedding）。

Embedding 表示“这是什么 Token”，位置信息表示“它出现在什么位置”。

5. Transformer 结合上下文进行计算

经过 Embedding 后，输入已经变成一组向量。随后，这些向量会依次经过多层 Transformer Block。

Embedding
→ Transformer Block 1
→ Transformer Block 2
→ ...
→ Transformer Block N
→ 最终隐藏状态

每个 Transformer Block 通常包含：

Transformer Block
├── Attention
├── Feed-Forward Network / MLP
├── Normalization
└── Residual Connection

Attention：结合上下文判断哪些内容重要

Attention 可以帮助模型在处理当前位置时，参考上下文中的其他 Token。比如：小明把书交给小李，因为他已经看完了。

模型在处理“他”时，需要结合前面的内容判断“他”可能指谁。

• Attention 会根据当前计算需要，对上下文中不同 Token 分配不同程度的关注。

• Attention 是一种对不同 Token 的向量信息进行加权组合的计算机制。

Forward Pass：执行一次完整的前向计算

Token 向量从模型第一层流向最后一层的过程，称为：Forward Pass，前向传播或前向计算。推理时：

输入 Token
→ Embedding
→ 多层 Transformer
→ 输出计算结果

训练和推理都会执行 Forward Pass，但两者之后的操作不同：

6. Logits：模型给出的候选分数

经过 Transformer 计算后，模型不会直接输出文字，而是为词表中的每一个 Token 计算一个分数。这些原始分数成为：Logits。

假设词表中只有几个候选 Token，模型可能得到：

Logit 越高，表示当前上下文下，该 Token 越可能成为下一个 Token。然后通过 Softmax 将 Logits 转换成概率分布：

Logits → Softmax → 下一个 Token 的概率分布

Logits 不是最终文本，也不是概率，而是模型为所有候选 Token 计算出的原始分数。

7. Sampling：从候选中选择下一个 Token

获得概率分布后，还需要决定究竟选择哪个 Token。这个过程通常称为：Decoding 或 Sampling。

Temperature 的直观理解

• 较低的 Temperature：

概率更加集中；
输出通常更稳定；
更倾向选择高概率 Token。

• 较高的 Temperature：

概率更加平缓；
候选范围更大；
输出可能更多样，也可能更不稳定。

这也解释了为什么在推理的时候，经常会看到“Temperature: 0.7”这样的参数设置。一般描述都是：如果需要多样性，可以设置一个较高的 Temperature。如果需要稳定性，可以设置一个较低的 Temperature。

8. 自回归生成：一次预测一个 Token

假设输入是：法国的首都是

模型第一次计算：法国的首都是 → 下一个 Token：“巴黎”

将它追加到上下文：法国的首都是巴黎

模型再次计算：法国的首都是巴黎 → 下一个 Token：“。”

继续追加：法国的首都是巴黎。

直到结束。

这种根据已有内容逐步生成后续内容的方式称为：Autoregressive Generation，自回归生成。

因此，大语言模型的生成过程可以概括为：

根据已有 Token
→ 预测下一个 Token
→ 把新 Token 加回输入
→ 再预测下一个 Token
→ 不断重复

这也是为什么模型生成内容时，通常可以一个 Token、一个 Token 地流式显示出来。

9. 什么时候停止生成？

自回归循环不会无限进行下去。常见停止条件包括：

• 生成了结束 Token，例如 EOS；
• 达到最大生成 Token 数量；
• 遇到预设的停止字符串；
• 应用程序主动终止；
• 工具调用或结构化输出完成。

其中：

EOS 是 End of Sequence 的缩写，表示序列结束。

模型选择 EOS 后，推理程序通常停止继续生成。

10. Decode：把 Token 转换回文本

模型生成的仍然是一系列 Token ID：[1384, 6752, 1773, 9]

Tokenizer 最后执行 Decode：Token ID → Token → 拼接和还原 → 人类可读文本

Tokenizer 实际上承担两个方向的转换：

• Encode：文本 → Token ID
• Decode：Token ID → 文本

11. Context Window：模型一次能处理多少上下文

Context Window，通常译为“上下文窗口”。表示模型在一次生成过程中能够处理的 Token 范围。

上下文通常不只包含当前用户问题，而是可能包括：

Context
├── System Prompt
├── Conversation History
├── 当前用户输入
├── RAG 检索内容
├── Tool 返回结果
└── 模型已经生成的 Token

输入 Token + 输出 Token ≤ 可用上下文范围

一个模型支持 128K Context，表示它能够在一次上下文中处理大约 128K 个 Token，而不是 128K 个汉字或单词。

上下文超过限制时，应用程序通常需要：

• 截断较早内容；
• 压缩或总结历史消息；
• 减少检索内容；
• 限制最大输出长度。

12. Prefill 和 Decode：推理过程中的两个阶段

模型首先一次性处理已有输入：

System Prompt
+ 对话历史
+ 当前问题
→ 建立上下文表示
→ 预测第一个输出 Token

通常称为 Prefill。

之后模型逐个生成新 Token：

生成 Token 1
→ 生成 Token 2
→ 生成 Token 3
→ ...

通常称为 Decode。

13. 多模态模型如何处理图片和视频？

文本通过 Tokenizer 转换，而图片、音频和视频通常通过相应的 Processor 或 Encoder 处理：

文本
→ Tokenizer
→ Text Tokens
 
图片
→ Image Processor / Vision Encoder
→ Visual Tokens
 
音频
→ Audio Processor / Audio Encoder
→ Audio Tokens 或特征
 
视频
→ Video Processor / Vision Encoder
→ Video Tokens

不同模态的表示被送入模型进行联合计算。

比如 Qwen 仓库中的：

• preprocessor_config.json；
• video_preprocessor_config.json；
• tokenizer.json；

分别服务于不同类型输入的预处理。

多模态输入不一定都采用与文本完全相同的 Tokenizer；不同模型会使用不同的 Encoder、Processor 和特征表示方案。

概念

Input to Output（从输入到输出）
│
├── Input Construction（输入组织）
│   ├── User Input
│   ├── System Prompt
│   ├── Conversation History
│   └── Chat Template
│
├── Input Encoding（输入编码）
│   ├── Tokenizer
│   ├── Token
│   ├── Token ID
│   ├── Embedding
│   └── Position Information
│
├── Model Computation（模型计算）
│   ├── Forward Pass
│   ├── Transformer Block
│   ├── Attention
│   └── Hidden State
│
├── Next-token Prediction（下一个 Token 预测）
│   ├── Logits
│   ├── Softmax
│   ├── Probability Distribution
│   └── Sampling / Decoding
│
├── Autoregressive Generation（自回归生成）
│   ├── Append Token
│   ├── Repeat
│   ├── Stop Condition
│   └── Tokenizer Decode
│
└── Input Limits（输入限制）
    ├── Context Window
    ├── Input Tokens
    ├── Output Tokens
    └── Max New Tokens

大语言模型不能直接读取文字。输入首先经过 Chat Template 组织，再由 Tokenizer 转换成 Token ID，并通过 Embedding 转换成向量。向量经过多层 Transformer 和 Attention 计算后，模型为下一个 Token 产生一组 Logits；推理程序再根据采样策略选择一个 Token，将其追加到上下文中并重复这一过程，最终由 Tokenizer 解码成人类可读的文本。

• 模型处理的不是文字，而是 Token 对应的数字和向量；
• 模型的核心任务是根据上下文预测下一个 Token；
• 完整回答是通过“预测—追加—再预测”的循环逐步生成的。