飞哥学习人工智能之路第三讲:CNN、RNN与Transformer

作为一线程序员高强度使用各种AI大模型和工具近1年，我深刻感受到了AI大模型的强大和便捷，但是一直在应用层不知道底层原理，很多概念理解的似是而非，没有体系化的知识体系,所以开始了这个自学人工智能之路。
1.我会结合视频教程、文档、大模型等学习资源，将自己学习人工智能的过程做个整理和记录。
2.后续会结合实际使用的案例和项目（有实际工作中的项目，也有自己兴趣使然的作品），逐步讲解一些经验和教训,希望能给大家带来一些帮助。
3.其中的一些错误和共鸣点欢迎大家指正和交流。

第三讲：深度学习三巨头-CNN、RNN与Transformer

文章导读：如果不理解这三大架构，就无法真正看懂现代 AI 的技术演进。本文将带你攻克深度学习的三座大山：

• 视觉先锋 CNN ：揭秘计算机如何像人类一样"看"懂图片，详解卷积 与池化的空间魔法。
• 序列大师 RNN ：剖析计算机如何像人类一样"读"懂文字，理解循环神经网络 的记忆机制与痛点。
• 注意力之王 Transformer ：复盘如何颠覆传统 RNN，通过自注意力机制 (Self-Attention) 开启大模型时代的霸业。

📊 统计信息：全文约 14024 字 | 预计阅读时长 35 分钟

第一部分：从全连接到专业化

在上一讲中，我们学习了全连接神经网络 (DNN/MLP)。虽然理论上它可以拟合任何函数，但在处理复杂数据（如图像和文本）时，它面临两个巨大挑战：

1. 参数爆炸：一张 的彩色图片，输入层就有 300 万个像素点。如果隐藏层也是 1000 个神经元，仅这一层的权重参数就高达 30 亿！这会导致计算量巨大且极易过拟合。
2. 结构丢失：把图片拉平成一维向量输入，破坏了像素间的空间邻域关系（比如眼睛通常在鼻子上面）；把文本打散成词袋，破坏了词序关系（"我爱你"和"你爱我"意思完全不同）。

为了解决这些问题，AI 进化出了三种专门的架构：CNN（处理空间数据） 、RNN（处理时间数据） 和 Transformer（处理序列数据的终极形态） 。

---

第二部分：视觉先锋 - 卷积神经网络 (CNN)

CNN (Convolutional Neural Network) 是计算机视觉领域的绝对霸主。它的核心思想是：与其盯着每一个像素，不如寻找局部的特征。

2.1 核心概念：卷积 (Convolution)

2.1.1 形象比喻：手电筒扫描

想象你在黑暗中用手电筒看一幅巨大的壁画。你无法一眼看清全貌，只能拿着手电筒（卷积核/Filter ）在壁画上（输入图像 ）从左到右、从上到下地扫描。 每次手电筒照亮的一小块区域，就是感受野 (Receptive Field)。你在这个区域里寻找特定的图案（比如"竖线"或"圆弧"），如果找到了，就记录下来。

2.1.2 工作原理

卷积核本质上是一个小的权重矩阵（比如 ）。 它在图像上滑动，每次覆盖 的像素区域，将像素值与卷积核的权重做点积（对应位置相乘再求和）。

这个操作的结果反映了该区域与卷积核特征的匹配程度。

• 如果卷积核是检测"边缘"的，那么边缘处的输出值就会很高。
• 这一层层卷积操作，就是在提取从低级（线条、颜色）到高级（眼睛、车轮）的特征。

2.2 核心概念：池化 (Pooling)

2.2.1 形象比喻：压缩概括

当你在看一张高清大图时，为了看清轮廓，你可能会眯起眼睛，或者把图片缩小。这就是池化。 池化层 的作用是降维 和保留主要特征。

2.2.2 常见操作

• 最大池化 (Max Pooling)：在 的区域里，只取最大的那个值。这就好比在选拔赛中，我们只关心最强的那个选手（最显著的特征），忽略其他的细节。
• 作用 ：减少计算量，防止过拟合，并且让模型具有平移不变性（猫在图片的左边还是右边，都能被识别为猫）。

2.3 CNN 的整体架构

经典的 CNN 架构（如 LeNet, AlexNet, ResNet）通常是这样的"三明治"结构：

架构详解：

1. 输入层 (Input Layer)：

   • 解释：原始图像数据。比如一张 32x32 的彩色图片，就是一个 32x32x3 的矩阵（长、宽、3个颜色通道RGB）。

2. 卷积层 (Convolution Layer) - "特征提取器" ：

   • 核心动作：拿着一个个小滤镜（卷积核）在图片上滑动扫描。
   • 作用：提取局部特征。第一层卷积可能提取出"线条"、"边缘"；深层的卷积可能提取出"眼睛"、"轮胎"等复杂形状。

3. 激活层 (ReLU Layer) - "非线性开关" ：

   • 解释 ：f(x) = max(0, x)。把负数变成0，正数保持不变。
   • 作用：给网络引入非线性能力，让它能拟合复杂的曲线，而不是只会画直线。

4. 池化层 (Pooling Layer) - "信息压缩机" ：

   • 解释：把图片缩小（降采样）。
   • 作用：减小计算量，防止过拟合，同时保留最显著的特征（比如不管猫在图片的左边还是右边，缩小后依然能看清是猫）。

5. 全连接层 (Fully Connected Layer) - "分类器" ：

   • 解释：把前面提取到的所有特征拉平成一条直线（向量），连接到分类器。
   • 作用：综合所有特征，计算出属于每个类别的概率（例如：猫 80%，狗 15%，鸟 5%）。

---

第三部分：序列大师 - 循环神经网络 (RNN)

如果说 CNN 是"看"图片的专家，那么 RNN (Recurrent Neural Network) 就是"读"文章的高手。

