大模型入门-day10-11-手动实现 Transformer(10 小时)

以下是为“第 10-11 天：手动实现 Transformer”设计的详细学习任务计划。这个任务旨在通过用 PyTorch 实现一个单层 Transformer，帮助你深入理解其核心组件（如自注意力机制、位置编码等），并将其应用于简单任务。任务参考了 GitHub 上的“minGPT”和“nanoGPT”代码，但以手动实现为主，确保你理解每个部分。

第 10-11 天：手动实现 Transformer（10 小时）

学习目标：

• 掌握 Transformer 的核心组件（自注意力、多头注意力、位置编码、前馈网络）的实现原理。
• 使用 PyTorch 构建一个单层 Transformer 模型（包括编码器和解码器）。
• 完成一个简单任务，如生成文本序列（字符级预测）。

任务概述：

• 用 PyTorch 实现一个单层 Transformer，包含编码器和解码器。
• 训练模型预测简单文本序列（如“hello”预测下一个字符）。
• 参考 minGPT 或 nanoGPT 的结构，但以自己编写代码为主。

学习资源：

• GitHub 项目：
• “minGPT”：Andrej Karpathy 的简洁 GPT 实现，适合学习注意力机制。
• “nanoGPT”：更轻量的版本，代码清晰，易于改编。
• 辅助资料：
• PyTorch 官方文档（torch.nn、torch.tensor）。
• 《The Annotated Transformer》博客（代码+注释）。

时间分配建议：

• 第 10 天（5 小时）：学习组件原理，搭建模型框架。
• 第 11 天（5 小时）：实现训练逻辑，调试并生成文本。

第 10 天：搭建 Transformer 框架（5 小时）

任务：

• 实现 Transformer 的核心模块，包括位置编码、自注意力、多头注意力和前馈网络。
• 用 PyTorch 搭建单层编码器和解码器框架。

具体步骤：

1. 准备环境（0.5 小时）
2. 安装 PyTorch（建议用 Colab 免费 GPU 或本地环境）。
3. 下载 minGPT/nanoGPT 代码，浏览结构，作为参考。
4. 实现位置编码（Positional Encoding）（1 小时）
5. 根据公式：
6. PE(pos, 2i) = \sin(pos / 10000^{2i/d}))
7. PE(pos, 2i+1) = \cos(pos / 10000^{2i/d}))
8. 代码示例：
9. python
10. import torch import math def positional_encoding(max_len, d_model): pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) return pe # 测试 pe = positional_encoding(10, 64) # 序列长度 10，维度 64 print(pe.shape) # 输出：torch.Size([10, 64])
11. 作用：生成位置信息，添加到词嵌入中。
12. 实现自注意力（Self-Attention）（1.5 小时）
13. 计算公式：
14. \text{Attention}(Q, K, V) = \text{softmax}(\frac{QK^T}{\sqrt{d_k}})V
15. 代码示例：
16. python
17. import torch.nn as nn import torch.nn.functional as F class SelfAttention(nn.Module): def __init__(self, d_model, d_k): super().__init__() self.d_k = d_k self.w_q = nn.Linear(d_model, d_k) # Query 权重 self.w_k = nn.Linear(d_model, d_k) # Key 权重 self.w_v = nn.Linear(d_model, d_k) # Value 权重 def forward(self, x): 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) scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.d_k) attn = F.softmax(scores, dim=-1) return torch.matmul(attn, v) # (batch, seq_len, d_k)
18. 作用：计算输入序列中每个词与其他词的关联。
19. 扩展到多头注意力（Multi-Head Attention）（1 小时）
20. 将注意力分成多头，拼接结果。
21. 代码示例：
22. python
23. class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads): super().__init__() self.d_k = d_model // num_heads self.num_heads = num_heads self.attn = SelfAttention(d_model, self.d_k) self.w_o = nn.Linear(self.d_k * num_heads, d_model) def forward(self, x): batch_size, seq_len, _ = x.size() # 分头处理 heads = [self.attn(x) for _ in range(self.num_heads)] # 拼接 multi_head = torch.cat(heads, dim=-1) return self.w_o(multi_head)
24. 搭建单层 Transformer（1 小时）
25. 编码器：多头注意力 + Add & Norm + 前馈网络 + Add & Norm。
26. 解码器：加 Masked 多头注意力（防止看到未来词）。
27. 代码示例：
28. python
29. class TransformerLayer(nn.Module): def __init__(self, d_model, num_heads): super().__init__() self.attn = MultiHeadAttention(d_model, num_heads) self.ffn = nn.Sequential( nn.Linear(d_model, d_model * 4), nn.ReLU(), nn.Linear(d_model * 4, d_model) ) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) def forward(self, x): # 编码器部分 attn_out = self.attn(x) x = self.norm1(x + attn_out) # 残差连接 + 归一化 ffn_out = self.ffn(x) return self.norm2(x + ffn_out)

