|
|
@@ -6,9 +6,9 @@
|
|
|
|
|
|
### 3.1.1 从 N-gram 到 RNN
|
|
|
|
|
|
-**语言模型 (Language Model, LM)** 是自然语言处理的核心，其根本任务是计算一个词序列（即一个句子）出现的概率。一个好的语言模型能够告诉我们什么样的句子是通顺的、自然的。在多智能体系统中，语言模型是智能体理解人类指令、生成回应的基础。本节将回顾从经典的统计方法到现代深度学习模型的演进历程，为理解后续的 Transformer 架构打下坚实的基础。
|
|
|
+<strong>语言模型 (Language Model, LM)</strong> 是自然语言处理的核心，其根本任务是计算一个词序列（即一个句子）出现的概率。一个好的语言模型能够告诉我们什么样的句子是通顺的、自然的。在多智能体系统中，语言模型是智能体理解人类指令、生成回应的基础。本节将回顾从经典的统计方法到现代深度学习模型的演进历程，为理解后续的 Transformer 架构打下坚实的基础。
|
|
|
|
|
|
-**（1）统计语言模型与N-gram的思想**
|
|
|
+<strong>（1）统计语言模型与N-gram的思想</strong>
|
|
|
|
|
|
在深度学习兴起之前，统计方法是语言模型的主流。其核心思想是，一个句子出现的概率，等于该句子中每个词出现的条件概率的连乘。对于一个由词 $w_1,w_2,dots,w_m$ 构成的句子 S，其概率 P(S) 可以表示为：
|
|
|
|
|
|
@@ -21,17 +21,17 @@ $$P(S)=P(w_1,w_2,…,w_m)=P(w_1)⋅P(w_2∣w_1)⋅P(w_3∣w_1,w_2)⋯P(w_m∣w_1
|
|
|
<p>图 3.1 马尔可夫假设示意图</p>
|
|
|
</div>
|
|
|
|
|
|
-为了解决这个问题，研究者引入了**马尔可夫假设 (Markov Assumption)** 。其核心思想是：我们不必回溯一个词的全部历史，可以近似地认为，一个词的出现概率只与它前面有限的 $n−1$ 个词有关，如图3.1所示。基于这个假设建立的语言模型，我们称之为 **N-gram模型**。这里的 "N" 代表我们考虑的上下文窗口大小。让我们来看几个最常见的例子来理解这个概念：
|
|
|
+为了解决这个问题，研究者引入了<strong>马尔可夫假设 (Markov Assumption)</strong> 。其核心思想是：我们不必回溯一个词的全部历史，可以近似地认为，一个词的出现概率只与它前面有限的 $n−1$ 个词有关，如图3.1所示。基于这个假设建立的语言模型，我们称之为 <strong>N-gram模型</strong>。这里的 "N" 代表我们考虑的上下文窗口大小。让我们来看几个最常见的例子来理解这个概念：
|
|
|
|
|
|
-- **Bigram (当 N=2 时)** ：这是最简单的情况，我们假设一个词的出现只与它前面的一个词有关。因此，链式法则中复杂的条件概率 $P(w_i∣w_1,dots,w_{i−1})$ 就可以被近似为更容易计算的形式：
|
|
|
+- <strong>Bigram (当 N=2 时)</strong> ：这是最简单的情况，我们假设一个词的出现只与它前面的一个词有关。因此，链式法则中复杂的条件概率 $P(w_i∣w_1,dots,w_{i−1})$ 就可以被近似为更容易计算的形式：
|
|
|
|
|
|
$$P(w_{i}∣w_{1},…,w_{i−1})≈P(w_{i}∣w_{i−1})$$
|
|
|
|
|
|
-- **Trigram (当 N=3 时)** ：类似地，我们假设一个词的出现只与它前面的两个词有关：
|
|
|
+- <strong>Trigram (当 N=3 时)</strong> ：类似地，我们假设一个词的出现只与它前面的两个词有关：
|
|
|
|
|
|
$$P(w_i∣w_1,…,w_{i−1})≈P(w_i∣w_{i−2},w_{i−1})$$
|
|
|
|
|
|
-这些概率可以通过在大型语料库中进行**最大似然估计(Maximum Likelihood Estimation,MLE)** 来计算。这个术语听起来很复杂，但其思想非常直观：最可能出现的，就是我们在数据中看到次数最多的。例如，对于 Bigram 模型，我们想计算在词 $w_{i−1}$ 出现后，下一个词是 $w_i$ 的概率 $P(w_i∣w_{i−1})$。根据最大似然估计，这个概率可以通过简单的计数来估算：
|
|
|
+这些概率可以通过在大型语料库中进行<strong>最大似然估计(Maximum Likelihood Estimation,MLE)</strong> 来计算。这个术语听起来很复杂，但其思想非常直观：最可能出现的，就是我们在数据中看到次数最多的。例如，对于 Bigram 模型，我们想计算在词 $w_{i−1}$ 出现后，下一个词是 $w_i$ 的概率 $P(w_i∣w_{i−1})$。根据最大似然估计，这个概率可以通过简单的计数来估算：
|
|
|
|
|
|
$$P(w_i∣w_{i−1})=Count(w_{i−1})Count(w_{i−1},w_i)$$
|
|
|
|
|
|
@@ -44,19 +44,19 @@ $$P(w_i∣w_{i−1})=Count(w_{i−1})Count(w_{i−1},w_i)$$
|
|
|
|
|
|
为了让这个过程更具体，我们来手动进行一次计算。假设我们拥有一个仅包含以下两句话的迷你语料库：`datawhale agent learns`, `datawhale agent works`。我们的目标是：使用 Bigram (N=2) 模型，估算句子 `datawhale agent learns` 出现的概率。根据 Bigram 的假设，我们每次会考察连续的两个词（即一个词对）。
|
|
|
|
|
|
-**第一步：计算第一个词的概率** $P(datawhale)$ 这是 `datawhale` 出现的次数除以总词数。`datawhale` 出现了 2 次，总词数是 6。
|
|
|
+<strong>第一步：计算第一个词的概率</strong> $P(datawhale)$ 这是 `datawhale` 出现的次数除以总词数。`datawhale` 出现了 2 次，总词数是 6。
|
|
|
|
|
|
$$P(\text{datawhale}) = \frac{\text{总语料中"datawhale"的数量}}{\text{总语料的词数}} = \frac{2}{6} \approx 0.333$$
|
|
|
|
|
|
-**第二步：计算条件概率** $P(agent∣datawhale)$ 这是词对 `datawhale agent` 出现的次数除以 `datawhale` 出现的总次数。`datawhale agent` 出现了 2 次，`datawhale` 出现了 2 次。
|
|
|
+<strong>第二步：计算条件概率</strong> $P(agent∣datawhale)$ 这是词对 `datawhale agent` 出现的次数除以 `datawhale` 出现的总次数。`datawhale agent` 出现了 2 次，`datawhale` 出现了 2 次。
|
|
|
|
|
|
$$P(\text{agent}|\text{datawhale}) = \frac{\text{Count}(\text{datawhale agent})}{\text{Count}(\text{datawhale})} = \frac{2}{2} = 1$$
|
|
|
|
|
|
-**第三步：计算条件概率** $P(learns∣agent)$ 这是词对 `agent learns` 出现的次数除以 `agent` 出现的总次数。`agent learns` 出现了 1 次，`agent` 出现了 2 次。
|
|
|
+<strong>第三步：计算条件概率</strong> $P(learns∣agent)$ 这是词对 `agent learns` 出现的次数除以 `agent` 出现的总次数。`agent learns` 出现了 1 次，`agent` 出现了 2 次。
|
|
|
|
|
|
$$P(\text{learns}|\text{agent}) = \frac{\text{Count(agent learns)}}{\text{Count(agent)}} = \frac{1}{2} = 0.5$$
|
|
|
|
|
|
-**最后：将概率连乘** 所以，整个句子的近似概率为：
|
|
|
+<strong>最后：将概率连乘</strong> 所以，整个句子的近似概率为：
|
|
|
|
|
|
$$P(\text{datawhale agent learns}) \approx P(\text{datawhale}) \cdot P(\text{agent}|\text{datawhale}) \cdot P(\text{learns}|\text{agent}) \approx 0.333 \cdot 1 \cdot 0.5 \approx 0.167$$
|
|
|
|
|
|
@@ -101,24 +101,24 @@ print(f"最后: P('datawhale agent learns') ≈ {p_datawhale:.3f} * {p_agent_giv
|
|
|
|
|
|
N-gram 模型虽然简单有效，但有两个致命缺陷：
|
|
|
|
|
|
-1. **数据稀疏性 (Sparsity)** ：如果一个词序列从未在语料库中出现，其概率估计就为 0，这显然是不合理的。虽然可以通过平滑 (Smoothing) 技术缓解，但无法根除。
|
|
|
-2. **泛化能力差：**模型无法理解词与词之间的语义相似性。例如，即使模型在语料库中见过很多次 `agent learns`，它也无法将这个知识泛化到语义相似的词上。当我们计算 `robot learns` 的概率时，如果 `robot` 这个词从未出现过，或者 `robot learns` 这个组合从未出现过，模型计算出的概率也会是零。模型无法理解 `agent` 和 `robot` 在语义上的相似性。
|
|
|
+1. <strong>数据稀疏性 (Sparsity)</strong> ：如果一个词序列从未在语料库中出现，其概率估计就为 0，这显然是不合理的。虽然可以通过平滑 (Smoothing) 技术缓解，但无法根除。
|
|
|
+2. <strong>泛化能力差：</strong>模型无法理解词与词之间的语义相似性。例如，即使模型在语料库中见过很多次 `agent learns`，它也无法将这个知识泛化到语义相似的词上。当我们计算 `robot learns` 的概率时，如果 `robot` 这个词从未出现过，或者 `robot learns` 这个组合从未出现过，模型计算出的概率也会是零。模型无法理解 `agent` 和 `robot` 在语义上的相似性。
|
|
|
|
|
|
-**（2）神经网络语言模型与词嵌入**
|
|
|
+<strong>（2）神经网络语言模型与词嵌入</strong>
|
|
|
|
|
|
-N-gram 模型的根本缺陷在于它将词视为孤立、离散的符号。为了克服这个问题，研究者们转向了神经网络，并提出了一种思想：用连续的向量来表示词。2003年，Bengio 等人提出的**前馈神经网络语言模型 (Feedforward Neural Network Language Model)** 是这一领域的里程碑^[1]^。
|
|
|
+N-gram 模型的根本缺陷在于它将词视为孤立、离散的符号。为了克服这个问题，研究者们转向了神经网络，并提出了一种思想：用连续的向量来表示词。2003年，Bengio 等人提出的<strong>前馈神经网络语言模型 (Feedforward Neural Network Language Model)</strong> 是这一领域的里程碑^[1]^。
|
|
|
|
|
|
其核心思想可以分为两步：
|
|
|
|
|
|
-1. **构建一个语义空间**：创建一个高维的连续向量空间，然后将词汇表中的每个词都映射为该空间中的一个点。这个点（即向量）就被称为**词嵌入 (Word Embedding)** 或词向量。在这个空间里，语义上相近的词，它们对应的向量在空间中的位置也相近。例如，`agent` 和 `robot` 的向量会靠得很近，而 `agent` 和 `apple` 的向量会离得很远。
|
|
|
-2. **学习从上下文到下一个词的映射**：利用神经网络的强大拟合能力，来学习一个函数。这个函数的输入是前 $n−1$ 个词的词向量，输出是词汇表中每个词在当前上下文后出现的概率分布。
|
|
|
+1. <strong>构建一个语义空间</strong>：创建一个高维的连续向量空间，然后将词汇表中的每个词都映射为该空间中的一个点。这个点（即向量）就被称为<strong>词嵌入 (Word Embedding)</strong> 或词向量。在这个空间里，语义上相近的词，它们对应的向量在空间中的位置也相近。例如，`agent` 和 `robot` 的向量会靠得很近，而 `agent` 和 `apple` 的向量会离得很远。
|
|
|
+2. <strong>学习从上下文到下一个词的映射</strong>：利用神经网络的强大拟合能力，来学习一个函数。这个函数的输入是前 $n−1$ 个词的词向量，输出是词汇表中每个词在当前上下文后出现的概率分布。
|
|
|
|
|
|
<div align="center">
|
|
|
<img src="https://raw.githubusercontent.com/datawhalechina/Hello-Agents/main/docs/images/3-figures/1757249275674-1.png" alt="图片描述" width="90%"/>
|
|
|
<p>图 3.2 神经网络语言模型架构示意图</p>
|
|
|
</div>
|
|
|
|
|
|
-如图3.2所示，在这个架构中，词嵌入是在模型训练过程中自动学习得到的。模型为了完成“预测下一个词”这个任务，会不断调整每个词的向量位置，最终使这些向量能够蕴含丰富的语义信息。一旦我们将词转换成了向量，我们就可以用数学工具来度量它们之间的关系。最常用的方法是**余弦相似度 (Cosine Similarity)** ，它通过计算两个向量夹角的余弦值来衡量它们的相似性。
|
|
|
+如图3.2所示，在这个架构中，词嵌入是在模型训练过程中自动学习得到的。模型为了完成“预测下一个词”这个任务，会不断调整每个词的向量位置，最终使这些向量能够蕴含丰富的语义信息。一旦我们将词转换成了向量，我们就可以用数学工具来度量它们之间的关系。最常用的方法是<strong>余弦相似度 (Cosine Similarity)</strong> ，它通过计算两个向量夹角的余弦值来衡量它们的相似性。
|
|
|
|
|
|
$$\text{similarity}(\vec{a}, \vec{b}) = \cos(\theta) = \frac{\vec{a} \cdot \vec{b}}{|\vec{a}| |\vec{b}|}$$
|
|
|
|
|
|
@@ -164,32 +164,32 @@ king - man + woman 的结果向量: [0.9 0.2]
|
|
|
|
|
|
神经网络语言模型通过词嵌入，成功解决了 N-gram 模型的泛化能力差的问题。然而，它仍然有一个类似 N-gram 的限制：上下文窗口是固定的。它只能考虑固定数量的前文，这为能处理任意长序列的循环神经网络埋下了伏笔。
|
|
|
|
|
|
-**（3）循环神经网络 (RNN) 与长短时记忆网络 (LSTM)**
|
|
|
+<strong>（3）循环神经网络 (RNN) 与长短时记忆网络 (LSTM)</strong>
|
|
|
|
|
|
-前一节的神经网络语言模型虽然引入了词嵌入解决了泛化问题，但它和 N-gram 模型一样，上下文窗口是固定大小的。为了预测下一个词，它只能看到前 n−1 个词，再早的历史信息就被丢弃了。这显然不符合我们人类理解语言的方式。为了打破固定窗口的限制，**循环神经网络 (Recurrent Neural Network, RNN)** 应运而生，其核心思想非常直观：为网络增加“记忆”能力^[2]^。
|
|
|
+前一节的神经网络语言模型虽然引入了词嵌入解决了泛化问题，但它和 N-gram 模型一样，上下文窗口是固定大小的。为了预测下一个词，它只能看到前 n−1 个词，再早的历史信息就被丢弃了。这显然不符合我们人类理解语言的方式。为了打破固定窗口的限制，<strong>循环神经网络 (Recurrent Neural Network, RNN)</strong> 应运而生，其核心思想非常直观：为网络增加“记忆”能力^[2]^。
|
|
|
|
|
|
-如图3.3所示，RNN 的设计引入了一个**隐藏状态 (hidden state)** 向量，我们可以将其理解为网络的短期记忆。在处理序列的每一步，网络都会读取当前的输入词，并结合它上一刻的记忆（即上一个时间步的隐藏状态），然后生成一个新的记忆（即当前时间步的隐藏状态）传递给下一刻。这个循环往复的过程，使得信息可以在序列中不断向后传递。
|
|
|
+如图3.3所示，RNN 的设计引入了一个<strong>隐藏状态 (hidden state)</strong> 向量，我们可以将其理解为网络的短期记忆。在处理序列的每一步，网络都会读取当前的输入词，并结合它上一刻的记忆（即上一个时间步的隐藏状态），然后生成一个新的记忆（即当前时间步的隐藏状态）传递给下一刻。这个循环往复的过程，使得信息可以在序列中不断向后传递。
|
|
|
|
|
|
<div align="center">
|
|
|
<img src="https://raw.githubusercontent.com/datawhalechina/Hello-Agents/main/docs/images/3-figures/1757249275674-2.png" alt="图片描述" width="90%"/>
|
|
|
<p>图 3.3 RNN 结构示意图</p>
|
|
|
</div>
|
|
|
|
|
|
-然而，标准的 RNN 在实践中存在一个严重的问题：**长期依赖问题 (Long-term Dependency Problem)** 。在训练过程中，模型需要通过反向传播算法根据输出端的误差来调整网络深处的权重。对于 RNN 而言，序列的长度就是网络的深度。当序列很长时，梯度在从后向前传播的过程中会经过多次连乘，这会导致梯度值快速趋向于零（**梯度消失**）或变得极大（**梯度爆炸**）。梯度消失使得模型无法有效学习到序列早期信息对后期输出的影响，即难以捕捉长距离的依赖关系。
|
|
|
+然而，标准的 RNN 在实践中存在一个严重的问题：<strong>长期依赖问题 (Long-term Dependency Problem)</strong> 。在训练过程中，模型需要通过反向传播算法根据输出端的误差来调整网络深处的权重。对于 RNN 而言，序列的长度就是网络的深度。当序列很长时，梯度在从后向前传播的过程中会经过多次连乘，这会导致梯度值快速趋向于零（<strong>梯度消失</strong>）或变得极大（<strong>梯度爆炸</strong>）。梯度消失使得模型无法有效学习到序列早期信息对后期输出的影响，即难以捕捉长距离的依赖关系。
|
|
|
|
|
|
-为了解决长期依赖问题，**长短时记忆网络 (Long Short-Term Memory, LSTM)** 被设计出来^[3]^。LSTM 是一种特殊的 RNN，其核心创新在于引入了**细胞状态 (Cell State)** 和一套精密的**门控机制 (Gating Mechanism)** 。细胞状态可以看作是一条独立于隐藏状态的信息通路，允许信息在时间步之间更顺畅地传递。门控机制则是由几个小型神经网络构成，它们可以学习如何有选择地让信息通过，从而控制细胞状态中信息的增加与移除。这些门包括：
|
|
|
+为了解决长期依赖问题，<strong>长短时记忆网络 (Long Short-Term Memory, LSTM)</strong> 被设计出来^[3]^。LSTM 是一种特殊的 RNN，其核心创新在于引入了<strong>细胞状态 (Cell State)</strong> 和一套精密的<strong>门控机制 (Gating Mechanism)</strong> 。细胞状态可以看作是一条独立于隐藏状态的信息通路，允许信息在时间步之间更顺畅地传递。门控机制则是由几个小型神经网络构成，它们可以学习如何有选择地让信息通过，从而控制细胞状态中信息的增加与移除。这些门包括：
|
|
|
|
|
|
-- **遗忘门 (Forget Gate)** : 决定从上一时刻的细胞状态中丢弃哪些信息。
|
|
|
-- **输入门 (Input Gate)** : 决定将当前输入中的哪些新信息存入细胞状态。
|
|
|
-- **输出门 (Output Gate)** : 决定根据当前的细胞状态，输出哪些信息到隐藏状态。
|
|
|
+- <strong>遗忘门 (Forget Gate)</strong> : 决定从上一时刻的细胞状态中丢弃哪些信息。
|
|
|
+- <strong>输入门 (Input Gate)</strong> : 决定将当前输入中的哪些新信息存入细胞状态。
|
|
|
+- <strong>输出门 (Output Gate)</strong> : 决定根据当前的细胞状态，输出哪些信息到隐藏状态。
|
|
|
|
|
|
### 3.1.2 Transformer 架构解析
|
|
|
|
|
|
-在上一节中，我们看到RNN及LSTM通过引入循环结构来处理序列数据，这在一定程度上解决了捕捉长距离依赖的问题。然而，这种循环的计算方式也带来了新的瓶颈：它必须按顺序处理数据。第 t 个时间步的计算，必须等待第 t−1 个时间步完成后才能开始。这意味着 RNN 无法进行大规模的并行计算，在处理长序列时效率低下，这极大地限制了模型规模和训练速度的提升。Transformer在2017 年由谷歌团队提出^[4]^。它完全抛弃了循环结构，转而完全依赖一种名为**注意力 (Attention)** 的机制来捕捉序列内的依赖关系，从而实现了真正意义上的并行计算。
|
|
|
+在上一节中，我们看到RNN及LSTM通过引入循环结构来处理序列数据，这在一定程度上解决了捕捉长距离依赖的问题。然而，这种循环的计算方式也带来了新的瓶颈：它必须按顺序处理数据。第 t 个时间步的计算，必须等待第 t−1 个时间步完成后才能开始。这意味着 RNN 无法进行大规模的并行计算，在处理长序列时效率低下，这极大地限制了模型规模和训练速度的提升。Transformer在2017 年由谷歌团队提出^[4]^。它完全抛弃了循环结构，转而完全依赖一种名为<strong>注意力 (Attention)</strong> 的机制来捕捉序列内的依赖关系，从而实现了真正意义上的并行计算。
|
|
|
|
|
|
-**（1）Encoder-Decoder 整体结构**
|
|
|
+<strong>（1）Encoder-Decoder 整体结构</strong>
|
|
|
|
|
|
-最初的 Transformer 模型是为端到端任务机器翻译而设计的。如图3.4所示，它在宏观上遵循了一个经典的**编码器-解码器 (Encoder-Decoder)** 架构。
|
|
|
+最初的 Transformer 模型是为端到端任务机器翻译而设计的。如图3.4所示，它在宏观上遵循了一个经典的<strong>编码器-解码器 (Encoder-Decoder)</strong> 架构。
|
|
|
|
|
|
<div align="center">
|
|
|
<img src="https://raw.githubusercontent.com/datawhalechina/Hello-Agents/main/docs/images/3-figures/1757249275674-3.png" alt="图片描述" width="50%"/>
|
|
|
@@ -199,8 +199,8 @@ king - man + woman 的结果向量: [0.9 0.2]
|
|
|
|
|
|
我们可以将这个结构理解为一个分工明确的团队：
|
|
|
|
|
|
-1. **编码器 (Encoder)** ：任务是“**理解**”输入的整个句子。它会读取所有输入词元(这个概念会在3.2.2节介绍)，最终为每个词元生成一个富含上下文信息的向量表示。
|
|
|
-2. **解码器 (Decoder)** ：任务是“**生成**”目标句子。它会参考自己已经生成的前文，并“咨询”编码器的理解结果，来生成下一个词。
|
|
|
+1. <strong>编码器 (Encoder)</strong> ：任务是“<strong>理解</strong>”输入的整个句子。它会读取所有输入词元(这个概念会在3.2.2节介绍)，最终为每个词元生成一个富含上下文信息的向量表示。
|
|
|
+2. <strong>解码器 (Decoder)</strong> ：任务是“<strong>生成</strong>”目标句子。它会参考自己已经生成的前文，并“咨询”编码器的理解结果，来生成下一个词。
|
|
|
|
|
|
为了真正理解 Transformer 的工作原理，最好的方法莫过于亲手实现它。在本节中，我们将采用一种“自顶向下”的方法：首先，我们搭建出 Transformer 完整的代码框架，定义好所有需要的类和方法。然后，我们将像完成拼图一样，逐一实现这些类的具体功能。
|
|
|
|
|
|
@@ -284,17 +284,17 @@ class DecoderLayer(nn.Module):
|
|
|
return x
|
|
|
```
|
|
|
|
|
|
-**3.1.2.2 从自注意力到多头注意力**
|
|
|
+<strong>3.1.2.2 从自注意力到多头注意力</strong>
|
|
|
|
|
|
现在，我们来填充骨架中最关键的模块，注意力机制。
|
|
|
|
|
|
-想象一下我们阅读这个句子：“The agent learns because **it** is intelligent.”。当我们读到加粗的 "**it**" 时，为了理解它的指代，我们的大脑会不自觉地将更多的注意力放在前面的 "agent" 这个词上。**自注意力 (Self-Attention)** 机制就是对这种现象的数学建模。它允许模型在处理序列中的每一个词时，都能兼顾句子中的所有其他词，并为这些词分配不同的“注意力权重”。权重越高的词，代表其与当前词的关联性越强，其信息也应该在当前词的表示中占据更大的比重。
|
|
|
+想象一下我们阅读这个句子：“The agent learns because <strong>it</strong> is intelligent.”。当我们读到加粗的 "<strong>it</strong>" 时，为了理解它的指代，我们的大脑会不自觉地将更多的注意力放在前面的 "agent" 这个词上。<strong>自注意力 (Self-Attention)</strong> 机制就是对这种现象的数学建模。它允许模型在处理序列中的每一个词时，都能兼顾句子中的所有其他词，并为这些词分配不同的“注意力权重”。权重越高的词，代表其与当前词的关联性越强，其信息也应该在当前词的表示中占据更大的比重。
|
|
|
|
|
|
为了实现上述过程，自注意力机制为每个输入的词元向量引入了三个可学习的角色：
|
|
|
|
|
|
-- **查询 (Query, Q)** : 代表当前词元，它正在主动地“查询”其他词元以获取信息。
|
|
|
-- **键 (Key, K)** : 代表句子中可被查询的词元“标签”或“索引”。
|
|
|
-- **值 (Value, V)** : 代表词元本身所携带的“内容”或“信息”。
|
|
|
+- <strong>查询 (Query, Q)</strong> : 代表当前词元，它正在主动地“查询”其他词元以获取信息。
|
|
|
+- <strong>键 (Key, K)</strong> : 代表句子中可被查询的词元“标签”或“索引”。
|
|
|
+- <strong>值 (Value, V)</strong> : 代表词元本身所携带的“内容”或“信息”。
|
|
|
|
|
|
这三个向量都是由原始的词嵌入向量乘以三个不同的、可学习的权重矩阵 ($W^Q,W^K,W^V$) 得到的。整个计算过程可以分为以下几步，我们可以把它想象成一次高效的开卷考试：
|
|
|
|
|
|
@@ -380,9 +380,9 @@ class MultiHeadAttention(nn.Module):
|
|
|
return output
|
|
|
```
|
|
|
|
|
|
-**3.1.2.3 前馈神经网络**
|
|
|
+<strong>3.1.2.3 前馈神经网络</strong>
|
|
|
|
|
|
-在每个 Encoder 和 Decoder 层中，多头注意力子层之后都跟着一个**逐位置前馈网络(Position-wise Feed-Forward Network, FFN)** 。如果说注意力层的作用是从整个序列中“动态地聚合”相关信息，那么前馈网络的作用从这些聚合后的信息中提取更高阶的特征。
|
|
|
+在每个 Encoder 和 Decoder 层中，多头注意力子层之后都跟着一个<strong>逐位置前馈网络(Position-wise Feed-Forward Network, FFN)</strong> 。如果说注意力层的作用是从整个序列中“动态地聚合”相关信息，那么前馈网络的作用从这些聚合后的信息中提取更高阶的特征。
|
|
|
|
|
|
这个名字的关键在于“逐位置”。它意味着这个前馈网络会独立地作用于序列中的每一个词元向量。换句话说，对于一个长度为 `seq_len` 的序列，这个 FFN 实际上会被调用 `seq_len` 次，每次处理一个词元。重要的是，所有位置共享的是同一组网络权重。这种设计既保持了对每个位置进行独立加工的能力，又大大减少了模型的参数量。这个网络的结构非常简单，由两个线性变换和一个 ReLU 激活函数组成：
|
|
|
|
|
|
@@ -414,18 +414,18 @@ class PositionWiseFeedForward(nn.Module):
|
|
|
return x
|
|
|
```
|
|
|
|
|
|
-**3.1.2.4 残差连接与层归一化**
|
|
|
+<strong>3.1.2.4 残差连接与层归一化</strong>
|
|
|
|
|
|
在 Transformer 的每个编码器和解码器层中，所有子模块（如多头注意力和前馈网络）都被一个 `Add & Norm` 操作包裹。这个组合是为了保证 Transformer 能够稳定训练。
|
|
|
|
|
|
这个操作由两个部分组成：
|
|
|
|
|
|
-- **残差连接 (Add)** : 该操作将子模块的输入 `x` 直接加到该子模块的输出 `Sublayer(x)` 上。这一结构解决了深度神经网络中的**梯度消失 (Vanishing Gradients)** 问题。在反向传播时，梯度可以绕过子模块直接向前传播，从而保证了即使网络层数很深，模型也能得到有效的训练。其公式可以表示为：$\text{Output} = x + \text{Sublayer}(x)$。
|
|
|
-- **层归一化 (Norm)** : 该操作对单个样本的所有特征进行归一化，使其均值为0，方差为1。这解决了模型训练过程中的**内部协变量偏移 (Internal Covariate Shift)** 问题，使每一层的输入分布保持稳定，从而加速模型收敛并提高训练的稳定性。
|
|
|
+- <strong>残差连接 (Add)</strong> : 该操作将子模块的输入 `x` 直接加到该子模块的输出 `Sublayer(x)` 上。这一结构解决了深度神经网络中的<strong>梯度消失 (Vanishing Gradients)</strong> 问题。在反向传播时，梯度可以绕过子模块直接向前传播，从而保证了即使网络层数很深，模型也能得到有效的训练。其公式可以表示为：$\text{Output} = x + \text{Sublayer}(x)$。
|
|
|
+- <strong>层归一化 (Norm)</strong> : 该操作对单个样本的所有特征进行归一化，使其均值为0，方差为1。这解决了模型训练过程中的<strong>内部协变量偏移 (Internal Covariate Shift)</strong> 问题，使每一层的输入分布保持稳定，从而加速模型收敛并提高训练的稳定性。
|
|
|
|
|
|
-**3.1.2.5 位置编码**
|
|
|
+<strong>3.1.2.5 位置编码</strong>
|
|
|
|
|
|
-我们已经了解，Transformer 的核心是自注意力机制，它通过计算序列中任意两个词元之间的关系来捕捉依赖。然而，这种计算方式有一个固有的问题：它本身不包含任何关于词元顺序或位置的信息。对于自注意力来说，“agent learns” 和 “learns agent” 这两个序列是完全等价的，因为它只关心词元之间的关系，而忽略了它们的排列。为了解决这个问题，Transformer 引入了**位置编码 (Positional Encoding)** 。
|
|
|
+我们已经了解，Transformer 的核心是自注意力机制，它通过计算序列中任意两个词元之间的关系来捕捉依赖。然而，这种计算方式有一个固有的问题：它本身不包含任何关于词元顺序或位置的信息。对于自注意力来说，“agent learns” 和 “learns agent” 这两个序列是完全等价的，因为它只关心词元之间的关系，而忽略了它们的排列。为了解决这个问题，Transformer 引入了<strong>位置编码 (Positional Encoding)</strong> 。
|
|
|
|
|
|
位置编码的核心思想是，为输入序列中的每一个词元嵌入向量，都额外加上一个能代表其绝对位置和相对位置信息的“位置向量”。这个位置向量不是通过学习得到的，而是通过一个固定的数学公式直接计算得出。这样一来，即使两个词元（例如，两个都叫 `agent` 的词元）自身的嵌入是相同的，但由于它们在句子中的位置不同，它们最终输入到 Transformer 模型中的向量就会因为加上了不同的位置编码而变得独一无二。原论文中提出的位置编码使用正弦和余弦函数来生成，其公式如下：
|
|
|
|
|
|
@@ -477,11 +477,11 @@ class PositionalEncoding(nn.Module):
|
|
|
|
|
|
前面一节中，我们动手构建了一个完整的Transformer 模型，它能在很多端到端的场景表现出色。但是当任务转换为构建一个与人对话、创作、作为智能体大脑的通用模型时，或许我们并不需要那么复杂的结构。
|
|
|
|
|
|
-Transformer的设计哲学是“先理解，再生成”。编码器负责深入理解输入的整个句子，形成一个包含全局信息的上下文记忆，然后解码器基于这份记忆来生成翻译。但 OpenAI 在开发 **GPT (Generative Pre-trained Transformer)** 时，提出了一个更简单的思想^[5]^：**语言的核心任务，不就是预测下一个最有可能出现的词吗？**
|
|
|
+Transformer的设计哲学是“先理解，再生成”。编码器负责深入理解输入的整个句子，形成一个包含全局信息的上下文记忆，然后解码器基于这份记忆来生成翻译。但 OpenAI 在开发 <strong>GPT (Generative Pre-trained Transformer)</strong> 时，提出了一个更简单的思想^[5]^：<strong>语言的核心任务，不就是预测下一个最有可能出现的词吗？</strong>
|
|
|
|
|
|
-无论是回答问题、写故事还是生成代码，本质上都是在一个已有的文本序列后面，一个词一个词地添加最合理的内容。基于这个思想，GPT 做了一个大胆的简化：**它完全抛弃了编码器，只保留了解码器部分。** 这就是 **Decoder-Only** 架构的由来。
|
|
|
+无论是回答问题、写故事还是生成代码，本质上都是在一个已有的文本序列后面，一个词一个词地添加最合理的内容。基于这个思想，GPT 做了一个大胆的简化：<strong>它完全抛弃了编码器，只保留了解码器部分。</strong> 这就是 <strong>Decoder-Only</strong> 架构的由来。
|
|
|
|
|
|
-Decoder-Only 架构的工作模式被称为**自回归 (Autoregressive)** 。这个听起来很专业的术语，其实描述了一个非常简单的过程：
|
|
|
+Decoder-Only 架构的工作模式被称为<strong>自回归 (Autoregressive)</strong> 。这个听起来很专业的术语，其实描述了一个非常简单的过程：
|
|
|
|
|
|
1. 给模型一个起始文本（例如 “Datawhale Agent is”）。
|
|
|
2. 模型预测出下一个最有可能的词（例如 “a”）。
|
|
|
@@ -493,17 +493,17 @@ Decoder-Only 架构的工作模式被称为**自回归 (Autoregressive)** 。这
|
|
|
|
|
|
你可能会问，解码器是如何保证在预测第 `t` 个词时，不去“偷看”第 `t+1` 个词的答案呢？
|
|
|
|
|
|
-答案就是**掩码自注意力 (Masked Self-Attention)** 。在 Decoder-Only 架构中，这个机制变得至关重要。它的工作原理非常巧妙：
|
|
|
+答案就是<strong>掩码自注意力 (Masked Self-Attention)</strong> 。在 Decoder-Only 架构中，这个机制变得至关重要。它的工作原理非常巧妙：
|
|
|
|
|
|
在自注意力机制计算出注意力分数矩阵（即每个词对其他所有词的关注度得分）之后，但在进行 Softmax 归一化之前，模型会应用一个“掩码”。这个掩码会将所有位于当前位置之后（即目前尚未观测到）的词元对应的分数，替换为一个非常大的负数。当这个带有负无穷分数的矩阵经过 Softmax 函数时，这些位置的概率就会变为 0。这样一来，模型在计算任何一个位置的输出时，都从数学上被阻止了去关注它后面的信息。这种机制保证了模型在预测下一个词时，能且仅能依赖它已经见过的、位于当前位置之前的所有信息，从而确保了预测的公平性和逻辑的连贯性。
|
|
|
|
|
|
-**Decoder-Only 架构的优势**
|
|
|
+<strong>Decoder-Only 架构的优势</strong>
|
|
|
|
|
|
这种看似简单的架构，却带来了巨大的成功，其优势在于：
|
|
|
|
|
|
-- **训练目标统一**：模型的唯一任务就是“预测下一个词”，这个简单的目标非常适合在海量的无标注文本数据上进行预训练。
|
|
|
-- **结构简单，易于扩展**：更少的组件意味着更容易进行规模化扩展。今天的 GPT-4、Llama 等拥有数千亿甚至万亿参数的巨型模型，都是基于这种简洁的架构。
|
|
|
-- **天然适合生成任务**：其自回归的工作模式与所有生成式任务（对话、写作、代码生成等）完美契合，这也是它能成为构建通用智能体基础的核心原因。
|
|
|
+- <strong>训练目标统一</strong>：模型的唯一任务就是“预测下一个词”，这个简单的目标非常适合在海量的无标注文本数据上进行预训练。
|
|
|
+- <strong>结构简单，易于扩展</strong>：更少的组件意味着更容易进行规模化扩展。今天的 GPT-4、Llama 等拥有数千亿甚至万亿参数的巨型模型，都是基于这种简洁的架构。
|
|
|
+- <strong>天然适合生成任务</strong>：其自回归的工作模式与所有生成式任务（对话、写作、代码生成等）完美契合，这也是它能成为构建通用智能体基础的核心原因。
|
|
|
|
|
|
总而言之，从 Transformer 的解码器演变而来的 Decoder-Only 架构，通过“预测下一个词”这一简单的范式，开启了我们今天所处的大语言模型时代。
|
|
|
|
|
|
@@ -511,13 +511,13 @@ Decoder-Only 架构的工作模式被称为**自回归 (Autoregressive)** 。这
|
|
|
|
|
|
### 3.2.1 提示工程
|
|
|
|
|
|
-如果我们把大语言模型比作一个能力极强的“大脑”，那么**提示 (Prompt)** 就是我们与这个“大脑”沟通的语言。提示工程，就是研究如何设计出精准的提示，从而引导模型产生我们期望输出的回复。对于构建智能体而言，一个精心设计的提示能让智能体之间协作分工变得高效。
|
|
|
+如果我们把大语言模型比作一个能力极强的“大脑”，那么<strong>提示 (Prompt)</strong> 就是我们与这个“大脑”沟通的语言。提示工程，就是研究如何设计出精准的提示，从而引导模型产生我们期望输出的回复。对于构建智能体而言，一个精心设计的提示能让智能体之间协作分工变得高效。
|
|
|
|
|
|
-**3.2.1.1 零样本、单样本与少样本提示**
|
|
|
+<strong>3.2.1.1 零样本、单样本与少样本提示</strong>
|
|
|
|
|
|
根据我们给模型提供示例（Exemplar）的数量，提示可以分为三种类型。为了更好地理解它们，让我们以一个情感分类任务为例，目标是让模型判断一段文本的情感色彩（如正面、负面或中性）。
|
|
|
|
|
|
-**零样本提示 (Zero-shot Prompting)** 这指的是我们不给模型任何示例，直接让它根据指令完成任务。这得益于模型在海量数据上预训练后获得的强大泛化能力。
|
|
|
+<strong>零样本提示 (Zero-shot Prompting)</strong> 这指的是我们不给模型任何示例，直接让它根据指令完成任务。这得益于模型在海量数据上预训练后获得的强大泛化能力。
|
|
|
|
|
|
案例： 我们直接向模型下达指令，要求它完成情感分类任务。
|
|
|
|
|
|
@@ -526,7 +526,7 @@ Decoder-Only 架构的工作模式被称为**自回归 (Autoregressive)** 。这
|
|
|
情感：正面
|
|
|
```
|
|
|
|
|
|
-**单样本提示 (One-shot Prompting)** 我们给模型提供一个完整的示例，向它展示任务的格式和期望的输出风格。
|
|
|
+<strong>单样本提示 (One-shot Prompting)</strong> 我们给模型提供一个完整的示例，向它展示任务的格式和期望的输出风格。
|
|
|
|
|
|
我们给模型提供一个完整的示例，向它展示任务的格式和期望的输出风格。
|
|
|
|
|
|
@@ -542,7 +542,7 @@ Decoder-Only 架构的工作模式被称为**自回归 (Autoregressive)** 。这
|
|
|
|
|
|
模型会模仿给出的示例格式，为第二段文本补全“正面”。
|
|
|
|
|
|
-**少样本提示 (Few-shot Prompting)** 我们提供多个示例，这能让模型更准确地理解任务的细节、边界和细微差别，从而获得更好的性能。
|
|
|
+<strong>少样本提示 (Few-shot Prompting)</strong> 我们提供多个示例，这能让模型更准确地理解任务的细节、边界和细微差别，从而获得更好的性能。
|
|
|
|
|
|
案例： 我们提供涵盖了不同情况的多个示例，让模型对任务有更全面的理解。
|
|
|
|
|
|
@@ -559,13 +559,13 @@ Decoder-Only 架构的工作模式被称为**自回归 (Autoregressive)** 。这
|
|
|
|
|
|
模型会综合所有示例，更准确地将最后一句的情感分类为“正面”。
|
|
|
|
|
|
-**3.2.1.2 指令调优的影响**
|
|
|
+<strong>3.2.1.2 指令调优的影响</strong>
|
|
|
|
|
|
早期的 GPT 模型（如 GPT-3）主要是“文本补全”模型，它们擅长根据前面的文本续写，但不一定能很好地理解并执行人类的指令。
|
|
|
|
|
|
-**指令调优 (Instruction Tuning)** 是一种微调技术，它使用大量“指令-回答”格式的数据对预训练模型进行进一步的训练。经过指令调优后，模型能更好地理解并遵循用户的指令。我们今天日常工作学习中使用的所有模型（如 `ChatGPT`, `DeepSeek`, `Qwen`）都是其模型家族中经过指令调优过的模型。
|
|
|
+<strong>指令调优 (Instruction Tuning)</strong> 是一种微调技术，它使用大量“指令-回答”格式的数据对预训练模型进行进一步的训练。经过指令调优后，模型能更好地理解并遵循用户的指令。我们今天日常工作学习中使用的所有模型（如 `ChatGPT`, `DeepSeek`, `Qwen`）都是其模型家族中经过指令调优过的模型。
|
|
|
|
|
|
-- **对“文本补全”模型的提示(你需要用少样本提示“教会”模型做什么)：**
|
|
|
+- <strong>对“文本补全”模型的提示(你需要用少样本提示“教会”模型做什么)：</strong>
|
|
|
|
|
|
```Plain
|
|
|
这是一段将英文翻译成中文的程序。
|
|
|
@@ -575,7 +575,7 @@ Decoder-Only 架构的工作模式被称为**自回归 (Autoregressive)** 。这
|
|
|
中文：
|
|
|
```
|
|
|
|
|
|
-- **对“指令调优”模型的提示(你可以直接下达指令)：**
|
|
|
+- <strong>对“指令调优”模型的提示(你可以直接下达指令)：</strong>
|
|
|
|
|
|
```Plain
|
|
|
请将下面的英文翻译成中文：
|
|
|
@@ -584,16 +584,16 @@ How are you?
|
|
|
|
|
|
指令调优的出现，极大地简化了我们与模型交互的方式，使得直接、清晰的自然语言指令成为可能。
|
|
|
|
|
|
-**3.2.1.3 基础提示技巧**
|
|
|
+<strong>3.2.1.3 基础提示技巧</strong>
|
|
|
|
|
|
-**角色扮演 (Role-playing)** 通过赋予模型一个特定的角色，我们可以引导它的回答风格、语气和知识范围，使其输出更符合特定场景的需求。
|
|
|
+<strong>角色扮演 (Role-playing)</strong> 通过赋予模型一个特定的角色，我们可以引导它的回答风格、语气和知识范围，使其输出更符合特定场景的需求。
|
|
|
|
|
|
```Plain
|
|
|
# 案例
|
|
|
你现在是一位资深的Python编程专家。请解释一下Python中的GIL（全局解释器锁）是什么，要让一个初学者也能听懂。
|
|
|
```
|
|
|
|
|
|
-**上下文示例 (In-context Example)** 这与少样本提示的思想一致，通过在提示中提供清晰的输入输出示例，来“教会”模型如何处理我们的请求，尤其是在处理复杂格式或特定风格的任务时非常有效。
|
|
|
+<strong>上下文示例 (In-context Example)</strong> 这与少样本提示的思想一致，通过在提示中提供清晰的输入输出示例，来“教会”模型如何处理我们的请求，尤其是在处理复杂格式或特定风格的任务时非常有效。
|
|
|
|
|
|
```Plain
|
|
|
# 案例
|
|
|
@@ -606,9 +606,9 @@ How are you?
|
|
|
输出：
|
|
|
```
|
|
|
|
|
|
-**3.2.1.4 思维链**
|
|
|
+<strong>3.2.1.4 思维链</strong>
|
|
|
|
|
|
-对于需要逻辑推理、计算或多步骤思考的复杂问题，直接让模型给出答案往往容易出错。**思维链 (Chain-of-Thought, CoT)** 是一种强大的提示技巧，它通过引导模型“一步一步地思考”，提升了模型在复杂任务上的推理能力。
|
|
|
+对于需要逻辑推理、计算或多步骤思考的复杂问题，直接让模型给出答案往往容易出错。<strong>思维链 (Chain-of-Thought, CoT)</strong> 是一种强大的提示技巧，它通过引导模型“一步一步地思考”，提升了模型在复杂任务上的推理能力。
|
|
|
|
|
|
实现 CoT 的关键，是在提示中加入一句简单的引导语，如“请逐步思考”或“Let's think step by step”。
|
|
|
|
|
|
@@ -634,26 +634,26 @@ How are you?
|
|
|
|
|
|
### 3.2.2 文本分词
|
|
|
|
|
|
-我们知道，计算机本质上只能理解数字。因此，在将自然语言文本喂给大语言模型之前，必须先将其转换成模型能够处理的数字格式。这个将文本序列转换为数字序列的过程，就叫做**分词 (Tokenization)** 。**分词器 (Tokenizer)** 的作用，就是定义一套规则，将原始文本切分成一个个最小的单元，我们称之为**词元 (Token)** 。
|
|
|
+我们知道，计算机本质上只能理解数字。因此，在将自然语言文本喂给大语言模型之前，必须先将其转换成模型能够处理的数字格式。这个将文本序列转换为数字序列的过程，就叫做<strong>分词 (Tokenization)</strong> 。<strong>分词器 (Tokenizer)</strong> 的作用，就是定义一套规则，将原始文本切分成一个个最小的单元，我们称之为<strong>词元 (Token)</strong> 。
|
|
|
|
|
|
-**3.2.2.1 为何需要分词**
|
|
|
+<strong>3.2.2.1 为何需要分词</strong>
|
|
|
|
|
|
早期的自然语言处理任务可能会采用简单的分词策略：
|
|
|
|
|
|
-- **按词分词 (Word-based)** ：直接用空格或标点符号将句子切分成单词。这种方法很直观，但会面临“词表爆炸”的问题。一个语言的词汇量是巨大的，如果每个词都作为一个独立的词元，词表会变得难以管理。更糟糕的是，模型将无法处理任何未在词表中出现过的词，例如 “DatawhaleAgent”。
|
|
|
-- **按字符分词 (Character-based)** ：将文本切分成单个字符。这种方法词表很小（例如英文字母、数字和标点），不存在 OOV 问题。但它的缺点是，单个字符大多不具备独立的语义，模型需要花费更多的精力去学习如何将字符组合成有意义的词，导致学习效率低下。
|
|
|
+- <strong>按词分词 (Word-based)</strong> ：直接用空格或标点符号将句子切分成单词。这种方法很直观，但会面临“词表爆炸”的问题。一个语言的词汇量是巨大的，如果每个词都作为一个独立的词元，词表会变得难以管理。更糟糕的是，模型将无法处理任何未在词表中出现过的词，例如 “DatawhaleAgent”。
|
|
|
+- <strong>按字符分词 (Character-based)</strong> ：将文本切分成单个字符。这种方法词表很小（例如英文字母、数字和标点），不存在 OOV 问题。但它的缺点是，单个字符大多不具备独立的语义，模型需要花费更多的精力去学习如何将字符组合成有意义的词，导致学习效率低下。
|
|
|
|
|
|
-为了兼顾词表大小和语义表达，现代大语言模型普遍采用**子词分词 (Subword Tokenization)** 算法。它的核心思想是：将常见的词（如 "agent"）保留为完整的词元，同时将不常见的词（如 "Tokenization"）拆分成多个有意义的子词片段（如 "Token" 和 "ization"）。这样既控制了词表的大小，又能让模型通过组合子词来理解和生成新词。
|
|
|
+为了兼顾词表大小和语义表达，现代大语言模型普遍采用<strong>子词分词 (Subword Tokenization)</strong> 算法。它的核心思想是：将常见的词（如 "agent"）保留为完整的词元，同时将不常见的词（如 "Tokenization"）拆分成多个有意义的子词片段（如 "Token" 和 "ization"）。这样既控制了词表的大小，又能让模型通过组合子词来理解和生成新词。
|
|
|
|
|
|
-**3.2.2.2 字节对编码算法解析**
|
|
|
+<strong>3.2.2.2 字节对编码算法解析</strong>
|
|
|
|
|
|
字节对编码 (Byte-Pair Encoding, BPE) 是最主流的子词分词算法之一^[6]^，GPT系列模型就采用了这种算法。其核心思想非常简洁，可以理解为一个“贪心”的合并过程：
|
|
|
|
|
|
-1. **初始化**：将词表初始化为所有在语料库中出现过的基本字符。
|
|
|
-2. **迭代合并**：在语料库上，统计所有相邻词元对的出现频率，找到频率最高的一对，将它们合并成一个新的词元，并加入词表。
|
|
|
-3. **重复**：重复第 2 步，直到词表大小达到预设的阈值。
|
|
|
+1. <strong>初始化</strong>：将词表初始化为所有在语料库中出现过的基本字符。
|
|
|
+2. <strong>迭代合并</strong>：在语料库上，统计所有相邻词元对的出现频率，找到频率最高的一对，将它们合并成一个新的词元，并加入词表。
|
|
|
+3. <strong>重复</strong>：重复第 2 步，直到词表大小达到预设的阈值。
|
|
|
|
|
|
-**案例演示：** 假设我们的迷你语料库是 `{"hug": 1, "pug": 1, "pun": 1, "bun": 1}`，并且我们想构建一个大小为 10 的词表。BPE 的训练过程可以用下表3.1来表示：
|
|
|
+<strong>案例演示：</strong> 假设我们的迷你语料库是 `{"hug": 1, "pug": 1, "pun": 1, "bun": 1}`，并且我们想构建一个大小为 10 的词表。BPE 的训练过程可以用下表3.1来表示：
|
|
|
|
|
|
<div align="center">
|
|
|
<p>表 3.1 BPE 算法合并过程示例</p>
|
|
|
@@ -719,24 +719,24 @@ for i in range(num_merges):
|
|
|
|
|
|
后续的许多算法都是在BPE的基础上进行优化的。其中，Google 开发的 WordPiece 和 SentencePiece 是影响力最大的两种。
|
|
|
|
|
|
-- **WordPiece**: Google BERT 模型采用的算法^[7]^。它与 BPE 非常相似，但合并词元的标准不是“最高频率”，而是“能最大化提升语料库的语言模型概率”。简单来说，它会优先合并那些能让整个语料库的“通顺度”提升最大的词元对。
|
|
|
-- **SentencePiece**: Google 开源的一款分词工具^[8]^，Llama 系列模型采用了此算法。它最大的特点是，将空格也视作一个普通字符（通常用下划线 `_` 表示）。这使得分词和解码过程完全可逆，且不依赖于特定的语言（例如，它不需要知道中文不使用空格分词）。
|
|
|
+- <strong>WordPiece</strong>: Google BERT 模型采用的算法^[7]^。它与 BPE 非常相似，但合并词元的标准不是“最高频率”，而是“能最大化提升语料库的语言模型概率”。简单来说，它会优先合并那些能让整个语料库的“通顺度”提升最大的词元对。
|
|
|
+- <strong>SentencePiece</strong>: Google 开源的一款分词工具^[8]^，Llama 系列模型采用了此算法。它最大的特点是，将空格也视作一个普通字符（通常用下划线 `_` 表示）。这使得分词和解码过程完全可逆，且不依赖于特定的语言（例如，它不需要知道中文不使用空格分词）。
|
|
|
|
|
|
-**3.2.2.3 分词器对开发者的意义**
|
|
|
+<strong>3.2.2.3 分词器对开发者的意义</strong>
|
|
|
|
|
|
理解分词算法的细节并非目的，但作为智能体的开发者，理解分词器的实际影响是重要，这直接关系到智能体的性能、成本和稳定性：
|
|
|
|
|
|
-- **上下文窗口限制**：模型的上下文窗口（如 8K, 128K）是以 **Token 数量**计算的，而不是字符数或单词数。同样一段话，在不同语言（如中英文）或不同分词器下，Token 数量可能相差巨大。精确管理输入长度、避免超出上下文限制是构建长时记忆智能体的基础。
|
|
|
-- **API 成本**：大多数模型 API 都是按 Token 数量计费的。了解你的文本会被如何分词，是预估和控制智能体运行成本的关键一步。
|
|
|
-- **模型表现的异常**：有时模型的奇怪表现根源在于分词。例如，模型可能很擅长计算 `2 + 2`，但对于 `2+2`（没有空格）就可能出错，因为后者可能被分词器视为一个独立的、不常见的词元。同样，一个词因为首字母大小写不同，也可能被切分成完全不同的 Token 序列，从而影响模型的理解。在设计提示词和解析模型输出时，考虑到这些“陷阱”有助于提升智能体的鲁棒性。
|
|
|
+- <strong>上下文窗口限制</strong>：模型的上下文窗口（如 8K, 128K）是以 <strong>Token 数量</strong>计算的，而不是字符数或单词数。同样一段话，在不同语言（如中英文）或不同分词器下，Token 数量可能相差巨大。精确管理输入长度、避免超出上下文限制是构建长时记忆智能体的基础。
|
|
|
+- <strong>API 成本</strong>：大多数模型 API 都是按 Token 数量计费的。了解你的文本会被如何分词，是预估和控制智能体运行成本的关键一步。
|
|
|
+- <strong>模型表现的异常</strong>：有时模型的奇怪表现根源在于分词。例如，模型可能很擅长计算 `2 + 2`，但对于 `2+2`（没有空格）就可能出错，因为后者可能被分词器视为一个独立的、不常见的词元。同样，一个词因为首字母大小写不同，也可能被切分成完全不同的 Token 序列，从而影响模型的理解。在设计提示词和解析模型输出时，考虑到这些“陷阱”有助于提升智能体的鲁棒性。
|
|
|
|
|
|
### 3.2.3 调用开源大语言模型
|
|
|
|
|
|
在本书的第一章，我们通过 API 来与大语言模型进行交互，以此驱动我们的智能体。这是一种快速、便捷的方式，但并非唯一的方式。对于许多需要处理敏感数据、希望离线运行或想精细控制成本的场景，将大语言模型直接部署在本地就显得至关重要。
|
|
|
|
|
|
-**Hugging Face Transformers** 是一个强大的开源库，它提供了标准化的接口来加载和使用数以万计的预训练模型。我们将使用它来完成本次实践。
|
|
|
+<strong>Hugging Face Transformers</strong> 是一个强大的开源库，它提供了标准化的接口来加载和使用数以万计的预训练模型。我们将使用它来完成本次实践。
|
|
|
|
|
|
-**配置环境与选择模型**：为了让大多数读者都能在个人电脑上顺利运行，我们特意选择了一个小规模但功能强大的模型：`Qwen/Qwen1.5-0.5B-Chat`。这是一个由阿里巴巴达摩院开源的拥有约 5 亿参数的对话模型，它体积小、性能优异，非常适合入门学习和本地部署。
|
|
|
+<strong>配置环境与选择模型</strong>：为了让大多数读者都能在个人电脑上顺利运行，我们特意选择了一个小规模但功能强大的模型：`Qwen/Qwen1.5-0.5B-Chat`。这是一个由阿里巴巴达摩院开源的拥有约 5 亿参数的对话模型，它体积小、性能优异，非常适合入门学习和本地部署。
|
|
|
|
|
|
首先，请确保你已经安装了必要的库：
|
|
|
|
|
|
@@ -832,59 +832,59 @@ print(response)
|
|
|
|
|
|
由于大语言模型技术正处于高速发展阶段，新模型、新版本层出不穷，迭代速度极快。本节在撰写时力求提供当前主流模型的概览和选型考量，但请读者注意，文中所提及的具体模型版本和性能数据可能随时间推移而发生变化，且只列举了部分工作并不完整。我们更侧重于介绍其核心技术特点、发展趋势以及在智能体开发中的通用选型原则。
|
|
|
|
|
|
-**3.2.4.1 模型选型的关键考量**
|
|
|
+<strong>3.2.4.1 模型选型的关键考量</strong>
|
|
|
|
|
|
在为您的智能体选择大语言模型时，可以从以下几个维度进行综合评估：
|
|
|
|
|
|
-- **性能与能力**：这是最核心的考量。不同的模型擅长的任务不同，有的长于逻辑推理和代码生成，有的则在创意写作或多语言翻译上更胜一筹。您可以参考一些公开的基准测试排行榜（如 LMSys Chatbot Arena Leaderboard）来评估模型的综合能力。
|
|
|
-- **成本**：对于闭源模型，成本主要体现在 API 调用费用，通常按 Token 数量计费。对于开源模型，成本则体现在本地部署所需的硬件（GPU、内存）和运维上。需要根据应用的预期使用量和预算做出选择。
|
|
|
-- **速度（延迟）**：对于需要实时交互的智能体（如客服、游戏 NPC），模型的响应速度至关重要。一些轻量级或经过优化的模型（如 GPT-3.5 Turbo, Claude 3.5 Sonnet）在延迟上表现更优。
|
|
|
-- **上下文窗口**：模型能一次性处理的 Token 数量上限。对于需要理解长文档、分析代码库或维持长期对话记忆的智能体，选择一个拥有较大上下文窗口（如 128K Token 或更高）的模型是必要的。
|
|
|
-- **部署方式**：使用 API 的方式最简单便捷，但数据需要发送给第三方，且受限于服务商的条款。本地部署则能确保数据隐私和最高程度的自主可控，但对技术和硬件要求更高。
|
|
|
-- **生态与工具链**：一个模型的流行程度也决定了其周边生态的成熟度。主流模型通常拥有更丰富的社区支持、教程、预训练模型、微调工具和兼容的开发框架（如 LangChain, LlamaIndex, Hugging Face Transformers），这能极大地加速开发进程，降低开发难度。选择一个拥有活跃社区和完善工具链的模型，可以在遇到问题时更容易找到解决方案和资源。
|
|
|
-- **可微调性与定制化**：对于需要处理特定领域数据或执行特定任务的智能体，模型的微调能力至关重要。一些模型提供了便捷的微调接口和工具，允许开发者使用自己的数据集对模型进行定制化训练，从而显著提升模型在特定场景下的性能和准确性。开源模型在这方面通常提供更大的灵活性。
|
|
|
-- **安全性与伦理**：随着大语言模型的广泛应用，其潜在的安全风险和伦理问题也日益凸显。选择模型时，需要考虑其在偏见、毒性、幻觉等方面的表现，以及服务商或开源社区在模型安全和负责任AI方面的投入。对于面向公众或涉及敏感信息的应用，模型的安全性和伦理合规性是不可忽视的考量。
|
|
|
+- <strong>性能与能力</strong>：这是最核心的考量。不同的模型擅长的任务不同，有的长于逻辑推理和代码生成，有的则在创意写作或多语言翻译上更胜一筹。您可以参考一些公开的基准测试排行榜（如 LMSys Chatbot Arena Leaderboard）来评估模型的综合能力。
|
|
|
+- <strong>成本</strong>：对于闭源模型，成本主要体现在 API 调用费用，通常按 Token 数量计费。对于开源模型，成本则体现在本地部署所需的硬件（GPU、内存）和运维上。需要根据应用的预期使用量和预算做出选择。
|
|
|
+- <strong>速度（延迟）</strong>：对于需要实时交互的智能体（如客服、游戏 NPC），模型的响应速度至关重要。一些轻量级或经过优化的模型（如 GPT-3.5 Turbo, Claude 3.5 Sonnet）在延迟上表现更优。
|
|
|
+- <strong>上下文窗口</strong>：模型能一次性处理的 Token 数量上限。对于需要理解长文档、分析代码库或维持长期对话记忆的智能体，选择一个拥有较大上下文窗口（如 128K Token 或更高）的模型是必要的。
|
|
|
+- <strong>部署方式</strong>：使用 API 的方式最简单便捷，但数据需要发送给第三方，且受限于服务商的条款。本地部署则能确保数据隐私和最高程度的自主可控，但对技术和硬件要求更高。
|
|
|
+- <strong>生态与工具链</strong>：一个模型的流行程度也决定了其周边生态的成熟度。主流模型通常拥有更丰富的社区支持、教程、预训练模型、微调工具和兼容的开发框架（如 LangChain, LlamaIndex, Hugging Face Transformers），这能极大地加速开发进程，降低开发难度。选择一个拥有活跃社区和完善工具链的模型，可以在遇到问题时更容易找到解决方案和资源。
|
|
|
+- <strong>可微调性与定制化</strong>：对于需要处理特定领域数据或执行特定任务的智能体，模型的微调能力至关重要。一些模型提供了便捷的微调接口和工具，允许开发者使用自己的数据集对模型进行定制化训练，从而显著提升模型在特定场景下的性能和准确性。开源模型在这方面通常提供更大的灵活性。
|
|
|
+- <strong>安全性与伦理</strong>：随着大语言模型的广泛应用，其潜在的安全风险和伦理问题也日益凸显。选择模型时，需要考虑其在偏见、毒性、幻觉等方面的表现，以及服务商或开源社区在模型安全和负责任AI方面的投入。对于面向公众或涉及敏感信息的应用，模型的安全性和伦理合规性是不可忽视的考量。
|
|
|
|
|
|
-**3.2.4.2 闭源模型概览**
|
|
|
+<strong>3.2.4.2 闭源模型概览</strong>
|
|
|
|
|
|
闭源模型通常代表了当前 AI 技术的最前沿，并提供稳定、易用的 API 服务，是构建高性能智能体的首选。
|
|
|
|
|
|
-1. **OpenAI GPT 系列**：从开启大模型时代的 GPT-3，到引入 RLHF（人类反馈强化学习）、实现与人类意图对齐的 ChatGPT，再到开启多模态时代的 GPT-4，OpenAI 持续引领行业发展。最新的 GPT-5 更是将多模态能力和通用智能水平提升到新的高度，能够无缝处理文本、音频和图像输入，并生成相应的输出，其响应速度和自然度也大幅提升，尤其在实时语音对话方面表现出色。
|
|
|
-2. **Google Gemini 系列**：Google DeepMind 推出的 Gemini 系列模型是原生多模态的代表，其核心特点是能统一处理文本、代码、音视频和图像等多种模态的数据，并以其超长的上下文窗口在海量信息处理上具备优势。Gemini Ultra 是其最强大的模型，适用于高度复杂的任务；Gemini Pro 适用于广泛的任务，提供高性能和效率；Gemini Nano 则针对设备端部署进行了优化。最新的 Gemini 2.5 系列模型，如 Gemini 2.5 Pro 和 Gemini 2.5 Flash，进一步提升了推理能力和上下文窗口，特别是 Gemini 2.5 Flash 以其更快的推理速度和成本效益，适用于需要快速响应的场景。
|
|
|
-3. **Anthropic Claude 系列**：Anthropic 是一家专注于 AI 安全和负责任 AI 的公司，其 Claude 系列模型从设计之初就将 AI 安全放在首位，以其在处理长文档、减少有害输出、遵循指令方面的可靠性而闻名，深受企业级应用青睐。Claude 3 系列包括 Claude 3 Opus（最智能、性能最强）、Claude 3 Sonnet（性能与速度兼顾的平衡之选）和 Claude 3 Haiku（最快、最紧凑的模型，适用于近乎实时的交互）。最新的 Claude 4 系列模型，如 Claude 4 Opus，在通用智能、复杂推理和代码生成方面取得了显著进展，进一步提升了处理长上下文和多模态任务的能力。
|
|
|
-4. **国内主流模型**：中国在大语言模型领域涌现出众多具有竞争力的闭源模型，以百度文心一言(ERNIE Bot)、腾讯混元(Hunyuan)、华为盘古(Pangu-α)、科大讯飞星火(SparkDesk)和月之暗面(Moonshot AI)等为代表的国产模型，在中文处理上具备天然优势，并深度赋能本土产业。
|
|
|
+1. <strong>OpenAI GPT 系列</strong>：从开启大模型时代的 GPT-3，到引入 RLHF（人类反馈强化学习）、实现与人类意图对齐的 ChatGPT，再到开启多模态时代的 GPT-4，OpenAI 持续引领行业发展。最新的 GPT-5 更是将多模态能力和通用智能水平提升到新的高度，能够无缝处理文本、音频和图像输入，并生成相应的输出，其响应速度和自然度也大幅提升，尤其在实时语音对话方面表现出色。
|
|
|
+2. <strong>Google Gemini 系列</strong>：Google DeepMind 推出的 Gemini 系列模型是原生多模态的代表，其核心特点是能统一处理文本、代码、音视频和图像等多种模态的数据，并以其超长的上下文窗口在海量信息处理上具备优势。Gemini Ultra 是其最强大的模型，适用于高度复杂的任务；Gemini Pro 适用于广泛的任务，提供高性能和效率；Gemini Nano 则针对设备端部署进行了优化。最新的 Gemini 2.5 系列模型，如 Gemini 2.5 Pro 和 Gemini 2.5 Flash，进一步提升了推理能力和上下文窗口，特别是 Gemini 2.5 Flash 以其更快的推理速度和成本效益，适用于需要快速响应的场景。
|
|
|
+3. <strong>Anthropic Claude 系列</strong>：Anthropic 是一家专注于 AI 安全和负责任 AI 的公司，其 Claude 系列模型从设计之初就将 AI 安全放在首位，以其在处理长文档、减少有害输出、遵循指令方面的可靠性而闻名，深受企业级应用青睐。Claude 3 系列包括 Claude 3 Opus（最智能、性能最强）、Claude 3 Sonnet（性能与速度兼顾的平衡之选）和 Claude 3 Haiku（最快、最紧凑的模型，适用于近乎实时的交互）。最新的 Claude 4 系列模型，如 Claude 4 Opus，在通用智能、复杂推理和代码生成方面取得了显著进展，进一步提升了处理长上下文和多模态任务的能力。
|
|
|
+4. <strong>国内主流模型</strong>：中国在大语言模型领域涌现出众多具有竞争力的闭源模型，以百度文心一言(ERNIE Bot)、腾讯混元(Hunyuan)、华为盘古(Pangu-α)、科大讯飞星火(SparkDesk)和月之暗面(Moonshot AI)等为代表的国产模型，在中文处理上具备天然优势，并深度赋能本土产业。
|
|
|
|
|
|
-**3.2.4.3 开源模型概览**
|
|
|
+<strong>3.2.4.3 开源模型概览</strong>
|
|
|
|
|
|
开源模型为开发者提供了最高程度的灵活性、透明度和自主性，催生了繁荣的社区生态。它们允许开发者在本地部署、进行定制化微调，并拥有完整的模型控制权。
|
|
|
|
|
|
-- **Meta Llama 系列**：Meta 推出的 Llama 系列是开源大语言模型的重要里程碑。该系列凭借出色的综合性能、开放的许可协议和强大的社区支持，成为许多衍生项目和研究的基座。Llama 4 系列于2025年4月发布，是Meta首批采用混合专家（MoE）架构的模型，该架构通过仅激活处理特定任务所需的模型部分来显著提升计算效率。该系列包含三款定位分明的模型：LLama 4 Scout支持1000万token的上下文窗口专为长文档分析和移动端部署设计。Llama 4 Maverick专注于多模态能力，在编码、复杂推理及多语言支持方面表现卓越。Llama 4 Behemoth多项STEM基准测试中表现超越竞争对手。是Meta目前最强大的模型
|
|
|
-- **Mistral AI 系列**：来自法国的 Mistral AI 以其“小尺寸、高性能”的模型设计而闻名。其最新模型 Mistral Medium 3.1 于2025年8月发布，在代码生成、STEM推理和跨领域问答等任务上准确率与响应速度均有显著提升，基准测试表现优于Claude Sonnet 3.7与Llama 4 Maverick等同级模型。它具备原生多模态能力，可同时处理图像与文字混合输入，并内置“语调适配层”，帮助企业更轻松实现符合品牌调性的输出。
|
|
|
-- **国内开源力量**：国内厂商和科研机构也在积极拥抱开源，例如阿里巴巴的**通义千问 (Qwen)** 系列和清华大学与智谱 AI 合作的 **ChatGLM** 系列，它们提供了强大的中文能力，并围绕自身构建了活跃的社区。
|
|
|
+- <strong>Meta Llama 系列</strong>：Meta 推出的 Llama 系列是开源大语言模型的重要里程碑。该系列凭借出色的综合性能、开放的许可协议和强大的社区支持，成为许多衍生项目和研究的基座。Llama 4 系列于2025年4月发布，是Meta首批采用混合专家（MoE）架构的模型，该架构通过仅激活处理特定任务所需的模型部分来显著提升计算效率。该系列包含三款定位分明的模型：LLama 4 Scout支持1000万token的上下文窗口专为长文档分析和移动端部署设计。Llama 4 Maverick专注于多模态能力，在编码、复杂推理及多语言支持方面表现卓越。Llama 4 Behemoth多项STEM基准测试中表现超越竞争对手。是Meta目前最强大的模型
|
|
|
+- <strong>Mistral AI 系列</strong>：来自法国的 Mistral AI 以其“小尺寸、高性能”的模型设计而闻名。其最新模型 Mistral Medium 3.1 于2025年8月发布，在代码生成、STEM推理和跨领域问答等任务上准确率与响应速度均有显著提升，基准测试表现优于Claude Sonnet 3.7与Llama 4 Maverick等同级模型。它具备原生多模态能力，可同时处理图像与文字混合输入，并内置“语调适配层”，帮助企业更轻松实现符合品牌调性的输出。
|
|
|
+- <strong>国内开源力量</strong>：国内厂商和科研机构也在积极拥抱开源，例如阿里巴巴的<strong>通义千问 (Qwen)</strong> 系列和清华大学与智谱 AI 合作的 <strong>ChatGLM</strong> 系列，它们提供了强大的中文能力，并围绕自身构建了活跃的社区。
|
|
|
|
|
|
对于智能体开发者而言，闭源模型提供了“开箱即用”的便捷，而开源模型则赋予了我们“随心所欲”的定制自由。理解这两大阵营的特点和代表模型，是为我们的智能体项目做出明智技术选型的第一步。
|
|
|
|
|
|
## 3.3 大语言模型的缩放法则与局限性
|
|
|
|
|
|
-大语言模型（LLMs）在近年来取得了令人瞩目的进展，其能力边界不断拓展，应用场景日益丰富。然而，这些成就的背后，离不开对模型规模、数据量和计算资源之间关系的深刻理解，即**缩放法则（Scaling Laws）**。同时，作为新兴技术，LLMs也面临着诸多挑战和局限性。本节将深入探讨这些核心概念，旨在帮助读者全面理解LLMs的能力边界，从而在构建智能体时扬长避短。
|
|
|
+大语言模型（LLMs）在近年来取得了令人瞩目的进展，其能力边界不断拓展，应用场景日益丰富。然而，这些成就的背后，离不开对模型规模、数据量和计算资源之间关系的深刻理解，即<strong>缩放法则（Scaling Laws）</strong>。同时，作为新兴技术，LLMs也面临着诸多挑战和局限性。本节将深入探讨这些核心概念，旨在帮助读者全面理解LLMs的能力边界，从而在构建智能体时扬长避短。
|
|
|
|
|
|
### 3.3.1 缩放法则
|
|
|
|
|
|
-**缩放法则（Scaling Laws）**是近年来大语言模型领域最重要的发现之一。它揭示了模型性能与模型参数量、训练数据量以及计算资源之间存在着可预测的幂律关系。这一发现为大语言模型的持续发展提供了理论指导，阐明了增加资源投入能够系统性提升模型性能的底层逻辑。
|
|
|
+<strong>缩放法则（Scaling Laws）</strong>是近年来大语言模型领域最重要的发现之一。它揭示了模型性能与模型参数量、训练数据量以及计算资源之间存在着可预测的幂律关系。这一发现为大语言模型的持续发展提供了理论指导，阐明了增加资源投入能够系统性提升模型性能的底层逻辑。
|
|
|
|
|
|
研究发现，在对数-对数坐标系下，模型的性能（通常用损失 Loss 来衡量）与参数量、数据量和计算量这三个因素都呈现出平滑的幂律关系^[9]^。简单来说，只要我们持续、按比例地增加这三个要素，模型的性能就会可预测地、平滑地提升，而不会出现明显的瓶颈。这一发现为大模型的设计和训练提供了清晰的指导：在资源允许的范围内，尽可能地扩大模型规模和训练数据量。
|
|
|
|
|
|
-早期的研究更侧重于增加模型参数量，但 DeepMind 在 2022 年提出的“Chinchilla 定律”对此进行了重要修正^[10]^。该定律指出，在给定的计算预算下，为了达到最优性能，**模型参数量和训练数据量之间存在一个最优配比**。具体来说，最优的模型应该比之前普遍认为的要小，但需要用多得多的数据进行训练。例如，一个 700 亿参数的 Chinchilla 模型，由于使用了比 GPT-3（1750 亿参数）多 4 倍的数据进行训练，其性能反而超越了后者。这一发现纠正了“越大越好”的片面认知，强调了数据效率的重要性，并指导了后续许多高效大模型（如 Llama 系列）的设计。
|
|
|
+早期的研究更侧重于增加模型参数量，但 DeepMind 在 2022 年提出的“Chinchilla 定律”对此进行了重要修正^[10]^。该定律指出，在给定的计算预算下，为了达到最优性能，<strong>模型参数量和训练数据量之间存在一个最优配比</strong>。具体来说，最优的模型应该比之前普遍认为的要小，但需要用多得多的数据进行训练。例如，一个 700 亿参数的 Chinchilla 模型，由于使用了比 GPT-3（1750 亿参数）多 4 倍的数据进行训练，其性能反而超越了后者。这一发现纠正了“越大越好”的片面认知，强调了数据效率的重要性，并指导了后续许多高效大模型（如 Llama 系列）的设计。
|
|
|
|
|
|
-缩放法则最令人惊奇的产物是“能力的涌现”。所谓能力涌现，是指当模型规模达到一定阈值后，会突然展现出在小规模模型中完全不存在或表现不佳的全新能力。例如，**链式思考 (Chain-of-Thought)** 、**指令遵循 (Instruction Following)** 、多步推理、代码生成等能力，都是在模型参数量达到数百亿甚至千亿级别后才显著出现的。这种现象表明，大语言模型不仅仅是简单地记忆和复述，它们在学习过程中可能形成了某种更深层次的抽象和推理能力。对于智能体开发者而言，能力的涌现意味着选择一个足够大规模的模型，是实现复杂自主决策和规划能力的前提。
|
|
|
+缩放法则最令人惊奇的产物是“能力的涌现”。所谓能力涌现，是指当模型规模达到一定阈值后，会突然展现出在小规模模型中完全不存在或表现不佳的全新能力。例如，<strong>链式思考 (Chain-of-Thought)</strong> 、<strong>指令遵循 (Instruction Following)</strong> 、多步推理、代码生成等能力，都是在模型参数量达到数百亿甚至千亿级别后才显著出现的。这种现象表明，大语言模型不仅仅是简单地记忆和复述，它们在学习过程中可能形成了某种更深层次的抽象和推理能力。对于智能体开发者而言，能力的涌现意味着选择一个足够大规模的模型，是实现复杂自主决策和规划能力的前提。
|
|
|
|
|
|
### 3.3.2 模型幻觉
|
|
|
|
|
|
-**模型幻觉（Hallucination）**通常指的是大语言模型生成的内容与客观事实、用户输入或上下文信息相矛盾，或者生成了不存在的事实、实体或事件。幻觉的本质是模型在生成过程中，过度自信地“编造”了信息，而非准确地检索或推理。根据其表现形式，幻觉可以被分为多种类型^[11]^，例如：
|
|
|
+<strong>模型幻觉（Hallucination）</strong>通常指的是大语言模型生成的内容与客观事实、用户输入或上下文信息相矛盾，或者生成了不存在的事实、实体或事件。幻觉的本质是模型在生成过程中，过度自信地“编造”了信息，而非准确地检索或推理。根据其表现形式，幻觉可以被分为多种类型^[11]^，例如：
|
|
|
|
|
|
-- **事实性幻觉 (Factual Hallucinations)** ： 模型生成与现实世界事实不符的信息。
|
|
|
-- **忠实性幻觉 (Faithfulness Hallucinations)** ： 在文本摘要、翻译等任务中，生成的内容未能忠实地反映源文本的含义。
|
|
|
-- **内在幻觉 (Intrinsic Hallucinations)** ： 模型生成的内容与输入信息直接矛盾。
|
|
|
+- <strong>事实性幻觉 (Factual Hallucinations)</strong> ： 模型生成与现实世界事实不符的信息。
|
|
|
+- <strong>忠实性幻觉 (Faithfulness Hallucinations)</strong> ： 在文本摘要、翻译等任务中，生成的内容未能忠实地反映源文本的含义。
|
|
|
+- <strong>内在幻觉 (Intrinsic Hallucinations)</strong> ： 模型生成的内容与输入信息直接矛盾。
|
|
|
|
|
|
幻觉的产生是多方面因素共同作用的结果。首先，训练数据中可能包含错误或矛盾的信息。其次，模型的自回归生成机制决定了它只是在预测下一个最可能的词元，而没有内置的事实核查模块。最后，在面对需要复杂推理的任务时，模型可能会在逻辑链条中出错，从而“编造”出错误的结论。例如：一个旅游规划 Agent，可能会为你推荐一个现实中不存在的景点，或者预订一个航班号错误的机票。
|
|
|
|
|
|
@@ -892,12 +892,12 @@ print(response)
|
|
|
|
|
|
为了提高大语言模型的可靠性，研究人员和开发者正在积极探索多种检测和缓解幻觉的方法：
|
|
|
|
|
|
-1. **数据层面**： 通过高质量数据清洗、引入事实性知识以及强化学习与人类反馈 (RLHF) 等方式^[13]^，从源头减少幻觉。
|
|
|
-2. **模型层面**： 探索新的模型架构，或让模型能够表达其对生成内容的不确定性。
|
|
|
-3. **推理与生成层面**：
|
|
|
- 1. **检索增强生成 (Retrieval-Augmented Generation, RAG)** ^[14]^： 这是目前缓解幻觉的有效方法之一。RAG 系统通过在生成之前从外部知识库（如文档数据库、网页）中检索相关信息，然后将检索到的信息作为上下文，引导模型生成基于事实的回答。
|
|
|
- 2. **多步推理与验证**： 引导模型进行多步推理，并在每一步进行自我检查或外部验证。
|
|
|
- 3. **引入外部工具**： 允许模型调用外部工具（如搜索引擎、计算器、代码解释器）来获取实时信息或进行精确计算。
|
|
|
+1. <strong>数据层面</strong>： 通过高质量数据清洗、引入事实性知识以及强化学习与人类反馈 (RLHF) 等方式^[13]^，从源头减少幻觉。
|
|
|
+2. <strong>模型层面</strong>： 探索新的模型架构，或让模型能够表达其对生成内容的不确定性。
|
|
|
+3. <strong>推理与生成层面</strong>：
|
|
|
+ 1. <strong>检索增强生成 (Retrieval-Augmented Generation, RAG)</strong> ^[14]^： 这是目前缓解幻觉的有效方法之一。RAG 系统通过在生成之前从外部知识库（如文档数据库、网页）中检索相关信息，然后将检索到的信息作为上下文，引导模型生成基于事实的回答。
|
|
|
+ 2. <strong>多步推理与验证</strong>： 引导模型进行多步推理，并在每一步进行自我检查或外部验证。
|
|
|
+ 3. <strong>引入外部工具</strong>： 允许模型调用外部工具（如搜索引擎、计算器、代码解释器）来获取实时信息或进行精确计算。
|
|
|
|
|
|
尽管幻觉问题短期内难以完全消除，但通过上述的策略，可以显著降低其发生频率和影响，提高大语言模型在实际应用中的可靠性和实用性。
|
|
|
|
|
|
@@ -905,14 +905,14 @@ print(response)
|
|
|
|
|
|
本章介绍了构建智能体所需的基础知识，重点围绕作为其核心组件的大语言模型 (LLM) 展开。内容从语言模型的早期发展开始，详细讲解了 Transformer 架构，并介绍了与 LLM 进行交互的方法。最后，本章对当前主流的模型生态、发展规律及其固有局限性进行了梳理。
|
|
|
|
|
|
-**核心知识点回顾：**
|
|
|
+<strong>核心知识点回顾：</strong>
|
|
|
|
|
|
-- **模型演进与核心架构**：本章追溯了从统计语言模型 (N-gram) 到神经网络模型 (RNN, LSTM)，再到奠定现代 LLM 基础的 Transformer 架构。通过“自顶向下”的代码实现，本章拆解了 Transformer 的核心组件，并阐述了自注意力机制在并行计算和捕捉长距离依赖中的关键作用。
|
|
|
-- **与模型的交互方式**：本章介绍了与 LLM 交互的两个核心环节：提示工程 (Prompt Engineering) 和文本分词 (Tokenization)。前者用于指导模型的行为，后者是理解模型输入处理的基础。通过本地部署并运行开源模型的实践，将理论知识应用于实际操作。
|
|
|
-- **模型生态与选型**：本章系统地梳理了为智能体选择模型时需要权衡的关键因素，并概览了以 OpenAI GPT、Google Gemini 为代表的闭源模型和以 Llama、Mistral 为代表的开源模型的特点与定位。
|
|
|
-- **法则与局限**：本章探讨了驱动 LLM 能力提升的缩放法则，阐述了其背后的基本原理。同时，本章也分析了模型存在的如事实幻觉、知识过时等固有局限性，这对于构建可靠、鲁棒的智能体至关重要。
|
|
|
+- <strong>模型演进与核心架构</strong>：本章追溯了从统计语言模型 (N-gram) 到神经网络模型 (RNN, LSTM)，再到奠定现代 LLM 基础的 Transformer 架构。通过“自顶向下”的代码实现，本章拆解了 Transformer 的核心组件，并阐述了自注意力机制在并行计算和捕捉长距离依赖中的关键作用。
|
|
|
+- <strong>与模型的交互方式</strong>：本章介绍了与 LLM 交互的两个核心环节：提示工程 (Prompt Engineering) 和文本分词 (Tokenization)。前者用于指导模型的行为，后者是理解模型输入处理的基础。通过本地部署并运行开源模型的实践，将理论知识应用于实际操作。
|
|
|
+- <strong>模型生态与选型</strong>：本章系统地梳理了为智能体选择模型时需要权衡的关键因素，并概览了以 OpenAI GPT、Google Gemini 为代表的闭源模型和以 Llama、Mistral 为代表的开源模型的特点与定位。
|
|
|
+- <strong>法则与局限</strong>：本章探讨了驱动 LLM 能力提升的缩放法则，阐述了其背后的基本原理。同时，本章也分析了模型存在的如事实幻觉、知识过时等固有局限性，这对于构建可靠、鲁棒的智能体至关重要。
|
|
|
|
|
|
-**从 LLM 基础到构建智能体：**
|
|
|
+<strong>从 LLM 基础到构建智能体：</strong>
|
|
|
|
|
|
这一章的LLM基础主要是为了帮助大家更好的理解大模型的诞生以及发展过程，其中也蕴含了智能体设计的部分思考。例如，如何设计有效的提示词来引导 Agent 的规划与决策，如何根据任务需求选择合适的模型，以及如何在 Agent 的工作流中加入验证机制以规避模型的幻觉等问题，其解决方案均建立在本章的基础之上。我们现在已经准备好从理论转向实践。在下一章，我们将开始探索智能体经典范式构建，将本章所学的知识应用于实际的智能体设计之中。
|
|
|
|
Sun Tao