3.1 核心痛点：序列与记忆

人类阅读文章时，对当前词语的理解是依赖于上下文 的。 比如："我到达了苹果..."，这里的"苹果"是指水果还是手机？ 如果后面接"...园，摘了一个吃"，那就是水果；如果接"...总部，购买了新手机"，那就是科技公司。 传统的全连接网络无法处理这种变长的、有前后依赖关系的序列数据。

3.2 核心机制：隐状态 (Hidden State)

RNN 的天才之处在于引入了隐状态 (Hidden State) ，你可以把它理解为记忆。

架构详解：

1. 时间步 (Time Step)：

   • 解释：RNN 是按顺序处理数据的。处理第一个词叫 ，处理第二个词叫 ，以此类推。
   • 比喻：就像你看电影，每一帧画面就是一个时间步。

2. 输入层 (Input Layer )：

   • 解释：当前时刻读入的那个词（的向量表示）。
   • 例子：读到"苹果"这个词。

3. 隐状态层 (Hidden Layer ) - "大脑/记忆" ：

   • 核心公式：
   • 解释 ：这是 RNN 最核心的部分。它把当前看到的信息 （）和上一时刻的记忆（）融合在一起，生成新的记忆。
   • 作用：保留上下文信息。比如读到"苹果"时，脑子里还记得前面有个"吃"字，所以知道这是水果。

4. 输出层 (Output Layer )：

   • 解释：基于当前的记忆，预测下一个词是什么，或者判断这句话的情感。

3.2.1 工作流程

RNN 处理序列数据（如一句话）是按时间步 (Time Step) 进行的：

1. 读入第一个词 ，结合初始记忆 ，计算出新的记忆 。
2. 读入第二个词 ，结合上一步的记忆 ，计算出新的记忆 。
3. ...以此类推。

每一个时刻的输出，都不仅取决于当前的输入，还取决于之前的记忆。这就好比你读书时，脑海里始终保留着对前文的印象。

3.3 致命缺陷：长短期记忆问题

虽然 RNN 理论上能记忆无限长的序列，但在实际训练中，它面临梯度消失 (Gradient Vanishing) 和 梯度爆炸 的问题。 简单说，就是记不住太久以前的事情。就像读一本很长的小说，读到最后几章时，已经忘了第一章的主角叫什么名字了。

为了解决这个问题，后来诞生了 LSTM (长短期记忆网络) 和 GRU 。它们通过引入精妙的门控机制 (Gating Mechanism)（遗忘门、输入门、输出门），主动选择该记住什么、该忘掉什么，大大延长了记忆的持续时间。

---

第四部分：颠覆者 - Transformer

尽管 LSTM 改进了 RNN，但它依然有一个致命弱点：无法并行计算。 RNN 必须读完第一个词才能读第二个词，这导致训练速度极慢，无法利用大规模 GPU 集群。而且，对于特别长的序列，LSTM 的记忆能力依然有限。

2017 年，Google 团队发表了划时代的论文 《Attention Is All You Need》 ，提出了 Transformer 架构，彻底改变了 NLP 乃至整个 AI 领域的格局。

4.1 架构解剖：Transformer 的完全体

虽然自注意力机制是核心，但要让它真正工作起来，还需要一个完整的身体架构。下图展示了 Transformer 的经典架构（Encoder-Decoder 结构）。

架构图解说明：

为了让你彻底看懂这张"神图"，我们将按照数据流动的方向，把每个方块拆碎了讲。

1. 输入处理层 (Inputs) - 数据的"安检口"

这里是数据进入模型的第一个关卡。在进入模型之前，其实还有一个隐含的步骤：分词 (Tokenization)。

• Tokenization (分词)：

  • 解释：机器看不懂中文或英文，它只能看懂数字。分词器把句子切成一个个"Token"（词元），并查表转换成数字 ID。
  • 比喻 ：就像查字典。把"我爱你"切分成"我"、"爱"、"你"，然后查字典得到它们的编号 [102, 520, 305]。

• Embedding (词嵌入)：

  • 作用：把文字转换成数学向量。
  • 比喻 ：就像把"苹果"这个词转换成一组坐标 [0.1, 0.5, ...]，让计算机能进行数学运算。

• Positional Encoding (位置编码)：

  • 痛点：Transformer 不像 RNN 那样按顺序一个个读词，而是一口气把所有词都吃进去（并行计算）。这就导致它分不清"我爱你"和"你爱我"的区别。
  • 解决：人为地给每个词加上一个"位置标记"。
  • 比喻：就像给旅行团的每个游客发一个编号牌（1号、2号、3号），这样即使大家散开了，也能知道谁排在谁前面。

2. 编码器 (Encoder) - 模型的"阅读理解中心"

左边的蓝色方块是 Encoder，它的任务是深刻理解输入的内容。

• Multi-Head Attention (多头自注意力)：

  • 作用：从不同角度观察词语之间的关系。
  • 比喻：如果单头注意力是"一只眼"，多头就是"八只眼"。一只眼关注语法（动词后面接名词），一只眼关注指代（"它"指代"猫"），一只眼关注情感。这样理解更全面。

• Add & Norm (残差连接与层归一化)：

  • Add (残差连接)：把输入直接加到输出上。就像在这个复杂的处理过程中修了一条"直通高速公路"，防止原始信息在层层传递中丢失。
  • Norm (归一化)：把数据调整到统一的范围内（比如均值为0，方差为1），让模型训练更稳定。

• Feed Forward (前馈神经网络)：

  • 作用：简单的全连接网络，对提取到的特征进行进一步的消化和整合。
  • 比喻：就像把刚才观察到的各种关系，在大脑皮层里再深加工一下。

3. 解码器 (Decoder) - 模型的"创作中心"

右边的橙色方块是 Decoder，它的任务是根据 Encoder 的理解，生成新的内容（比如翻译结果）。