第 11 天：训练与生成文本（5 小时）

任务：

• 完成模型的训练逻辑，用简单数据集训练并生成文本序列。

具体步骤：

1. 准备数据（1 小时）
2. 用简单文本（如“hello world”），构建字符级数据集。
3. 代码示例：
4. python
5. text = "hello world" chars = sorted(list(set(text))) vocab_size = len(chars) char_to_idx = {ch: i for i, ch in enumerate(chars)} idx_to_char = {i: ch for i, ch in enumerate(chars)} data = [char_to_idx[c] for c in text]
6. 生成输入-目标对：输入“hel”，目标“ell”。
7. 完成完整模型（1.5 小时）
8. 添加嵌入层和输出层。
9. 代码示例：
10. python
11. class SimpleTransformer(nn.Module): def __init__(self, vocab_size, d_model, num_heads): super().__init__() self.embedding = nn.Embedding(vocab_size, d_model) self.pos_encoding = positional_encoding(50, d_model) self.layer = TransformerLayer(d_model, num_heads) self.fc = nn.Linear(d_model, vocab_size) def forward(self, x): x = self.embedding(x) + self.pos_encoding[:x.size(1), :].to(x.device) x = self.layer(x) return self.fc(x)
12. 训练模型（1.5 小时）
13. 设置超参数并训练：
14. python
15. model = SimpleTransformer(vocab_size, d_model=64, num_heads=4) optimizer = torch.optim.Adam(model.parameters(), lr=0.001) criterion = nn.CrossEntropyLoss() for epoch in range(200): inputs = torch.tensor(data[:-1], dtype=torch.long).unsqueeze(0) targets = torch.tensor(data[1:], dtype=torch.long).unsqueeze(0) outputs = model(inputs) loss = criterion(outputs.view(-1, vocab_size), targets.view(-1)) optimizer.zero_grad() loss.backward() optimizer.step() if epoch % 50 == 0: print(f"Epoch {epoch}, Loss: {loss.item()}")
16. 生成文本（1 小时）
17. 从起始字符生成序列：
18. python
19. def generate(model, start_char, max_len=10): model.eval() input_idx = torch.tensor([char_to_idx[start_char]], dtype=torch.long).unsqueeze(0) generated = [start_char] for _ in range(max_len): output = model(input_idx) next_idx = torch.argmax(output[:, -1, :], dim=-1).item() next_char = idx_to_char[next_idx] generated.append(next_char) input_idx = torch.tensor([char_to_idx[c] for c in generated], dtype=torch.long).unsqueeze(0) return ''.join(generated) print(generate(model, 'h')) # 期望类似 "hello worl"

输出要求

• 代码：一个完整的 PyTorch 脚本，实现单层 Transformer。
• 结果：生成简单文本序列（如“hello”或类似）。
• 可选：写 200 字总结，记录实现心得。

注意事项

• 维度匹配：检查张量形状（如 batch_size, seq_len, d_model）。
• Masked Attention：解码器需屏蔽未来信息（可选简化）。
• 计算资源：用 GPU 加速训练（Colab 免费）。

学习成果预期

完成任务后，你将掌握 Transformer 的核心实现，并能用 PyTorch 构建神经网络。动手试试吧，我可以随时帮你调试！