【收藏版】大模型 Transformer 架构从 0 到 1 深度解析｜零基础吃透核心原理

原创于 2025-12-29 11:24:20 发布 · 514 阅读

CC 4.0 BY-SA版权

文章标签：

#人工智能 #大模型学习 #大模型 #agi #java #程序员 #agent

一、Transformer到底是个啥?

简单来说，Transformer 是一种革命性的神经网络架构，就像搭建 AI 模型的「黄金设计图纸」。2017 年 Google 团队在顶刊论文《Attention is All You Need》中首次提出这一架构，直接颠覆了当时的 AI 技术格局，成为如今所有大模型的技术基石。

1.1 Transformer解决了什么问题?

在 Transformer 诞生前，NLP 领域的主流方案是 RNN（循环神经网络）和它的升级版 LSTM，这类模型处理文本时存在无法并行、长文本效率暴跌的核心缺陷。

举个通俗例子：

翻译句子「我今天早上吃了一个苹果」时，RNN 必须严格按「我→今天→早上→吃了→一个→苹果」的顺序逐字处理，前一个词的计算完成后，才能开始下一个词的运算。这就像单窗口排队办业务，前面的人不结束，后面所有人都得等待，文本越长，耗时越久
而 Transformer 的核心突破在于引入了自注意力机制（Self-Attention），它能「一眼扫遍」句子中的所有字词，同时完成所有信息的处理与关联计算 —— 相当于开启多窗口并行办公，效率实现质的飞跃，处理长文本的能力也大幅提升。

1.2 Transformer的核心思想

Transformer的核心是"注意力机制"。什么意思呢？

想象你在读一篇文章：

当你看到"它"这个字时，你的大脑会自动往前找，"它"指的是什么
可能是前面提到的"猫"，也可能是"汽车"
你的大脑会自动"注意"到相关的词

Transformer就是模仿这个过程，让模型学会关注句子中最重要的部分。

二、Transformer和大模型是什么关系?

2.1 简单类比

Transformer = 建筑设计图纸
大模型 = 用这个图纸建出来的摩天大楼

更具体地说：

Transformer是架构，告诉你神经网络应该怎么搭建
大模型是用这个架构训练出来的具体模型

2.2 著名的大模型都用Transformer

看看这些你肯定听过的名字：

GPT系列 (GPT-3, GPT-4, ChatGPT)
只用了Transformer的**解码器(Decoder)**部分
擅长生成文本、对话、写代码
BERT
只用了Transformer的**编码器(Encoder)**部分
擅长理解文本、分类、问答
T5、BART
用了完整的Transformer(Encoder + Decoder)
擅长翻译、摘要等任务

2.3 训练大模型的过程

大模型使用了Transformer架构训练过程是这样的：

准备数据：收集海量文本(比如整个互联网的文章)
搭建架构：按照Transformer设计搭建神经网络
开始训练：让模型不断学习，调整参数
得到大模型：训练好后就能用了

就像：

Transformer = 健身房的器材和训练计划
训练过程 = 你每天去健身
大模型 = 练出来的好身材

三、神经网络是什么?

在讲激活函数之前，我们得先理解什么是神经网络。

3.1 人脑神经元的启发

人的大脑有大约860亿个神经元，它们互相连接，传递信息。神经网络就是模仿这个原理！

一个神经元的工作原理：

接收信号：从其他神经元接收电信号
处理信号：把这些信号加起来
决定是否激活：如果信号够强，就"点亮"，传给下一个神经元

3.2 人工神经元

计算机里的神经元是这样工作的：

输入1 × 权重1 ＋输入2 × 权重2 ＋输入3 × 权重3 ＋偏置 = 输出

举个实际例子，判断要不要出门买奶茶：

输入1：天气好不好 (0-10分)
输入2：有多渴 (0-10分)
输入3：钱包里有多少钱 (0-10分)

每个输入都有一个权重（重要性）：

天气权重 = 0.3 (不太重要)
渴的程度权重 = 0.5 (比较重要)
钱的数量权重 = 0.2 (不太重要)

计算：

决策分数 = 天气×0.3 + 渴×0.5 + 钱×0.2 + 偏置

如果分数 > 5，就去买奶茶！

3.3 神经网络 = 很多神经元连在一起

一个神经元只能做简单判断，但把成千上万个神经元连起来，分成好几层，就能处理超级复杂的任务！

典型的三层结构：

输入层：接收原始数据
隐藏层：进行复杂计算（可以有很多层）
输出层：给出最终结果

