Agent（1）：深入理解LLM

前言

大语言模型（Large Language Model，LLM）迭代发展非常迅速，它们已经不再局限于传统的文本生成任务，而是逐渐具备代码编写、知识问答、数学推理、信息提取以及复杂任务处理等能力。

尤其是如今Agent兴起以及技术不断创新完善，
大语言模型逐渐成为智能体系统的核心组成部分。无论是 Agent 的任务规划、工具选择，还是多轮交互与结果分析，都离不开大语言模型提供的语言理解和生成能力。

在真正学习 Agent 之前，我们需要先回答一个更基础的问题：

大语言模型究竟是什么？它为什么能够通过预测下一个 Token，表现出如此复杂的能力？

我们有必要先从底层建立对 LLM 的完整认知。

一、LLM是什么？

1.1 从人工智能到大语言模型

我们先明确几个经常出现的概念：

人工智能（Artificial Intelligence，AI）：研究如何让机器表现出通常需要人类智能才能完成的能力。
机器学习（Machine Learning，ML）：人工智能的一个重要分支，通过数据让计算机学习规律，而不是完全依赖人工编写规则。
深度学习（Deep Learning，DL）：机器学习的一个分支，主要利用多层神经网络学习数据中的复杂特征和表示。
生成式人工智能（Generative AI，AIGC）：利用生成模型产生新的内容，包括文本、图片、音频、视频和代码等。
大语言模型（Large Language Model，LLM）：以语言建模为核心目标，通过大规模数据和深度神经网络训练得到的模型，通常具备文本理解与生成能力。

可以将它们的关系简单理解为：

人工智能 → 机器学习 → 深度学习 → 大语言模型。

需要注意的是，生成式 AI是更广泛的技术范畴，既包含大语言模型，也包含图像扩散模型、音频生成模型和视频生成模型等。

1.2 什么是语言模型

在理解大语言模型之前，需要先理解语言模型（Language Model，LM）。

简单来说：

语言模型就是一个用于估计文本序列概率的模型。

例如，给定一句话：

今天天气非常____。

人类很容易想到：

好
热
糟糕

语言模型也在做类似的事情：根据已有上下文，计算不同后续 Token 出现的概率。

假设模型给出的概率分布如下：

候选词	概率
好	0.55
热	0.25
糟糕	0.15
其他	0.05

那么模型认为接下来出现“好”的可能性最大。

这就是语言模型最基础的工作方式。

早期语言模型主要采用统计方法，例如 N-gram 模型。

N-gram 的核心思想是：通过统计语料中连续出现的 N 个词或字符，估计下一个词出现的概率。
（即条件概率公式）：

$P(w_i \mid w_{i-n+1},\dots,w_{i-1}) = \frac{\operatorname{count}(w_{i-n+1},\dots,w_{i-1},w_i)}{\operatorname{count}(w_{i-n+1},\dots,w_{i-1})}$

这种方法实现简单，但存在明显局限：

依赖局部上下文，难以捕获较远距离的语义关系。
数据稀疏问题明显，未出现过的组合难以估计。
很难从大量文本中学习复杂的语义和语言结构。

随着神经网络和深度学习的发展，语言模型逐渐从基于统计频率的方法，转向基于神经网络的概率建模方法。

1.3 什么是大语言模型

大语言模型并没有一个适用于所有模型的严格参数规模分界线。

通常来说，它是指使用大规模数据训练、拥有大量可学习参数，并能够建模复杂语言规律的神经网络模型。

语言模型参数量大到一定程度能够涌现出一定的智能，具有较强的泛化性。

LLM通常具有以下特点：

大规模参数
大规模训练数据
强大的上下文建模能力
通用任务能力
上下文学习能力

LLM 并不是一个简单的知识数据库，而是一个通过训练学习语言和数据模式的神经网络模型。

模型参数中编码了大量从训练数据中学习到的信息，但这些参数并不等同于一个可以直接查询的结构化知识库。

二、LLM的核心：Next Token Prediction

2.1 什么是 Next Token Prediction？

Next Token Prediction 指的是：给定一段已有的 Token 序列，让模型预测下一个 Token 出现的概率分布。

例如：

输入：

AI正在改变

模型根据当前上下文，可能预测：

世界：0.35
社会：0.25
生活：0.20
技术：0.10
其他：0.10

这里的概率仅用于说明原理，并非真实模型的实验数据。

