01-Transformer基础入门-从词嵌入到注意力机制

Transformer基础入门:从词嵌入到注意力机制 | 吴恩达2025最新课程笔记

本文基于吴恩达2025年最新Transformer课程,深入浅出地讲解大语言模型如何"理解"语言。从最朴素的词袋模型到革命性的注意力机制,通过可视化图表和代码示例,帮助初学者快速掌握Transformer的核心基础。涵盖词嵌入原理、上下文编码、语义相似度计算等关键技术点,是入门现代LLM必读教程。

一、为什么要学习Transformer?

如果说深度学习是AI的引擎,那么Transformer就是这个引擎的核心。从ChatGPT到GPT-4,从Claude到文心一言,几乎所有现代大语言模型都建立在Transformer架构之上。

1.1 LLM发展简史

timeline title 大语言模型进化史 2013 : Word2Vec : 词嵌入时代开启 2017 : Transformer诞生 : "Attention Is All You Need" 2018 : BERT & GPT-1 : 双向编码与自回归生成 2020 : GPT-3 : 1750亿参数突破 2022 : ChatGPT : AI走向大众 2023 : GPT-4 & Claude : 多模态超级模型 2025 : 百花齐放 : 开源模型崛起

1.2 Transformer的革命性优势

与传统RNN/LSTM相比:

特性	RNN/LSTM	Transformer
计算方式	串行计算,必须按时序	并行计算,可同时处理
长距离依赖	梯度消失,难以捕捉	自注意力直连,轻松捕捉
训练速度	慢(无法并行)	快(GPU加速显著)
可扩展性	难以扩展到超大规模	可扩展到千亿参数

二、语言模型如何"看懂"文字?

2.1 最简单的方法:词袋模型(Bag of Words)

核心思想:把句子看成一个"词的袋子",不考虑顺序,只统计词频。

graph LR A["句子: 我爱学习AI"] --> B[分词] B --> C["词袋: {我, 爱, 学习, AI}"] C --> D["向量: [1, 1, 1, 1]"] style A fill:#e3f2fd style D fill:#c8e6c9

问题示例:

python 复制代码

sentence1 = "狗咬了人"  → [1, 1, 1]
sentence2 = "人咬了狗"  → [1, 1, 1]  # 完全相同!

❌ 致命缺陷:

丢失词序信息
无法区分"狗咬人"和"人咬狗"
无法理解上下文

2.2 进化:词嵌入(Word Embeddings)

核心思想:把每个词映射到高维向量空间,让语义相近的词在空间中靠近。

graph TD subgraph 词嵌入空间 A["国王 [0.8, 0.3, -0.2, ...]"] B["女王 [0.75, 0.4, -0.15, ...]"] C["男人 [0.6, 0.2, -0.1, ...]"] D["女人 [0.55, 0.3, -0.05, ...]"] E["苹果 [0.1, 0.9, 0.7, ...]"] end A -.相似度高.-> B C -.相似度高.-> D A -.相似度高.-> C style A fill:#bbdefb style B fill:#c5cae9 style C fill:#b3e5fc style D fill:#b2dfdb style E fill:#fff9c4

2.3 经典的词向量关系

最著名的例子:King - Man + Woman = Queen

python 复制代码

# 词嵌入的神奇特性
vector("国王") - vector("男人") + vector("女人") ≈ vector("女王")
vector("中国") - vector("北京") + vector("东京") ≈ vector("日本")

可视化理解:

graph LR subgraph 语义空间 direction LR King["👑 国王 [0.8, 0.3]"] Man["👨 男人 [0.6, 0.2]"] Woman["👩 女人 [0.55, 0.3]"] Queen["👸 女王 [0.75, 0.4]"] end King -->|"- 男性"| Vector1["向量1"] Vector1 -->|"+ 女性"| Queen style King fill:#e1bee7 style Queen fill:#f8bbd0 style Man fill:#bbdefb style Woman fill:#ffccbc

2.4 词嵌入的训练方式

Word2Vec (2013)

graph TD A[输入: 我爱学习] --> B[中心词: 爱] B --> C[上下文: 我, 学习] C --> D[神经网络预测] D --> E[更新词向量] style B fill:#fff59d style D fill:#e1f5fe

