10分钟掌握Bigram语言模型：从数学原理到PyTorch实战

在深度学习和大语言模型快速发展的今天，很多开发者希望从基础原理入手，真正理解模型的核心工作机制。Andrej Karpathy 提出的 Bigram 语言模型，以其极简的设计和清晰的逻辑，成为了学习语言模型入门的最佳起点。本文将以“Caleb Writes Code”视频中精讲的实现思路为蓝本，带你用10分钟掌握 Bigram 模型的完整构建过程，从理论到代码实现，再到训练与推理，让你不仅知其然，更知其所以然。

1. Bigram 语言模型核心概念解析

1.1 什么是 Bigram 模型

Bigram（二元语法）模型是自然语言处理中最简单的语言模型之一。它的核心思想非常直观：基于前一个词来预测下一个词的概率分布。比如在句子 "I love programming" 中，"love" 的出现只依赖于前一个词 "I"，"programming" 的出现只依赖于 "love"。

从概率论的角度来看，Bigram 模型将一个句子的概率分解为一系列条件概率的乘积： P(w1, w2, ..., wn) = P(w1) × P(w2|w1) × P(w3|w2) × ... × P(wn|wn-1)

这种简化虽然丢失了长距离的依赖关系，但使得模型非常容易理解和实现，特别适合作为理解更复杂语言模型（如 RNN、Transformer）的入门阶梯。

1.2 Bigram 模型的应用场景与局限性

在实际应用中，Bigram 模型虽然简单，但仍然有其价值。它常用于：

• 文本生成的基础实验
• 拼写检查和自动更正
• 简单的语音识别系统
• 作为更复杂模型的组成部分

然而，Bigram 模型的局限性也很明显：

• 无法捕捉长距离依赖关系
• 数据稀疏问题严重（很多词对在训练数据中从未出现）
• 生成文本的连贯性有限

理解这些局限性有助于我们明白为什么需要更复杂的模型，以及如何通过平滑技术等方法来改进基础模型。

2. 环境准备与工具选择

2.1 开发环境配置

为了跟随本文实现 Bigram 模型，你需要准备以下环境：

操作系统：Windows、macOS 或 Linux 均可Python 版本：3.8 或以上版本主要依赖库：

• PyTorch：用于张量运算和自动梯度计算
• NumPy：数值计算基础库

你可以使用以下命令快速安装所需依赖：

pip install torch numpy

2.2 代码编辑器选择

推荐使用 Jupyter Notebook 或 VS Code 进行实验：

• Jupyter Notebook：适合交互式开发和逐步调试
• VS Code：配合 Python 插件，提供完整的开发体验

如果你选择 Jupyter Notebook，可以使用以下命令安装：

pip install jupyter jupyter notebook

3. Bigram 模型数学原理深入理解

3.1 概率估计与计数统计

Bigram 模型的核心是计算条件概率 P(wj|wi)。在训练过程中，我们通过简单的计数统计来估计这些概率：

P(wj|wi) = count(wi, wj) / count(wi)

其中 count(wi, wj) 表示词对 (wi, wj) 在训练语料中出现的次数，count(wi) 表示词 wi 出现的总次数。

这种最大似然估计方法虽然直观，但会遇到零概率问题——当训练语料中未出现某个词对时，模型会赋予其零概率。为了解决这个问题，实践中会使用各种平滑技术。

3.2 模型的数据表示

在实现 Bigram 模型时，我们需要将文本转换为模型可以处理的数值形式。这通常涉及两个步骤：

1. 构建词汇表：将每个唯一的词映射到一个整数索引
2. 创建映射关系：词到索引的映射（word_to_index）和索引到词的映射（index_to_word）

这种表示方法使得我们可以用张量运算来高效处理文本数据。

4. 完整实现：从数据预处理到模型训练

4.1 数据准备与预处理

让我们从一个简单的文本开始，实现完整的数据处理流程：

import torch import torch.nn as nn import torch.nn.functional as F # 示例训练数据 text = "hello world hello python hello deep learning" words = text.split() # 构建词汇表 vocab = sorted(set(words)) vocab_size = len(vocab) # 创建词到索引的映射 word_to_index = {word: idx for idx, word in enumerate(vocab)} index_to_word = {idx: word for idx, word in enumerate(vocab)} print("词汇表:", vocab) print("词汇表大小:", vocab_size) print("词到索引映射:", word_to_index)

4.2 Bigram 模型类实现

