Let's learn Stanford CS336 - LLM Systems! | Lin Shang

CS336 lecture-01 - tokenizer

Tue, 16 Dec 2025 00:00:00 +0800

致谢：本单元内容的灵感来源于 Andrej Karpathy 关于 Tokenization 的，强烈推荐观看。

在语言模型中，Tokenizer（分词器） 扮演着“翻译官”的角色，负责在 字符串（Strings） 和 Token 序列（Indices） 之间进行转换。语言模型本质上是对 Token 序列（通常由整数索引表示）的概率分布进行建模。例如：

输入字符串："Hello, 🌍! 你好!"
Token 序列：[15496, 11, 995, 0]

我们需要一个过程将字符串编码（Encode）为 Token，也需要一个过程将 Token 解码（Decode）回字符串。虽然将文本视为 Unicode 字符序列或字节序列在理论上是可行的，但在实际应用中，基于 BPE（字节对编码） 的方法是目前最高效的启发式算法。

以下我们将逐步演进，从最简单的分词方法直到 BPE。

1. 基础分词方法的尝试与局限

为了直观感受分词器的工作原理，我们可以先定义一个抽象基类，并尝试几种朴素的实现。

from abc import ABC, abstractmethod
class Tokenizer(ABC):
 @abstractmethod
 def encode(self, string: str) -> list[int]:
 pass

 @abstractmethod
 def decode(self, indices: list[int]) -> str:
 pass


class BPETokenizerParams:
 """All you need to specify a BPETokenizer."""
 vocab: dict[int, bytes] # index -> bytes
 merges: dict[tuple[int, int], int] # index1, index2 -> new_index

1.1 字符级分词 (Character-based Tokenization)

Unicode 字符串本质上是字符的序列。我们可以直接利用ord() 将字符转换为码点（整数），用 chr() 转回字符。

class CharacterTokenizer(Tokenizer):
 """将字符串表示为 Unicode 码点序列"""
 def encode(self, string: str) -> list[int]:
 return list(map(ord, string))

 def decode(self, indices: list[int]) -> str:
 return "".join(map(chr, indices))

# 测试
# string = "Hello, 🌍! 你好!"
# ord("a") == 97, ord("🌍") == 127757

局限性：

词表过大：Unicode 字符集大约有 1百万个字符，这意味着模型的词汇表（Vocabulary Size）非常庞大。
效率低下：许多字符（如 🌍）非常罕见，占据了词表空间却很少被学习到，这是对资源的浪费。

1.2 字节级分词 (Byte-based Tokenization)

为了解决词表过大的问题，我们可以将 Unicode 字符串视为字节序列（UTF-8 编码）。每个字节由 0 到 255 之间的整数表示。

class ByteTokenizer(Tokenizer):
 """将字符串表示为字节序列"""
 def encode(self, string: str) -> list[int]:
 string_bytes = string.encode("utf-8")
 indices = list(map(int, string_bytes))
 return indices

 def decode(self, indices: list[int]) -> str:
 string_bytes = bytes(indices)
 string = string_bytes.decode("utf-8")
 return string

# 测试
# bytes("a", encoding="utf-8") == b"a"
# bytes("🌍", encoding="utf-8") == b"\xf0\x9f\x8c\x8d" (4个字节)

局限性：
虽然词表大小完美地控制在 256，但压缩率（Compression Ratio） 极差。

Compression Ratio = Bytes / Tokens在这里，比率为 1。
这意味着序列会变得非常长。由于 Transformer 的注意力机制计算复杂度是序列长度的平方级，过长的序列会导致推理极其缓慢且上下文窗口被浪费。

ASCII，Unicode，UTF-8 到底是什么？ —> 这篇

值得深入学习!

1.3 词级分词 (Word-based Tokenization)

这是传统 NLP 中常用的方法，使用正则表达式按空格或标点切分。

import regex

# GPT-2 使用的正则模式示例
GPT2_TOKENIZER_REGEX = r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""

def word_tokenizer_demo(string):
 # 简单的正则切分
 segments = regex.findall(r"\w+|.", string)
 return segments