两种训练方法:

CBOW: 用上下文预测中心词
Skip-gram: 用中心词预测上下文

三、上下文的重要性:从静态到动态

3.1 词嵌入的局限性

考虑"银行"这个词:

python 复制代码

sentence1 = "我去银行取钱"    # 金融机构
sentence2 = "河流的银行很陡"   # 河岸

# 传统词嵌入的问题:
embedding("银行") = [0.5, 0.3, 0.7, ...]  # 永远是同一个向量!

❌ 问题:一词多义无法区分

3.2 上下文感知的词向量

ELMo (2018) 的突破:根据上下文动态生成词向量

graph TB subgraph 传统词嵌入 W1["银行"] --> V1["固定向量 [0.5, 0.3, 0.7]"] end subgraph 上下文感知 S1["我去银行取钱"] --> V2["动态向量1 [0.8, 0.1, 0.2] 金融含义"] S2["河流的银行很陡"] --> V3["动态向量2 [0.2, 0.9, 0.6] 河岸含义"] end style V1 fill:#ffcdd2 style V2 fill:#c8e6c9 style V3 fill:#b2dfdb

四、注意力机制的诞生

4.1 为什么需要注意力?

翻译句子时,不同的词需要关注不同的上下文:

vbnet 复制代码

英文: The animal didn't cross the street because it was too tired.
中文: 动物没有过马路,因为它太累了。

问题:"it" 指的是什么?

graph LR A["it"] -.高注意力.-> B["animal"] A -.低注意力.-> C["street"] style A fill:#fff59d style B fill:#a5d6a7 style C fill:#ef9a9a

4.2 注意力机制的直观理解

核心思想:在处理每个词时,让模型自动计算该词应该"关注"哪些其他词。

graph TD subgraph 句子处理 W1["我"] W2["爱"] W3["学习"] W4["AI"] end W2 -->|"注意力0.1"| W1 W2 -->|"注意力0.5"| W3 W2 -->|"注意力0.4"| W4 style W2 fill:#fff59d style W3 fill:#a5d6a7 style W4 fill:#90caf9

处理"爱"这个词时:

对"我"的注意力: 0.1 (低)
对"学习"的注意力: 0.5 (高)
对"AI"的注意力: 0.4 (高)

最终表示 = 0.1 × vector(我) + 0.5 × vector(学习) + 0.4 × vector(AI)

五、编码器与解码器:Seq2Seq架构

5.1 机器翻译的挑战

sequenceDiagram participant 源语言 participant 编码器 participant 解码器 participant 目标语言源语言->>编码器: 我爱学习AI Note over 编码器: 理解语义 提取特征编码器->>解码器: 上下文向量解码器->>目标语言: I 解码器->>目标语言: love 解码器->>目标语言: learning 解码器->>目标语言: AI Note over 解码器: 逐词生成 考虑上下文

5.2 编码器-解码器架构

graph TB subgraph Encoder[编码器 - 理解输入] E1["我"] --> E2[双向LSTM] E3["爱"] --> E2 E4["AI"] --> E2 E2 --> Context["上下文向量 [综合理解]"] end subgraph Decoder[解码器 - 生成输出] Context --> D1["生成: I"] D1 --> D2["生成: love"] D2 --> D3["生成: AI"] end style E2 fill:#bbdefb style Context fill:#fff59d style D1 fill:#c8e6c9 style D2 fill:#c8e6c9 style D3 fill:#c8e6c9

六、代码实战:词嵌入入门

6.1 使用Gensim加载预训练词向量

python 复制代码

from gensim.models import KeyedVectors
import numpy as np

# 加载Word2Vec预训练模型(需要下载)
# 下载地址: https://github.com/Embedding/Chinese-Word-Vectors
model = KeyedVectors.load_word2vec_format('sgns.zhihu.word', binary=False)

# 获取词向量
king_vector = model['国王']
print(f"'国王'的向量维度: {king_vector.shape}")  # (300,)

# 计算词语相似度
similarity = model.similarity('国王', '女王')
print(f"'国王'与'女王'的相似度: {similarity:.4f}")  # 0.7234