四、激活函数：神经网络的灵魂

激活函数是神经网络中非常重要的部分。

4.1 为什么需要激活函数?

不用激活函数会怎样？

如果没有激活函数，神经网络就只能做线性计算：

y = w1×x1 + w2×x2 + w3×x3 + b

这样不管你堆多少层，本质上都等于一个简单的线性函数！就像：

1层线性 = y = 2x + 1
100层线性堆叠 = 还是 y = 某个数×x + 某个数

这太简单了，根本处理不了复杂问题！

有了激活函数之后：

激活函数引入了非线性，让神经网络可以学习复杂的模式。就像：

线性 = 只能画直线
非线性 = 可以画曲线、圆、各种复杂图形

4.2 常见的激活函数

Sigmoid函数

公式： σ(x) = 1 / (1 + e^(-x))

特点：

输出范围：0到1之间
形状：S形曲线
可以理解为"概率"

形象理解： 就像一个温柔的开关：

当输入很小时(负数)，输出接近0 = “关”
当输入很大时(正数)，输出接近1 = “开”
中间过渡是平滑的

什么时候用？

二分类问题的输出层(判断是或否)
需要输出概率的时候

缺点：

容易梯度消失(训练变慢)
计算相对慢

ReLU (Rectified Linear Unit) - 最常用！

公式： f(x) = max(0, x)

特点：

输入为负数时，输出0
输入为正数时，输出就是输入本身

形象理解： 就像一个严格的门卫：

负面情绪(负数)一律拦住 = 输出0
正面能量(正数)直接放行 = 输出原值

为什么这么受欢迎？

计算超快(只需要比较大小)
缓解梯度消失问题
训练效果好

什么时候用？

隐藏层的默认选择
几乎所有的深度学习模型

缺点：

"Dead ReLU"问题：有些神经元可能永远输出0

Leaky ReLU - ReLU的改进版

公式： f(x) = max(0.01x, x)

特点：

负数时不是完全为0，而是一个很小的负数(0.01x)

形象理解： 比ReLU温柔一点的门卫：

负面情绪不是完全拦住，而是让它稍微进来一点点

优点：

解决了Dead ReLU问题
保留了ReLU的优点

GELU (Gaussian Error Linear Unit) - Transformer最爱！

公式： f(x) = x × Φ(x) (其中Φ(x)是高斯分布的累积分布函数)

特点：

更平滑的曲线
结合了概率的思想

形象理解： 就像一个会思考的智能门卫：

不只看正负，还看"有多正"或"有多负"
决策更细腻、更智能

为什么Transformer用它？

训练效果更好
更符合自然语言的分布特征
GPT、BERT都在用！

Tanh (双曲正切函数)

公式： tanh(x) = (e^x - e^(-x)) / (e^x + e^(-x))

特点：

输出范围：-1到1之间
形状：S形曲线，但中心在0

形象理解： 类似Sigmoid，但更对称：

负输入给负输出
正输入给正输出
比Sigmoid收敛更快

什么时候用？

需要输出正负值的场景
LSTM等循环神经网络

Softmax - 多分类专用

公式： Softmax(xi) = e^xi / Σe^xj

特点：

把一堆数字转成概率分布
所有输出加起来=1

形象理解： 就像评委打分：

输入：[猫:5分, 狗:2分, 兔子:1分]
输出：[猫:70%, 狗:24%, 兔子:6%]
把分数变成百分比，加起来刚好100%

什么时候用？

多分类问题的输出层
需要概率分布的时候

五、总结：把所有知识串起来

📚 知识框架

Transformer是什么？
一种神经网络架构（设计图纸）
基于自注意力机制
可以并行处理，速度快
Transformer和大模型的关系
Transformer = 架构设计
大模型 = 用这个架构训练出来的成品
GPT、BERT都是基于Transformer
神经网络基础
模仿人脑神经元
由输入层、隐藏层、输出层组成
通过权重和偏置进行计算
激活函数的作用
引入非线性
让网络能学习复杂模式
不同场景选择不同的激活函数

如果你要做NLP任务（比如训练一个小型语言模型）：

架构：Transformer

隐藏层激活函数：GELU

输出层：Softmax（分类）或Linear（生成）

如果你要做图像识别：

架构：CNN

隐藏层激活函数：ReLU

输出层：Softmax

如果你遇到训练问题：

ReLU导致神经元死亡 → 试试Leaky ReLU
训练太慢 → 检查是不是用了Sigmoid/Tanh在隐藏层
Transformer效果不好 → 确认是否用了GELU