• Inputs (Shifted Right)：

  • 解释：这是 Decoder 的输入。为什么叫"右移一位"？因为在训练时，我们是把"标准答案"喂给 Decoder，让它预测下一个词。为了不让它看到"当前要预测的词"，我们需要把输入往后挪一位。
  • 比喻：就像老师教学生写作文，老师写第一个字，学生猜第二个字；老师写前两个字，学生猜第三个字。学生永远只能看到"之前"的字，看不到"现在"要写的字。

• Masked Multi-Head Attention (掩码多头注意力)：

  • 痛点：在训练时，我们不能让模型看到"未来"的答案。比如翻译"I love you" -> "我爱你"，生成"我"的时候，不能让它看到后面是"爱"。
  • 解决：用一个 Mask（掩码/遮羞布）把后面的词挡住，强制模型只能根据已知信息去预测。

• Cross Attention (交叉注意力)：

  • 关键点：这是连接 Encoder 和 Decoder 的桥梁。
  • 机制 ：这里的 Q (Query) 来自 Decoder（我现在想生成什么？），而 K (Key) 和 V (Value) 来自 Encoder（原文里有什么信息？）。
  • 比喻：就像考试写作文（Decoder），写每一句时都要回头去查阅阅读理解的原文（Encoder），看看有哪些信息可用。

4. 输出层 (Output) - 最终结果

• Linear (线性层)：把 Transformer 复杂的输出向量，映射回词表的大小（比如词表有 10000 个词，就输出 10000 个数值）。
• Softmax ：把这些数值转换成概率。比如"猫"的概率是 0.8，"狗"是 0.1。模型最终会选择概率最大的那个词作为输出。

4.2 核心理念：自注意力机制 (Self-Attention)

Transformer 抛弃了循环（RNN）和卷积（CNN），完全依赖注意力机制。

4.2.1 形象比喻：鸡尾酒会效应

在嘈杂的鸡尾酒会上，你的耳朵能接收到所有人的声音，但你的大脑会自动聚焦 (Attention) 在和你聊天的那个人身上，通过上下文理解他的话，同时忽略背景噪音。

4.2.2 Q, K, V 模型

Transformer 将注意力机制形式化为 Query (查询) , Key (键) , Value (值) 的操作。 这很像在图书馆找书 或数据库查询：

1. Query (Q)：你手里的借书卡（你想查什么）。
2. Key (K)：书脊上的标签（索引匹配）。
3. Value (V)：书里的内容（实际信息）。

计算过程：

1. 拿你的 去和所有书的 计算相似度（点积）。
2. 相似度越高，说明这本书越相关，权重 (Attention Score) 就越大。
3. 最后根据权重，把所有书的 加权求和，得到最终的输出。

通过这种方式，Transformer 可以一次性看到整句话的所有词，并计算出每个词与其他所有词的关联程度。比如在"银行 里的钱"这句话中，"银行"会特别关注"钱"这个词，从而确定自己是"金融机构"而不是"河岸"。

这就是为什么 Transformer 能理解上下文：它把上下文的信息"加"到了当前词的向量里。

4.2.3 深度解析：自注意力计算五步法 (Developer Edition)

这里我们可以跳过通俗的比喻，直接看数据流 和矩阵变换。这才是 Transformer 的灵魂所在。

假设我们有一个输入序列 （比如 "Thinking Machines" 两个词），每个词已经 Embedding 为一个 4 维向量。 输入矩阵 的维度是 [2, 4] (sequence_length=2, embedding_dim=4)。

Step 1: 线性投影 (Linear Projections) - 生成 Q, K, V

Transformer 内部维护了三个可训练的权重矩阵：。 我们将输入 分别乘以这三个矩阵，得到查询(Query)、键(Key)、值(Value)三个新矩阵。

• 公式：
• 维度变化 ：[2, 4] * [4, 3] -> [2, 3] (假设 projected_dim=3)
• 代码意义：这一步相当于把原始特征空间映射到了三个不同的子空间，分别用于"提问"、"被查"和"内容提取"。

Step 2: 矩阵点积 (Dot Product) - 计算相关性

计算 Q 和 K 的转置矩阵的乘积。

• 公式：

• 维度变化 ：[2, 3] * [3, 2] -> [2, 2]

• 物理意义 ：得到一个 seq_len * seq_len 的方阵。矩阵中第 行第 列的值，代表第 个词和第 个词的相关性分数。

  • 比如 Scores[0][0] 是 "Thinking" 对 "Thinking" 的关注度。
  • Scores[0][1] 是 "Thinking" 对 "Machines" 的关注度。

Step 3: 缩放 (Scaling) - 梯度稳定

将分数除以 (key 向量维度的平方根，这里是 )。

• 公式：
• 目的：防止点积结果过大导致 Softmax 进入饱和区（梯度极小），让模型训练更稳定。

Step 4: 归一化 (Softmax) - 概率分布

对每一行进行 Softmax 操作。

• 公式：
• 物理意义：将分数转换为概率分布（和为1）。这意味着对于当前词来说，其他所有词的重要性占比是多少。

Step 5: 加权求和 (Weighted Sum) - 生成上下文向量

用算出的概率去加权 Value 矩阵。

• 公式：

• 维度变化 ：[2, 2] * [2, 3] -> [2, 3]

• 最终结果：生成的 矩阵维度与 一致。

  • 的第一行不再只是 "Thinking" 的信息，而是包含了 80% 的 "Thinking" 和 20% 的 "Machines" (假设权重) 的混合信息。
  • 这就是所谓的"上下文感知" (Context Aware)。

👨‍💻 代码实战：NumPy 手搓 Self-Attention

为了彻底理解，我们用最基础的 NumPy 来还原这个过程：

import numpy as np