# 找出最相似的词
similar_words = model.most_similar('国王', topn=5)
print("与'国王'最相似的词:")
for word, score in similar_words:
    print(f"  {word}: {score:.4f}")

# 输出示例:
#   女王: 0.7234
#   王后: 0.6892
#   皇帝: 0.6543
#   君主: 0.6321
#   统治者: 0.6102

6.2 词向量的算术运算

python 复制代码

# 经典例子: King - Man + Woman = Queen
result = model.most_similar(positive=['女王', '男人'], 
                            negative=['国王'], 
                            topn=1)
print(result)  # [('女王', 0.8234)]

# 中国之于北京 = 日本之于?
result = model.most_similar(positive=['日本', '北京'], 
                            negative=['中国'], 
                            topn=1)
print(result)  # [('东京', 0.7654)]

6.3 可视化词嵌入

python 复制代码

from sklearn.manifold import TSNE
import matplotlib.pyplot as plt

# 选择一些词
words = ['国王', '女王', '男人', '女人', '王子', '公主', 
         '苹果', '香蕉', '汽车', '飞机']

# 获取词向量
vectors = [model[word] for word in words]

# 使用t-SNE降维到2D
tsne = TSNE(n_components=2, random_state=42)
vectors_2d = tsne.fit_transform(vectors)

# 绘图
plt.figure(figsize=(10, 8))
for i, word in enumerate(words):
    x, y = vectors_2d[i]
    plt.scatter(x, y, marker='o', s=100)
    plt.annotate(word, (x, y), fontsize=12, ha='center')

plt.title('词嵌入空间可视化 (t-SNE降维)')
plt.xlabel('维度 1')
plt.ylabel('维度 2')
plt.grid(True, alpha=0.3)
plt.show()

输出效果:你会看到"国王/女王"、"男人/女人"聚在一起,而"苹果/香蕉"在另一个区域。

七、上下文编码实战

7.1 使用PyTorch实现简单的上下文编码器

python 复制代码

import torch
import torch.nn as nn

class ContextEncoder(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim):
        super().__init__()
        # 词嵌入层
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        # 双向LSTM捕捉上下文
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, 
                           bidirectional=True, batch_first=True)
        
    def forward(self, x):
        # x: [batch_size, seq_len]
        embedded = self.embedding(x)  # [batch_size, seq_len, embedding_dim]
        output, (h_n, c_n) = self.lstm(embedded)
        # output: [batch_size, seq_len, hidden_dim*2] (双向)
        return output

# 示例使用
vocab_size = 10000  # 词汇表大小
embedding_dim = 128  # 词嵌入维度
hidden_dim = 256     # LSTM隐藏层维度

model = ContextEncoder(vocab_size, embedding_dim, hidden_dim)

# 模拟输入 [batch_size=2, seq_len=10]
sample_input = torch.randint(0, vocab_size, (2, 10))
context_output = model(sample_input)

print(f"输入形状: {sample_input.shape}")        # torch.Size([2, 10])
print(f"上下文编码形状: {context_output.shape}") # torch.Size([2, 10, 512])

7.2 注意力权重可视化

python 复制代码

import torch.nn.functional as F
import seaborn as sns

def compute_attention(query, keys):
    """
    计算注意力权重
    query: [hidden_dim]
    keys: [seq_len, hidden_dim]
    """
    # 点积注意力
    scores = torch.matmul(keys, query)  # [seq_len]
    # Softmax归一化
    attention_weights = F.softmax(scores, dim=0)
    return attention_weights

# 模拟例子
seq_len = 7
hidden_dim = 64
words = ['我', '爱', '学习', '人工', '智能', '技术', '!']

# 随机生成keys和query(实际中由神经网络生成)
keys = torch.randn(seq_len, hidden_dim)
query = torch.randn(hidden_dim)

# 计算注意力
attention = compute_attention(query, keys)

# 可视化
plt.figure(figsize=(10, 2))
sns.heatmap([attention.numpy()], 
            xticklabels=words,
            yticklabels=['注意力'],
            cmap='YlOrRd',
            annot=True,
            fmt='.3f')