深度理解Transformer的注意力机制

一、先搞清楚：PyTorch和Transformer到底啥关系？

很多刚入门的朋友容易搞混这两个概念，但是压根不是一个层面的东西：

PyTorch是什么？

它是一个深度学习框架，就像你盖房子用的工具箱
提供了张量计算、自动求导、GPU加速等基础功能
你可以用它来实现各种神经网络模型

Transformer是什么？

它是一种神经网络架构，是一种具体的模型设计方案
就像房子的设计图纸，规定了怎么组织各个组件
可以用PyTorch、TensorFlow等任何框架来实现

打个比方：

PyTorch = 锤子、钉子、电钻（工具）
Transformer = 房子设计图（架构方案）
你用PyTorch这套工具，按照Transformer的设计图，把模型搭建出来

所以当你听到"用PyTorch实现Transformer"，意思就是用PyTorch这个工具箱，按照Transformer的架构把模型代码写出来。

二、AI建模的核心：特征抽取器

什么是特征抽取？

咱们先从一个简单例子说起。假设你要教电脑识别猫和狗：

原始数据： 一张（比如256×256像素，3个颜色通道） 最终目标： 判断是猫还是狗

中间这个把"原始像素"转化成"可以用来分类的有用信息"的过程，就叫特征抽取。

传统方法的困境：

原始像素 → 手工设计的特征（边缘、纹理、颜色等）→ 分类器

↑ 这一步需要专家经验，很难

深度学习的突破：

原始数据 → 神经网络（自动学习特征）→ 输出结果

↑ 这就是特征抽取器！

为什么说Transformer是最核心的特征抽取器？

在深度学习发展史上，特征抽取器经历了几个时代：

CNN时代（2012-2017）： 卷积神经网络，擅长处理图像
RNN/LSTM时代（2014-2017）： 循环神经网络，擅长处理序列
Transformer时代（2017-至今）： 统治级架构，横扫NLP、CV、语音等所有领域

Transformer为什么这么牛？

因为它有一个超级武器——注意力机制（Attention）！这个机制让模型能够：

并行处理： 不像RNN那样必须一个一个字处理，Transformer可以同时看所有输入
长距离依赖： 轻松捕捉句子中相隔很远的词之间的关系
动态权重： 根据上下文动态调整每个词的重要性

举个例子：

句子：“银行账户里的钱不够了”

传统方法：按顺序处理，"银行"的信息可能传到"钱"时已经衰减了
Transformer：同时看整个句子，立刻知道"银行"指的是金融机构而不是河岸

这就是为什么GPT、BERT、DALL-E、Stable Diffusion等顶级模型全都基于Transformer架构！

三、Transformer整体架构详解

好，现在进入重头戏！咱们来看看Transformer长什么样。

3.1 高层视角：黑盒模型

最简单的理解：Transformer就是一个"翻译机器"

输入： 一句法语
输出： 对应的英语翻译

3.2 打开黑盒：编码器-解码器结构

Transformer由两大部分组成：

编码器（Encoder）： 理解输入的含义
解码器（Decoder）： 生成输出

这就像你听到法语（编码器理解），然后用英语说出来（解码器生成）。

3.3 堆叠结构：6层编码器 + 6层解码器

原始论文中：

6个相同结构的编码器堆叠起来（不共享权重）
6个相同结构的解码器堆叠起来
为什么是6？没有特别原因，你可以试试其他数字

3.4 编码器内部结构

每个编码器有两个子层：

Self-Attention层（自注意力层）：
让模型在处理每个词时，能看到句子中的其他所有词
这是核心！后面会详细讲
Feed Forward层（前馈神经网络）：
就是普通的全连接神经网络
对每个位置独立应用（位置之间不共享信息）

数据流动过程：

输入词 → Embedding（词向量）

↓

Self-Attention（关注上下文）

↓

Add & Norm（残差连接+归一化）

↓

Feed Forward（非线性变换）

↓

Add & Norm

↓

输出到下一层编码器

3.5 解码器内部结构

解码器比编码器多了一层，有三个子层：

Masked Self-Attention： 只能看到当前位置之前的词（不能偷看后面的答案）
Encoder-Decoder Attention： 关注编码器的输出（读取原文信息）
Feed Forward： 和编码器一样

为什么要Mask？

假设你在翻译"我爱你"→"I love you"：

生成"I"时：只能基于"我"
生成"love"时：可以看"我爱"和已生成的"I"
生成"you"时：可以看"我爱你"和"I love"

