338 lines
14 KiB
Markdown
338 lines
14 KiB
Markdown
# 5.2 训练 Tokenizer
|
||
|
||
在自然语言处理 (NLP) 中，Tokenizer 是一种将文本分解为较小单位（称为 token）的工具。这些 token 可以是词、子词、字符，甚至是特定的符号。Tokenization 是 NLP 中的第一步，直接影响后续处理和分析的效果。不同类型的 tokenizer 适用于不同的应用场景，以下是几种常见的 tokenizer 及其特点。
|
||
|
||
## 5.3.1 Word-based Tokenizer
|
||
|
||
**Word-based Tokenizer** 是最简单和直观的一种分词方法。它将文本按空格和标点符号分割成单词。这种方法的优点在于其简单和直接，易于实现，且与人类对语言的直觉相符。然而，它也存在一些明显的缺点，如无法处理未登录词（OOV，out-of-vocabulary）和罕见词，对复合词（如“New York”）或缩略词（如“don't”）的处理也不够精细。此外，Word-based Tokenizer 在处理不同语言时也会遇到挑战，因为一些语言（如中文、日文）没有显式的单词分隔符。
|
||
|
||
示例：
|
||
```
|
||
Input: "Hello, world! There is Datawhale."
|
||
Output: ["Hello", ",", "world", "!", "There", "is", "Datawhale", "."]
|
||
```
|
||
|
||
在这个例子中，输入的句子被分割成一系列单词和标点符号，每个单词或标点符号都作为一个独立的 token。
|
||
|
||
## 5.2.2 Character-based Tokenizer
|
||
|
||
**Character-based Tokenizer** 将文本中的每个字符视为一个独立的 token。这种方法能非常精细地处理文本，适用于处理拼写错误、未登录词或新词。由于每个字符都是一个独立的 token，因此这种方法可以捕捉到非常细微的语言特征。这对于一些特定的应用场景，如生成式任务或需要处理大量未登录词的任务，特别有用。但是，这种方法也会导致 token 序列变得非常长，增加了模型的计算复杂度和训练时间。此外，字符级的分割可能会丢失一些词级别的语义信息，使得模型难以理解上下文。
|
||
|
||
示例：
|
||
```
|
||
Input: "Hello"
|
||
Output: ["H", "e", "l", "l", "o"]
|
||
```
|
||
|
||
在这个例子中，单词“Hello”被分割成单个字符，每个字符作为一个独立的 token。这种方法能够处理任何语言和字符集，具有极大的灵活性。
|
||
|
||
## 5.2.3 Subword Tokenizer
|
||
|
||
**Subword Tokenizer** 介于词和字符之间，能够更好地平衡分词的细粒度和处理未登录词的能力。Subword Tokenizer 的关键思想是将文本分割成比单词更小的单位，但又比字符更大，这样既能处理未知词，又能保持一定的语义信息。常见的子词分词方法包括 BPE、WordPiece 和 Unigram。
|
||
|
||
### （1）Byte Pair Encoding (BPE)
|
||
|
||
**BPE** 是一种基于统计方法，通过反复合并频率最高的字符或字符序列对来生成子词词典。这种方法的优点在于其简单和高效，能够有效地处理未知词和罕见词，同时保持较低的词典大小。BPE 的合并过程是自底向上的，逐步将频率最高的字符对合并成新的子词，直到达到预定的词典大小或不再有高频的字符对。
|
||
|
||
示例：
|
||
```
|
||
Input: "lower"
|
||
Output: ["low", "er"]
|
||
|
||
Input: "newest"
|
||
Output: ["new", "est"]
|
||
```
|
||
|
||
在这个例子中，单词“lower”被分割成子词“low”和“er”，而“newest”被分割成“new”和“est”。这种方法有效地处理了词干和词缀，保持了单词的基本语义结构。
|
||
|
||
### （2）WordPiece
|
||
|
||
**WordPiece** 是另一种基于子词的分词方法，最初用于谷歌的 BERT 模型。与 BPE 类似，WordPiece 通过最大化子词序列的似然函数来生成词典，但在合并子词时更注重语言模型的优化。WordPiece 会优先选择能够最大化整体句子概率的子词，使得分词结果在语言模型中具有更高的概率。
|
||
|
||
示例：
|
||
```
|
||
Input: "unhappiness"
|
||
Output: ["un", "##happiness"]
|
||
```
|
||
|
||
在这个例子中，单词“unhappiness”被分割成子词“un”和“##happiness”，其中“##”表示这是一个后缀子词。通过这种方式，WordPiece 能够更好地处理复合词和派生词，保留更多的语义信息。
|
||
|
||
### （3）Unigram
|
||
|
||
**Unigram** 分词方法基于概率模型，通过选择具有最高概率的子词来分割文本。Unigram 词典是通过训练语言模型生成的，可以处理多种语言和不同类型的文本。Unigram 模型会为每个子词分配一个概率，然后根据这些概率进行最优分割。
|
||
|
||
示例：
|
||
```
|
||
Input: "unhappiness"
|
||
Output: ["un", "happiness"]
|
||
|
||
Input: "newest"
|
||
Output: ["new", "est"]
|
||
```
|
||
|
||
在这个例子中，单词“unhappiness”被分割成子词“un”和“happiness”，而“newest”被分割成“new”和“est”。这种方法通过概率模型有效地处理了子词分割，使得分割结果更符合语言使用习惯。
|
||
|
||
每种 Tokenizer 方法都有其特定的应用场景和优缺点，选择适合的 Tokenizer 对于自然语言处理任务的成功至关重要。
|
||
|
||
## 5.2.4 训练一个 Tokenizer
|
||
|
||
这里我们选择使用 BPE 算法来训练一个 Subword Tokenizer。BPE 是一种简单而有效的分词方法，能够处理未登录词和罕见词，同时保持较小的词典大小。我们将使用 Hugging Face 的 `tokenizers` 库来训练一个 BPE Tokenizer。
|
||
|
||
|
||
### Step 1: 安装和导入依赖库
|
||
|
||
首先，我们需要安装 `tokenizers` 库，除此之外还需要安装 `datasets` 和 `transformers` 库，用于加载训练数据和加载训练完成后的 Tokenizer。
|
||
|
||
```bash
|
||
pip install tokenizers datasets transformers
|
||
```
|
||
|
||
然后，导入所需的库。
|
||
|
||
```python
|
||
import random
|
||
import json
|
||
import os
|
||
from transformers import AutoTokenizer, PreTrainedTokenizerFast
|
||
from tokenizers import (
|
||
decoders,
|
||
models,
|
||
pre_tokenizers,
|
||
trainers,
|
||
Tokenizer,
|
||
)
|
||
from tokenizers.normalizers import NFKC
|
||
from typing import Generator
|
||
```
|
||
|
||
### Step 2: 加载训练数据
|
||
|
||
我们使用 `datasets.load_dataset()` 库加载一个英文文本数据集，用于训练 BPE Tokenizer。这里我们使用 `wikitext` 数据集，包含了维基百科的文章文本。
|
||
|
||
```python
|
||
dataset = load_dataset("wikitext", "wikitext-103-v1", split="train")
|
||
|
||
# 准备训练数据
|
||
def batch_iterator(batch_size=1000):
|
||
for i in range(0, len(dataset), batch_size):
|
||
yield dataset[i:i + batch_size]["text"]
|
||
```
|
||
|
||
如果你使用本地的文本数据集，可以将数据加载到一个列表中，然后传入 `batch_iterator()` 函数中。如下所示：
|
||
|
||
```python
|
||
def load_text_from_files(path_list):
|
||
text_data = []
|
||
for file_path in path_list:
|
||
with open(file_path, 'r', encoding='utf-8') as file:
|
||
text_data.extend(file.readlines())
|
||
return text_data
|
||
|
||
def batch_iterator(text_data, batch_size=1000):
|
||
for i in range(0, len(text_data), batch_size):
|
||
yield text_data[i:i + batch_size]
|
||
|
||
# 假设你的文件路径列表是
|
||
path_list = ['text_data1.txt', 'text_data2.txt', 'text_data3.txt']
|
||
text_data = load_text_from_files(path_list)
|
||
```
|
||
|
||
### Step 3: 创建配置文件
|
||
|
||
在训练 BPE Tokenizer 之前，我们需要创建一个完整的 `Tokenizer` 配置文件，包括 `tokenizer_config.json` 和 `special_tokens_map.json`。这些配置文件定义了 `Tokenizer` 的参数和特殊标记，用于训练和加载 `Tokenizer`。此处的`chat_template`我们与`Qwen2.5`模型保持一致。
|
||
|
||
```python
|
||
def create_tokenizer_config(save_dir: str) -> None:
|
||
"""创建完整的tokenizer配置文件"""
|
||
config = {
|
||
"add_bos_token": False,
|
||
"add_eos_token": False,
|
||
"add_prefix_space": True,
|
||
"bos_token": "<|im_start|>",
|
||
"eos_token": "<|im_end|>",
|
||
"pad_token": "<|im_end|>",
|
||
"unk_token": "<unk>",
|
||
"model_max_length": 1000000000000000019884624838656,
|
||
"clean_up_tokenization_spaces": False,
|
||
"tokenizer_class": "PreTrainedTokenizerFast",
|
||
"chat_template": (
|
||
"{% for message in messages %}"
|
||
"{% if message['role'] == 'system' %}"
|
||
"<|im_start|>system\n{{ message['content'] }}<|im_end|>\n"
|
||
"{% elif message['role'] == 'user' %}"
|
||
"<|im_start|>user\n{{ message['content'] }}<|im_end|>\n"
|
||
"{% elif message['role'] == 'assistant' %}"
|
||
"<|im_start|>assistant\n{{ message['content'] }}<|im_end|>\n"
|
||
"{% endif %}"
|
||
"{% endfor %}"
|
||
"{% if add_generation_prompt %}"
|
||
"{{ '<|im_start|>assistant\n' }}"
|
||
"{% endif %}"
|
||
)
|
||
}
|
||
|
||
# 保存主配置文件
|
||
with open(os.path.join(save_dir, "tokenizer_config.json"), "w", encoding="utf-8") as f:
|
||
json.dump(config, f, ensure_ascii=False, indent=4)
|
||
|
||
# 创建special_tokens_map.json
|
||
special_tokens_map = {
|
||
"bos_token": "<|im_start|>",
|
||
"eos_token": "<|im_end|>",
|
||
"unk_token": "<unk>",
|
||
"pad_token": "<|im_end|>",
|
||
"additional_special_tokens": ["<s>", "</s>"]
|
||
}
|
||
with open(os.path.join(save_dir, "special_tokens_map.json"), "w", encoding="utf-8") as f:
|
||
json.dump(special_tokens_map, f, ensure_ascii=False, indent=4)
|
||
```
|
||
|
||
### Step 4: 训练 BPE Tokenizer
|
||
|
||
在训练 BPE Tokenizer 之前，我们需要定义一个训练函数，用于训练 Tokenizer 并保存训练好的 Tokenizer 文件。这里我们使用 `tokenizers` 库中的 `Tokenizer` 类来训练 BPE Tokenizer。
|
||
|
||
可以看到我们在训练 Tokenizer 时，配置了一些特殊的 token，如 `<unk>`、`<s>`、`</s>`、`<|im_start|>` 和 `<|im_end|>`。这些 token 用于标记未知词、句子的开始和结束，以及对话的开始和结束。这些特殊 token 可以帮助模型更好地理解文本数据，提高模型的泛化能力和效果。
|
||
|
||
```python
|
||
def train_tokenizer(data_path: str, save_dir: str, vocab_size: int = 8192) -> None:
|
||
"""训练并保存自定义tokenizer"""
|
||
os.makedirs(save_dir, exist_ok=True)
|
||
|
||
# 初始化tokenizer
|
||
tokenizer = Tokenizer(models.BPE(unk_token="<unk>"))
|
||
tokenizer.normalizer = NFKC() # 添加文本规范化
|
||
tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=False)
|
||
tokenizer.decoder = decoders.ByteLevel()
|
||
|
||
# 配置特殊token
|
||
special_tokens = [
|
||
"<unk>",
|
||
"<s>",
|
||
"</s>",
|
||
"<|im_start|>",
|
||
"<|im_end|>"
|
||
]
|
||
|
||
# 配置训练器
|
||
trainer = trainers.BpeTrainer(
|
||
vocab_size=vocab_size,
|
||
special_tokens=special_tokens,
|
||
min_frequency=2, # 提高低频词过滤
|
||
show_progress=True,
|
||
initial_alphabet=pre_tokenizers.ByteLevel.alphabet()
|
||
)
|
||
|
||
# 训练tokenizer
|
||
print(f"Training tokenizer with data from {data_path}")
|
||
texts = read_texts_from_jsonl(data_path)
|
||
tokenizer.train_from_iterator(texts, trainer=trainer, length=os.path.getsize(data_path))
|
||
|
||
# 验证特殊token映射
|
||
try:
|
||
assert tokenizer.token_to_id("<unk>") == 0
|
||
assert tokenizer.token_to_id("<s>") == 1
|
||
assert tokenizer.token_to_id("</s>") == 2
|
||
assert tokenizer.token_to_id("<|im_start|>") == 3
|
||
assert tokenizer.token_to_id("<|im_end|>") == 4
|
||
except AssertionError as e:
|
||
print("Special tokens mapping error:", e)
|
||
raise
|
||
|
||
# 保存tokenizer文件
|
||
tokenizer.save(os.path.join(save_dir, "tokenizer.json"))
|
||
|
||
# 创建配置文件
|
||
create_tokenizer_config(save_dir)
|
||
print(f"Tokenizer saved to {save_dir}")
|
||
```
|
||
|
||
|
||
### Step 5: 使用训练好的 Tokenizer
|
||
|
||
我们可以使用训练好的 Tokenizer 来处理文本数据，如编码、解码、生成对话等。下面是一个简单的示例，展示了如何使用训练好的 Tokenizer 来处理文本数据。
|
||
|
||
```python
|
||
def eval_tokenizer(tokenizer_path: str) -> None:
|
||
"""评估tokenizer功能"""
|
||
try:
|
||
tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)
|
||
except Exception as e:
|
||
print(f"Error loading tokenizer: {e}")
|
||
return
|
||
|
||
# 测试基本属性
|
||
print("\n=== Tokenizer基本信息 ===")
|
||
print(f"Vocab size: {len(tokenizer)}")
|
||
print(f"Special tokens: {tokenizer.all_special_tokens}")
|
||
print(f"Special token IDs: {tokenizer.all_special_ids}")
|
||
|
||
# 测试聊天模板
|
||
messages = [
|
||
{"role": "system", "content": "你是一个AI助手。"},
|
||
{"role": "user", "content": "How are you?"},
|
||
{"role": "assistant", "content": "I'm fine, thank you. and you?"},
|
||
{"role": "user", "content": "I'm good too."},
|
||
{"role": "assistant", "content": "That's great to hear!"},
|
||
]
|
||
|
||
print("\n=== 聊天模板测试 ===")
|
||
prompt = tokenizer.apply_chat_template(
|
||
messages,
|
||
tokenize=False,
|
||
# add_generation_prompt=True
|
||
)
|
||
print("Generated prompt:\n", prompt, sep="")
|
||
|
||
# 测试编码解码
|
||
print("\n=== 编码解码测试 ===")
|
||
encoded = tokenizer(prompt, truncation=True, max_length=256)
|
||
decoded = tokenizer.decode(encoded["input_ids"], skip_special_tokens=False)
|
||
print("Decoded text matches original:", decoded == prompt)
|
||
|
||
# 测试特殊token处理
|
||
print("\n=== 特殊token处理 ===")
|
||
test_text = "<|im_start|>user\nHello<|im_end|>"
|
||
encoded = tokenizer(test_text).input_ids
|
||
decoded = tokenizer.decode(encoded)
|
||
print(f"Original: {test_text}")
|
||
print(f"Decoded: {decoded}")
|
||
print("Special tokens preserved:", decoded == test_text)
|
||
```
|
||
|
||
```python
|
||
eval_tokenizer('your tokenizer path')
|
||
```
|
||
|
||
OUT:
|
||
```
|
||
=== Tokenizer基本信息 ===
|
||
Vocab size: 6144
|
||
Special tokens: ['<|im_start|>', '<|im_end|>', '<unk>', '<s>', '</s>']
|
||
Special token IDs: [3, 4, 0, 1, 2]
|
||
|
||
=== 聊天模板测试 ===
|
||
Generated prompt:
|
||
<|im_start|>system
|
||
你是一个AI助手。<|im_end|>
|
||
<|im_start|>user
|
||
How are you?<|im_end|>
|
||
<|im_start|>assistant
|
||
I'm fine, thank you. and you?<|im_end|>
|
||
<|im_start|>user
|
||
I'm good too.<|im_end|>
|
||
<|im_start|>assistant
|
||
That's great to hear!<|im_end|>
|
||
|
||
|
||
=== 编码解码测试 ===
|
||
Decoded text matches original: False
|
||
|
||
=== 特殊token处理 ===
|
||
Original: <|im_start|>user
|
||
Hello<|im_end|>
|
||
Decoded: <|im_start|> user
|
||
Hello<|im_end|>
|
||
Special tokens preserved: False
|
||
```
|
||
|