局限性：

词汇量依然巨大（甚至比 Unicode 字符还多）。
UNK 问题：训练中未见过的词（Out of Vocabulary）会被标记为 <UNK>，这会破坏信息的完整性并影响困惑度（Perplexity）的计算。

2. 最佳实践： (BPE)

BPE(字节对编码)最初由 Philip Gage 在 1994 年作为提出，后被工作引入 NLP 领域（在那之前，基于词的 tokenizer 方法是主流），并被等现代大模型广泛采用。

2.1 核心思想

BPE的基础想法：在一个原始文本上训练一个分词器来确定一个词表。 BPE 的核心直觉是：常见字符序列用单个 Token 表示，罕见序列用多个Token 表示。它是“字符级”和“词级”的折中方案。

GPT-2的论文使用基于词的分词方法将文本拆分为初始片段，并在每个片段上运行原始的BPE算法。

BPE 算法流程草图

初始化：从字节级 Token 开始（初始词表大小为 256）。
统计频率：遍历语料，统计所有相邻 Token 对的出现频率。
寻找最频对：找到出现频率最高的一对（例如 (e, s)）。
合并与更新：将这对 Token 合并为一个新的 Token（例如 es，分配新索引 256），并更新词表。
迭代：重复上述步骤 2-4，直到达到预设的合并次数或目标词表大小。

2.2 训练一个 tokenizer

string = "the cat in the hat"
params = train_bpe(string, num_merges=3)

def train_bpe(string: str, num_merges: int) -> BPETokenizerParams:
 """
 这里是一个简单的训练 bpe 的代码原型
 按照之前的设想，我们应该维护好下面三个变量：
 1. indices 所有原始文档的 utf-8 字节编码
 2. merges 记录每次遍历时的相邻 token 共现计数器
 3. 初始 vocab ，所有的词表拓展都从 256 个字节编码开始。

 """
 indices = list(map(int, string.encode("utf-8")))
 merges: dict[tuple[int, int], int] = {} # 对关联 index 进行合并 index1,index2 => merged index
 vocab: dict[int, bytes] = {x: bytes([x]) for x in range(256)} # index -> bytes

 for i in range(num_merges):
 # 统计每对 tokens 的出现次数
 counts = defaultdict(int)
 for index1, index2 in zip(indices, indices[1:]): # 抽取每一个相邻 pair
 counts[(index1, index2)] += 1

 # 找到出现次数最多的 pair
 pair = max(counts, key=counts.get)
 index1, index2 = pair

 # 融合 Pair ，新增 Token
 new_index = 256 + i
 merges[pair] = new_index
 vocab[new_index] = vocab[index1] + vocab[index2]
 indices = merge(indices, pair, new_index)

 return BPETokenizerParams(vocab=vocab, merges=merges)

def merge(indice: list[int], pair: tuple[int, int], new_index: int) -> list[int]:
 """返回`indices`，但将所有`pair`实例替换为`new_index`"""
 # 初始化一个新的 indice 来完成对现有 indice 的更新
 new_indices = []
 i = 0
 # 
 while i < len(indices):
 if i + 1 < len(indices) and indices[i] == pair[0] and indices[i+1] == pair[1]:
 new_indices.append(new_index)
 i += 2
 else:
 new_indices.append(indices[i])
 i += 1
 return new_indices

2.3 使用tokenizer

# 推理阶段
tokenizer = BPETokenizer(params)
test_string = "the quick brown fox"

# 编码与解码
indices = tokenizer.encode(test_string)
reconstructed_string = tokenizer.decode(indices)

assert test_string == reconstructed_string
print(f"原始字符串: {test_string}")
print(f"Token ID: {indices}")

2.4 可交互 python 环境

该交互环境仅为测试代码和想法使用，并未安装很多依赖包(e.g. torch)，建议不要执行很重的代码！

TERMINAL

> Ready.

总结

分词是一种“必要的恶（Necessary Evil）”。虽然理想情况下我们希望模型能直接理解原始字节，但 BPE 是目前平衡词表大小、序列长度和信息密度的最有效手段。