def self_attention(X, W_Q, W_K, W_V):
    """
    X: [seq_len, d_model] - 输入矩阵
    W_Q, W_K, W_V: [d_model, d_k] - 权重矩阵
    """
    
    # 1. 线性投影 (Linear Projections)
    # 这一步通常由 nn.Linear 完成
    Q = np.dot(X, W_Q) # shape: [seq_len, d_k]
    K = np.dot(X, W_K) 
    V = np.dot(X, W_V) 

    # 2. 矩阵点积 (Dot Product)
    # Q 乘以 K 的转置
    scores = np.dot(Q, K.T) # shape: [seq_len, seq_len]

    # 3. 缩放 (Scaling)
    d_k = Q.shape[1]
    scores = scores / np.sqrt(d_k)

    # 4. 归一化 (Softmax)
    # 对每一行做 softmax
    exp_scores = np.exp(scores)
    attention_weights = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)
    # shape: [seq_len, seq_len]

    # 5. 加权求和 (Weighted Sum)
    # 权重矩阵乘以 V
    output = np.dot(attention_weights, V) # shape: [seq_len, d_k]
    
    return output, attention_weights

# --- 测试数据 ---
X = np.array([
  [1, 0, 1, 0], # Input 1
  [0, 2, 0, 2], # Input 2
  [1, 1, 1, 1]  # Input 3
])
# 随机初始化权重
W_Q = np.random.rand(4, 3)
W_K = np.random.rand(4, 3)
W_V = np.random.rand(4, 3)

output, weights = self_attention(X, W_Q, W_K, W_V)
print("Attention Weights Matrix:\n", np.round(weights, 2))
print("\nContextualized Output:\n", np.round(output, 2))

一句话总结：自注意力机制本质上就是一个"基于内容的动态加权求和"算法。它通过矩阵运算，让序列中的每个元素都能聚合全局信息。

4.2.4 进阶机制：Multi-Head Attention (多头注意力)

很多开发者第一次看 Transformer 代码时，最困惑的就是 Multi-Head 到底是怎么"切"出来的。是把输入复制多份吗？还是有什么黑魔法？

其实，它的实现非常优雅且高效，核心就在于矩阵维度的 Reshape 和 Transpose。

1. 为什么要"多头"？

如果是单头（Single-Head），Q、K、V 的维度就是 d_model（比如 512）。这意味着我们只能在一个特征空间里寻找词与词的关系。 但语言是复杂的：

• Head 1 可能关注语法结构（比如主谓宾关系）。
• Head 2 可能关注指代关系（比如"它"指代"猫"）。
• Head 3 可能关注位置关系（比如相邻的词）。

多头机制就是让模型拥有"分身术"，同时在多个不同的子空间（Subspace）里捕捉信息，最后再拼起来。

2. "切分"的物理过程

假设 d_model = 512，我们要分 h = 8 个头。 每个头的维度就是 d_k = 512 / 8 = 64。

关键点：我们并不是创建了 8 个独立的矩阵，而是把一个大矩阵"拆"成了 8 个小矩阵。

数据流向 (Data Flow)：

1. 线性投影 (Linear Projection) ： 输入 经过 投影后，维度依然是 [batch, seq_len, d_model] (例如 [32, 10, 512])。

2. 切分 (Split / Reshape) ： 我们将最后一维 512 拆解为 8 * 64。

   • 操作 ：view(batch, seq_len, heads, d_k)
   • 维度变化 ：[32, 10, 512] -> [32, 10, 8, 64]

3. 转置 (Transpose / Permute) ： 为了让每个头能独立计算 Attention，我们需要把 heads 维度移到前面。

   • 操作 ：transpose(1, 2)
   • 维度变化 ：[32, 10, 8, 64] -> [32, 8, 10, 64]
   • 现在，我们在逻辑上拥有了 8 个独立的"小世界"。

4. 并行计算 Attention ： 现在的维度是 [32, 8, 10, 64]。 当我们做矩阵乘法时，后两维 [10, 64] 参与运算，前两维 [32, 8] 被视为 Batch 处理。 这意味着 8 个头的注意力计算是完全并行发生的，GPU 极其擅长这种操作。

5. 拼接 (Concat) ： 计算完 Attention 后，维度变回 [32, 8, 10, 64]。 我们需要把它还原回去：

   • 转置回来 ：[32, 10, 8, 64]
   • 拼接 (Reshape) ：[32, 10, 512]

6. 最终线性层 (Final Linear)： 最后经过一个 矩阵，融合 8 个头的信息。

👨‍💻 代码实战：PyTorch 中的 Multi-Head 实现逻辑

# 假设 batch_size=32, seq_len=10, d_model=512, heads=8, d_k=64
def multi_head_attention_split(x):
    # x: [batch, seq_len, d_model] -> [32, 10, 512]
    
    # 1. 线性投影得到 Q (这里简化演示，实际会有 W_q)
    # q = linear(x) 
    # q shape: [32, 10, 512]
    
    # 2. Reshape: 把 512 拆成 8 * 64
    # 此时维度: [32, 10, 8, 64]
    q = q.view(32, 10, 8, 64)
    
    # 3. Transpose: 把头(8) 换到 序列长度(10) 前面
    # 这一步是核心！让每个头独立
    # 此时维度: [32, 8, 10, 64]
    q = q.transpose(1, 2)
    
    # ... 对 K, V 做同样操作 ...
    
    # 4. 计算 Attention
    # 这里的矩阵乘法只发生在后两维 [10, 64] * [64, 10]
    # 前面的 [32, 8] 就像是 32*8 = 256 个独立的任务在并行
    scores = torch.matmul(q, k.transpose(-2, -1)) 
    
    return scores

一句话总结：Multi-Head 不是物理上的"分身"，而是逻辑上的"多视角切片"。通过 Reshape 和 Transpose，我们在不增加计算量级的前提下，让模型拥有了"多重思维"。

