当前位置：首页 > news >正文

【大模型 Tokenizer 核心技术解析】从 BPE 到 Byte-Level 的完整指南

news 2025/11/4 8:39:21

文章目录

- 前言
- 一、Tokenizer 基础概念
- - 1.1 什么是 Tokenizer
  - 1.2 为什么需要分词
  - 1.3 常见分词级别（字符级 / 单词级 / 子词级）对比
  - - 1. 字符级 (Character-level)
    - 2. 单词级 (Word-level)
    - 3. 子词级 (Subword-level)
- 二、字符编码基础
- - 2.1 Unicode 与 UTF-8、ASCII 码的核心原理
  - 2.2 UTF-8 字节级编码示例
- 三、BPE 算法原理
- - 3.1 BPE 核心思想
  - 3.2 BPE 训练过程
  - 3.3 BPE 编码新文本
  - 3.4 BPE 的局限性
  - 3.4 BPE 的局限性
- 四、Byte-Level BPE 深入解析
- - 4.1 为什么需要 Byte-Level 改进
  - 4.2 BBPE 工作原理
  - 4.3 BBPE 的优势
- 五、实践：BPE 实现代码和结果分析
- - 5.1 BPE 算法实现代码
  - 5.2 BPE 算法完整实现步骤
  - 5.3 Byte-Level 改进方案
- 六、总结
- 七、参考

前言

本文深入探讨了大语言模型 Tokenizer 的核心技术，涵盖 BPE 算法原理、Byte-Level 处理机制、特殊 Token 设计等关键知识点，帮助读者全面理解现代 NLP 模型的文本处理基础。

一、Tokenizer 基础概念

Tokenizer（分词器）作为 LLM 的核心预处理组件，承担着将原始文本转换为模型可处理数字表示的关键任务。

1.1 什么是 Tokenizer

Tokenizer（分词器）是将文本转换为模型可理解数字的桥梁。由于计算机只能处理数字，Tokenizer 的任务就是将人类可读的文本转换成模型可处理的 Token ID 序列。

基本工作流程：

原始文本 → 预处理 → Tokenization（分词） → 编码为 ID → 输入模型

1.2 为什么需要分词

字符级分词：序列过长且语义信息稀疏（稀疏性指文本未充分利用词汇表，例如某些字符虽在词汇表中却很少出现，导致词汇表利用率偏低）
- 例如：“apple” → [“a”, “p”, “p”, “l”, “e”]（5个Token）
单词级分词：词典庞大，无法处理未登录词
- 例如：“appler” → [UNK]（未知Token）
子词级分词（现代主流）：平衡词典大小和序列长度
- 例如：“playing” → [“play”, “ing”]

1.3 常见分词级别（字符级 / 单词级 / 子词级）对比

在自然语言处理中，根据不同的任务需求和语言特点，主要存在三种分词级别：

1. 字符级 (Character-level)

基本单位：将文本分解为单个字符
优点：
- 适用于形态丰富的语言（如中文）
- 词汇表极小（通常不超过1000个字符）
- 天然解决未登录词问题
缺点：
- 失去语义单元信息
- 序列长度显著增加
- 对长距离依赖建模困难
典型应用：
- 中文文本处理
- 拼写检查
- 语音识别后处理

2. 单词级 (Word-level)

基本单位：以空格或标点为分隔的自然单词
优点：
- 保留完整语义单元
- 序列长度适中
- 与人类认知一致
缺点：
- 词汇表膨胀（英语通常需要3万-10万个词）
- 难以处理未登录词
- 对形态变化敏感（如"run"/“ran”/“running”）
典型应用：
- 传统机器翻译
- 情感分析
- 英语文本分类

3. 子词级 (Subword-level)

基本单位：介于字符和单词之间（常用BPE/WordPiece算法）
优点：
- 平衡词汇表大小（通常8000-32000）
- 可处理未登录词（通过子词组合）
- 共享词根信息（如"unhappy"分解为"un"+“happy”）
缺点：
- 需要预训练分词模型
- 解码时需要重组
典型应用：
- 现代NLP模型（BERT、GPT等）
- 多语言处理
- 专业领域术语处理