在实际的大模型训练（如 GPT-2/3/4）中，BPE 的实现会更加复杂，包括：

预分词（Pre-tokenization）：先用正则将文本切分为单词块，再在块内进行 BPE，防止跨单词合并。
特殊 Token：处理 <|endoftext|> 等控制符。
性能优化：编码过程需要极度优化，不能像上述代码那样遍历所有合并规则。

Pipeline of CS336

Sun, 14 Dec 2025 00:00:00 +0800

课程组成

所有的一切都关乎效率

资源：数据+硬件（计算，内存，计算带宽）给定一组受限的资源，你会如何训练一个最佳的模型？举例：给定Common Crawl 的语料和两周 32 卡的 H100s 使用权，你将会如何行动？

课程组成大纲：

效率驱动着设计决策

如今，我们受限于计算资源，因此设计决策将着力于充分利用给定的硬件。

数据处理：避免浪费宝贵的计算资源去更新不良或无关的数据
分词：直接处理原始字节虽然简洁，但在当今的模型架构下计算效率低下。
模型架构：许多改动旨在减少内存占用或浮点运算次数（例如，共享键值缓存、滑动窗口注意力机制）
训练：我们只需一个 epoch 就能完成训练！
缩放定律：在较小的模型上使用更少的计算资源来进行超参数调优
对齐：如果针对特定用例对模型进行更多调优，那么所需的基础模型会更小未来，我们将受限于数据……

Section-1 : 基础概念 & 任务

目标：对整个工作流程有一个基本的概念认知并感知对应的课程任务设计

组成：分词，模型架构，训练

分词

一个分词器的抽象代码实现如下：

class Tokenizer(ABC):
 """Abstract interface for a tokenizer"""
 def encode(self, string: str) -> list[int]:
 raise NotImplementedError

 def decode(self, indices: list[int]) -> str:
 raise NotImplementedError

分词器可以在strings 和整数序列(tokens)两个相互转换。

直觉来看：将字符串拆分为常见片段。

本次课程将要讲授的方法是 , 当然目前也在一些 Tokenizer-free的方法， , , , 。直接实用 bytes 的方法看起来非常有前景，但是目前还没有被大规模应用到前沿模型。

架构

所有的起点：原始 Transformer

变体：

激活函数（Activation functions）：ReLU,
位置编码（Positional encodings）：Sinusoidal,
正则化（Normalization）LayerNorm ， RMSNorm
正则化的替代项 : pre-norm 与
感知机（MLP）：dense，Mixture of experts
注意力机制（Attention）：full，sliding windows，linear ，
低维注意力（lower-dimensional attention）：分组查询注意力（group-query attention, aka GQA），多头潜在注意力（multi-head latent attention, aka MLA）
状态空间模型（state-space model，aka SSM）

训练

优化器（Optimizer）例如，，，
学习率调度器（learning rate schedule），例如 ,
批大小（batch size），例如
正则化（regularization），例如 dropout, weight decay
超参数设置（hyperparameters），例如注意力的头数量，隐藏层维度：用网格搜索完成探索。

任务1

Stanford CS336原版：，

实现一个 BPE 分词器
实现 transformers，交叉熵（Cross-entropy loss），AdamW 优化器，训练循环
在 TinyStories 和 OpenWebText上进行训练
榜单：给定 90 分钟的 H100 训练时间，最小化 OpenWebText 的困厚度。

Section-2 系统设计 & 任务

目标：将硬件设备的性能都压榨出来

组成：核（kernel），并行化（parallelism），推理（inference）

核（ kernels）

GPU 的内部结果如下所示，以 A100 为例：

类比：仓库 : 动态随机存取存储器(DRAM) :: 工厂 : 静态随机存取存储器(SRAM)

技巧：通过减少数据移动来组织计算，以最大限度地提高GPU的利用率,使用CUDA/Triton/CUTLASS/ThunderKittens编写内核程序。

并行度（Parallelism ）

