第 2 章 LLMGPT深度学习

第 2 章 处理文本数据

第 2 章 处理文本数据

本章来源:本文整理自 LLMs-from-scratch 仓库的 ch02/01_main-chapter-code/ch02.ipynb,原书为 Sebastian Raschka《Build a Large Language Model (From Scratch)》。

这章要解决什么问题

第 1 章我们把地图画好了:LLM 就是一台"文字接龙机"。可这台机器内部全是加减乘除——它根本不认识"猫"这个字,只认识数字。

所以这章的任务只有一句话:把人类能读的文本,翻译成机器能算的数字,并且翻译得让后面的模型好训练。

听起来像是个不起眼的"数据搬运"活,但作者把它单列一章,是有原因的。你可以把它想成做菜前备料:

  • 菜买回来不能直接下锅——得洗、切、分装(把文本切成 token);
  • 切好的料得贴上编号标签,厨师才能按单抓取(token 转成 token ID);
  • 一锅炒不下,得按份量装盘,每盘配料还得"对齐"(滑动窗口切出输入-目标对);
  • 最后每份料还要调味成统一规格,才能进锅(嵌入成向量)。

这章就是把这条"备料流水线"一步步手工搭出来。走完它,你会得到一台专门为 GPT 喂数据的传送带——也就是后面几章真正训练模型时反复调用的那个 create_dataloader_v1。

一句话预告:这章结束时,原文那篇小说会变成一串串整数张量,随时可以喂给一个还没出生的 GPT。

用大白话讲原理

在动手之前,先把这条流水线上的几个关键名词用类比讲透。代码只是把它们翻译成 Python 而已。

为什么要"分词"?因为模型的最小单位不是字

人读书是连字成词、连词成句。模型没法直接处理"一整句话",它需要一个最小的处理单位,我们叫它 token(词元)。

分词(tokenization)就是把一句话切成一个个 token。切法有三种层次:

  • 按字符切:"cat" → ["c", "a", "t"],切得太碎;
  • 按单词切:"cat" → ["cat"],但这要求词汇表覆盖所有单词,遇到没见过的词就傻眼;
  • 按子词切:"cat"、"cats" → ["cat", "s"],既不碎也不漏——这是 GPT 的选择。

你可以把分词理解成"给模型发一盒乐高"。整句话是一辆车,模型手里只有零件。零件(token)怎么切、切多大,直接决定模型能拼出什么。

token ID:给每个 token 编个号

token 还是文字,模型仍然不认。于是我们建一个词汇表(vocabulary):把语料里出现过的所有 token 排好队,每个发一个整数编号。

"cat" → 1023
"dog" → 2088
...

这个"文字 → 整数"的字典就是 token ID 映射。有了它,整篇文本就变成了一串整数,比如 [1023, 2088, ...]。

特殊 token:给模型留的几个"暗号"

光有普通词还不够。文本总有边界,总有不认识的词。于是我们额外塞几个特殊的 token 当暗号:

  • <|unk|>:未知词。突然冒出一个词汇表里没有的词,就把它换成这个暗号,别让程序崩掉。
  • <|endoftext|>:文本结束。把两篇不相关的文章拼在一起时,用它隔开,告诉模型"这里断开了"。

有意思的是,GPT-2 很"极简":它只用 <|endoftext|> 一个特殊 token,既当结束符又当填充符,连 <|unk|> 都省了——因为它的分词器(BPE)几乎能把任何词拆成认识的小块,不太会出现真正的"完全不认识"。

BPE:遇到生词就"拆零件"

你一定在想:如果遇到了词汇表里完全没有的词怎么办?

这就是 BPE(BytePair Encoding,字节对编码) 要解决的。它不硬记所有整词,而是统计出最常见的"字符组合",遇到没见过的词就把它拆成认识的小碎片。