plt.title('注意力权重分布')
plt.show()

# 输出示例:
# 我    爱    学习  人工  智能  技术   !
# 0.08  0.25  0.31  0.15  0.12  0.07  0.02

八、关键概念总结

8.1 核心技术对比

graph TB subgraph 进化历程 A["词袋模型 ❌ 无序,无语义"] B["词嵌入 ✅ 语义空间 ❌ 无上下文"] C["上下文编码 ✅ 动态表示 ❌ 串行计算"] D["Transformer ✅ 并行+上下文 ✅ 长距离依赖"] end A --> B --> C --> D style A fill:#ffcdd2 style B fill:#fff9c4 style C fill:#c5cae9 style D fill:#a5d6a7

8.2 重要公式

词嵌入相似度(余弦相似度)

$similarity ( A , B ) = A ⋅ B ∣ ∣ A ∣ ∣ ⋅ ∣ ∣ B ∣ ∣ = ∑ i = 1 n A i B i ∑ i = 1 n A i 2 ⋅ ∑ i = 1 n B i 2 \text{similarity}(A, B) = \frac{A \cdot B}{||A|| \cdot ||B||} = \frac{\sum_{i=1}^{n} A_i B_i}{\sqrt{\sum_{i=1}^{n} A_i^2} \cdot \sqrt{\sum_{i=1}^{n} B_i^2}}$ similarity(A,B)=∣∣A∣∣⋅∣∣B∣∣A⋅B=∑i=1nAi2 ⋅∑i=1nBi2 ∑i=1nAiBi

注意力权重

$Attention ( Q , K , V ) = softmax ( Q K T d k ) V \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$ Attention(Q,K,V)=softmax(dk QKT)V

其中:

$Q Q$ Q (Query): 查询向量
$K K$ K (Key): 键向量
$V V$ V (Value): 值向量
$d k d_k$ dk: 键向量的维度

九、学习路径与资源

9.1 推荐学习路线

graph TD Start[开始学习] --> Basic[基础概念] Basic --> Embed[词嵌入实践] Embed --> Attention[注意力机制] Attention --> Trans[Transformer架构] Trans --> Advanced[进阶优化技术] Basic -.推荐.-> Book1["《动手学深度学习》 第10章"] Embed -.实践.-> Code1["Gensim Word2Vec"] Attention -.论文.-> Paper1["Attention Is All You Need"] Trans -.课程.-> Course1["吴恩达Transformer课程"] Advanced -.博客.-> Blog1["Hugging Face Blog"] style Start fill:#a5d6a7 style Trans fill:#fff59d style Advanced fill:#ce93d8

9.2 实践建议

初学者(第1-2周)

✅ 理解词袋模型 → 词嵌入的进化
✅ 动手实践Word2Vec
✅ 可视化词向量空间
✅ 理解上下文的重要性

进阶学习(第3-4周)

✅ 深入学习注意力机制
✅ 实现简单的Seq2Seq模型
✅ 对比RNN与Transformer
✅ 阅读经典论文

9.3 常见问题FAQ

Q1: 词嵌入的维度如何选择?

A: 常见选择:

小数据集: 50-128维
中等数据集: 256-512维
大规模预训练: 768维(BERT)、1024维(GPT-2)

Q2: 为什么需要上下文感知?

python 复制代码

# 一词多义问题
"我去银行取钱"    # 银行 = 金融机构
"河流的银行很陡"   # 银行 = 河岸

# 静态词嵌入无法区分,上下文编码可以根据周围词汇动态调整

Q3: 注意力机制与全连接层的区别?

全连接: 固定权重,所有输入同等重要
注意力: 动态权重,根据输入自适应调整

十、下一步学习

恭喜你完成了Transformer基础入门!接下来我们将深入学习:

下篇预告: Transformer核心架构详解

graph LR Current["✅ 当前篇 词嵌入与注意力基础"] Next["📖 下一篇 Self-Attention详解 Multi-Head Attention Transformer Block"] Future["🚀 进阶篇 KV Cache GQA优化 MoE架构"] Current --> Next --> Future style Current fill:#a5d6a7 style Next fill:#fff59d style Future fill:#ce93d8