模型会根据生成策略，从概率分布中选择或采样一个 Token。

假设本次选择了“世界”，那么输入序列就变成：

AI正在改变世界

接下来，模型再根据更新后的上下文预测下一个 Token。如此循环，直到满足结束条件。
这就是现代自回归语言模型最基本的生成机制。

2.2 什么是自回归语言模型

自回归（Autoregressive）是指当前时刻的预测依赖于之前已经生成的内容。

对于一个 Token 序列：

$X = (x_1, x_2, \ldots, x_n)$

根据概率链式法则，整个序列的联合概率可以分解为：

$P(X)=\prod_{t=1}^{n}P(x_t \mid x_1,\ldots,x_{t-1})$

也可以写成：

$P(X)=\prod_{t=1}^{n}P(x_t \mid x_{<t})$

其中：

X：完整的 Token 序列。
：第 t 个位置的 Token。
$x_{<t}$ ：当前位置之前的所有 Token。
$P(x_t \mid x_{<t})$ ：给定之前上下文时，当前位置 Token 出现的条件概率。

这个公式说明：
模型不需要一次性预测整个句子，而是将整个序列的概率分解为一系列条件概率的乘积。

例如：
我 / 喜欢 / 学习 / AI

模型可以依次学习：

$P(like \mid I)$

$P(learning \mid I,like)$

$P(AI \mid I,like,learning)$

通过学习大量这样的序列，模型逐渐掌握文本中不同 Token 之间的统计关系。

需要注意，现代模型通常以 Token 而不是完整单词作为基本预测单位。

2.3 为什么预测下一个Token就能产生复杂能力？

直觉上看，预测下一个 Token 似乎只是一个简单的文本补全任务。
但问题在于：如果模型想要在大量不同场景中准确预测下一个 Token，就必须学习上下文中包含的各种信息。

因此，虽然训练目标是预测下一个 Token，但为了提高预测准确率，模型需要从训练数据中学习不同层次的信息。

这些能力并不是通过给模型预先编写一套完整的规则获得的，而是在训练过程中通过参数优化逐渐形成的。

GPT-3 的研究表明，随着模型规模扩大，模型在 Zero-shot 和 Few-shot 场景中的表现得到明显提升。

这说明大规模预训练不仅能够让模型学习语言模式，也能够为多种下游任务提供通用能力。但是规模并不是能力的唯一决定因素

三、Tokenization：模型如何处理人类语言？

计算机如何把人类输入的文本转换成模型可以处理的数据？

答案就是 Tokenization 。

3.1 什么是Token

Token （词元）是大语言模型处理文本时使用的基本单位。

它不一定等于一个完整单词，也不一定等于一个汉字。
具体拆分方式取决于模型使用的 Tokenizer 和词表。
因此，不同模型对同一段文本的 Token 数量可能不同。

3.2 为什么不直接使用单词作为 Token？

假设我们采用完整单词作为词表。

那么需要考虑一个问题：

如果训练语料中没有出现过某个新单词，模型应该如何处理？

例如：

AIFullStackEngineer

如果将整个字符串视为一个独立 Token，就可能出现词表中不存在该 Token 的情况。

这就是词表覆盖率和 OOV（Out Of Vocabulary）问题。

另一方面，如果采用字符级别 Tokenization，虽然可以覆盖更多文本，但序列长度会明显增加。

因此，现代语言模型通常采用子词（Subword）或字节级别的 Tokenization 方法，在词表规模和序列长度之间进行权衡。

3.3 BPE：字节对编码

BPE（Byte Pair Encoding）最初是一种数据压缩算法，后来被应用于 NLP 领域的 Tokenization。

其核心思想是：

从较小的基础符号开始，不断合并语料中出现频率较高的相邻符号，逐渐构建更大的 Token。

举一个简单例子。

假设训练语料中出现了：

hug
hug
hug
pug
pug
pun
bun

最初可以将单词拆分成字符：

h u g
h u g
h u g
p u g
p u g
p u n
b u n

统计相邻字符组合的出现频率。

假设 u 和 g 是最频繁出现的相邻组合，那么将它们合并：

u + g -> ug

之后再统计新的相邻组合，继续合并。

最终可能得到：

hug -> ["hug"]
pug -> ["p", "ug"]
pun -> ["p", "u", "n"]
bun -> ["b", "u", "n"]