比如 unfamiliarword 没见过,BPE 可能把它拆成 ["unfam", "iliar", "word"]。再生的词,最极端也能拆成单个字符。这就像拼乐高:没有现成的"汽车"零件,那就用"轮子 + 车身 + 车窗"拼出来。这是 GPT 能"以不变应万变"的关键一招。

滑动窗口:把长文本切成"上下文-答案"训练样本

前面说了 LLM 是接龙机:给它一段上文,预测下一个词。那训练数据长什么样?

答案是输入和目标错开一位:

输入 x:the cat sat on
目标 y:    cat sat on the

y 就是 x 往右挪一格。模型的任务是"看着 x,猜出 y"。

一篇长文本怎么变成一堆这样的样本?用滑动窗口:一个固定长度的窗口在文本上一点点滑动,每滑一步就取出一对 x 和 y。窗口每次滑动的步长叫 stride(步幅)。滑得慢(步幅 < 窗口长度),样本之间就有重叠;滑得太快(步幅 = 窗口长度),样本就不重叠了。

嵌入:把 ID 变成"有含义的坐标"

整数 ID 有个致命问题:它只是个编号,没有含义。 编号 1023 和 2088 之间没有"谁离谁近"一说,模型学不到"猫"和"狗"是亲戚。

于是我们要把每个 ID 换成一串小数,叫嵌入(embedding)。这串小数可以看作高维空间里的一个坐标点,含义相近的词,坐标就靠得近。

注意:第 1 章说过,真实 LLM 用的是几千维的高维空间。我们人脑只能想象一维到三维,所以书里的图都用二维示意——图是二维的,但概念是几千维的。

位置编码:光有"是什么"还不够,还得知道"排第几"

有个隐藏的坑:如果只把每个 token 换成向量,那 "dog bites man" 和 "man bites dog" 会得到一模一样的向量集合——因为词一样,只是顺序反了。

可意思完全相反!所以我们必须额外告诉模型每个词的位置。做法很直白:再造一个"位置向量",第 1 个位置一个向量、第 2 个位置另一个向量……然后把它加到 token 向量上:

input_embeddings=token_embeddings+pos_embeddings\text{input\_embeddings} = \text{token\_embeddings} + \text{pos\_embeddings}

位置信息就这样"拌"进了输入里。这就是位置嵌入(positional embedding)。

好,地图画完了,下面正式开工。

2.1 理解词嵌入(理解嵌入,本节没有代码)

如前面所说,嵌入(embedding) 就是把离散的东西(比如 token ID)映射成连续向量的过程。

作者强调了一点,很容易被忽略:嵌入不只有文本这一种,推荐系统里给用户、商品做嵌入,图像里给像素块做嵌入,都在用同一套思想。本书只聚焦文本嵌入。

而 LLM 是在高维空间(几千维)里做嵌入运算的。书里所有示意图之所以画成二维或三维,纯粹是因为我们人类只能在一维、二维、三维里思考——那个"设法用二维图讲几千维"的取舍,请记在心里。

2.2 对文本进行分词(Tokenizing text)

先把语料下载下来

我们要处理的原始文本是 《The Verdict》——作者 Edith Wharton 的一篇公有领域(public domain,即版权已过期、可自由使用)的短篇小说。选它是因为够干净、够长、又没有版权麻烦。

这一步就是把小说从仓库地址下载下来、存成本地文件 the-verdict.txt。它只是普通的 HTTP 请求,和后面的分词逻辑无关,所以本书不列出代码,你拿到这份文本即可开始。

书里原本用的是 Python 自带的 urllib,但它的协议设置偏旧,有读者用 VPN 时会出问题,所以改用更稳的 requests。你用哪个版本都行,只要能顺利把文件下到本地。

如果遇到 SSL 证书报错

  • 有读者在 VSCode 或 Jupyter 里跑 urllib.request.urlretrieve 时报了 ssl.SSLCertVerificationError: SSL: CERTIFICATE_VERIFY_FAILED。
  • 这通常是 Python 的证书包(certifi)过期导致的。