GPU之间的数据移动甚至更慢，但“最小化数据移动”这一原则仍然适用。使用集合操作，例如，收集（gather）、归约（reduce）、全归约（all-reduce）。在GPU之间分片，例如，参数、激活值、梯度、优化器状态）。如何拆分计算：{数据（data-para）、张量（tensor-para）、流水线（pipe-para）、序列（seq-para）}并行性。

推理（inference）

生成令牌为模型实际使用时的必需操作；

推理对强化学习、测试时计算、评估均不可或缺；

全球范围内，推理计算（每次使用）成本已超过训练计算（一次性成本）；

推理包含预填充、解码两个阶段。如下所示：

预填充（类似于训练）：给定标记，可以一次性处理所有标记（计算受限）

解码：需要一次生成一个标记（内存受限）

加速解码的方法： • 使用更轻量的模型（通过模型剪枝、量化、蒸馏） • 推测性解码：使用更轻量的“草稿”模型生成多个标记，然后使用完整模型并行评分（精确解码！） • 系统优化：KV缓存、批处理。

任务 2

Stanford CS336原版：，

在Triton中实现融合的RMSNorm内核。
实现分布式数据并行训练。
实现优化器状态分片。
对实现进行基准测试和性能分析。

Section-3 Scaling 定律 & 任务

目标：进行小规模实验，预测大规模下的超参数/损失。

问题：给定一个浮点运算次数预算（$C$），是使用更大的模型（$N$）还是在更多的标记（$D$）上训练？ Compute-optimal scaling laws: ,

TL;DR：$D^* = 20 N^*$（例如，14亿参数的模型应该在280亿个token上进行训练), 但这并没有考虑到推理成本！

👉 点击展开：为什么说它没有考虑“推理成本”？

这里有一个关键的反转：Chinchilla 定律 ($D^*=20N^*$) 追求的是 训练成本最低（Compute-optimal）。

但在实际应用中，模型训练只有一次，而 推理(被用户使用) 会有无数次。

如果严格遵守 20倍定律，我们会得到一个参数很大、但训练数据适中的模型。虽然训练省钱，但因为它太大了，每次运行都很贵且慢。
现代模型（如 Llama 3）通常会打破这个定律，用远超 20 倍的数据（比如 100 倍）去“过度训练”一个小模型。这样虽然训练时多花了钱，但得到的小模型在未来使用时速度快、成本低。

任务 3

Stanford CS336 原版： ,

我们基于之前的运行定义了一个训练API（超参数→损失）
在FLOPs预算下提交“训练任务”并收集数据点
为数据点拟合缩放定律
提交按比例放大的超参数的预测
排行榜：在给定的FLOPs预算下最小化损失

Section-4 数据 & 任务

问题：我们希望模型有什么样子的能力？多语言？代码？数学？

困惑度：语言模型的标准评估

标准化测试（例如，MMLU、HellaSwag、GSM8K）
指令遵循（例如，AlpacaEval、IFEval、WildBench）
缩放测试时计算：思维链、集成
以语言模型作为评判者：评估生成任务
完整系统：检索增强生成（RAG）、智能体

数据整理

• 数据并非凭空而来。

def look_at_web_data():

 urls = get_common_crawl_urls()[:3] # @inspect urls

 documents = list(read_common_crawl(urls[1], limit=300))

 random.seed(40)

 random.shuffle(documents)

 documents = markdownify_documents(documents[:10])

 write_documents(documents, "var/sample-documents.txt")

# urls=[
"https://data.commoncrawl.org/crawl-data/CC-MAIN-2024-18/segments/1712296815919.75/warc/CC-MAIN-20240412101354-20240412131354-00000.warc.gz",
"https://data.commoncrawl.org/crawl-data/CC-MAIN-2024-18/segments/1712296815919.75/warc/CC-MAIN-20240412101354-20240412131354-00001.warc.gz",
"https://data.commoncrawl.org/crawl-data/CC-MAIN-2024-18/segments/1712296815919.75/warc/CC-MAIN-20240412101354-20240412131354-00002.warc.gz",
]