对比示例：处理单词"unbelievable":

字符级：u n b e l i e v a b l e
单词级：unbelievable
子词级（BPE）：un believe able

选择建议：

计算资源有限 → 字符级
专业领域且词汇固定 → 单词级
通用场景+大模型 → 子词级

二、字符编码基础

在深入讲解Byte-Level BPE算法之前，有必要先了解Unicode字符集、UTF-8编码方式以及字节级处理的基本概念。

2.1 Unicode 与 UTF-8、ASCII 码的核心原理

Unicode vs UTF-8 vs ASCII：

特性	Unicode	UTF-8	ASCII
本质	字符标准/映射表	编码规则/实现方式	古老编码规则
核心工作	定义字符↔码点映射	定义码点↔字节序列映射	定义字符↔数字映射
范围	全球所有字符(>14万)	全球所有字符	仅128个英文字符
存储单位	抽象概念	字节(1-4个)	字节(仅用7位)

比喻理解：

Unicode：联合国公民ID管理局，给每个字符分配唯一身份证号（码点）
UTF-8：智能护照编码规则，决定如何存储这些身份证号
ASCII：古老国家的本地身份证系统，只能处理本国公民

三者之间的关系
Unicode 是字符集标准（定义字符编号），UTF-8 是 Unicode 的一种可变长度编码方式（将编号转为二进制存储），ASCII 是早期兼容的单字节编码（UTF-8 前 128 字符与 ASCII 完全一致）。

2.2 UTF-8 字节级编码示例

# 字符到UTF-8字节的转换示例
characters = ["A", "牛", "£", "😊"]
for char in characters:bytes_repr = char.encode('utf-8')print(f"字符 '{char}': UTF-8字节 {list(bytes_repr)}")# 输出：
# 字符 'A': UTF-8字节 [65]           (1字节)
# 字符 '牛': UTF-8字节 [231, 137, 155] (3字节)  
# 字符 '£': UTF-8字节 [194, 163]     (2字节)
# 字符 '😊': UTF-8字节 [240, 159, 152, 138] (4字节)

三、BPE 算法原理

BPE（Byte Pair Encoding）作为分词算法已被应用于GPT-2、GPT-3、GPT-4以及LLaMA系列等多个大型语言模型中。

3.1 BPE 核心思想

BPE（Byte Pair Encoding）最初是一种数据压缩算法，后来被应用于 NLP 分词。其核心思想是：迭代合并最频繁的相邻符号对。

3.2 BPE 训练过程

# 训练语料
corpus = "low lower newest widest"# 初始化：拆分为字符并添加结束符
["l o w </w>", "l o w e r </w>", "n e w e s t </w>", "w i d e s t </w>"]# 迭代合并过程：
# 第1轮：合并 (e, s) → es
["l o w </w>", "l o w e r </w>", "n e w es t </w>", "w i d es t </w>"]# 第2轮：合并 (es, t) → est  
["l o w </w>", "l o w e r </w>", "n e w est </w>", "w i d est </w>"]# 第3轮：合并 (l, o) → lo
["lo w </w>", "lo w e r </w>", "n e w est </w>", "w i d est </w>"]# 第4轮：合并 (lo, w) → low
["low </w>", "low e r </w>", "n e w est </w>", "w i d est </w>"]

每轮产生的合并规则都会被保存。

3.3 BPE 编码新文本

当遇到新词 “lowest” 时：

初始拆分：l o w e s t </w>
应用合并规则：
- 合并 l o → lo
- 合并 lo w → low
- 合并 e s → es
- 合并 es t → est
最终结果：["low", "est"]

3.4 BPE 的局限性

虽然 BPE（Byte Pair Encoding）算法在 NLP 领域取得了广泛成功，但它仍存在一些明显的局限性：