修复方法

  • 用 Python ≥ 3.9(运行 import sys; print(sys.__version__) 即可查看当前版本)。
  • 升级证书包:
    • pip:pip install --upgrade certifi
    • uv:uv pip install --upgrade certifi
  • 升级后重启 Jupyter 内核。
  • 若仍报 ssl.SSLCertVerificationError,参见 GitHub 讨论:更多信息在这里

读进来,数数字符

把《The Verdict》读进内存:打开文件、一次性读成一个大字符串 raw_text。读进来后先看看这篇小说有多少个字符、开头长什么样,心里对数据量有个数——这段准备在下面会反复用到,这里就不再列代码了。

从最简单的分词开始:拿一句话当试验田

不要一上来就对着整篇小说分词,先在一小句上把规则调对。最粗暴的版本是按空白字符切(\s 代表任意空白:空格、换行、制表符都算),用 re.split(r'(\s)', text) 就能把一句话拆成单词和空白。

re.split 是"按给定规则切割字符串",括号 () 的作用是把分隔符本身也保留下来(否则空白就被吃掉了,后面还原会丢空格)。

让标点也独立成 token

光按空白切是不够的:标点应该和单词分开(不然 "world." 会被当做一个 token,跟 "world" 就不是同一个东西了)。于是把逗号、句号也加进切分规则:re.split(r'([,.]|\s)', text)。

但这样会切出空字符串(相邻的两个分隔符之间什么都没有),得把它们清掉——对每个切出的片段做一次 strip(),再把空串过滤掉。

补齐其它标点

再换一句,把问号、破折号、冒号、分号等等也纳进来,切分规则变成 re.split(r'([,.:;?_!"()\']|--|\s)', text),再统一做一次 strip() 和空串过滤。

注意这条正则里的 -- 是单独列出来的:它是个多字符标点,如果只用单字符类,它会被拆成两个减号,得特殊照应。

规则调好了,应用到整篇小说

规则定下来,就可以把它套到整篇《The Verdict》上——同样是先 re.split 切分,再 strip() 去空白、滤掉空串,得到存着所有 token 的列表 preprocessed。顺带数一下一共切出了多少个 token,对数据规模有个概念。

到这里,整篇小说已经从"一团文字"变成了"一长串 token"。但注意——这些 token 还是文字,模型还是读不懂。

2.3 把 token 转换成 token ID

建词汇表:给每个 token 发编号

自然的做法是先找出所有唯一的 token(去重),排个序,然后按顺序编号。用一行 sorted(set(preprocessed)) 就能得到去重且排好序的 token 列表,它的长度就是 vocab_size(词表大小)。

set() 去重、sorted() 排序(定序很重要,不然每次运行编号都在变,结果无法复现)。

接着用 enumerate 给每个 token 发一个从 0 开始的整数编号,就建好了"token → 整数"的字典 vocab。翻开词典就能看到,"!"、"\"" 这类标点往往排在最前面,"the"、"and" 这些高频词也各自有了编号。

把逻辑装进一个分词器类:SimpleTokenizerV1

上面是散装的操作。真正的工程里要把它们封装起来,方便复用。这就是第一个分词器类——只管 encode(文字→ID)和 decode(ID→文字)两件事:

class SimpleTokenizerV1:
    def __init__(self, vocab):
        self.str_to_int = vocab
        self.int_to_str = {i:s for s,i in vocab.items()}
    
    def encode(self, text):
        preprocessed = re.split(r'([,.:;?_!"()\']|--|\s)', text)
                                
        preprocessed = [
            item.strip() for item in preprocessed if item.strip()
        ]
        ids = [self.str_to_int[s] for s in preprocessed]
        return ids
        
    def decode(self, ids):
        text = " ".join([self.int_to_str[i] for i in ids])
        # Replace spaces before the specified punctuations
        text = re.sub(r'\s+([,.?!"()\'])', r'\1', text)
        return text
  • encode:把文本切成 token,再查字典换成 ID。
  • decode:把 ID 查回 token,拼成文本。注意最后那行 re.sub 是个小细节——拼句时 token 之间默认加了空格,得把标点前多出来的空格去掉(否则会拼出 "Hello , world" 这种别扭结果)。