不能让模型在生成"I"的时候就看到答案里的"love"，那不就作弊了吗？

3.6 完整数据流

训练时的完整流程：

输入句子 → Embedding + 位置编码 → 进入编码器
编码器逐层处理，提取特征
编码器输出 → 传给解码器的Encoder-Decoder Attention
解码器逐词生成翻译
最后Linear层 + Softmax → 输出概率分布

四、Decoder-Only架构的应用（GPT系列的秘密）

现在最火的GPT系列（ChatGPT、GPT-4等）用的不是完整的Transformer，而是只用了解码器（Decoder-Only）！

4.1 为什么只用Decoder？

原始Transformer是为了翻译任务设计的：

编码器：理解源语言
解码器：生成目标语言

但对于文本生成任务（比如写文章、对话），我们只需要：

输入：一段文本提示
输出：续写的内容

这种情况下，不需要分开的编码器和解码器，只用解码器就够了！

4.2 Decoder-Only的工作原理

核心思想： 把输入和输出看成同一个序列

举个例子：

输入提示：“今天天气”

模型处理：“今天天气真好啊”

↑输入↑ ←→ ↑输出↑

模型在生成"真"的时候：

可以看到"今天天气"（输入）
不能看到"好啊"（未来的输出）

关键配置：

使用Masked Self-Attention（遮住未来信息）
没有Encoder-Decoder Attention层
堆叠N个相同的Decoder Block

著名的Decoder-Only模型：

GPT系列： GPT-2、GPT-3、GPT-4、ChatGPT
LLaMA系列： Meta开源的大模型
Claude：
PaLM： Google的大模型

4.3 Decoder-Only vs 完整Transformer

特性	完整Transformer	Decoder-Only
典型应用	机器翻译	文本生成、对话
结构	Encoder + Decoder	仅Decoder
输入输出	输入和输出是不同序列	输入输出是同一序列
训练目标	Seq2Seq（序列到序列）	语言建模（预测下一个词）
代表模型	BERT（只用Encoder）、T5	GPT系列、LLaMA

五、注意力机制图解（Self-Attention的魔法）

好了，终于到最核心的部分了！注意力机制到底是什么？

5.1 直观理解：什么是"注意力"？

咱们先看一个经典例子：

句子： “The animal didn’t cross the street because it was too tired” 问题： "it"指的是什么？

人类秒懂：it = animal（而不是street）

但对于计算机，怎么让它理解这种关系呢？这就需要注意力机制！

当模型处理"it"这个词时：

注意力机制让它"关注"句子中的其他词
发现"animal"和"it"的关系最强
把"animal"的信息融入到"it"的表示中

5.2 注意力计算的直观过程

假设我们在处理句子：“Thinking Machines”

Step 1：为每个词创建三个向量

对于每个词（比如"Thinking"），我们创建三个向量：

Query（查询）： “我想查询什么信息？”
Key（键）： “我能提供什么信息？”
Value（值）： “我的具体信息内容是什么？”

类比：图书馆检索系统

Query = 你输入的搜索关键词：“人工智能”
Key = 每本书的索引标签：“机器学习”、“深度学习”、“AI”…
Value = 书的实际内容

怎么得到这三个向量？

X = 词的embedding向量（维度：512）
Q = X @ W_Q # 查询向量（维度：64）
K = X @ W_K # 键向量（维度：64）
V = X @ W_V # 值向量（维度：64）

其中W_Q、W_K、W_V是模型训练学习到的权重矩阵。 Step 2：计算注意力分数

假设我们在处理"Thinking"这个词：

计算"Thinking"的Q和所有词的K的点积（dot product）
这给出了"Thinking"对每个词的"关注程度"

对于第一个词"Thinking"
score_1 = Q_thinking · K_thinking # 自己和自己
score_2 = Q_thinking · K_machines # 和"Machines"

为什么用点积？

点积大 → 两个向量方向相似 → 关系密切
点积小 → 两个向量方向不同 → 关系不大

Step 3 & 4：缩放 + Softmax归一化

缩放：除以sqrt(d_k)，这里d_k=64
scaled_scores = scores / sqrt(64) = scores / 8
Softmax：转换成概率分布（和为1）
attention_weights = softmax(scaled_scores)

为什么要除以8？

点积的结果可能很大，导致梯度消失
除以sqrt(d_k)让数值更稳定

Softmax的作用：

原始分数：[12, 8, 15]

Softmax后：[0.2, 0.1, 0.7] ← 变成概率，和为1