下面是完整的 Bigram 模型实现，包含嵌入层和概率计算：

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, vocab_size) 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.forward(idx) # 只关注最后一个时间步 logits = logits[:, -1, :] # 变为 (B, C) # 应用softmax获取概率 probs = F.softmax(logits, dim=-1) # 从概率分布中采样 idx_next = torch.multinomial(probs, num_samples=1) # 将采样结果拼接到序列中 idx = torch.cat((idx, idx_next), dim=1) return idx

4.3 训练数据准备与批处理

为了高效训练，我们需要将文本数据转换为模型可处理的格式：

# 将文本转换为索引序列 data = torch.tensor([word_to_index[word] for word in words], dtype=torch.long) # 准备输入-目标对 inputs = data[:-1] # 除最后一个词外的所有词 targets = data[1:] # 除第一个词外的所有词 print("输入序列:", inputs) print("目标序列:", targets) print("输入序列对应的词:", [index_to_word[idx.item()] for idx in inputs]) print("目标序列对应的词:", [index_to_word[idx.item()] for idx in targets])

4.4 模型训练循环

现在让我们实现完整的训练过程：

# 初始化模型 model = BigramLanguageModel(vocab_size) # 创建优化器 optimizer = torch.optim.Adam(model.parameters(), lr=0.01) # 训练循环 for epoch in range(100): # 前向传播 logits, loss = model(inputs.unsqueeze(0), targets.unsqueeze(0)) # 反向传播 optimizer.zero_grad() loss.backward() optimizer.step() if epoch % 20 == 0: print(f'Epoch {epoch}, Loss: {loss.item():.4f}') print(f'最终损失: {loss.item():.4f}')

5. 文本生成与模型推理

5.1 使用训练好的模型生成文本

训练完成后，我们可以使用模型来生成新的文本：

# 从"hello"开始生成 start_word = "hello" start_idx = torch.tensor([[word_to_index[start_word]]], dtype=torch.long) # 生成5个新词 generated_indices = model.generate(start_idx, max_new_tokens=5) generated_words = [index_to_word[idx.item()] for idx in generated_indices[0]] print("生成的文本:", ' '.join(generated_words))

5.2 概率分析与采样策略

理解模型的预测概率分布对于调试和改进模型至关重要：

# 查看模型对特定词的预测概率 test_word = "hello" test_idx = torch.tensor([[word_to_index[test_word]]], dtype=torch.long) with torch.no_grad(): logits, _ = model(test_idx) probs = F.softmax(logits, dim=-1) print("当前词:", test_word) print("下一个词的预测概率分布:") for i, prob in enumerate(probs[0, -1]): print(f" {index_to_word[i]}: {prob.item():.3f}")

6. 模型优化与改进方案

6.1 平滑技术解决零概率问题

基础的 Bigram 模型面临严重的零概率问题。以下是几种常见的平滑技术：

加一平滑（Laplace Smoothing）： P(wj|wi) = (count(wi, wj) + 1) / (count(wi) + V) 其中 V 是词汇表大小

回退平滑（Backoff）： 当 Bigram 计数为零时，回退到 Unigram 概率

在 PyTorch 实现中，我们可以在损失函数中加入标签平滑：

def forward_with_smoothing(self, idx, targets=None, smoothing=0.1): logits = self.token_embedding_table(idx) if targets is None: loss = None else: logits = logits.view(-1, logits.size(-1)) targets = targets.view(-1) # 标签平滑 confidence = 1.0 - smoothing log_probs = F.log_softmax(logits, dim=-1) nll_loss = -log_probs.gather(dim=-1, index=targets.unsqueeze(1)) nll_loss = nll_loss.squeeze(1) smooth_loss = -log_probs.mean(dim=-1) loss = confidence * nll_loss + smoothing * smooth_loss loss = loss.mean() return logits, loss

6.2 对数概率的数值稳定性

在实际实现中，我们通常使用对数概率来避免数值下溢问题：

def log_probability(self, sequence): """计算序列的对数概率""" total_log_prob = 0.0 for i in range(1, len(sequence)): current_word = sequence[i] previous_word = sequence[i-1] # 获取条件概率（实际实现中会使用平滑版本） prob = self.get_bigram_prob(previous_word, current_word) total_log_prob += torch.log(prob + 1e-8) # 避免log(0) return total_log_prob

7. 扩展到更大数据集

7.1 使用真实文本数据