来源：从互联网爬取的网页、书籍、arXiv论文、GitHub代码等。
诉诸合理使用来使用版权数据进行训练？( )
可能需要授权数据（例如， )
格式：HTML、PDF、目录（而非文本！）

数据处理

转换：将HTML/PDF转换为文本（保留内容、部分结构、重写）。
过滤：保留高质量数据，移除有害内容（通过分类器）。
去重：节省计算资源，避免记忆；使用布隆过滤器或最小哈希。

任务4

Stanford 原版： ,

将通用爬虫（Common Crawl）的HTML转换为文本
训练分类器以过滤出高质量内容和有害内容
使用最小哈希进行去重
排行榜：在给定的令牌预算下最小化困惑度

Section-5 对齐 & 任务

到目前为止，基础模型只是原始的潜力，非常擅长完成下一个标记。对齐能让模型真正变得有用。

对齐的目标：

让语言模型遵循指令。
调整风格（格式、长度、语气等）。
融入安全性（例如，拒绝回答有害问题）。
两个阶段：
- supervised_finetuning(）
- learning_from_feedback()

有监督微调 supervised_finetuning

指令数据格式：（prompt，response）pair

sft_data = list[chatExample] = [
 ChatExample(
 turns = [
 Turn(role="system", content="You are a helpful assistant."),
 Turn(role="user", content="what is 1 + 1?),
 Turn(role="assistant", content="The answer is 2."),
 ],
 ),
]

数据通常涉及人工标注。

直觉：基础模型已经具备相关技能，只需要几个例子就能展现出来。

监督学习：微调模型以最大化 Prob(response | prompt）。

从反馈中学习

现在我们有一个初步的指令遵循模型。让我们在不进行昂贵标注的情况下改进它。

反馈学习的重点是偏好数据，验证器，和算法。

一个偏好的数据的格式如下：

使用模型针对给定提示生成多个响应（例如，[A、B]）。用户给出偏好（例如，A < B 或 A > B）。

preference_data: list[PreferenceExample] = [

 PreferenceExample(

 history=[

 Turn(role="system", content="You are a helpful assistant."),

 Turn(role="user", content="What is the best way to train a language model?"),

 ],

 response_a="You should use a large dataset and train for a long time.",

 response_b="You should use a small dataset and train for a short time.",

 chosen="a",

 )

]

验证器（Verifiers）

形式化验证器（例如，用于代码、数学的验证器）
习得验证器：针对作为评判者的大语言模型进行训练

算法（Algorithm）

Proximal Policy Optimization (PPO) from reinforcement learning ,
Direct Policy Optimization (DPO): for preference data, simpler
Group Relative Preference Optimization (GRPO): remove value function

任务 5

Stanford 官方链接：，

实现有监督微调
实现直接偏好优化（DPO）
实现群相对偏好优化（GRPO）

Let's learn Stanford CS336 - LLM Systems! | Lin Shang

CS336 lecture-01 - tokenizer

1. 基础分词方法的尝试与局限

1.1 字符级分词 (Character-based Tokenization)

1.2 字节级分词 (Byte-based Tokenization)

1.3 词级分词 (Word-based Tokenization)

2. 最佳实践： (BPE)

2.1 核心思想

2.2 训练一个 tokenizer

2.3 使用tokenizer

2.4 可交互 python 环境

总结

Pipeline of CS336

课程组成

所有的一切都关乎效率

效率驱动着设计决策

Section-1 : 基础概念 & 任务

分词

架构

变体：

训练

任务1

Section-2 系统设计 & 任务

核（ kernels）

并行度（Parallelism ）

推理 （inference）

任务 2

Section-3 Scaling 定律 & 任务

任务 3

Section-4 数据 & 任务

困惑度：语言模型的标准评估

数据整理

数据处理

任务4

Section-5 对齐 & 任务

有监督微调 supervised_finetuning

从反馈中学习

验证器 （Verifiers）

算法（Algorithm）

任务 5

推理（inference）

验证器（Verifiers）