实际 BPE 实现还涉及文本预处理、预分词、字节处理及合并规则等步骤，以上只是简化演示。

这种方式兼顾了词表规模和序列长度。

3.4 Tokenization 的完整流程

一般来说，文本进入模型之前需要经历以下过程：

原始文本
   |
   v
文本规范化
   |
   v
预分词
   |
   v
Tokenizer 编码
   |
   v
Token 序列
   |
   v
Token ID 序列

例如：

原始文本：
I love AI.

假设经过 Tokenizer 处理后：

Token：
["I", " love", " AI", "."]

再通过词表映射为整数：

Token ID：
[42, 573, 375, 24]

这里的数字仅为示意，不代表真实词表中的 ID。

模型最终处理的是这些数字，而不是直接处理字符串。

需要特别区分：

Token：文本被拆分后的基本单元。
Token ID：Token 在词表中对应的整数编号。
Embedding：将 Token ID 映射为向量后的表示。

3.5 实践：使用 tiktoken 查看 Tokenization

可以使用 OpenAI 开源的 tiktoken 库进行简单实验。

安装：

pip install tiktoken

代码：

import tiktoken

# 获取 GPT-4o 使用的 o200k_base 编码
encoding = tiktoken.get_encoding("o200k_base")

texts = [
    "Hello, world!",
    "你好，世界！",
    "Artificial Intelligence",
    "人工智能 Agent 开发",
]

for text in texts:
    tokens = encoding.encode(text)

    print(f"原始文本: {text}")
    print(f"Token IDs: {tokens}")
    print(f"Token 数量: {len(tokens)}")
    print(f"解码结果: {encoding.decode(tokens)}")
    print("-" * 50)

运行之后，可以观察：

不同语言的 Token 数量可能不同。
不同文本长度并不一定与 Token 数量成正比。
空格、标点和特殊字符也可能影响 Tokenization。

这里使用的 o200k_base 只是一个具体编码示例，不代表所有模型都使用它。

以下是我运行的结果（我直接在vscode里随手打开了一个项目文件并使用以前的anaconda环境演示的）

(DL_pytorch) D:\Vscode\goLearning\web_app>D:/anaconda/envs/DL_pytorch/python.exe d:/Vscode/ai/项目落地.py
原始文本: Hello, world!
Token IDs: [13225, 11, 2375, 0]
Token 数量: 4
解码结果: Hello, world!
--------------------------------------------------
原始文本: 你好，世界！
Token IDs: [177519, 979, 28428, 3393]
Token 数量: 4
解码结果: 你好，世界！
--------------------------------------------------
原始文本: Artificial Intelligence
Token IDs: [186671, 42378]
Token 数量: 2
解码结果: Artificial Intelligence
--------------------------------------------------
原始文本: 人工智能 Agent 开发
Token IDs: [47243, 60319, 28237, 39339, 2233]
Token 数量: 5
解码结果: 人工智能 Agent 开发
--------------------------------------------------

Token 数量为什么重要？

Token 数量不仅影响模型输入长度，还会影响实际工程成本。

例如：

API 通常按照输入 Token 和输出 Token 计费。
上下文窗口通常以 Token 数量衡量。
Token 数量会影响模型推理时的计算量。
输入序列越长，注意力机制通常需要处理更多位置之间的关系。

因此，在 RAG 系统中，文档切片（Chunking）也需要考虑 Token 数量，而不能只按照字符数量进行切分。

四、Embedding 与模型参数

经过 Tokenization 之后，文本已经转换成 Token ID。

但是，整数编号本身并不包含丰富的语义信息。

例如：

苹果 -> 100
香蕉 -> 200
汽车 -> 300

这些数字只是索引，并不能直接表示它们之间的语义关系。

因此，还需要通过 Embedding 将离散的 Token ID 转换为连续的向量表示。

4.1 何为Embedding？

Embedding（嵌入）是一种将离散对象映射到连续向量空间的表示方式。
对于 LLM 来说，Token Embedding 的作用就是将 Token ID 映射成一个高维向量。

需要注意：Embedding 并不是通过人为规定每个维度的含义来工作的，而是通过训练不断更新向量表示，使其适应模型的预测目标。

另外，Embedding 也不等同于我们在 RAG 中使用的文本 Embedding 模型。

二者虽然都涉及向量表示，但训练目标、模型结构和实际用途可能不同。