词汇量不可控：
- 在训练过程中，BPE 会持续合并高频字符对直到达到预设的词汇量大小，但这个过程可能导致生成的子词单元数量超出实际需求
- 例如，在某些语料中可能会生成过多细粒度的子词变体（如 “ing”、“ings”、“inging” 等）
编码效率问题：
- 标准 BPE 基于 Unicode 字符级别操作，在处理多语言文本时会遇到编码兼容性问题
- 当遇到罕见字符（如特殊符号或表情符号）时，可能导致词汇表膨胀
字节不连续性：
- 直接操作 Unicode 字符可能导致跨语言处理时出现字节级不连续问题
- 例如，在处理中日韩等语言的混合文本时，字符编码可能会破坏语言本身的语义连续性
OOV（Out of Vocabulary）问题：
- 尽管 BPE 通过子词分割减少了 OOV 情况，但对于完全未见的字符序列仍然无法处理
- 特别是当遇到新出现的网络用语或专业术语时表现不佳
计算资源消耗：
- 处理大规模多语言语料时，标准的 BPE 实现需要消耗大量内存和计算资源
- 合并操作的复杂度随语料规模呈非线性增长

这些局限性促使研究者开发改进算法，其中最具代表性的是 Byte-Level BPE（字节级 BPE），通过直接在字节级别进行操作来解决上述问题。字节级编码不仅可以更好地处理多语言场景，还能更高效地利用计算资源，同时保持对罕见字符的良好处理能力。

四、Byte-Level BPE 深入解析

4.1 为什么需要 Byte-Level 改进

传统 BPE 的问题：

字符爆炸：Unicode 字符超过15万个，基础词汇表稀疏
未知字符：遇到训练时未见过的字符只能回退到 [UNK]
跨语言复杂性：为每种语言建立有效子词单元困难

Byte-Level BPE 解决方案：

在字节级别而非字符级别运行 BPE，基础词汇表固定为256个字节值。

4.2 BBPE 工作原理

训练过程：

所有文本通过 UTF-8 编码转换为字节序列
在字节序列上运行 BPE 算法
基础词汇表：256个字节值(0x00-0xFF)

编码示例：

# 字符 "牛" 的处理过程
character = "牛"
utf8_bytes = [0xE7, 0x89, 0x9B]  # UTF-8编码# BBPE 看到的是3个独立字节，而非一个中文字符

4.3 BBPE 的优势

永不产生 [UNK]：任何字符都可分解为1-4个基础字节
词汇表简洁：基础单元只有256个，无稀疏问题
语言无关：底层字节对所有语言一视同仁
真正跨语言：无需为不同语言设计不同分词器

五、实践：BPE 实现代码和结果分析

5.1 BPE 算法实现代码