4.3 Transformer 与神经网络的关系

Transformer 依然属于神经网络 家族，它的底层同样由神经元（矩阵乘法、激活函数）组成，但它在架构设计上与前辈们有着本质的区别。为了让你从传统软件开发的视角理解它们的关系，我们可以用软件开发架构的演进史来类比：

1. 从"流水线工人"到"会议室高管"

• RNN（循环神经网络） 像一个勤劳但记忆力有限的流水线工人。他必须一个接一个地处理零件（读单词），处理当前零件时只能凭借对上一个零件的记忆。如果序列太长，他可能会忘记最开始说了什么。而且他必须从头干到尾，无法并行。
• Transformer 像一个高效的公司高管开会。他把所有待办事项（整个句子）一次性摊在桌上看（并行计算），不需要按顺序读，而是看一眼全局，瞬间找出不同事项之间的关系（自注意力）。

2. 从计算机体系结构理解

• 神经网络 是通用的计算单元，就像 CPU 的核心。
• RNN 是 串行计算架构，就像早期的单核 CPU，必须一条指令一条指令地执行。
• Transformer 是 多核并行架构 + 全局内存共享。它配备了"注意力机制"这根总线，让每个核心都能瞬间从全局获取相关信息，而不需要像 RNN 那样一步步传递。

3. 从数据结构理解

• RNN 像链表：要想找到第 100 个元素，必须先遍历前 99 个。信息的流动是受限的、顺序的。
• Transformer 像带索引的数据库表 ：它把整个句子看作一张表，自注意力 就像建立了动态的关联索引。当要查"它"指代什么时，不是从头遍历，而是通过索引机制，一次性计算出所有词的相关性分数。

简单说：Transformer 是神经网络家族中，目前最先进、最能打的一个"变种"。

4.4 为什么它是颠覆者？

1. 并行计算：不再需要按顺序读词，可以一次性输入整篇文章，GPU 利用率拉满，使得训练超大规模模型（如 GPT-4）成为可能。
2. 全局视野：无论序列多长，任何两个词之间的距离都是 1（直接计算注意力），彻底解决了长距离依赖问题。
3. 位置编码 (Positional Encoding)：因为没有了先后顺序，Transformer 额外引入了位置编码来告诉模型每个词的位置。

4.5 家族繁衍：BERT 与 GPT

Transformer 的出现催生了现在的 LLM（大语言模型）盛世：

• Encoder-only (如 BERT) ：只用 Transformer 的编码器部分。擅长"理解"任务（完形填空、情感分析），像一个博学的阅读理解专家。
• Decoder-only (如 GPT) ：只用 Transformer 的解码器部分。擅长"生成"任务（像接龙一样写文章），像一个才华横溢的作家。
• Encoder-Decoder (如 T5)：保留完整架构。擅长序列到序列的任务（翻译、摘要）。

---

第五部分：三大架构总结对比

最后，我们将这三位巨头做一个横向对比，帮助大家建立完整的知识图谱。

特性	CNN (卷积神经网络)	RNN (循环神经网络)	Transformer
核心操作	卷积核滑动窗口	循环递归 (隐状态)	自注意力机制 (Self-Attention)
擅长领域	计算机视觉 (CV) 图像分类、检测	自然语言处理 (NLP) 语音识别、时间序列	全能霸主 (NLP + CV) 大语言模型、多模态
数据特征	空间局部性 (Grid)	时间顺序性 (Sequence)	全局关联性 (Set/Graph)
并行计算	✅ 容易并行	❌ 难以并行 (串行)	✅ 极易并行
长距离依赖	❌ 较弱 (受限于感受野)	⚠️ 一般 (受限于梯度消失)	✅ 极强 (全局视野)
代表模型	ResNet, YOLO, VGG	LSTM, GRU	BERT, GPT, LLaMA

总结：

• CNN 教会了 AI "看"世界，捕捉纹理与轮廓。
• RNN 教会了 AI "记"历史，理解前后因果。
• Transformer 也就是我们现在所处的时代，它整合了并行与注意力的力量，让 AI 涌现出了惊人的通用智能。

第六部分：FAQ

6.1 Tokenization和大模型经常提到的100k限制是什么关系

Tokenization和大模型中常提到的"100k限制"之间是计量单位与容量上限 的关系。简单来说，Tokenization（分词） 定义了模型认识和使用的"语言单元"------Token ，而 "100k限制" 就是指模型一次性能处理的最大Token数量 ，也就是它的上下文窗口大小。

打个比方，可以把大模型想象成一个记忆力超群，但"工作记忆"有限的读者：

• Tokenization（分词） 就像是把一段话拆解成一个个有意义的"词汇卡"的过程。
• Token 就是这些"词汇卡"本身。它可以是一个完整的词（如 apple），也可以是一个词的一部分（如 ing），甚至是一个标点符号。对中文来说，一个汉字通常就是一个Token。
• 100k上下文窗口 就是这个读者一次最多能摆在桌面上阅读的"词汇卡"总数，也就是 100k个Token。如果一本书有200k个Token，他就得分两次才能看完。

1. Tokenization：定义"语言单元"的规则

Tokenization是让大模型理解文本的第一步，它有一套自己的拆解规则：

• 子词拆分 ：现代大模型（如GPT系列、LLaMA）为了高效处理各种词汇，普遍采用"子词"拆分方式。例如，单词 unhappiness 可能会被拆成 un、happi 和 ness 这样三个Token。这样做的好处是，即使遇到没见过的生僻词，模型也能通过拆解后的已知子词来"猜"出大概意思，有效避免了"词汇表里没有，我就不认识"的尴尬。
• 语言差异 ：不同语言的分词效率也不同。在英文中，1个Token大约对应0.75个单词；而在中文里，由于汉字信息密度高，1个汉字通常就是1~2个Token。

2. 100k上下文窗口：模型"工作记忆"的容量上限