具体Embedding过程包含了:
词嵌入 --> 位置编码 --> 得到的这两个向量相加融合 --> (可选：层归一化 + Dropout 大多数模型会进行此项操作作为进入Transformer前的预处理)

4.2 什么是模型参数？

模型参数（Parameters）是神经网络在训练过程中需要学习和更新的数值。

例如：

Embedding 矩阵中的权重。
Attention 层中的权重矩阵。
Feed Forward Network 中的权重矩阵。
其他网络层中的可学习参数。

训练的本质，就是根据模型预测结果与真实目标之间的差异，调整这些参数。

我们经常听到：

7B 模型
32B 模型
70B 模型
2800B模型（2.8万亿参数）

其中 B 表示 Billion，即十亿。

但需要注意：

参数数量不等于模型文件大小，也不等于模型运行时需要的全部显存。

模型文件大小还与参数精度、量化方式等有关；实际推理还需要额外的激活值、KV Cache 和运行时内存。

4.3 参数越多，模型能力就越强吗？

不能简单这样理解。

模型能力通常受到多个因素影响：

模型参数规模。
预训练数据的数量和质量。
模型架构。
训练 Token 数量。
训练计算预算。
后训练方法与数据质量。

DeepMind 在 Chinchilla 论文中研究了给定计算预算下模型规模与训练数据量之间的关系，研究发现，部分此前的大模型存在训练不足的问题。在相同计算预算下，合理平衡模型参数量和训练 Token 数量，可能获得更好的效果。

这说明模型训练不是简单地堆叠参数就可以解决的。

五、LLM是如何训练出来的

一个大语言模型究竟是如何从大量文本中学习知识和语言规律的？

现代 LLM 的训练通常可以从两个大的阶段理解：

预训练（Pre-training）。
后训练（Post-training）。

这是一种便于理解的总体划分，不代表所有模型都采用完全相同的训练流程。

5.1 预训练：让模型学习语言规律（学习知识）

预训练是大语言模型训练的重要阶段。

它的核心目标是：

利用大量训练数据，让模型学习语言序列中的统计规律，并通过不断预测下一个 Token 来优化模型参数。

现代 GPT 类模型通常采用因果语言建模（Causal Language Modeling，CLM）目标。

假设有一段训练文本：

人工智能正在改变世界

经过 Tokenization：

[x1, x2, x3, x4, x5]

模型的训练目标可以理解为：

输入上下文	预测目标
x1	x2
x1, x2	x3
x1, x2, x3	x4
x1, x2, x3, x4	x5

也就是说，模型需要根据前面的 Token 预测下一个 Token。

在实际训练中，通常可以将一段 Token 序列同时输入模型，通过因果掩码限制每个位置只能利用当前位置及之前的信息，从而并行计算多个位置的预测损失。

这也是 GPT 类模型能够高效进行训练的重要原因之一。

需要注意：

训练阶段可以并行计算多个位置的预测结果，但生成阶段通常仍然需要按照自回归顺序逐步生成 Token。

5.2 训练数据哪来？

模型训练需要大量数据。

常见数据来源包括：

网页文本。
电子书籍。
学术论文。
新闻文章。
技术文档。
开源代码。
对话数据。
其他经过处理的专业语料。
私有（真实采集）数据

但是，原始数据并不能直接全部投入训练。

通常还需要经过：

数据清洗。
数据去重。
质量过滤。
敏感内容处理。
数据格式转换。
Tokenization。
训练数据构造。

为什么需要数据清洗？

因为互联网上的数据并不都是高质量的。

其中可能存在：

重复内容
错误信息
无意义文本符号
垃圾广告
格式异常的数据
不适合训练的内容

如果不进行适当的数据处理，可能极大影响模型的训练效果。

因此，训练数据质量是影响模型能力的重要因素。

5.3 模型如何判断自己预测得对不对？

这里就涉及一个非常重要的概念：

Loss Function（损失函数）。

损失函数用于衡量模型预测结果与真实目标之间的差异。

对于自回归语言模型，常见的训练目标是交叉熵损失（Cross Entropy Loss）。

假设模型需要预测下一个 Token：

真实 Token：人工智能

模型输出的概率分布为：

Token	概率
人工智能	0.8
机器学习	0.1
深度学习	0.1

模型对真实 Token 分配的概率越高，损失通常越小。