这样我们就知道了：对于"Thinking"这个词，应该给"Machines"0.7的权重。

Step 5 & 6：加权求和

最后一步：用注意力权重对Value向量加权求和

output = attention_weights[0] * V_thinking + \
attention_weights[1] * V_machines

这个output就是"Thinking"这个词经过Self-Attention后的新表示，它融合了句子中其他词的信息！

5.3 矩阵形式计算（实际代码中的做法）

实际中，我们不会一个词一个词算，而是用矩阵一次性处理所有词：

Step 1：计算Q、K、V矩阵

X: (seq_len, d_model) = (句子长度, 512)
W_Q, W_K, W_V: (d_model, d_k) = (512, 64)
Q = X @ W_Q # (seq_len, 64)
K = X @ W_K # (seq_len, 64)
V = X @ W_V # (seq_len, 64)

Step 2：一个公式搞定所有！Attention(Q, K, V) = softmax(Q @ K^T / sqrt(d_k)) @ V

这一个公式包含了之前所有步骤：

Q @ K^T → 计算所有词对之间的分数
/ sqrt(d_k) → 缩放
softmax(...) → 归一化成概率
@ V → 加权求和

维度变化：

Q: (seq_len, d_k)
K^T: (d_k, seq_len)
Q@K^T: (seq_len, seq_len) ← 注意力矩阵！
softmax: (seq_len, seq_len)
@V: (seq_len, d_k) ← 输出维度

5.4 真实案例演示

让我们用一个真实例子走一遍流程：

输入句子： "I love AI"（3个词）

假设参数：

词向量维度 d_model = 512
Q/K/V 维度 d_k = 64

数据流：

第1步：Embedding

"I" → x1: [0.2, 0.5, ..., 0.3] # 512维
"love" → x2: [0.8, 0.1, ..., 0.7] # 512维
"AI" → x3: [0.4, 0.9, ..., 0.2] # 512维

第2步：生成Q、K、V

q1 = x1 @ W_Q → [0.1, 0.3, ..., 0.5] # 64维
k1 = x1 @ W_K → [0.2, 0.1, ..., 0.8] # 64维
v1 = x1 @ W_V → [0.5, 0.4, ..., 0.2] # 64维

同样处理 love、AI 第3步：计算attention scores（以"I"为例）

score_I_I = q1 · k1 = 32.5
score_I_love = q1 · k2 = 28.3
score_I_AI = q1 · k3 = 15.7

第4步：缩放

scaled_scores = [32.5/8, 28.3/8, 15.7/8] = [4.06, 3.54, 1.96]

第5步：Softmax

weights = softmax([4.06, 3.54, 1.96]) = [0.51, 0.41, 0.08]

意思是："I"主要关注自己(51%)和love(41%)，很少关注AI(8%) 第6步：加权求和

output_I = 0.51*v1 + 0.41*v2 + 0.08*v3

最终，output_I就是"I"这个词在这个句子中的新表示，它已经融入了"love"和"AI"的上下文信息！

六、多头注意力（Multi-Head Attention）

6.1 为什么需要多个头？

单头注意力有个问题：它只能学习一种关系模式。

但语言中的关系是多样的：

语法关系：“主语-动词”、“动词-宾语”
语义关系：“同义词”、“反义词”
位置关系：“相邻词”、“远距离依赖”

多头注意力的思想： 让模型同时学习多种不同的关系！

6.2 多头注意力的实现

原理很简单：并行运行h个不同的注意力机制

Transformer使用8个注意力头

h = 8

每个头有自己的W_Q、W_K、W_V

for i in range(h):

Q_i = X @ W_Q_i

K_i = X @ W_K_i

V_i = X @ W_V_i

# 独立计算attention

Z_i = Attention(Q_i, K_i, V_i)

最后得到8个输出：Z_0, Z_1, …, Z_7

6.3 合并多头输出

问题：前馈网络期望一个矩阵输入，但我们现在有8个！

解决办法：拼接 + 线性变换

拼接所有头的输出

Z_concat = concat(Z_0, Z_1, ..., Z_7) # (seq_len, 8*d_k)

线性变换回原始维度

Z_final = Z_concat @ W_O # (seq_len, d_model)

6.4 完整流程图

总结：

输入X分别传给8个注意力头
每个头独立计算attention
拼接8个头的输出
线性变换得到最终结果

6.5 多头注意力的可视化

看看不同的头在关注什么：

当模型处理"it"这个词时：