当我们将 Bigram 模型应用于更大规模的真实数据时，需要改进数据处理流程：

def load_and_preprocess_text(file_path): """加载和预处理文本文件""" with open(file_path, 'r', encoding='utf-8') as f: text = f.read() # 基础文本清理 text = text.lower() # 更复杂的分词处理可以在这里添加 words = text.split() return words def create_batches(data, batch_size, seq_length): """创建训练批次""" num_batches = len(data) // (batch_size * seq_length) data = data[:num_batches * batch_size * seq_length] data = data.reshape(batch_size, -1) batches = [] for i in range(0, data.shape[1] - seq_length, seq_length): x = data[:, i:i+seq_length] y = data[:, i+1:i+seq_length+1] batches.append((x, y)) return batches

7.2 内存优化的实现

对于大规模数据，我们需要考虑内存使用效率：

class MemoryEfficientBigramModel(nn.Module): def __init__(self, vocab_size): super().__init__() # 使用更紧凑的表示 self.bigram_counts = nn.Parameter(torch.zeros(vocab_size, vocab_size)) self.unigram_counts = nn.Parameter(torch.zeros(vocab_size)) def forward(self, idx, targets): # 使用稀疏矩阵运算提高效率 batch_size, seq_len = idx.shape # 计算条件概率（使用对数空间） log_probs = self.compute_log_probs(idx) # 只计算目标位置的损失 loss = -log_probs.gather(2, targets.unsqueeze(2)).squeeze(2).mean() return log_probs, loss

8. 常见问题与调试技巧

8.1 训练过程中的典型问题

损失不下降：

• 检查学习率是否合适
• 验证数据预处理是否正确
• 确认模型参数初始化是否合理

梯度爆炸/消失：

• 使用梯度裁剪：torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
• 检查激活函数和初始化方法

过拟合：

• 增加训练数据量
• 使用早停法（early stopping）
• 添加正则化项

8.2 模型评估指标

除了损失函数，我们还应该关注其他评估指标：

def evaluate_model(model, test_data): """评估模型性能""" model.eval() total_loss = 0 total_tokens = 0 with torch.no_grad(): for batch in test_data: inputs, targets = batch logits, loss = model(inputs, targets) total_loss += loss.item() * inputs.numel() total_tokens += inputs.numel() perplexity = torch.exp(torch.tensor(total_loss / total_tokens)) return total_loss / total_tokens, perplexity.item() # 计算困惑度（Perplexity） loss, perplexity = evaluate_model(model, test_batches) print(f'测试集困惑度: {perplexity:.2f}')

9. 从 Bigram 到现代语言模型

9.1 Bigram 与 N-gram 模型的关系

Bigram 是 N-gram 模型家族中最简单的成员。理解 Bigram 为学习更复杂的模型奠定了基础：

• Trigram：基于前两个词预测下一个词
• 4-gram、5-gram：捕捉更长的上下文，但数据稀疏性问题更严重
• 神经网络语言模型：使用神经网络来估计概率，克服了 N-gram 模型的局限性

9.2 通向 Transformer 的路径

Bigram 模型的学习为理解现代大语言模型提供了重要基础：

1. 词嵌入概念：Bigram 中的查找表是现代词嵌入的雏形
2. 条件概率建模：自回归生成的核心思想
3. 概率链式法则：语言模型的基本数学框架

理解这些基础概念后，学习 Transformer 架构和注意力机制会更加自然。

10. 实际项目应用建议

10.1 教学与实验场景

Bigram 模型在以下场景中特别有用：

• 教学演示：直观展示语言模型的基本原理
• 算法原型：快速验证文本处理流程
• 基准测试：作为更复杂模型的性能基准

10.2 生产环境注意事项

虽然 Bigram 模型简单，但在实际应用中仍需注意：

数据质量：训练数据的质量直接影响模型性能内存使用：词汇表大小会显著影响内存占用推理速度：对于实时应用，需要优化推理性能

# 生产环境中的优化版本 class OptimizedBigramModel: def __init__(self, model_path): self.model = torch.jit.load(model_path) self.model.eval() def predict_next_word(self, current_word): with torch.no_grad(): # 优化后的推理逻辑 pass

通过本文的完整实现和深入解析，你应该已经掌握了 Bigram 语言模型的核心概念和实现技巧。这个简单的模型是理解现代大语言模型的重要基石，为你进一步学习 Transformer、BERT、GPT 等先进模型奠定了坚实的基础。