上下文窗口的大小，直接决定了模型在生成回答时，能同时"回顾"多少前文信息。

• 硬性限制：这里的"100k"是模型架构和硬件资源共同决定的硬性上限。它的计算和存储成本会随着Token数量的增加而急剧（平方级）上升。例如，LLaMA2模型原本的上下文窗口只有4k，通过LongLoRA等特殊微调技术，才得以扩展到100k。
• 实际影响：这个数字直接关系到你能用模型做什么。一篇《了不起的盖茨比》大约有72k个Token，拥有100k窗口的模型就可以一次"读完"这本小说并回答其中的细节问题。

总结

所以，当你向一个拥有100k上下文窗口的模型提问时，你的输入文本会先经过分词器，被拆解成一个个Token ，然后模型会在这个不超过 100k个Token 的范围内，理解你的意思并组织语言进行回复。

6.2 为什么是100k的限制，这个原因是什么

这个问题触及了大模型技术的核心瓶颈。之所以会有100k（即10万token左右）这个限制，根本原因在于计算成本、内存消耗和模型架构三者之间的复杂博弈。

简单来说，不是不想做得更大，而是做到100k级别已经是当前技术在"成本"和"性能"之间找到的一个艰难平衡点。

以下是导致这个限制的几个核心原因：

1. 核心痛点：Transformer架构的"平方级"复杂度

目前绝大多数大模型（如GPT系列）都基于Transformer架构 。它的核心机制是自注意力机制，这个机制允许模型在处理一个词时，同时关注句子中所有其他词。

• 数学关系 ：如果输入文本的长度是 ( n )（即Token数量），那么模型需要计算两两之间的注意力。这种计算量和内存占用的增长速度大约是 ( n^2 )（即平方级增长）。

• 直观理解：

  • 如果 ( n=1000 )，计算量大约是 100万次。
  • 如果 ( n=100k )（即10万），计算量大约是 100亿次。
  • 如果想把窗口扩大到 1M（100万），计算量将直接飙升至 1万亿次。 这种几何级的爆炸式增长，使得无限制地扩大窗口在物理上变得极其困难且昂贵。

2. 硬件层面的"内存墙"

即便算力足够，内存也是一个巨大的制约因素。这里的"内存"指的是显卡的显存（VRAM）。

• 存储中间结果：在推理（生成答案）或训练过程中，模型需要把每个Token的计算中间结果（Key和Value矩阵，即KV Cache）暂存在显存里，以备后续生成新的Token时使用。
• 线性增长变平方：对于100k的输入，KV Cache本身就需要占用巨大的显存空间。假设一个模型有70亿参数，处理100k上下文时，KV Cache的大小甚至可能超过模型参数本身的大小。
• 后果：如果窗口过大，即使是目前最顶尖的H100或A100显卡，也无法同时容纳下模型参数和庞大的上下文数据，最终会导致"显存不足"的错误。

3. 模型自身的"注意力迷失"（距离诅咒）

即使硬件的钱不是问题，模型本身的数学特性也会带来挑战。

• 信息稀释：当上下文窗口达到100k甚至更大时，模型需要在海量的文本中寻找关键信息。由于注意力机制是"软性"的，距离较远的信息在传递过程中容易衰减，导致模型出现"中间遗忘"现象，即很难准确提取长文本中部的细节。
• 位置编码的限制：为了让模型知道词的顺序，研究者发明了"位置编码"。早期的很多位置编码（如RoPE，即旋转位置编码）具有一定的外推性，但通常都有一个有效范围。一旦超过100k这个阈值，模型可能无法准确区分不同位置的相对距离，导致位置感混乱。

4. 数据与成本的商业考量

除了技术原因，商业因素也决定了为什么主流产品目前普遍选择100k（如GPT-4 Turbo, Claude 3）作为标准。

• 推理成本：用户每问一次问题，模型都需要对上下文进行重新计算。100k的上下文比10k的上下文成本要高出几十倍甚至上百倍。如果直接开放1M的窗口而不优化，API的调用费用可能会高到用户无法承受。
• 边际效用：从实际应用来看，100k的窗口足以覆盖一本长篇小说（如三体全集约90万字）或几百页的技术文档。对绝大多数商业场景（如客服、文档总结、代码库分析）来说，100k已经是够用的上限，再往上增长对用户体验的提升有限，但成本却会急剧增加。

目前的技术突破（为什么有些模型号称1M甚至无限？）

你可能会问，那为什么现在有一些模型（如Google的Gemini 1.5 Pro，或者一些国产模型）开始支持1M（100万）甚至更大的窗口呢？

这是因为业界正在通过算法优化来"绕过"平方级的复杂度：

1. 稀疏注意力：不再计算所有Token两两之间的关系，而是只让模型关注最重要的那些Token。
2. NIOE技术：通过特定的检索机制，在超长文本中快速找到与问题最相关的片段，而不是一股脑地把所有文本都塞进显卡计算。
3. 硬件升级：新的显存技术（如HBM3e）和更高效的计算卡，提供了更大的物理容量。

总结

所以，100k的限制本质上是 "数学定律（平方级增长）"、"物理限制（内存墙）"和"经济规律（成本效益）"共同作用的结果。

100k是当前工程实践中的一个黄金分割点------它足够覆盖绝大多数人类知识载体（如书籍、报告），同时又能让普通用户的显卡和云端算力勉强承受得住。而突破100k向1M迈进，则意味着必须在算法或硬件上进行革命性的创新。

6.3 窗口大小和计算量之间的关系是怎么计算出来的

这个问题很有深度，触及了大模型计算复杂度的核心。要理解窗口大小（序列长度 ( n )）和计算量之间的关系，关键在于剖析 Transformer模型中自注意力机制的计算过程。