__init__ 里那份 int_to_str 就是 str_to_int 的反向字典,方便 decode 用。

试一下

现在拿例子里那句 "It's the last he painted, you know," Mrs. Gisburn said with pardonable pride." 试一下:先 encode 把它变成一串 ID,再 decode 把这串 ID 还原回文字。如果它能原样还原,说明这一版分词器基本能用了。

2.4 添加特殊上下文 token

先认识几个"暗号"

有些分词器会引入一些特殊 token,帮助 LLM 获得额外上下文信息。常见的有:

  • [BOS](beginning of sequence,序列开始):标记文本开始。
  • [EOS](end of sequence,序列结束):标记文本在哪结束。常用于把多段不相关文本拼起来(比如两篇不同的维基文章、两本书),用它在中间断开。
  • [PAD](padding,填充):当批量大小 > 1 时,一批里的句子长短不一,得用填充 token 把短的补齐到一样长。
  • [UNK]:表示词汇表里没收录的词。

但 GPT-2 走的是极简路线:它只用一个 <|endoftext|> 来降低复杂度。这个 token 同时兼了几件事:

  • 当 [EOS] 用:标记文本结束、分隔多段文本;
  • 当 [PAD] 用:GPT 训练时通常会给 padding 位置加掩码(mask),那些位置的 token 是什么根本不重要,所以填什么无所谓,就用 <|endoftext|> 凑合;
  • 不设 <UNK>:因为 GPT-2 用 BPE 分词器,几乎任何词都能拆成子词单元,不需要"未知词"这个兜底(BPE 下一节讲)。

暴露出问题:未知词会让 V1 崩溃

换一段文本试试,比如 "Hello, do you like tea. Is this-- a test?"——这一行会报错。原因很简单:"Hello" 这个词在《The Verdict》的词汇表里根本没出现过,字典查不到,直接 KeyError。

这就是 [UNK] 存在的意义。既然要扩词表,那顺便再补一个 <|endoftext|>(用于表示文本结束、以及拼接多段文本时的分界):在原来排好序的 token 列表后面 extend 上 ["<|endoftext|>", "<|unk|>"],再重新 enumerate 建一遍 vocab。这样一来,词表末尾就多出了这两个特殊 token。

升级成分词器:SimpleTokenizerV2

问题摆在眼前,升级顺理成章。SimpleTokenizerV2 和 V1 唯一的区别,就是在 encode 里多了一步:遇到字典里没有的 token,就把它换成 <|unk|>。落到代码上就是那段列表推导——item if item in self.str_to_int else "<|unk|>",认识的保留,不认识的一律打成 <|unk|>;decode 部分则和 V1 完全一样。

验证一下:拼接两段文本

把两句不相干的文本用 " <|endoftext|> ".join(...) 拼起来,再交给 V2 分词。这一次 "Hello" 不会再报错,而是被换成 <|unk|>。中间那个 <|endoftext|> 就是我们主动告诉模型的"这里断开"的暗号。

2.5 BytePair 编码(BPE)

为什么还需要 BPE

V2 虽然不会崩了,但它有个硬伤:<|unk|> 是把信息丢掉了。一个没见过的词,被压成一个"不知道是啥"的暗号,模型学不到任何东西。

GPT-2 的解决方案是 BPE(BytePair Encoding,字节对编码)。它不把生词压成 <|unk|>,而是把它拆成认识的小碎片,这样信息一点不丢。

比如 GPT-2 词表里没有 unfamiliarword,它可能把它切成 ["unfam", "iliar", "word"]——至于具体怎么切,取决于它训练时学到的合并规则。

BPE 的直觉:它像一个懂"造词法"的裁缝。看到生词不慌,先找词根词缀这些常见零件,硬拼出最接近的切法。所以"以不变应万变"——理论上任何字符串都能拆成字节级的最小单位。

