返回专栏
· 18 分钟阅读

大语言模型是如何工作的?从输入处理到文本生成的完整技术原理


一、大语言模型的工作原理概览

大语言模型(Large Language Model,LLM)的核心工作机制可以概括为:

接收输入 → 转换 Token → 向量表示 → Transformer 计算 → 预测下一个 Token → 循环生成 → 输出文本。

当用户向模型输入:

什么是机器学习?

模型并不是直接理解这句话,然后从某个知识库中搜索答案。

它会先将文本转换为 Token ID,再通过 Embedding 映射为向量,经过多层 Transformer 网络计算上下文表示,最后预测下一个 Token 的概率分布。

模型不断选择并生成新的 Token,直到满足停止条件。

整体过程:

flowchart TB
    A["用户输入文本"] --> B["Tokenizer:文本切分"]
    B --> C["Token ID:整数序列"]
    C --> D["Embedding:向量映射"]
    D --> E["Transformer:上下文计算"]
    E --> F["LM Head:生成 Logits"]
    F --> G["Softmax:计算概率分布"]
    G --> H["解码策略:选择 Token"]
    H --> I["追加到当前序列"]
    I --> J{"是否结束生成"}
    J -->|"否"| E
    J -->|"是"| K["Tokenizer 解码"]
    K --> L["返回文本回答"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F

理解这套流程,需要区分两个阶段:

阶段 核心任务 是否更新模型参数
训练(Training) 从数据中学习语言规律和知识表示 是
推理(Inference) 使用训练好的模型生成预测结果 通常否

训练决定模型学到了什么,推理决定模型如何根据当前输入使用已经学到的能力。

二、第一步:输入文本如何转换为 Token?

计算机不能直接将自然语言作为神经网络的数值输入,因此需要先进行文本编码。

这个过程由 Tokenizer 完成。

2.1 Token 是什么?

Token 是大语言模型处理文本的基本单位。

它不一定等于一个汉字或一个英文单词,具体取决于模型使用的分词算法和词表。

例如:

输入文本:
Artificial intelligence is powerful.

可能被拆分为:

["Artificial", " intelligence", " is", " powerful", "."]

中文文本也可能按照汉字、词语或子词片段进行切分。

不同模型的 Tokenizer 不一定相同,因此同一段文本在不同模型中可能对应不同数量的 Token。

2.2 Tokenizer 的编码过程

Tokenizer 通常负责两个方向的转换:

  • Encoding:文本转换为 Token ID。
  • Decoding:Token ID 转换回文本。

例如:

Token Token ID
Artificial 1024
intelligence 2056
is 3108
powerful 4216

以上仅为示意数据。

编码后,输入文本变成一个整数序列:

X=[1024,2056,3108,4216]

这些整数是词表中的索引,并不直接表达语义。

2.3 Tokenizer 的内部机制

常见的 Tokenizer 算法包括:

算法 基本机制
BPE 通过反复合并高频相邻符号构建子词词表
WordPiece 根据词片段得分构建子词词表
Unigram 从候选子词集合中选择更合适的词表
SentencePiece 直接对原始文本进行子词建模

Tokenizer 的设计会影响:

  • 模型词表规模。
  • 输入序列长度。
  • 不同语言的编码效率。
  • 训练和推理计算成本。
  • 特殊符号与代码的处理方式。

需要注意,Tokenizer 本身不负责理解文本语义。它只负责按照词表规则完成文本与 Token ID 之间的映射。

三、第二步:Embedding 将 Token ID 转换为向量

经过 Tokenizer 编码后,模型得到的是整数序列。

但神经网络需要通过连续数值进行计算,因此还需要 Embedding 层。

3.1 Embedding 的基本原理

Embedding(嵌入)是一种将离散 ID 映射为连续向量的机制。

假设模型词表大小为 V,隐藏维度为 d,那么 Embedding 矩阵可以表示为:

E\in\mathbb{R}^{V\times d}

其中:

  • V:词表大小。
  • d:每个 Token 对应的向量维度。
  • E:模型可学习的嵌入矩阵。

对于 Token ID i,模型通过查表获得对应向量:

e_i=E[i]

例如:

TokenID=1024

经过 Embedding 映射后,可能得到:

e_{1024}= [0.12,-0.31,0.45,0.08,\ldots]

这个向量通常具有数百到数千个维度,具体取决于模型架构。

3.2 为什么需要向量表示?

整数 ID 只表示 Token 在词表中的位置。

例如:

苹果 = 1024
香蕉 = 2056
汽车 = 3108

这些数字之间不存在天然的语义距离关系。

Embedding 则通过训练学习不同 Token 的连续向量表示,使模型能够利用向量运算处理语言信息。

需要注意:

  • Embedding 向量不是人工编写的语义字典。
  • 每个维度通常不能直接解释为某个明确的人类概念。
  • 语义信息通常分布在多个维度和网络层中。
  • 向量之间的相似性只是表示关系的一种方式,不等同于完整语义理解。

3.3 位置表示:模型如何知道 Token 的顺序?

Embedding 主要提供 Token 的内容表示,但语言还具有顺序信息。

例如:

猫追老鼠
老鼠追猫

两句话使用的 Token 可能相同,但顺序不同,表达的含义也不同。

因此,Transformer 还需要位置信息。

常见方式包括:

  • 绝对位置编码(Absolute Positional Encoding)。
  • 相对位置编码(Relative Positional Encoding)。
  • RoPE(Rotary Position Embedding)。
  • ALiBi(Attention with Linear Biases)。

对于使用 RoPE 的模型,位置信息通过对 Query 和 Key 向量进行旋转变换融入注意力计算。

Embedding 与位置表示结合后,形成 Transformer 的输入表示。

flowchart TB
    A["Token ID 序列"] --> B["Embedding 查表"]
    C["Token 位置信息"] --> D["位置表示计算"]
    B --> E["组合输入表示"]
    D --> E
    E --> F["输入 Transformer"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F

四、第三步:Transformer 如何处理输入?

Transformer 是当前主流生成式大语言模型的核心架构。

它通过多层神经网络,对输入序列中的 Token 表示进行上下文计算。

典型 Decoder-only Transformer 的主要组成部分包括:

  1. Masked Self-Attention。
  2. Feed Forward Network。
  3. Residual Connection。
  4. Layer Normalization。

多个 Transformer Block 依次堆叠,逐层处理输入表示。

4.1 Transformer Block 的基本结构

一个简化的 Transformer Block 可以表示为:

flowchart TB
    A["输入隐藏状态 x"] --> B["Layer Normalization"]
    B --> C["Masked Self-Attention"]
    C --> D["残差连接"]
    A --> D
    D --> E["Layer Normalization"]
    E --> F["Feed Forward Network"]
    F --> G["残差连接"]
    D --> G
    G --> H["输出隐藏状态"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F

上图采用 Pre-LN 结构进行说明。实际模型可能采用不同的归一化方式、注意力结构和前馈网络设计。

4.2 Self-Attention:建立上下文关联

Self-Attention 是 Transformer 的核心机制。

它让序列中的每个 Token 根据当前任务需要,聚合其他位置的信息。

例如:

小明把书放在桌子上,因为它很重。

模型处理“它”时,需要利用前文中的相关信息,判断这个代词与其他 Token 的关联。

Self-Attention 通过 Query、Key、Value 三种向量完成这一过程。

Query、Key、Value

对于输入隐藏状态矩阵 X,通过三个不同的可学习线性映射得到:

Q=XW_Q
K=XW_K
V=XW_V

其中:

  • Query:表示当前位置希望获取什么信息。
  • Key:表示当前位置可以通过什么特征被匹配。
  • Value:表示当前位置实际提供的信息内容。

这三个名称是帮助理解计算过程的抽象,不代表模型真的在执行数据库查询。

Attention 的计算过程

首先计算 Query 和 Key 的点积:

S=QK^T

点积反映不同位置表示之间的匹配程度。

然后进行缩放:

S'=\frac{QK^T}{\sqrt{d_k}}

再使用 Softmax 转换为注意力权重:

A=softmax\left(\frac{QK^T}{\sqrt{d_k}}\right)

最后使用注意力权重对 Value 加权求和:

Attention(Q,K,V)=AV

合并后:

Attention(Q,K,V)= softmax\left(\frac{QK^T}{\sqrt{d_k}}\right)V

其中 d_k 是 Key 向量的维度。

为什么需要除以平方根?

随着向量维度增大,Query 与 Key 的点积数值可能变大。

如果直接进行 Softmax,可能导致概率分布过度集中,使梯度变小,影响训练稳定性。

除以 \sqrt{d_k} 可以控制点积的数值尺度。

4.3 Causal Mask:为什么不能看到未来 Token?

对于自回归语言模型,模型在预测当前位置时,只允许使用当前及之前的 Token。

例如:

我 喜欢 学习 人工智能

当模型预测“学习”后面的 Token 时,不能提前访问“人工智能”。

因此,需要使用因果掩码(Causal Mask)。

对于长度为 4 的序列,其注意力可见关系可以表示为:

当前位置 Token 1 Token 2 Token 3 Token 4
Token 1 可见 不可见 不可见 不可见
Token 2 可见 可见 不可见 不可见
Token 3 可见 可见 可见 不可见
Token 4 可见 可见 可见 可见

在注意力计算中,通常通过将不允许关注的位置设置为负无穷或等效的极小值,使 Softmax 后这些位置的权重为零。

这保证了训练和自回归生成的因果约束。

4.4 Multi-Head Attention:为什么需要多个注意力头?

单个注意力头只能在一个投影子空间中进行注意力计算。

多头注意力通过多个独立的投影矩阵,并行计算不同的注意力结果。

head_i=Attention(QW_i^Q,KW_i^K,VW_i^V)

多个头的输出拼接后,再通过输出投影矩阵:

MultiHead(Q,K,V)= Concat(head_1,\ldots,head_h)W^O

多个注意力头能够学习不同的关联模式,但不能简单地认为每个头只负责一种固定语义关系。

4.5 Feed Forward Network:进一步变换特征

Attention 负责 Token 之间的信息交互,FFN 则对每个位置的隐藏表示进行非线性变换。

典型形式:

FFN(x)=\sigma(xW_1+b_1)W_2+b_2

其中:

  • W_1、W_2:权重矩阵。
  • b_1、b_2:偏置。
  • \sigma:激活函数。

现代模型中还可能采用 SwiGLU 等门控结构。

4.6 残差连接与归一化

深层 Transformer 通常包含大量重复的计算模块。

残差连接允许信息跨越子层传递:

y=x+F(x)

它有助于改善深层网络中的梯度传播和优化稳定性。

Layer Normalization 则对隐藏表示进行归一化,帮助稳定网络训练。

五、第四步:多层 Transformer 如何逐层处理信息?

一个 Transformer Block 只能完成一次上下文交互和特征变换。

实际大语言模型通常堆叠几十层甚至更多层 Transformer Block。

例如,一个包含 N 层 Transformer Block 的模型,可以表示为:

H_0=Embedding(X)+Position(X)
H_1=Block_1(H_0)
H_2=Block_2(H_1)
\cdots
H_N=Block_N(H_{N-1})

最终得到:

H_N

其中:

  • H_0:初始输入表示。
  • H_i:第 i 层的隐藏状态。
  • N:Transformer Block 数量。

每一层都会对隐藏表示进行进一步计算。

从整体上看,模型不断对输入进行信息整合和特征变换,形成更适合当前预测任务的上下文表示。

需要注意,不能简单地将底层、中层和高层分别固定解释为语法、语义和推理。不同层的表示功能可能交叉,实际机制也远比这种分层描述复杂。

六、第五步:模型如何预测下一个 Token?

经过多层 Transformer 计算后,模型获得最终隐藏状态。

对于自回归生成,通常使用最后一个有效位置的隐藏状态预测下一个 Token。

6.1 LM Head:输出投影层

假设最后一个位置的隐藏状态为:

h_t\in\mathbb{R}^{d}

词表大小为 V,模型通过输出投影层得到:

z_t=h_tW_{vocab}+b

其中:

  • h_t:当前位置隐藏状态。
  • W_{vocab}:输出投影矩阵。
  • b:偏置。
  • z_t:Logits 向量。

Logits 的维度为:

z_t\in\mathbb{R}^{V}

也就是说,模型会为词表中的每个 Token 计算一个未归一化分数。

例如:

候选 Token Logit
数据 2.8
模型 2.1
算法 1.5
系统 0.8

这些分数本身不是概率。

6.2 Softmax:将 Logits 转换为概率

通过 Softmax 可以将 Logits 转换为概率分布:

P(x_i)= \frac{e^{z_i}}{\sum_{j=1}^{V}e^{z_j}}

其中:

  • z_i:第 i 个 Token 的 Logit。
  • V:词表大小。
  • P(x_i):对应 Token 的预测概率。

例如:

候选 Token 示例概率
数据 0.55
模型 0.25
算法 0.15
系统 0.05

这些数值仅用于解释概率分布。

Softmax 输出的概率之和为 1。

6.3 为什么不是直接选择概率最高的 Token?

如果每次都选择概率最高的 Token,就属于 Greedy Decoding。

这种方式简单,但容易产生重复、缺乏多样性或局部最优问题。

因此,模型还可以使用不同的解码策略:

  • Temperature。
  • Top-K Sampling。
  • Top-P Sampling。
  • Beam Search。
  • Greedy Search。

这些方法决定如何从概率分布中选择下一个 Token。

七、第六步:模型如何逐 Token 生成完整回答?

大语言模型通常不会一次性生成完整答案,而是通过自回归方式逐步生成。

假设用户输入:

人工智能的核心技术包括

模型可能按照以下步骤生成:

步骤 当前上下文 生成 Token
1 人工智能的核心技术包括 机器学习
2 人工智能的核心技术包括机器学习 、
3 人工智能的核心技术包括机器学习、 深度学习
4 人工智能的核心技术包括机器学习、深度学习 和
5 人工智能的核心技术包括机器学习、深度学习和 自然语言处理

每生成一个 Token,模型都会将它加入当前上下文,用于下一次预测。

7.1 自回归生成的数学表达

假设已有上下文:

x_1,x_2,\ldots,x_t

模型预测下一个 Token:

P(x_{t+1}|x_1,\ldots,x_t)

选择一个 Token 后,序列变为:

x_1,x_2,\ldots,x_t,x_{t+1}

然后继续预测:

P(x_{t+2}|x_1,\ldots,x_t,x_{t+1})

最终,整个序列的联合概率可以表示为:

P(X)=\prod_{t=1}^{T}P(x_t|x_{<t})

这就是自回归语言模型的核心机制。

7.2 生成什么时候结束?

常见的停止条件包括:

  • 生成 EOS(End of Sequence)结束 Token。
  • 生成模型配置的停止 Token。
  • 达到最大生成 Token 数量。
  • 命中用户或应用程序配置的停止字符串。
  • 外部推理服务主动终止生成。

实际模型可能使用专门的对话结束 Token,例如区分一条消息结束和整个助手回合结束。

因此,停止条件不一定只有一个 EOS Token。

八、第七步:KV Cache 如何加速生成?

自回归生成有一个重要的性能问题:

每生成一个新 Token,都需要利用之前的上下文。

如果每次都重新计算所有历史 Token 的 Key 和 Value,会产生大量重复计算。

KV Cache 就是为了解决这个问题。

8.1 不使用 KV Cache 的情况

假设模型已经生成了:

A B C

现在需要预测 D。

如果不使用 KV Cache,模型需要重新处理:

A B C

生成 D 后,再预测 E 时,又需要重新处理:

A B C D

历史 Token 的 Key 和 Value 被重复计算。

8.2 使用 KV Cache 的情况

Transformer 的注意力计算会生成 Key 和 Value。

KV Cache 会保存已经处理过的历史 Token 对应的 Key 和 Value。

生成下一个 Token 时:

  1. 读取历史 Token 的缓存。
  2. 只计算新 Token 对应的 Query、Key 和 Value。
  3. 将新 Key 和 Value 追加到缓存。
  4. 使用历史缓存与当前 Token 进行注意力计算。

过程如下:

flowchart TB
    A["输入历史 Token"] --> B["计算历史 K、V"]
    B --> C["保存到 KV Cache"]
    C --> D["输入新的 Token"]
    D --> E["计算当前 Q、K、V"]
    E --> F["读取历史 KV Cache"]
    F --> G["拼接历史与当前 K、V"]
    G --> H["执行 Attention"]
    H --> I["预测下一个 Token"]
    I --> J["追加新的 K、V 到缓存"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

8.3 KV Cache 的性能价值

KV Cache 能够显著减少自回归解码阶段的重复计算。

但它也会增加显存占用。

其显存需求大致与以下因素相关:

Memory_{KV} \propto 2\times L\times B\times T\times H_{kv}\times d_h

其中:

  • L:Transformer 层数。
  • B:Batch Size。
  • T:缓存 Token 数量。
  • H_{kv}:Key/Value 头数量。
  • d_h:每个头的维度。
  • 2:分别存储 Key 和 Value。

如果使用 BF16 或 FP16,每个元素通常占用 2 字节。

更完整的估算还需要考虑数据类型、缓存布局、对齐和推理框架实现。

8.4 MHA、GQA 与 MQA

KV Cache 的大小还与注意力结构有关。

结构 特点
MHA 每个 Query Head 对应独立的 Key/Value Head
GQA 多个 Query Head 共享一组 Key/Value Head
MQA 所有 Query Head 共享一组 Key/Value Head

GQA 和 MQA 可以减少 Key/Value 的头数量,从而降低 KV Cache 显存占用和相关访存压力。

九、训练阶段与推理阶段有什么区别?

虽然训练和推理使用相同的模型架构,但它们的执行方式和计算目标不同。

9.1 训练阶段

训练阶段的目标是优化模型参数。

典型过程:

  1. 输入训练样本。
  2. 执行前向传播。
  3. 计算预测结果。
  4. 计算损失函数。
  5. 反向传播计算梯度。
  6. 优化器更新参数。