import re
import json
import time
from collections import defaultdictclass BPETokenizer:"""BPE (Byte Pair Encoding) 分词器完整实现包含训练、编码、解码和词汇表管理功能"""def __init__(self):self.raw_corpus = []self.preprocessed_corpus = []self.initial_vocab = defaultdict(int)self.vocab = {}self.merges = {}self.merge_history = []self.token_to_id = {}self.id_to_token = {}# 特殊 token 配置self.special_tokens = {'PAD': '<pad>','UNK': '<unk>','BOS': '<bos>','EOS': '<eos>'}print("🔧 BPE 分词器初始化完成")# ------------------ 数据收集 ------------------def collect_data(self, texts=None):print("\n📥 阶段 1: 数据收集")print("-" * 40)if texts is None:self.raw_corpus = ["The quick brown fox jumps over the lazy dog.","I love machine learning and natural language processing.","This is an example text for BPE training."]else:self.raw_corpus = textsprint(f"收集到 {len(self.raw_corpus)} 条文本:")for i, text in enumerate(self.raw_corpus, 1):print(f"  {i}. {text}")return self.raw_corpus# ------------------ 文本预处理 ------------------def preprocess_text(self, text):text_lower = text.lower()text_no_punct = re.sub(r'[^\w\s]', '', text_lower)text_normalized = ' '.join(text_no_punct.split())text_with_boundary = text_normalized.replace(' ', ' </w> ') + ' </w>'return text_with_boundary# ------------------ 构建初始词汇表 ------------------def build_initial_vocab(self):print("\n📚 阶段 2: 构建初始词汇表")print("-" * 40)self.preprocessed_corpus = [self.preprocess_text(t) for t in self.raw_corpus]print("预处理后的语料库:")for i, text in enumerate(self.preprocessed_corpus, 1):print(f"  {i}. {text}")self.initial_vocab = defaultdict(int)for text in self.preprocessed_corpus:for word in text.split():if word != '</w>':chars = ' '.join(list(word))self.initial_vocab[chars] += 1else:self.initial_vocab[word] += 1print(f"\n初始词汇表大小: {len(self.initial_vocab)}")sorted_vocab = sorted(self.initial_vocab.items(), key=lambda x: x[1], reverse=True)[:10]for i, (token, count) in enumerate(sorted_vocab, 1):print(f"  {i}. '{token}' : {count}")return dict(self.initial_vocab)# ------------------ 统计符号对频率 ------------------def get_stats(self, vocab):pairs = defaultdict(int)for word, freq in vocab.items():symbols = word.split()for i in range(len(symbols) - 1):pairs[(symbols[i], symbols[i + 1])] += freqreturn pairs# ------------------ 合并符号对 ------------------def merge_vocab(self, pair, vocab):new_vocab = defaultdict(int)bigram = ' '.join(pair)replacement = ''.join(pair)for word, freq in vocab.items():new_word = word.replace(bigram, replacement)new_vocab[new_word] += freqreturn new_vocab# ------------------ BPE 训练 ------------------def train(self, num_merges=10):print("\n🏋️ 阶段 3: BPE 训练")print("-" * 40)self.vocab = self.initial_vocab.copy()self.merges = {}self.merge_history = []print(f"计划执行 {num_merges} 次合并")print(f"初始词汇表大小: {len(self.vocab)}")for step in range(num_merges):pairs = self.get_stats(self.vocab)if not pairs:print("没有找到可合并的符号对，训练提前结束")breakbest_pair = max(pairs, key=pairs.get)best_freq = pairs[best_pair]merged_token = ''.join(best_pair)print(f"\n合并步骤 {step + 1}:")print(f"  最佳符号对: {best_pair} → '{merged_token}' (频率: {best_freq})")self.merges[best_pair] = (merged_token, best_freq)self.merge_history.append((best_pair, merged_token, best_freq))old_size = len(self.vocab)self.vocab = self.merge_vocab(best_pair, self.vocab)print(f"  词汇表变化: {old_size} → {len(self.vocab)}")print(f"\n训练完成! 学习到 {len(self.merges)} 条合并规则")return self.merges# ------------------ 构建最终词汇表 ------------------def build_final_vocabulary(self):print("\n📖 阶段 4: 构建最终词汇表")print("-" * 40)self.vocab = {}self.token_to_id = {}self.id_to_token = {}# 特殊 tokentoken_id = 0for name, token in self.special_tokens.items():self.vocab[token] = token_idtoken_id += 1print(f"添加特殊 token: '{token}' → ID {self.vocab[token]}")# 字符 tokenall_chars = set()for token_str in self.initial_vocab.keys():all_chars.update(token_str.split())for char in sorted(all_chars):if char not in self.vocab:self.vocab[char] = token_idtoken_id += 1print(f"添加字符 token: '{char}' → ID {self.vocab[char]}")# 合并 tokenmerge_tokens = [(merged, freq) for (_, _), (merged, freq) in self.merges.items()]merge_tokens.sort(key=lambda x: x[1], reverse=True)for merged_token, freq in merge_tokens:if merged_token not in self.vocab:self.vocab[merged_token] = token_idtoken_id += 1print(f"添加合并 token: '{merged_token}' → ID {self.vocab[merged_token]} (频率: {freq})")self.token_to_id = self.vocab.copy()self.id_to_token = {v: k for k, v in self.vocab.items()}print(f"\n最终词汇表大小: {len(self.vocab)}")return self.vocab# ------------------ 编码 ------------------def encode_word(self, word):tokens = list(word) + ['</w>']while True:changes = Falsesorted_merges = sorted(self.merges.items(), key=lambda x: x[1][1], reverse=True)for pair, (merged_token, _) in sorted_merges:i = 0while i < len(tokens) - 1:if tokens[i] == pair[0] and tokens[i + 1] == pair[1]:tokens[i] = merged_tokendel tokens[i + 1]changes = Trueelse:i += 1if changes:breakif not changes:breakreturn tokensdef encode(self, text, verbose=False):if verbose:print(f"\n🔄 编码文本: '{text}'")text_lower = text.lower()text_clean = re.sub(r'[^\w\s]', '', text_lower)words = text_clean.split()if verbose:print(f"预处理后: '{text_clean}'")print(f"分词: {words}")all_tokens = []for word in words:tokens = self.encode_word(word)all_tokens.extend(tokens)if verbose:print(f"  '{word}' → {tokens}")token_ids = [self.token_to_id.get(tok, self.token_to_id['<unk>']) for tok in all_tokens]if verbose:print(f"最终 token IDs: {token_ids}")print(f"压缩率: {len(text_clean)}/{len(all_tokens)} = {len(text_clean) / len(all_tokens):.2f}")return token_ids# ------------------ 解码 ------------------def decode(self, token_ids, verbose=False):if verbose:print(f"\n🔄 解码 IDs: {token_ids}")tokens = [self.id_to_token.get(id_, '<unk>') for id_ in token_ids]if verbose:print(f"Tokens: {tokens}")combined = ''.join(tokens)text = combined.replace('</w>', ' ').strip()if verbose:print(f"重建文本: '{text}'")return text# ------------------ 保存 / 加载 ------------------def save(self, filepath):# tuple key -> str keymerges_str = {f"{k[0]}@@{k[1]}": v for k, v in self.merges.items()}data = {'vocab': self.vocab,'merges': merges_str,'token_to_id': self.token_to_id,'id_to_token': self.id_to_token,'special_tokens': self.special_tokens}with open(filepath, 'w', encoding='utf-8') as f:json.dump(data, f, ensure_ascii=False, indent=2)print(f"分词器已保存到: {filepath}")def load(self, filepath):with open(filepath, 'r', encoding='utf-8') as f:data = json.load(f)self.vocab = data['vocab']# str key -> tuple keyself.merges = {tuple(k.split("@@")): v for k, v in data['merges'].items()}self.token_to_id = data['token_to_id']self.id_to_token = {int(k): v for k, v in data['id_to_token'].items()}self.special_tokens = data['special_tokens']print(f"分词器已从 {filepath} 加载")# ------------------ 演示 ------------------
def main():print("🎯 BPE 算法完整演示")print("=" * 50)tokenizer = BPETokenizer()tokenizer.collect_data()tokenizer.build_initial_vocab()tokenizer.train(num_merges=15)tokenizer.build_final_vocabulary()print("\n🎯 阶段 5: 编码解码演示")print("-" * 40)test_texts = ["the quick brown fox", "machine learning", "hello world"]for text in test_texts:print(f"\n处理文本: '{text}'")token_ids = tokenizer.encode(text, verbose=True)decoded = tokenizer.decode(token_ids, verbose=True)original_clean = re.sub(r'[^\w\s]', '', text.lower()).strip()print(f"编码解码一致性: {'✅' if decoded == original_clean else '❌'}")tokenizer.save("bpe_tokenizer.json")print("\n🎉 BPE 算法演示完成!")print("=" * 50)print("📊 最终统计:")print(f"   - 词汇表大小: {len(tokenizer.vocab)}")print(f"   - 合并规则数: {len(tokenizer.merges)}")print(f"   - 特殊 token: {list(tokenizer.special_tokens.values())}")if __name__ == "__main__":main()