直接用 tiktoken

原始 BPE 分词器在这里能看到:openai/gpt-2 的 encoder.py。但本书直接用 OpenAI 开源的 tiktoken 库——它的核心算法用 Rust 实现,快得多(作者在 ./bytepair_encoder 里做了对比,示例文本上 tiktoken 大约快 5 倍)。

用起来也就一行:pip install tiktoken 装好之后,tokenizer = tiktoken.get_encoding("gpt2") 就能拿到 GPT-2 的分词器,后面的编码、解码都交给它。

亲眼看看 BPE 怎么切生词

拿一句混了特殊 token 和生造词的话试试,比如 "Hello, do you like tea? <|endoftext|> In the sunlit terraces of someunknownPlace.",调用 tokenizer.encode(text, allowed_special={"<|endoftext|>"}) 就能看到它被切成了哪些整数 ID,再用 decode 还原回来。

注意 allowed_special={"<|endoftext|>"} 这个参数:它告诉 tiktoken "<|endoftext|> 是我特意写的暗号,请把它当成一个特殊 token 处理",而不要把它拆成一个个普通字符。

someunknownPlace 这种明显生造的词,BPE 会拆成子词和单个字符——这就是它对付未知词的看家本领。

2.6 用滑动窗口做数据采样

训练数据长什么样:输入和答案错开一位

前面讲过,LLM 是"看着上文猜下一个词"。所以训练样本是一对:

输入 x=[t1,t2,…,tn],目标 y=[t2,t3,…,tn+1]\text{输入 } x = [t_1, t_2, \dots, t_n], \qquad \text{目标 } y = [t_2, t_3, \dots, t_{n+1}]

y 就是 x 向右平移一位。模型学着由 x 推出 y,就学会了预测下一个词。

先把整篇小说用分词器编码成一串 ID(记作 enc_text),并取其中一小段(跳过开头)做演示。设定上下文长度(context size)为 4,也就是"看 4 个词、预测第 5 个":取前 4 个 ID 当输入 x,取第 2 到第 5 个 ID 当目标 y。可以清楚地看到 y 相对 x 错开一位。

一步一步看预测过程

模型训练时,不是只做一次预测,而是每一步都预测一次——上面出现过几个词,就对应几条训练信号。做法是让窗口从第 1 个 token 开始逐步加长:第 1 步用前 1 个词预测第 2 个词,第 2 步用前 2 个词预测第 3 个词,以此类推。把上下文和解码后的目标并排打印出来,就能直观看出这就是"接龙"。

至于模型内部怎么把上下文变成预测结果,那要到后面讲注意力机制时才能揭晓。这里我们先把数据管道铺好。

把流水线封装成 PyTorch 组件

数据管道的实现依赖 PyTorch(先确认已装好 torch)。现在用滑动窗口把长文本切成一个个 x/y 对。GPTDatasetV1 继承自 PyTorch 的 Dataset(数据集基类),把切好的样本存起来:

from torch.utils.data import Dataset, DataLoader


class GPTDatasetV1(Dataset):
    def __init__(self, txt, tokenizer, max_length, stride):
        self.input_ids = []
        self.target_ids = []

        # Tokenize the entire text
        token_ids = tokenizer.encode(txt, allowed_special={"<|endoftext|>"})
        assert len(token_ids) > max_length, "Number of tokenized inputs must at least be equal to max_length+1"

        # Use a sliding window to chunk the book into overlapping sequences of max_length
        for i in range(0, len(token_ids) - max_length, stride):
            input_chunk = token_ids[i:i + max_length]
            target_chunk = token_ids[i + 1: i + max_length + 1]
            self.input_ids.append(torch.tensor(input_chunk))
            self.target_ids.append(torch.tensor(target_chunk))

    def __len__(self):
        return len(self.input_ids)

    def __getitem__(self, idx):
        return self.input_ids[idx], self.target_ids[idx]