对于单个预测位置，可以写为：

$L = -\log P(x_t \mid x_{<t})$

对于一整个训练序列，可以写为：

$L = -\sum_{t=1}^{n} \log P(x_t \mid x_{<t})$

实际训练通常还会对有效预测位置求平均，并考虑 Padding、特殊 Token 等因素。

模型给真实 Token 分配的概率越低，损失越大。
因此，训练的目标就是不断降低预测损失。

5.4 模型如何更新参数

仅仅计算损失还不够。

我们还需要让模型知道：

应该调整哪些参数，才能让下一次预测更加准确？

这就涉及反向传播（Backpropagation）和梯度下降（Gradient Descent）。

整体过程如下：

输入训练数据
    |
    v
模型前向传播
    |
    v
得到预测结果
    |
    v
计算 Loss
    |
    v
反向传播
    |
    v
计算各参数梯度
    |
    v
优化器更新参数
    |
    v
进入下一轮训练

梯度下降的基本更新公式：

$\theta_{t+1} = \theta_t - \eta \nabla_\theta L$

其中：

$\theta$ ：模型参数。
$\eta$ ：学习率（Learning Rate）。
$\nabla_\theta L$ ：损失函数对模型参数的梯度。

简单理解：

梯度告诉我们，参数朝哪个方向调整能够使损失下降得更快。

优化器则根据梯度和相应的优化策略更新模型参数。

实际大模型训练中，常使用 AdamW 等优化器，并结合学习率调度、梯度裁剪、混合精度训练等技术。

通过大量训练迭代，模型逐渐学习训练语料中的语言规律。

5.5 训练完成意味着什么？

当预训练结束后，我们得到一个 Base Model（基础模型）。

它已经具备一定的语言建模能力，能够根据输入上下文预测后续 Token。

但这并不意味着它已经成为一个优秀的对话助手。

例如，给模型输入：

请介绍一下什么是 Go 语言。

一个基础模型可能继续生成：

Go 语言是一种由 Google 开发的编程语言...

也可能采用其他文本续写方式。

它的核心目标仍然是预测合理的后续 Token，而不是天然理解并执行人类的指令。

这就引出了后训练阶段。

六、从 Base Model 到 Chat Model：模型后训练（如何回答）

预训练让模型获得了语言建模能力，但我们希望模型不仅能够续写文本，还能够：

理解用户指令。
按照指定格式回答。
遵循任务约束。
拒绝不合适的请求。
尽可能提供有帮助的回答。

因此，需要通过后训练（Post-training）进一步调整模型行为。

6.1 SFT：监督微调

SFT（Supervised Fine-Tuning）即监督微调。

其核心思想是：

使用高质量的指令与回答数据，让模型学习如何按照人类的要求完成任务。

例如：

{
  "messages": [
    {
      "role": "user",
      "content": "请解释什么是 Go 语言。"
    },
    {
      "role": "assistant",
      "content": "Go 是一种由 Google 开发的静态类型、编译型编程语言，具有简洁的语法和较好的并发支持。"
    }
  ]
}

模型在 SFT 阶段学习：

给定用户输入，应该生成怎样的回答。

从训练目标来看，SFT 仍然可以使用自回归语言建模目标，只不过训练数据从普通文本转变成了具有指令和回答结构的数据。

SFT 的价值在于：

让模型从单纯的文本续写，逐渐转向按照指令完成任务。

6.2 RLHF：基于人类反馈的强化学习

仅仅通过人工编写的标准答案进行监督训练，还不一定能够完全满足人类对回答质量的要求。

例如：

同一个问题可能存在多个合理答案。

那么，怎样让模型学习人类更喜欢哪种回答？

RLHF（Reinforcement Learning from Human Feedback）就是一种利用人类偏好反馈优化模型行为的方法。

以经典 InstructGPT 训练流程为例，可以分为三个主要步骤。

第一步：监督微调（SFT）

收集人工编写的高质量示范回答，用于训练初始指令模型。

第二步：训练奖励模型（Reward Model）

让模型针对同一个问题生成多个回答，再由人工标注人员比较回答质量。

例如：

问题：

什么是 Go 语言？

回答 A：

Go 是一种编程语言。

回答 B：

Go 是 Google 开发的一种静态类型、编译型语言，具有简洁的语法和原生并发支持，常用于后端服务和云原生开发。