这个关系通常被称为 ( O(n^2) ) 复杂度。这里的 ( n ) 指的是输入序列的长度（Token数量），而 ( O ) 表示算法的复杂度。

我们可以把计算过程拆解为两个主要部分来理解这个 ( n^2 ) 是如何产生的：

1. 核心计算：注意力分数矩阵

假设我们有一个长度为 ( n ) 的句子（即 ( n ) 个Token）。在自注意力机制中，模型需要找出这 ( n ) 个词中，每一个词与其他所有词之间的关系强度。

步骤拆解：

1. 准备数据：模型为每个单词生成三个向量：查询向量、键向量、值向量。

2. 两两组合计算：

   • 为了计算第一个词与所有词的关系，我们需要拿第一个词的查询向量，去点乘（一种数学运算）第1、2、3...直到第 ( n ) 个词的键向量。这会产生 ( n ) 个分数。
   • 然后，为了计算第二个词与所有词的关系，我们又要拿第二个词的查询向量，去点乘所有 ( n ) 个词的键向量。这又会产生 ( n ) 个分数。
   • 以此类推，直到第 ( n ) 个词。

数学关系：

• 我们需要执行 ( n )（查询的数量）乘以 ( n )（键的数量）次点乘运算。
• 因此，计算出来的注意力分数矩阵的大小就是 ( n \times n )。
• 这意味着，计算量大致与 ( n \times n = n^2 ) 成正比。

直观对比：

• 如果 ( n = 1000 )，我们需要计算 1000 ( \times ) 1000 = 100万次 点乘。
• 如果 ( n = 100,000 ) (100k)，我们需要计算 100,000 ( \times ) 100,000 = 100亿次 点乘。
• 如果 ( n = 1,000,000 ) (1M)，我们需要计算 1,000,000 ( \times ) 1,000,000 = 1万亿次 点乘。

可以看到，当 ( n ) 扩大10倍（从100k到1M），计算量不是扩大10倍，而是扩大 ( 10^2 = 100 ) 倍。

2. 物理表现：显存占用

这个 ( n \times n ) 的注意力矩阵不仅需要计算，还需要临时存储在显卡（GPU）的显存中，以便进行后续的梯度计算。

• 存储关系：这个矩阵的大小同样是 ( n^2 )。

• 举例说明：

  • 如果 ( n = 100k )，这个矩阵就有 100亿个数字。
  • 假设每个数字用常见的 32位浮点数（占4字节）存储，仅仅存储这一个矩阵就需要：( 10^{10} \times 4 ) 字节 = 40 GB（吉字节）的显存。
  • 而目前最顶级的商用显卡（如NVIDIA H100），显存容量通常在 80 GB 左右。这意味着，仅仅存储这一个中间计算结果，就已经占用了显卡一半的容量，这还没算上模型本身的参数（通常也有几十GB）和其他数据。

这就是为什么说大窗口会导致 "内存墙" ------显存的物理容量限制了我们能处理的最大 ( n )。

3. 为什么有些模型看起来没有 ( n^2 ) 的限制？

你可能会好奇，既然 ( n^2 ) 这么可怕，为什么现在有些模型号称支持 1M 甚至 10M 的上下文？它们是怎么绕过这个数学定律的？

这主要归功于工程和算法上的近似优化，它们不再计算完整的 ( n^2 ) 矩阵：

1. 稀疏注意力：

   • 原理：不计算所有词两两之间的关系，而是假设"距离太远的词关联不大"。
   • 做法：只计算每个词与附近固定数量（比如 1000个）词的关系。
   • 结果：复杂度从 ( O(n^2) ) 降低为 ( O(n) )。无论文本多长，每个词只看周围一小块区域。

2. RNN（循环神经网络）式线性化：

   • 原理：改变计算顺序，把注意力机制改成类似状态空间模型的形式。
   • 代表技术：Mamba模型、RWKV模型。
   • 结果：彻底去除了 ( n^2 ) 项，实现了严格意义上的线性复杂度。

3. 检索增强生成：

   • 原理：这是一种投机取巧但非常实用的方法。不把整个1M文本都塞进显卡计算，而是先把文本存到外部数据库里。当用户提问时，只检索出最相关的 10k 文本片段，然后让模型阅读这 10k。
   • 结果：实际参与计算的窗口仍然是 10k，成本可控。

总结

窗口大小 ( n ) 与计算量的关系 ( O(n^2) ) ，来源于自注意力机制必须计算每个Token与其他所有Token之间关系的设计。

• 100k窗口：意味着 100亿次基本运算和巨大的显存占用，这已经是当前硬件在不进行复杂优化下的承受极限。
• 1M窗口 ：如果完全按照标准算法计算，意味着 1万亿次运算和超出硬件承载能力的显存需求。因此，要支持1M窗口，必须依赖上述提到的稀疏化、线性化或检索等近似技术。

6.4 图片、文档、视频的token是怎么计算的？

我们来完整地看一下图片、文档和视频这三种模态的Token计算方式。它们遵循完全不同的逻辑：图片和视频是按"视觉块"算的，文档则通常是先转成纯文本再计算。

🖼️ 图片Token：切块处理

模型通过视觉编码器处理图片，核心是将其切割成固定大小的方块。

1. 切分图片 ：模型会将图片均匀切割成固定大小的小方块（Patch）。例如，BEiT模型会把图片切分成一个 14x14 的网格，共196个方块。
2. 转换为Token ：每个小方块都被转换成一个视觉Token，包含了该区域的视觉信息。
3. 总数计算 ：因此，一张图片消耗的Token数量，基本就等于它被切分成的方块数量。

有趣的是，这种方式信息压缩效率极高。研究发现，一篇约1000个文字Token的文档，如果换成"看图"的方式处理，可能只需要100个视觉Token就能以97%的精度还原，相当于压缩了10倍。

不同模型的具体参数可能略有差异，建议查阅官方文档获取精确值。