头1： 主要关注"animal"（语义关系）
头2： 关注"tired"（属性关系）
其他头关注不同的语法和语义模式

这就是为什么多头注意力这么强大——它能同时从多个角度理解句子！

七、位置编码（Positional Encoding）

7.1 为什么需要位置信息？

Self-Attention有个严重问题：它不知道词的顺序！

想象一下：

“狗咬了人” 和 “人咬了狗” 在Self-Attention眼里是一样的！
因为注意力只看词之间的关系，不管它们的位置

但词的顺序在语言中太重要了！

7.2 位置编码的方案

7.3 位置编码可视化

这是20个位置、512维的位置编码：

每一行是一个位置的编码
颜色代表数值大小
可以看出明显的周期性模式

为什么用sin/cos函数？

值在[-1, 1]之间，不会太大
对于任意长度的句子都能生成编码
相对位置关系可以通过简单的线性变换得到

八、QKV架构细节深入剖析

8.1 为什么是Query、Key、Value？

这个命名来自于信息检索领域，让我们用一个完整类比理解：

场景：你在YouTube搜视频

┌─────────────────────────────────────┐

│ 1. 你输入搜索词：“transformer教程” │ ← Query（查询）

└─────────────────────────────────────┘

↓

┌─────────────────────────────────────────────────┐

│ 2. YouTube数据库里每个视频都有标签： │

│ 视频1: “AI, 机器学习, 神经网络” │ ← Key（索引）

│ 视频2: “transformer, NLP, 注意力” │ ← Key

│ 视频3: “做饭, 美食, 教程” │ ← Key

└─────────────────────────────────────────────────┘

↓

┌─────────────────────────────────────────────────┐

│ 3. 匹配度计算： │

│ 视频1: 匹配度 0.2（有点相关） │

│ 视频2: 匹配度 0.9（非常相关！） │

│ 视频3: 匹配度 0.0（不相关） │

└─────────────────────────────────────────────────┘

↓

┌─────────────────────────────────────────────────┐

│ 4. 返回视频内容（根据匹配度加权）： │

│ 主要展示视频2的内容(90%) │ ← Value（内容）

│ 少量展示视频1的内容(10%) │ ← Value

│ 不展示视频3 │

└─────────────────────────────────────────────────┘

对应到Self-Attention：

Query: 当前词想要查找什么信息
Key: 每个词能被什么样的查询匹配到
Value: 每个词实际包含的信息内容

8.2 QKV的维度设计

8.3 QKV变换的详细过程

单个词的变换：

假设词"love"的embedding
x_love = [0.8, 0.1, 0.3, ..., 0.7] # 512维
三个权重矩阵（512×64）
W_Q = [[0.1, 0.2, ..., 0.5],
[0.3, 0.1, ..., 0.8],
...] # 512行64列
W_K = [...] # 512×64
W_V = [...] # 512×64
矩阵乘法
q_love = x_love @ W_Q # (1, 512) @ (512, 64) = (1, 64)
k_love = x_love @ W_K # (1, 64)
v_love = x_love @ W_V # (1, 64)

整个句子的变换： 句子矩阵：每行是一个词

X = [[x_I], # 512维
[x_love], # 512维
[x_AI]] # 512维
X的形状：(3, 512)
批量计算
Q = X @ W_Q # (3, 512) @ (512, 64) = (3, 64)
K = X @ W_K # (3, 64)
V = X @ W_V # (3, 64)
结果：
Q[0] = "I"的query向量
Q[1] = "love"的query向量
Q[2] = "AI"的query向量

8.4 实际代码实现

import torch
import torch.nn as nn
class SelfAttention(nn.Module):
def __init__(self, d_model=512, d_k=64):
super().__init__()
self.d_k = d_k
# 定义三个线性变换
self.W_Q = nn.Linear(d_model, d_k, bias=False)
self.W_K = nn.Linear(d_model, d_k, bias=False)
self.W_V = nn.Linear(d_model, d_k, bias=False)
def forward(self, X):
"""
X: (batch_size, seq_len, d_model)
输出: (batch_size, seq_len, d_k)
"""
# Step 1: 生成Q、K、V
Q = self.W_Q(X) # (batch, seq_len, d_k)
K = self.W_K(X) # (batch, seq_len, d_k)
V = self.W_V(X) # (batch, seq_len, d_k)
# Step 2: 计算attention scores
scores = torch.matmul(Q, K.transpose(-2, -1)) # (batch, seq_len, seq_len)
scores = scores / (self.d_k ** 0.5) # 缩放
# Step 3: Softmax
attention_weights = torch.softmax(scores, dim=-1)
# Step 4: 加权求和
output = torch.matmul(attention_weights, V) # (batch, seq_len, d_k)
return output, attention_weights