三个关键点:

  • max_length:每个样本的窗口有多宽(即上下文长度);
  • stride:窗口每次滑多少。stride < max_length 就会产生重叠的样本;
  • target_chunk 永远是 input_chunk 右移一位的结果。

再用一个函数把它包成方便调用的数据加载器(DataLoader):

def create_dataloader_v1(txt, batch_size=4, max_length=256, 
                         stride=128, shuffle=True, drop_last=True,
                         num_workers=0):

    # Initialize the tokenizer
    tokenizer = tiktoken.get_encoding("gpt2")

    # Create dataset
    dataset = GPTDatasetV1(txt, tokenizer, max_length, stride)

    # Create dataloader
    dataloader = DataLoader(
        dataset,
        batch_size=batch_size,
        shuffle=shuffle,
        drop_last=drop_last,
        num_workers=num_workers
    )

    return dataloader

这个函数是本章的"主角"之一:后面几章训练 GPT 时会反复用它。参数里 batch_size 是每批几条样本、shuffle 是打不打乱、drop_last 是"最后不足一批的样本要不要丢掉"。

小批量试跑:批量大小 1

先按 batch_size=1, max_length=4, stride=1, shuffle=False 跑一遍。这里 stride=1、max_length=4:窗口每次只滑 1 格,于是样本高度重叠——连续取两批出来看,相邻两批的输入只差一个 token。

当 stride 等于 max_length(这里是 4)时,窗口之间不再重叠,样本一个挨一个、整齐排布。

加大批量:批量大小 8、无重叠

作者提了一句经验:重叠太多可能加剧过拟合,所以这里把 stride 调大到等于窗口长度,让批次之间不重叠——改成 batch_size=8, max_length=4, stride=4 再跑一次,每批就得到一组规整的 inputs / targets。

到这里,数据已经被切成了规规矩矩的 inputs / targets 张量对。但它们还是整数 ID,最后一步——把它们变成有含义的向量。

2.7 创建 token 嵌入

用嵌入层把 ID 变成向量

现在要给"传送带"加最后一道工序:把 token ID 嵌入到连续的向量表示里。这些嵌入层通常是 LLM 本身的一部分,会在模型训练时一起被训练、更新。

为演示方便,假设词表只有 6 个词、每个 token 表示成 3 维向量,那么 torch.nn.Embedding(6, 3) 就会生成一个 6×3 的权重矩阵(6 个词、每个 3 维)——每一行对应一个 token 的向量,打印 embedding_layer.weight 就能看到它。

给学过 one-hot 编码的读者:这个嵌入层,本质上就是"one-hot 编码 + 全连接层矩阵乘法"的高效等价实现。因为等价,它就是一个可以用反向传播来优化的普通神经网络层——而不是一张写死的查询表。作者在补充代码 ./embedding_vs_matmul 里给出了推导。

查一个 ID 试试

把 ID 为 3 的 token 传进 embedding_layer,你会发现结果正好是权重矩阵的第 4 行(ID 从 0 开始数,所以 ID 3 就是第 4 行)。这正是"查表"的含义。同理,把一组 ID [2, 3, 5, 1] 一次性都传进去,取出的就是对应的四行。

所以,嵌入层本质上就是一个查表操作:拿 ID 当行号,去矩阵里取对应那一行。

想深入比较嵌入层和普通线性层的读者,可以看补充内容:../03_bonus_embedding-vs-matmul

2.8 编码词位置

提醒:嵌入层自己不知道位置

这里有个关键提醒:嵌入层把同一个 ID 转成完全相同的向量,不管它在句子里的哪个位置。

也就是说,如果不做处理,"dog bites man" 和 "man bites dog" 会得到一模一样的向量集合。意思南辕北辙,模型却分不出来。这就是位置编码存在的理由。

做法是:给每个位置单独造一个"位置向量",再与 token 向量相加,得到最终的输入嵌入。

真实的嵌入维度