📄 文档Token：先提取文字再计算

对于PDF、Word等文档，其计算方式非常直接：

1. 提取纯文本 ：模型会忽略所有排版、字体等格式信息，只提取文档中的纯文字内容。
2. 按文本规则计算 ：提取出的纯文本，遵循标准的文本分词规则 来计算Token。在中文环境下，大致是1个汉字对应1~2个Token。
3. 注意内嵌图片：文档中内嵌的图片，会按照上述图片的规则单独计算。

🎬 视频Token：三维网格化处理

视频的处理最为复杂，因为它增加了时间维度。视频被看作一系列图片（帧）的集合，计算方式是在图片的二维网格基础上，再增加一个时间轴，形成三维的立方块。

1. 三维切分 ：一个视频片段会被切分成 T x H x W 的网格。其中 T 代表时间维度的帧数，H 和 W 代表每帧图片的高度和宽度上的网格数。
2. 转换为Token ：每个这样的小立方块（包含了时间与空间信息）会被转换为一个视频Token。
3. 总数计算 ：因此，视频的Token总数大致等于 T * H * W。

例如，一个包含10帧、每帧切分成14x14网格的视频，其Token总数大约为 10 * 14 * 14 = 1960 个。为了提升效率，一些技术会通过剪枝（Pruning）策略，智能地保留信息量大的Token，丢弃冗余的Token，从而减少计算量。

⚠️ 关键提醒：规则因"模"而异

最后有一个非常重要的提醒：不同的模型服务商和模型版本，其具体的Token计算规则（特别是视觉部分的编码方式）可能不一样。最准确的方法是查阅你所使用模型的官方技术文档。

---

第七部分：主流大模型全维度对比

随着 AI 技术的指数级迭代，2026 年的大模型领域已进入"Agent（智能体）"与"原生多模态"的全新时代。为了让你在选择模型时不再迷茫，我们从开源属性 、模型类型 、擅长领域等多个维度，对目前（截至 2026 年）国内外的主流大模型进行一次盘点。

7.1 全球主流大模型概览

模型名称	厂商 (国家)	核心类型	开源情况	核心优势 / 擅长领域
GPT-5 (Orion) / o3	OpenAI (美)	原生多模态 / 强推理	❌ 闭源	AGI雏形，o3 具备自主反思与长程规划能力，GPT-5 实现毫秒级全模态交互
Claude 4 Opus	Anthropic (美)	多模态	❌ 闭源	最强安全性与长窗口，支持 10M+ token 上下文，代码架构能力无可匹敌
Gemini 2.0 Ultra	Google (美)	原生多模态	❌ 闭源	生态整合之王，与 Android/Workspace 深度绑定，视频理解与生成能力业界第一
Llama 4 (405B)	Meta (美)	文本 / 多模态	✅ 开源	开源界定海神针，性能对标 GPT-5，全球开发者首选基座，私有化部署标准
DeepSeek-V4 / R2	深度求索 (中)	稀疏混合专家 / 推理	✅ 开源	极致性价比，R2 在数学/代码竞赛中超越 o3，推理成本仅为 GPT-5 的 1/10
Qwen 3 (通义千问)	阿里巴巴 (中)	多模态 Agent	✅ 开源	最强中文能力，视觉智能体 (Visual Agent) 能力突出，在手机端侧表现优异
Grok 3	xAI (美)	实时多模态	⚠️ 部分开源	实时信息流，直接接入 X (Twitter) 实时数据，具备独特的"叛逆/幽默"模式
Kimi (Moonshot)	月之暗面 (中)	长文本 / 智能体	❌ 闭源	长文本鼻祖，支持 100M+ 级无损上下文，擅长财报分析与长篇小说创作
MiniMax (海螺 AI)	稀宇科技 (中)	多模态 / 语音	❌ 闭源	拟人化最强，语音合成 (TTS) 极其逼真，角色扮演 (Roleplay) 体验业界第一
Yi-Lightning 2	零一万物 (中)	长文本	❌ 闭源	超长文档分析，在千万级 token 的大海捞针测试中保持 100% 召回率

7.2 选型建议：我该用哪个？

1. 如果你是开发者 (Developer)

• 复杂系统架构/Agent开发 ：首选 Claude 4 Opus。它的逻辑稳定性和指令遵循能力依然是业界天花板，适合编写复杂的 Agent 编排逻辑。
• 私有化部署/行业大模型 ：首选 Llama 4 或 Qwen 3。Llama 4 生态最成熟，Qwen 3 在中文和视觉任务上更具优势。
• 低成本推理/数学逻辑 ：DeepSeek-R2。如果你需要大规模处理逻辑密集型任务（如代码生成、数学证明），它的性价比无敌。

2. 如果你是内容创作者 (Creator)

• 多媒体创作/视频脚本 ：Gemini 2.0 Ultra 或 GPT-5。它们能理解和生成视频分镜，甚至直接生成短视频片段。
• 深度长文/书籍创作 ：Claude 4 Opus。超大上下文窗口让它能记住整本书的情节，写作风格最像人类作家。

3. 如果你是科研人员 (Researcher)

• 科学发现/复杂推理 ：OpenAI o3 或 DeepSeek-R2。这两款模型专为"慢思考"设计，擅长处理复杂的科学文献综述和实验设计。

4. 2026 年技术趋势总结

• Agentic AI (智能体化)：模型不再只是"聊天机器人"，而是能操作电脑、调用工具、自主完成任务的"数字员工"。
• 原生多模态 (Native Multimodal)：文本、图像、音频、视频不再是分离的模块，模型天生就能"看、听、说"，交互像人类一样自然。
• 端侧智能 (On-Device AI)：随着手机 NPU 性能暴涨，7B-10B 参数的模型（如 Llama 4-8B, Qwen 3-Mobile）已能流畅运行在手机上，数据隐私更有保障。