从Bigram语言模型入门LLM：Andrej Karpathy经典实现解析

这次我们来深入解析 Andrej Karpathy 的 Bigram 语言模型，这是一个非常适合入门自然语言处理的经典项目。作为 OpenAI 创始成员和前特斯拉 AI 总监，Karpathy 设计的这个模型虽然结构简单，但完整展示了语言模型的核心原理，特别适合想要从零理解 LLM（大语言模型）工作原理的开发者。

Bigram 模型最大的特点是实现简洁、训练快速、资源要求极低。你不需要高端显卡，甚至用 CPU 就能在几分钟内完成训练和推理。本文将带你完整实现一个 Bigram 语言模型，并验证其文本生成能力。

1. 核心能力速览

2. 适用场景与使用边界

Bigram 模型最适合以下场景：

教育学习用途：

• 理解语言模型的基本构建流程：数据准备、模型定义、训练循环、推理生成
• 掌握 PyTorch 张量操作和自动梯度计算
• 学习如何评估文本生成质量

实验验证用途：

• 快速验证文本生成想法
• 测试不同训练数据对模型效果的影响
• 作为更复杂模型（如 GPT、LSTM）的对比基线

使用边界提醒：

• 生成文本长度有限，通常适合短文本生成
• 无法处理长距离依赖关系
• 生成内容可能存在重复或不连贯现象
• 不适合生产环境部署，主要用于教学演示

3. 环境准备与前置条件

3.1 基础软件环境

# 检查 Python 版本 python --version # 推荐 Python 3.8+ # 安装核心依赖 pip install torch numpy matplotlib

3.2 验证 PyTorch 安装

import torch import numpy as np print(f"PyTorch 版本: {torch.__version__}") print(f"CUDA 是否可用: {torch.cuda.is_available()}")

3.3 准备训练数据

Bigram 模型对数据要求很灵活，可以使用任何文本文件：

• 英文小说文本（如莎士比亚作品）
• 中文古诗集（需调整分词方式）
• 代码文件（学习编程语言模式）
• 自定义文本语料

4. Bigram 模型原理与实现

4.1 Bigram 基本概念

Bigram（二元语法）模型基于一个简单的假设：每个字符的出现概率只依赖于前一个字符。这种马尔可夫假设大大简化了模型复杂度。

数学上，Bigram 概率可以表示为：

P(当前字符 | 前一个字符) = count(前一个字符, 当前字符) / count(前一个字符)

4.2 完整模型实现代码

import torch import torch.nn as nn import torch.nn.functional as F class BigramLanguageModel(nn.Module): def __init__(self, vocab_size): super().__init__() # 每个字符的嵌入向量 self.token_embedding_table = nn.Embedding(vocab_size, vocab_size) def forward(self, idx, targets=None): # idx 和 targets 都是 (B,T) 的张量 logits = self.token_embedding_table(idx) # (B,T,C) if targets is None: loss = None else: B, T, C = logits.shape logits = logits.view(B*T, C) targets = targets.view(B*T) loss = F.cross_entropy(logits, targets) return logits, loss def generate(self, idx, max_new_tokens): # idx 是当前上下文 (B,T) 数组 for _ in range(max_new_tokens): # 获取预测 logits, loss = self(idx) # 只关注最后时间步 logits = logits[:, -1, :] # 变成 (B,C) # 应用 softmax 获取概率 probs = F.softmax(logits, dim=-1) # (B,C) # 从分布中采样 idx_next = torch.multinomial(probs, num_samples=1) # (B,1) # 添加到序列中 idx = torch.cat((idx, idx_next), dim=1) # (B,T+1) return idx

5. 数据预处理与训练流程

5.1 文本数据预处理

def prepare_data(text): # 获取所有唯一字符 chars = sorted(list(set(text))) vocab_size = len(chars) # 创建字符到索引的映射 stoi = {ch: i for i, ch in enumerate(chars)} itos = {i: ch for i, ch in enumerate(chars)} encode = lambda s: [stoi[c] for c in s] # 编码器 decode = lambda l: ''.join([itos[i] for i in l]) # 解码器 # 将文本转换为张量 data = torch.tensor(encode(text), dtype=torch.long) # 分割训练和验证集 n = int(0.9 * len(data)) train_data = data[:n] val_data = data[n:] return train_data, val_data, vocab_size, encode, decode # 示例文本数据 text = """Hello, this is a simple Bigram language model. It learns to predict the next character based on the previous one.""" train_data, val_data, vocab_size, encode, decode = prepare_data(text)

5.2 训练循环实现

def train_model(model, train_data, val_data, iterations=1000): optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3) for iter in range(iterations): # 获取一个小批量数据 ix = torch.randint(len(train_data) - 1, (4,)) # 批量大小4 xb = train_data[ix] yb = train_data[ix + 1] # 前向传播 logits, loss = model(xb, yb) # 反向传播 optimizer.zero_grad(set_to_none=True) loss.backward() optimizer.step() # 每100次迭代打印损失 if iter % 100 == 0: with torch.no_grad(): val_loss = estimate_loss(model, val_data) print(f"迭代 {iter}: 训练损失 {loss.item():.4f}, 验证损失 {val_loss:.4f}") def estimate_loss(model, data): model.eval() losses = torch.zeros(10) for k in range(10): ix = torch.randint(len(data) - 1, (4,)) xb = data[ix] yb = data[ix + 1] _, loss = model(xb, yb) losses[k] = loss.item() model.train() return losses.mean() # 初始化并训练模型 model = BigramLanguageModel(vocab_size) train_model(model, train_data, val_data)