5.2 BPE 算法完整实现步骤

🎯 BPE 算法完整演示
==================================================
🔧 BPE 分词器初始化完成📥 阶段 1: 数据收集
----------------------------------------
收集到 3 条文本:1. The quick brown fox jumps over the lazy dog.2. I love machine learning and natural language processing.3. This is an example text for BPE training.📚 阶段 2: 构建初始词汇表
----------------------------------------
预处理后的语料库:1. the </w> quick </w> brown </w> fox </w> jumps </w> over </w> the </w> lazy </w> dog </w>2. i </w> love </w> machine </w> learning </w> and </w> natural </w> language </w> processing </w>3. this </w> is </w> an </w> example </w> text </w> for </w> bpe </w> training </w>初始词汇表大小: 251. '</w>' : 252. 't h e' : 23. 'q u i c k' : 14. 'b r o w n' : 15. 'f o x' : 16. 'j u m p s' : 17. 'o v e r' : 18. 'l a z y' : 19. 'd o g' : 110. 'i' : 1🏋️ 阶段 3: BPE 训练
----------------------------------------
计划执行 15 次合并
初始词汇表大小: 25合并步骤 1:最佳符号对: ('i', 'n') → 'in' (频率: 5)词汇表变化: 25 → 25合并步骤 2:最佳符号对: ('t', 'h') → 'th' (频率: 3)词汇表变化: 25 → 25合并步骤 3:最佳符号对: ('in', 'g') → 'ing' (频率: 3)词汇表变化: 25 → 25合并步骤 4:最佳符号对: ('a', 'n') → 'an' (频率: 3)词汇表变化: 25 → 25合并步骤 5:最佳符号对: ('th', 'e') → 'the' (频率: 2)词汇表变化: 25 → 25合并步骤 6:最佳符号对: ('r', 'o') → 'ro' (频率: 2)词汇表变化: 25 → 25合并步骤 7:最佳符号对: ('f', 'o') → 'fo' (频率: 2)词汇表变化: 25 → 25合并步骤 8:最佳符号对: ('m', 'p') → 'mp' (频率: 2)词汇表变化: 25 → 25合并步骤 9:最佳符号对: ('o', 'v') → 'ov' (频率: 2)词汇表变化: 25 → 25合并步骤 10:最佳符号对: ('ov', 'e') → 'ove' (频率: 2)词汇表变化: 25 → 25合并步骤 11:最佳符号对: ('l', 'e') → 'le' (频率: 2)词汇表变化: 25 → 25合并步骤 12:最佳符号对: ('r', 'a') → 'ra' (频率: 2)词汇表变化: 25 → 25合并步骤 13:最佳符号对: ('i', 's') → 'is' (频率: 2)词汇表变化: 25 → 25合并步骤 14:最佳符号对: ('e', 'x') → 'ex' (频率: 2)词汇表变化: 25 → 25合并步骤 15:最佳符号对: ('q', 'u') → 'qu' (频率: 1)词汇表变化: 25 → 25训练完成! 学习到 15 条合并规则📖 阶段 4: 构建最终词汇表
----------------------------------------
添加特殊 token: '<pad>' → ID 0
添加特殊 token: '<unk>' → ID 1
添加特殊 token: '<bos>' → ID 2
添加特殊 token: '<eos>' → ID 3
添加字符 token: '</w>' → ID 4
添加字符 token: 'a' → ID 5
添加字符 token: 'b' → ID 6
添加字符 token: 'c' → ID 7
添加字符 token: 'd' → ID 8
添加字符 token: 'e' → ID 9
添加字符 token: 'f' → ID 10
添加字符 token: 'g' → ID 11
添加字符 token: 'h' → ID 12
添加字符 token: 'i' → ID 13
添加字符 token: 'j' → ID 14
添加字符 token: 'k' → ID 15
添加字符 token: 'l' → ID 16
添加字符 token: 'm' → ID 17
添加字符 token: 'n' → ID 18
添加字符 token: 'o' → ID 19
添加字符 token: 'p' → ID 20
添加字符 token: 'q' → ID 21
添加字符 token: 'r' → ID 22
添加字符 token: 's' → ID 23
添加字符 token: 't' → ID 24
添加字符 token: 'u' → ID 25
添加字符 token: 'v' → ID 26
添加字符 token: 'w' → ID 27
添加字符 token: 'x' → ID 28
添加字符 token: 'y' → ID 29
添加字符 token: 'z' → ID 30
添加合并 token: 'in' → ID 31 (频率: 5)
添加合并 token: 'th' → ID 32 (频率: 3)
添加合并 token: 'ing' → ID 33 (频率: 3)
添加合并 token: 'an' → ID 34 (频率: 3)
添加合并 token: 'the' → ID 35 (频率: 2)
添加合并 token: 'ro' → ID 36 (频率: 2)
添加合并 token: 'fo' → ID 37 (频率: 2)
添加合并 token: 'mp' → ID 38 (频率: 2)
添加合并 token: 'ov' → ID 39 (频率: 2)
添加合并 token: 'ove' → ID 40 (频率: 2)
添加合并 token: 'le' → ID 41 (频率: 2)
添加合并 token: 'ra' → ID 42 (频率: 2)
添加合并 token: 'is' → ID 43 (频率: 2)
添加合并 token: 'ex' → ID 44 (频率: 2)
添加合并 token: 'qu' → ID 45 (频率: 1)最终词汇表大小: 46🎯 阶段 5: 编码解码演示
----------------------------------------处理文本: 'the quick brown fox'🔄 编码文本: 'the quick brown fox'
预处理后: 'the quick brown fox'
分词: ['the', 'quick', 'brown', 'fox']'the' → ['the', '</w>']'quick' → ['qu', 'i', 'c', 'k', '</w>']'brown' → ['b', 'ro', 'w', 'n', '</w>']'fox' → ['fo', 'x', '</w>']
最终 token IDs: [35, 4, 45, 13, 7, 15, 4, 6, 36, 27, 18, 4, 37, 28, 4]
压缩率: 19/15 = 1.27🔄 解码 IDs: [35, 4, 45, 13, 7, 15, 4, 6, 36, 27, 18, 4, 37, 28, 4]
Tokens: ['the', '</w>', 'qu', 'i', 'c', 'k', '</w>', 'b', 'ro', 'w', 'n', '</w>', 'fo', 'x', '</w>']
重建文本: 'the quick brown fox'
编码解码一致性: ✅处理文本: 'machine learning'🔄 编码文本: 'machine learning'
预处理后: 'machine learning'
分词: ['machine', 'learning']'machine' → ['m', 'a', 'c', 'h', 'in', 'e', '</w>']'learning' → ['le', 'a', 'r', 'n', 'ing', '</w>']
最终 token IDs: [17, 5, 7, 12, 31, 9, 4, 41, 5, 22, 18, 33, 4]
压缩率: 16/13 = 1.23🔄 解码 IDs: [17, 5, 7, 12, 31, 9, 4, 41, 5, 22, 18, 33, 4]
Tokens: ['m', 'a', 'c', 'h', 'in', 'e', '</w>', 'le', 'a', 'r', 'n', 'ing', '</w>']
重建文本: 'machine learning'
编码解码一致性: ✅处理文本: 'hello world'🔄 编码文本: 'hello world'
预处理后: 'hello world'
分词: ['hello', 'world']'hello' → ['h', 'e', 'l', 'l', 'o', '</w>']'world' → ['w', 'o', 'r', 'l', 'd', '</w>']
最终 token IDs: [12, 9, 16, 16, 19, 4, 27, 19, 22, 16, 8, 4]
压缩率: 11/12 = 0.92🔄 解码 IDs: [12, 9, 16, 16, 19, 4, 27, 19, 22, 16, 8, 4]
Tokens: ['h', 'e', 'l', 'l', 'o', '</w>', 'w', 'o', 'r', 'l', 'd', '</w>']
重建文本: 'hello world'
编码解码一致性: ✅
分词器已保存到: bpe_tokenizer.json🎉 BPE 算法演示完成!
==================================================
📊 最终统计:- 词汇表大小: 46- 合并规则数: 15- 特殊 token: ['<pad>', '<unk>', '<bos>', '<eos>']