如果人工标注人员认为 B 更好，那么这类偏好数据就可以用于训练奖励模型。

奖励模型的目标是学习人类偏好的相对评价规律。

第三步：强化学习优化

使用奖励模型为模型生成的回答提供奖励信号，再通过强化学习方法优化模型策略。

经典 InstructGPT 方案使用 PPO（Proximal Policy Optimization）进行优化。

其基本过程：

用户 Prompt
    |
    v
模型生成回答
    |
    v
奖励模型评分
    |
    v
计算奖励信号
    |
    v
PPO 优化策略模型
    |
    v
更新模型参数

这套流程让模型不仅学习如何生成文本，还进一步学习如何生成更符合人类偏好的回答。

6.3 DPO：直接偏好优化

RLHF 中通常需要训练奖励模型，并通过强化学习算法优化模型。

DPO（Direct Preference Optimization）提出了另一种思路：

利用偏好数据直接优化语言模型，而不需要像经典 RLHF 流程那样单独训练奖励模型并运行 PPO 优化。

偏好数据通常包含：

Prompt
Chosen：更受偏好的回答。
Rejected：不太受偏好的回答。

例如：

{
  "prompt": "什么是 RAG？",
  "chosen": "RAG 是检索增强生成技术，通过检索外部知识并将相关信息提供给大语言模型，从而增强回答的知识依据。",
  "rejected": "RAG 就是让模型自己搜索一下。"
}

DPO 通过偏好优化目标，推动模型提高 Chosen 回答相对于 Rejected 回答的偏好概率。

它简化了部分传统 RLHF 的训练流程，但并不意味着所有模型都使用 DPO。

6.4 Base Model、Instruct Model 与 Reasoning Model

实际使用模型时，经常会遇到这些概念。

类型	主要特点
Base Model	主要经过预训练，擅长根据上下文续写
Instruct Model	经过指令微调和相关后训练，更适合遵循用户指令
Reasoning Model	经过针对推理能力的训练与优化，强调复杂问题求解

它们并不是完全互斥的模型架构分类，而是从训练目标和使用方式等角度进行的概括。

对于 Agent 开发而言，我们通常更关注模型是否具备较好的指令遵循、结构化输出、工具调用和复杂任务处理能力。

七、LLM的推理与文本生成机制

模型训练完成之后，就可以进入实际使用阶段。

我们向模型输入一段 Prompt，它就能生成一段回答。

但模型内部究竟经历了什么？

这里需要理解 Inference（推理）和 Decoding（解码）。

7.1 什么是模型推理？

模型推理是指使用已经训练好的模型参数，对新的输入进行计算，并产生预测结果的过程。

与训练不同：

训练阶段需要计算损失并更新模型参数。
推理阶段通常不更新模型参数，而是使用已有参数进行前向计算。

例如：

用户输入：
请解释什么是 Agent。

模型会先对输入进行 Tokenization，然后将 Token ID 输入神经网络。

经过模型计算后，得到下一个 Token 的预测结果。

需要注意：

推理阶段并不意味着模型完全不进行计算梯度以外的操作，而是通常不进行用于训练的参数更新。

7.2 Logits：模型输出的原始分数

Logits 是模型输出的未归一化分数。

它们不是概率，也不要求加起来等于 1。

要得到概率分布，需要通过 Softmax 函数进行转换。

7.3 Softmax：将分数转换成概率

Softmax 的计算公式：

$P_i = \frac{e{z_i}}{\sum_{j=1}{V} e^{z_j}}$

其中：

：第 i 个 Token 对应的 Logit。
V：词表大小。
：对应 Token 的概率。

经过Softmax。模型就得到一个完整的候选Token概率分布

7.4 Temperature：控制生成随机性

模型得到概率分布后，不一定总是选择概率最大的 Token。

我们可以通过 Temperature（温度）参数调整概率分布。粗略控制模型回答的准确性与创造性

T < 1:概率分布通常更加集中 T > 1:低概率 Token 获得更多被采样的机会

需要注意，Temperature 并不直接控制模型的知识量，也不意味着温度越高，回答就一定越有创造性。

7.5 Top-K Sampling

Top-K Sampling 是一种限制候选 Token 数量的采样策略。

模型只从概率最高的K个 Token 中进行采样。

其余 Token 不参与本次采样。

这样可以减少低概率 Token 带来的不稳定性。