BPE 词表大小是 50,257。我们想把每个 token 编码成 256 维,于是造一个 torch.nn.Embedding(50257, 256) 作为 token 嵌入层 token_embedding_layer。

先取一批数据

如果我们从数据加载器取一批样本,并把每个 token 都嵌入成 256 维——那么"批量大小 8、每批 4 个 token"会得到 8×4×256 的张量:先按 batch_size=8, max_length=4, stride=4 取一批 inputs,再把它送进 token_embedding_layer 完成嵌入。

形状是 torch.Size([8, 4, 256]):8 条样本、每条 4 个 token、每个 token 256 维。

造位置嵌入

GPT-2 用的是绝对位置嵌入(absolute positional embedding)——给序列里每个固定位置都配一个可学习的向量。于是照着 token 嵌入层再造一个 torch.nn.Embedding(max_length, output_dim) 作为位置嵌入层 pos_embedding_layer。用 torch.arange(max_length) 生成 [0, 1, 2, 3]——也就是位置编号,逐一查表就得到位置向量 pos_embeddings。

相加,得到最终输入嵌入

要造出真正喂给 LLM 的输入,只需把两者相加:

# token ID 查表得到 token 嵌入
token_embeddings = token_embedding_layer(inputs)

# 位置编号 [0, 1, 2, 3] 查表得到位置嵌入
pos_embeddings = pos_embedding_layer(torch.arange(max_length))

# 两者相加,就是最终喂给 LLM 的输入嵌入
input_embeddings = token_embeddings + pos_embeddings

形状依然是 [8, 4, 256]——token 的"是什么"和位置的"排第几"被融合进了同一组向量里。这,就是 LLM 真正会"看"到的东西。

至此,整条流水线打通:原始文本 → 分词 → token ID → 滑动窗口切样本 → token 嵌入 + 位置嵌入 → 输入嵌入。

关键概念

  • 分词(tokenization):把文本拆成更小的单元(词、标点、子词)。
  • 词汇表(vocabulary):所有唯一 token 的集合,每个 token 映射到一个整数 ID。
  • 特殊 token:<|endoftext|>(文本结束 / 分隔 / 填充)、<|unk|>(未知词)等。GPT-2 只用 <|endoftext|>。
  • BPE(BytePair Encoding,字节对编码):GPT-2 用的分词算法,把未知词拆成子词甚至单字符,从而不丢信息地处理生词。
  • 滑动窗口采样:用重叠窗口从长文本里切出 input/target 对,target 是 input 右移一位。stride 决定窗口滑动步长。
  • token 嵌入(token embedding):本质是一个查表操作,把 token ID 映射成连续向量(等价于 one-hot 乘矩阵的高效实现)。
  • 位置嵌入(positional embedding):给序列里每个位置一个向量,与 token 嵌入相加形成输入嵌入,让模型知道词的先后顺序。
  • 输入嵌入(input embedding):input_embeddings=token_embeddings+pos_embeddings\text{input\_embeddings} = \text{token\_embeddings} + \text{pos\_embeddings},这才是最终喂给 LLM 的张量。

动手练习

练习解答见仓库的 ch02/01_main-chapter-code/exercise-solutions.ipynb。动手前可以先自己想一遍:

  1. 对比不同分词器:除了 tiktoken.get_encoding("gpt2"),再试试别的编码(比如 "r50k_base"),观察同一段文本被切出的 token 有什么不同。
  2. 换个 stride 会怎样:把 create_dataloader_v1 的 stride 分别设成 1、2、max_length,看看生成的样本数量和重叠程度如何变化。
  3. 把位置嵌入去掉会怎样:跳过 + pos_embeddings 这一步,思考模型还能不能区分"词序相同但顺序不同"的两句话——这正是后面要讲注意力机制时的一个伏笔。
  4. 换一篇文本:随便找一段中文或英文文本替换《The Verdict》,跑完整条流水线,观察 vocab_size 和分词结果的差异。

学完这章,你已经把"备料流水线"全部搭好。接下来的一章,我们开始动手搭模型本身。