6. 文本生成测试与效果验证

6.1 基础生成测试

# 从起始字符开始生成 context = torch.zeros((1, 1), dtype=torch.long) generated_ids = model.generate(context, max_new_tokens=100)[0].tolist() generated_text = decode(generated_ids) print("生成的文本:") print(generated_text)

6.2 不同起始点的生成效果

通过改变初始上下文，观察模型生成文本的多样性：

# 测试不同的起始字符 start_chars = ['H', 'T', 'I', 'M'] for start_char in start_chars: context = torch.tensor([[encode(start_char)[0]]], dtype=torch.long) generated = model.generate(context, max_new_tokens=50)[0].tolist() print(f"以 '{start_char}' 开头: {decode(generated)}")

6.3 生成质量评估标准

评估 Bigram 模型生成文本时，关注以下几个维度：

1. 连贯性：生成的字符序列是否形成有意义的单词
2. 多样性：不同起始点是否能产生不同的文本模式
3. 训练稳定性：损失函数是否平稳下降
4. 过拟合检查：训练损失和验证损失的差距

7. 模型性能与资源观察

7.1 训练时间与资源占用

Bigram 模型的优势在于极低的资源需求：

• 训练时间：1000 次迭代通常在 10-30 秒内完成（CPU）
• 内存占用：模型参数极少，几乎不占用显存
• 推理速度：生成 100 个字符约需 1-2 毫秒

7.2 性能优化技巧

虽然 Bigram 模型本身已经很轻量，但可以进一步优化：

# 使用 torch.jit.script 加速推理 scripted_model = torch.jit.script(model) # 批量生成提高效率 def batch_generate(model, contexts, max_new_tokens=100): """批量生成文本""" with torch.no_grad(): return model.generate(contexts, max_new_tokens=max_new_tokens)

8. 扩展到更复杂模型

8.1 从 Bigram 到 Trigram

理解了 Bigram 后，可以自然扩展到考虑更多上下文的模型：

class TrigramLanguageModel(nn.Module): def __init__(self, vocab_size): super().__init__() self.token_embedding = nn.Embedding(vocab_size, 64) self.position_embedding = nn.Embedding(2, 64) # 前两个位置 self.lm_head = nn.Linear(64, vocab_size) def forward(self, idx, targets=None): B, T = idx.shape token_emb = self.token_embedding(idx) # (B,T,C) pos_emb = self.position_embedding(torch.arange(T)) # (T,C) x = token_emb + pos_emb # (B,T,C) logits = self.lm_head(x) # (B,T,vocab_size) if targets is None: loss = None else: loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1)) return logits, loss

8.2 与现代 LLM 的关联

Bigram 模型虽然简单，但包含了现代大语言模型的核心要素：

• 嵌入层（Embedding Layer）：将离散符号映射到连续向量空间
• Softmax 输出：将网络输出转换为概率分布
• 自回归生成：基于前面生成的内容预测下一个 token
• 交叉熵损失：衡量预测分布与真实分布的差异

9. 常见问题与排查方法

9.1 调试技巧

# 添加训练监控 def debug_training(model, data): # 检查模型参数 for name, param in model.named_parameters(): print(f"{name}: {param.shape}") # 验证前向传播 xb = data[:4].unsqueeze(0) yb = data[1:5].unsqueeze(0) logits, loss = model(xb, yb) print(f"初始损失: {loss.item()}")

10. 实践建议与下一步学习路径

10.1 Bigram 模型的最佳实践

数据准备阶段：

• 使用纯净的文本数据，避免特殊字符干扰
• 保持适当的数据量（几千到几万字符）
• 对中文文本需要先进行分词处理

训练调优：

• 从小学习率开始（如 1e-3），根据损失曲线调整
• 使用合适的批量大小（通常 4-32）
• 定期验证集评估，防止过拟合

生成控制：

• 通过调整温度参数控制生成随机性
• 尝试不同的起始字符获得多样结果
• 限制生成长度避免无限循环

10.2 进阶学习方向

掌握了 Bigram 模型后，可以沿着以下路径深入学习：

1. 增加模型复杂度：尝试 LSTM、GRU 等循环神经网络
2. 引入注意力机制：学习 Transformer 架构的基本原理
3. 使用预训练模型：上手 Hugging Face 的 Transformers 库
4. 实践完整项目：实现聊天机器人、文本分类等应用
5. 学习优化技巧：掌握模型压缩、量化、蒸馏等实用技术

Bigram 语言模型作为 LLM 学习的起点，其价值不在于生成质量，而在于帮助开发者建立对语言模型工作原理的直观理解。通过这个简单的模型，你可以清晰地看到从字符统计到神经网络生成的整个流程，为后续学习更复杂的 GPT、BERT 等模型打下坚实基础。

建议在实际操作中重点关注数据流向、损失变化和生成效果之间的关系，这种直观感受比单纯学习理论更能加深理解。完成本实验后，你会对"语言模型如何学习文本规律"这个问题有更具体的认识。