7.6 Top-P Sampling

与 Top-K 固定候选数量不同，Top-P 根据累计概率选择候选集合。

例如：

Token	概率	累计概率
A	0.40	0.40
B	0.30	0.70
C	0.15	0.85
D	0.10	0.95
E	0.05	1.00

假设：P=0.8

那么按照概率从高到低排序，选择累计概率首次达到或超过 0.8 的最小候选集合。

因此：

候选集合 = {A, B, C}

之后只在这个集合内重新归一化并进行采样。

Top-P 的优势在于：

候选集合大小不是固定的，而是根据当前概率分布动态变化。

7.7 一次完整的文本生成过程

现在将上述内容串联起来：

用户输入 Prompt
        |
        v
Tokenizer 编码
        |
        v
Token ID 序列
        |
        v
输入模型进行前向计算
        |
        v
输出 Logits
        |
        v
Softmax 转换为概率分布
        |
        v
Temperature / Top-K / Top-P
        |
        v
选择或采样下一个 Token
        |
        v
追加到原始序列
        |
        v
继续生成下一个 Token
        |
        v
是否遇到停止条件？
        |
        +---- 否：继续生成
        |
        +---- 是：结束生成

这里还需要了解几个概念：

EOS：End Of Sequence，表示序列结束的特殊 Token。
Stop Sequence：用户或应用配置的停止字符串。
Max New Tokens：限制本次生成的最大新 Token 数量。

八、为什么 LLM 能力如此强大？

模型只是通过预测下一个 Token 训练出来的，为什么能够完成如此多样化的任务？

8.1 In-Context Learning：上下文学习

In-Context Learning（ICL）是指模型通过 Prompt 中提供的任务说明、示例或上下文，在不更新模型参数的情况下完成任务。

例如：

请根据下面的示例判断情绪。

示例：
输入：这部电影非常精彩。
输出：积极

输入：这次体验太糟糕了。
输出：消极

现在判断：
输入：今天的服务还不错。
输出：

模型可以根据前面的示例，推断当前任务需要输出情绪分类结果。

整个过程不需要重新训练模型，也不需要更新模型参数。

这就是上下文学习。

8.2 Zero-shot 与 Few-shot

Zero-shot：

不提供具体示例，只通过指令描述任务。

例如：

判断以下句子的情绪：
这次购物体验非常糟糕。

Few-shot：

在 Prompt 中提供少量示例，再让模型处理新输入。

例如：

示例：
好吃 -> 积极
难吃 -> 消极

判断：
味道不错 ->

8.3 什么是涌现能力

Emergent Abilities（涌现能力）通常用于描述模型规模扩大后，某些能力在特定评测中表现出明显变化的现象。

例如：

多步推理。
数学问题求解。
复杂指令处理。
上下文学习。

不过，需要谨慎理解这个概念。

研究中存在一种观点认为，部分所谓的涌现现象可能受到评测指标、任务难度和数据分布的影响。

因此，不能简单认为模型规模达到某个阈值，就一定会突然产生人类级别的推理能力。

更准确的理解是：

随着模型规模、数据和训练方法的发展，模型在更多复杂任务上的表现可能持续改善，但不同能力的形成机制和增长规律并不完全相同。

九、LLM局限性

后续 RAG 和 Agent 技术的出现，很大程度上就是为了弥补模型在实际应用中的部分不足。

9.1 幻觉问题（Hallucination）

幻觉是指模型生成了看似合理，但实际上错误或缺乏事实依据的内容。

为什么会出现这种情况？

因为语言模型的核心训练目标是预测合理的后续 Token，而不是天然具备事实验证机制。

即使模型生成了一段语法正确、逻辑连贯的内容，也不能证明内容一定真实。

常见缓解方法：

RAG：通过检索外部资料提供事实依据。
工具调用：让模型调用搜索、数据库或计算工具。
输出验证：对重要事实进行二次检查。
结构化约束：限制模型输出格式。

9.2 知识截止与知识更新问题

模型的参数是在训练过程中学习到的。

如果某个事件发生在模型训练数据截止时间之后，那么模型可能并不知道这个事件。

例如：

今天发布了新闻，但模型的训练数据并没有包含该新闻信息。

这时模型可能会根据已有知识生成一个看似合理但已经过时的答案。

解决思路：