九、Attention输出计算的完整演示

9.1 手算一个简单例子

假设我们有一个极简化的例子（方便手算）：

输入： 2个词，维度为4

词向量（实际是512维，这里简化成4维）
X = [[1, 0, 1, 0], # "I"
[0, 2, 0, 2]] # "love"
权重矩阵（实际是512×64，这里简化成4×2）
W_Q = [[1, 0],
[0, 1],
[1, 0],
[0, 1]]
W_K = [[0, 1],
[1, 0],
[0, 1],
[1, 0]]
W_V = [[1, 1],
[1, 1],
[0, 0],
[0, 0]]

Step 1: 计算Q、K、V

Q = X @ W_Q
= [[1, 0, 1, 0], @ [[1, 0],
[0, 2, 0, 2]] [0, 1],
[1, 0],
[0, 1]]
= [[1*1+0*0+1*1+0*0, 1*0+0*1+1*0+0*1],
[0*1+2*0+0*1+2*0, 0*0+2*1+0*0+2*1]]
= [[2, 0],
[0, 4]]
K = X @ W_K = [[0, 1],
[2, 2]]
V = X @ W_V = [[2, 2],
[2, 2]]

Step 2: 计算Attention Scores

Scores = Q @ K^T
= [[2, 0], @ [[0, 2],
[0, 4]] [1, 2]]
= [[2*0+0*1, 2*2+0*2],
[0*0+4*1, 0*2+4*2]]
= [[0, 4],
[4, 8]]

意义解读：

Scores0 = 0: "I"对"I"的关注度
Scores0 = 4: "I"对"love"的关注度
Scores1 = 4: "love"对"I"的关注度
Scores1 = 8: "love"对"love"的关注度

Step 3: 缩放（d_k=2）

Scaled = Scores / sqrt(2) = Scores / 1.414

= [[0, 2.83],

[2.83, 5.66]]

Step 4: Softmax

对每一行做softmax

Row 0: [0, 2.83]
exp: [1, 16.95]
sum: 17.95
softmax: [0.06, 0.94]
Row 1: [2.83, 5.66]
exp: [16.95, 287.28]
sum: 304.23
softmax: [0.06, 0.94]
Attention_Weights = [[0.06, 0.94],
[0.06, 0.94]]

意义：

“I"这个词：6%关注自己，94%关注"love”
“love"这个词：6%关注"I”，94%关注自己

Step 5: 加权求和

Output = Attention_Weights @ V
= [[0.06, 0.94], @ [[2, 2],
[0.06, 0.94]] [2, 2]]
= [[0.06*2+0.94*2, 0.06*2+0.94*2],
[0.06*2+0.94*2, 0.06*2+0.94*2]]
= [[2, 2],
[2, 2]]

9.2 完整架构图演示

让我们画一个完整的Attention计算流程图：

9.3 实际尺寸的计算

让我们用真实的Transformer参数走一遍：

9.4 可视化Attention矩阵

Attention Weights矩阵（seq_len × seq_len）是最关键的，它告诉我们每个词关注哪些词。

例子： “The cat sat on the mat”

The cat sat on the mat

The [ 0.8 0.1 0.0 0.0 0.1 0.0 ]

cat [ 0.2 0.5 0.2 0.0 0.0 0.1 ]

sat [ 0.0 0.3 0.4 0.2 0.0 0.1 ]

on [ 0.0 0.0 0.3 0.4 0.2 0.1 ]

the [ 0.0 0.0 0.0 0.3 0.5 0.2 ]

mat [ 0.0 0.1 0.0 0.1 0.3 0.5 ]

解读：

“cat"这个词：50%关注自己，20%关注"The”，20%关注"sat"
“sat"这个词：40%关注自己，30%关注"cat”，20%关注"on"
可以看出动词"sat"关注了主语"cat"和介词"on"

十、实战：用PyTorch实现完整的Transformer Block

10.1 完整代码

import torch
import torch.nn as nn
import math
class MultiHeadAttention(nn.Module):
"""多头注意力层"""
def __init__(self, d_model=512, num_heads=8):
super().__init__()
assert d_model % num_heads == 0, "d_model必须能被num_heads整除"
self.d_model = d_model
self.num_heads = num_heads
self.d_k = d_model // num_heads # 每个头的维度
# Q、K、V的权重矩阵（包含所有头）
self.W_Q = nn.Linear(d_model, d_model)
self.W_K = nn.Linear(d_model, d_model)
self.W_V = nn.Linear(d_model, d_model)
# 最后的线性变换
self.W_O = nn.Linear(d_model, d_model)
def split_heads(self, x, batch_size):
"""
将最后一维分成(num_heads, d_k)
x: (batch, seq_len, d_model)
输出: (batch, num_heads, seq_len, d_k)
"""
x = x.view(batch_size, -1, self.num_heads, self.d_k)
return x.transpose(1, 2)
def forward(self, Q, K, V, mask=None):
"""
Q, K, V: (batch, seq_len, d_model)
mask: (batch, seq_len, seq_len) 可选
"""
batch_size = Q.shape[0]
# 1. 线性变换
Q = self.W_Q(Q) # (batch, seq_len, d_model)
K = self.W_K(K)
V = self.W_V(V)
# 2. 分成多头
Q = self.split_heads(Q, batch_size) # (batch, num_heads, seq_len, d_k)
K = self.split_heads(K, batch_size)
V = self.split_heads(V, batch_size)
# 3. 计算attention
scores = torch.matmul(Q, K.transpose(-2, -1)) # (batch, num_heads, seq_len, seq_len)
scores = scores / math.sqrt(self.d_k) # 缩放
# 4. 应用mask（如果有）
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
# 5. Softmax
attention_weights = torch.softmax(scores, dim=-1)
# 6. 加权求和
output = torch.matmul(attention_weights, V) # (batch, num_heads, seq_len, d_k)
# 7. 合并多头
output = output.transpose(1, 2).contiguous() # (batch, seq_len, num_heads, d_k)
output = output.view(batch_size, -1, self.d_model) # (batch, seq_len, d_model)
# 8. 最后的线性变换
output = self.W_O(output)
return output, attention_weights
class FeedForward(nn.Module):
"""前馈神经网络"""
def __init__(self, d_model=512, d_ff=2048):
super().__init__()
self.linear1 = nn.Linear(d_model, d_ff)
self.linear2 = nn.Linear(d_ff, d_model)
self.relu = nn.ReLU()
def forward(self, x):
# x: (batch, seq_len, d_model)
return self.linear2(self.relu(self.linear1(x)))
class TransformerBlock(nn.Module):
"""Transformer编码器块"""
def __init__(self, d_model=512, num_heads=8, d_ff=2048, dropout=0.1):
super().__init__()
# 多头注意力
self.attention = MultiHeadAttention(d_model, num_heads)
# 前馈网络
self.feed_forward = FeedForward(d_model, d_ff)
# Layer Normalization
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
# Dropout
self.dropout = nn.Dropout(dropout)
def forward(self, x, mask=None):
"""
x: (batch, seq_len, d_model)
mask: (batch, seq_len, seq_len)
"""
# 1. 多头注意力 + 残差连接 + LayerNorm
attn_output, attention_weights = self.attention(x, x, x, mask)
x = self.norm1(x + self.dropout(attn_output))
# 2. 前馈网络 + 残差连接 + LayerNorm
ff_output = self.feed_forward(x)
x = self.norm2(x + self.dropout(ff_output))
return x, attention_weights
使用示例
if name == "__main__":
# 参数
batch_size = 2
seq_len = 10
d_model = 512
# 创建模型
transformer_block = TransformerBlock(d_model=512, num_heads=8)
# 随机输入
x = torch.randn(batch_size, seq_len, d_model)
# 前向传播
output, attention_weights = transformer_block(x)
print(f"输入形状: {x.shape}")
print(f"输出形状: {output.shape}")
print(f"注意力权重形状: {attention_weights.shape}")
# 输出:
# 输入形状: torch.Size([2, 10, 512])
# 输出形状: torch.Size([2, 10, 512])
# 注意力权重形状: torch.Size([2, 8, 10, 10])

10.2 代码详解

关键点1：split_heads函数

这个函数把(batch, seq_len, d_model)转换成(batch, num_heads, seq_len, d_k)

关键点2：残差连接（Residual Connection）

为什么重要？

防止梯度消失
允许更深的网络（Transformer可以堆叠100+层）
加速训练

关键点3：Layer Normalization

归一化每个样本的每个位置

x = self.norm(x) # 在d_model维度上归一化

作用：

稳定训练
加速收敛

如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

这份完整版的大模型 AI 学习资料已经上传优快云，朋友们如果需要可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】