使用搜索引擎获取实时信息。
使用 RAG 检索最新知识。
接入外部数据库和 API。
在必要时进行模型微调或继续训练。

9.3 上下文窗口限制

上下文窗口（Context Window）指模型一次处理过程中能够使用的上下文 Token 容量。

例如，假设模型支持 128K Token 的上下文窗口。

这意味着模型在一次请求中能够处理一定规模的输入和生成内容，但实际可用预算还需要考虑 Prompt、历史对话、工具结果和输出 Token 等部分。

上下文窗口并不等同于模型能够完美理解和利用其中的全部信息。

长上下文还可能出现：

重要信息被大量无关内容干扰（噪声）。
远距离信息利用效果下降。
推理成本增加。
Lost in the middle

这也是为什么 RAG 系统需要进行文档切片、检索和上下文压缩。

9.4 知识与推理并不等于事实正确

模型可能具备较强的数学推理或代码生成能力，但仍然可能产生错误结果。

例如：

数学计算错误。
代码存在边界条件问题。
引用不存在的 API。
对不确定问题给出过于自信的回答。

因此，对于实际工程系统，不能将模型输出直接视为可靠结果。

尤其在金融、医疗、法律等高风险场景中，更需要外部验证机制和必要的人类审核。

10、从 LLM 到 Agent

当模型不仅能够生成文本，还可以结合外部工具、任务规划、状态管理和执行反馈完成多步骤任务时，就逐渐形成了 Agent 系统。

一个简化的 Agent 架构可以表示为：

              用户目标
                 |
                 v
          +--------------+
          |     LLM      |
          |  理解与规划   |
          +--------------+
                 |
                 v
          +--------------+
          |  Action决策  |
          +--------------+
                 |
          +------+------+
          |             |
          v             v
       工具调用       直接回答
          |
          v
       外部工具
          |
          v
       执行结果
          |
          v
       返回 LLM
          |
          v
       继续分析与决策

一个完整的 Agent 系统通常还需要考虑：

Memory：记忆与上下文管理。
Planning：任务规划。
Tools：外部工具。
State：状态管理。
Reflection：结果反思与修正。
Execution：任务执行。
Guardrails：安全与权限约束。
这些内容会在后续 Agent 专题中逐步展开。

LLM 能够为Agent提供：

自然语言理解能力。
上下文信息处理能力。
任务分解与规划能力。
工具选择与参数生成能力。
执行结果分析能力。
自然语言交互能力。

但也需要认识到：

LLM 并不等于 Agent。

LLM 是 Agent 的核心智能组件之一，而 Agent 是围绕模型构建的、更完整的任务执行系统。

一个仅仅调用 LLM API 并返回文本的应用，不一定能够称为具备自主执行能力的 Agent。

这也是我们后续需要深入学习 Agent 架构、Tool Calling、MCP 和 LangGraph 的原因。

11、本章总结

通过本章，我们从基础概念出发，完整梳理了大语言模型的基本工作原理。

可以将核心知识归纳为以下几个部分：

核心知识	关键理解
LLM	基于大规模数据训练的神经网络语言模型
Tokenization	将文本转换为 Token ID
Embedding	将离散 Token 映射为向量表示
Next Token Prediction	根据上下文预测下一个 Token
Pre-training	通过大规模语料学习语言规律
SFT	通过指令数据学习遵循任务要求
RLHF / DPO	利用人类偏好优化模型行为
Inference	使用训练好的模型进行预测
Sampling	根据概率分布选择下一个 Token
RAG	通过外部检索增强模型回答
Agent	将 LLM 与工具、状态和执行机制结合

最后，再用一张图总结整个过程：

              大规模训练数据
                    |
                    v
                Tokenization
                    |
                    v
                Token ID
                    |
                    v
                 Embedding
                    |
                    v
               LLM 预训练
                    |
                    v
               参数不断优化
                    |
                    v
                Base Model
                    |
                    v
                后训练
          (SFT / 偏好优化等)
                    |
                    v
                Chat Model
                    |
                    v
                 Inference
                    |
                    v
           Logits -> Softmax
                    |
                    v
              Token Sampling
                    |
                    v
                文本生成
                    |
                    v
               LLM 应用
                    |
                    v
                  Agent

posted @ 2026-11-07 23:32 Dawn拂晓阅读(4) 评论(0) 收藏举报

刷新页面返回顶部

Dawn拂晓