update ch05
This commit is contained in:
KMnO4-zx
@@ -1,157 +1,266 @@
|
||||
# 5.3 预训练一个小型LLM
|
||||
|
||||
在前面的章节中，我们熟悉了各种大模型的模型结构，以及如如何训练Tokenizer。在本节中，我们将动手训练一个小型的LLM。
|
||||
在前面的章节中，我们熟悉了各种大模型的模型结构，以及如如何训练Tokenizer。在本节中，我们将动手训练一个八千万参数的LLM。
|
||||
|
||||
## 5.3.1 训练Tokenizer
|
||||
## 5.3.0 数据下载
|
||||
|
||||
首先，我们需要为文本处理训练一个Tokenizer。Tokenizer的作用是将文本转换为数字序列，以便模型能够理解和处理。我们使用的数据集是 [TinyStory](https://www.modelscope.cn/datasets/AI-ModelScope/TinyStories) ，它是一个由GPT-3.5和GPT-4生成的小型故事数据集，包含简短的故事，且词汇量有限。在这个任务中，我们采用字符级Tokenizer，将文本中的每个字符映射为对应的数字。通过以下命令可以下载数据集并训练Tokenizer。
|
||||
训练模型首先需要找到训练的数据
|
||||
|
||||
```python
|
||||
# 下载预训练数据集
|
||||
os.system("modelscope download --dataset ddzhu123/seq-monkey mobvoi_seq_monkey_general_open_corpus.jsonl.tar.bz2 --local_dir your_local_dir")
|
||||
# 解压预训练数据集
|
||||
os.system("tar -xvf your_local_dir/mobvoi_seq_monkey_general_open_corpus.jsonl.tar.bz2")
|
||||
|
||||
# 下载SFT数据集
|
||||
os.system(f'huggingface-cli download --repo-type dataset --resume-download BelleGroup/train_3.5M_CN --local-dir BelleGroup')
|
||||
|
||||
|
||||
|
||||
# 1 处理预训练数据
|
||||
def split_text(text, chunk_size=512):
|
||||
"""将文本按指定长度切分成块"""
|
||||
return [text[i:i+chunk_size] for i in range(0, len(text), chunk_size)]
|
||||
|
||||
input_file = 'mobvoi_seq_monkey_general_open_corpus.jsonl'
|
||||
|
||||
with open('seq_monkey_datawhale.jsonl', 'a', encoding='utf-8') as pretrain:
|
||||
with open(input_file, 'r', encoding='utf-8') as f:
|
||||
data = f.readlines()
|
||||
for line in tqdm(data, desc=f"Processing lines in {input_file}", leave=False): # 添加行级别的进度条
|
||||
line = json.loads(line)
|
||||
text = line['text']
|
||||
chunks = split_text(text)
|
||||
for chunk in chunks:
|
||||
pretrain.write(json.dumps({'text': chunk}, ensure_ascii=False) + '\n')
|
||||
|
||||
# 2 处理SFT数据
|
||||
|
||||
def convert_message(data):
|
||||
"""
|
||||
将原始数据转换为标准格式
|
||||
"""
|
||||
message = [
|
||||
{"role": "system", "content": "你是一个AI助手"},
|
||||
]
|
||||
for item in data:
|
||||
if item['from'] == 'human':
|
||||
message.append({'role': 'user', 'content': item['value']})
|
||||
elif item['from'] == 'assistant':
|
||||
message.append({'role': 'assistant', 'content': item['value']})
|
||||
return message
|
||||
|
||||
with open('BelleGroup_sft.jsonl', 'a', encoding='utf-8') as sft:
|
||||
with open('BelleGroup/train_3.5M_CN.json', 'r') as f:
|
||||
data = f.readlines()
|
||||
for item in tqdm(data, desc="Processing", unit="lines"):
|
||||
item = json.loads(item)
|
||||
message = convert_message(item['conversations'])
|
||||
sft.write(json.dumps(message, ensure_ascii=False) + '\n')
|
||||
```
|
||||
|
||||
## 5.3.1 训练Tokenize
|
||||
|
||||
首先，我们需要为文本处理训练一个Tokenizer。Tokenizer的作用是将文本转换为数字序列，以便模型能够理解和处理。我们使用的数据集是 [出门问问序列猴子开源数据集](https://www.modelscope.cn/datasets/ddzhu123/seq-monkey/files) ，来自网页、百科、博客、问答、开源代码、书籍、报刊、专利、教材、考题等多种公开可获取的数据进行汇总清洗之后而形成的大语言模型预训练语料。它将不同来源的HTML、TEXT、PDF、EPUB等各类格式的数据统一整理为JSONL格式，并进行了仔细的筛选、去重、清洗和价值对齐，从而形成了一份覆盖全面、规模庞大、安全可信、质量上乘的预训练语料，具备处理细致、价值对齐、简洁易用等特点。
|
||||
|
||||
> 注：由于数据集较大，如果大家在自己本地电脑训练的话进度比较慢，所以在这里我们提供了一个已经训练好的Tokenizer，大家可以直接使用。如果大家想要自己训练的话，可以参考下面的代码。
|
||||
|
||||
```bash
|
||||
python train_vocab.py --download True --vocab_size 4096
|
||||
python code/train_tokenizer.py
|
||||
|
||||
```
|
||||
|
||||
LLaMA2 的词表大小为 32,000，但由于 TinyStory 数据集较小，词汇量有限，我们将词表大小设置为 4,096。训练完成后，我们得到的 Tokenizer 能够将文本转换为数字序列，也可以将数字序列还原为文本。
|
||||
|
||||
```python
|
||||
def download_file(url: str, fname: str, chunk_size=1024):
|
||||
"""发送HTTP GET请求以流式方式获取文件"""
|
||||
···
|
||||
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
|
||||
|
||||
def download():
|
||||
"""执行 download_file 下载数据集"""
|
||||
···
|
||||
random.seed(42)
|
||||
|
||||
def train_vocab(vocab_size: int=32000, num_shards: int=20):
|
||||
"""
|
||||
vocab_size: int, 词汇表的大小，决定分词器的词汇量。
|
||||
num_shards: int, 用于加快词汇表训练的效率，指定要处理的分片数量。
|
||||
"""
|
||||
# 确保词汇表大小为正数
|
||||
assert vocab_size > 0, "Vocab size must be positive"
|
||||
def read_texts_from_jsonl(file_path: str) -> Generator[str, None, None]:
|
||||
"""读取JSONL文件并安全提取文本数据"""
|
||||
with open(file_path, 'r', encoding='utf-8') as f:
|
||||
for line_num, line in enumerate(f, 1):
|
||||
try:
|
||||
data = json.loads(line)
|
||||
if 'text' not in data:
|
||||
raise KeyError(f"Missing 'text' field in line {line_num}")
|
||||
yield data['text']
|
||||
except json.JSONDecodeError:
|
||||
print(f"Error decoding JSON in line {line_num}")
|
||||
continue
|
||||
except KeyError as e:
|
||||
print(e)
|
||||
continue
|
||||
|
||||
# SentencePiece 模型的前缀路径，将用于保存分词器
|
||||
prefix = os.path.join(DATA_CACHE_DIR, f"tok{vocab_size}")
|
||||
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 %}"
|
||||
)
|
||||
}
|
||||
|
||||
# 1) 将多个分片中的文本导出为单个文本文件 tiny.txt
|
||||
tiny_file = os.path.join(DATA_CACHE_DIR, "tiny.txt")
|
||||
data_dir = os.path.join(DATA_CACHE_DIR, "TinyStories_all_data")
|
||||
shard_filenames = sorted(glob.glob(os.path.join(data_dir, "*.json")))
|
||||
# 保存主配置文件
|
||||
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)
|
||||
|
||||
# 创建 tiny.txt 文件并写入指定数量的分片中的文本
|
||||
print(f"Writing temporary file {tiny_file} with {num_shards} shards...")
|
||||
with open(tiny_file, "w", encoding="utf-8") as of:
|
||||
# 遍历前 num_shards 个分片
|
||||
for shard in tqdm(shard_filenames[:num_shards]):
|
||||
with open(shard, "r") as f:
|
||||
data = json.load(f) # 读取分片中的JSON数据
|
||||
# 遍历每个例子，将其中的故事文本写入 tiny.txt 文件
|
||||
for example in data:
|
||||
text = example["story"]
|
||||
text = text.strip() # 去除文本首尾的空白字符
|
||||
of.write(text + "\n") # 每个文本写入一行
|
||||
# 创建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)
|
||||
|
||||
# 输出生成的 tiny.txt 文件的大小
|
||||
print(f"Size is: {os.path.getsize(tiny_file) / 1024 / 1024:.2f} MB")
|
||||
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()
|
||||
|
||||
# 2) 使用 SentencePiece 训练分词器
|
||||
print("Will now train the vocab...")
|
||||
spm.SentencePieceTrainer.train(
|
||||
input=tiny_file, # 输入文件为之前生成的 tiny.txt
|
||||
model_prefix=prefix, # 模型前缀路径
|
||||
model_type="bpe", # 使用 Byte-Pair Encoding (BPE) 训练分词器
|
||||
vocab_size=vocab_size, # 词汇表大小
|
||||
self_test_sample_size=0, # 自测样本大小设置为 0
|
||||
input_format="text", # 输入文件格式为纯文本
|
||||
character_coverage=1.0, # 覆盖所有字符（包括非常见字符）
|
||||
num_threads=os.cpu_count(), # 使用 CPU 的线程数
|
||||
split_digits=True, # 拆分数字
|
||||
allow_whitespace_only_pieces=True, # 允许仅由空格组成的词元
|
||||
byte_fallback=True, # 启用字节级回退
|
||||
unk_surface=r" \342\201\207 ", # UNK token 表示未知字符的方式
|
||||
normalization_rule_name="identity" # 使用“identity”归一化规则
|
||||
# 配置特殊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()
|
||||
)
|
||||
|
||||
# 3) 可选的清理操作，询问用户是否删除临时文件 tiny.txt
|
||||
dec = input(f"Delete the temporary file {tiny_file}? [y/N] ")
|
||||
if dec.lower() == "y":
|
||||
os.remove(tiny_file) # 删除临时文件
|
||||
print(f"Deleted {tiny_file}")
|
||||
# 训练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))
|
||||
|
||||
# 输出模型保存的路径
|
||||
print(f"Trained tokenizer is in {prefix}.model")
|
||||
print("Done.")
|
||||
```
|
||||
# 验证特殊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
|
||||
|
||||
在本部分中，我们使用了 `SentencePiece` 库来训练自定义的 `Tokenizer`。首先，我们需要从 `TinyStory` 数据集中提取文本内容，作为训练的输入数据。`SentencePiece` 是一种基于子词单元的分词算法，能够有效处理不同语言中的词汇碎片化问题。
|
||||
# 保存tokenizer文件
|
||||
tokenizer.save(os.path.join(save_dir, "tokenizer.json"))
|
||||
|
||||
# 创建配置文件
|
||||
create_tokenizer_config(save_dir)
|
||||
print(f"Tokenizer saved to {save_dir}")
|
||||
|
||||
训练 `Tokenizer` 时，`SentencePiece` 会自动生成两个文件：`tok4096.model` 和 `tok4096.vocab`，其中 `tok4096.model` 是我们训练好的模型文件，位于 `data` 目录下。这个文件可以用于将文本数据转换为 `Token` 序列，也可以将 `Token` 序列还原为文本。
|
||||
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
|
||||
|
||||
为了更便捷地使用这个 `Tokenizer`，我们还在 `tokenizer.py` 文件中定义了一个 `Tokenizer` 类。这个类封装了 `Tokenizer` 的常用操作，例如文本编码和解码功能，并支持加载我们训练好的模型文件。通过这个类，我们可以轻松地将文本转换为模型可接受的数字序列，或将预测结果转化为可读的文本。
|
||||
# 测试基本属性
|
||||
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}")
|
||||
|
||||
具体的代码实现和细节可以在 `tokenizer.py` 文件中找到，接下来我们将进一步展示如何使用该类来处理 `TinyStory` 数据集中的故事文本。
|
||||
# 测试聊天模板
|
||||
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="")
|
||||
|
||||
```python
|
||||
class Tokenizer:
|
||||
def __init__(self, tokenizer_model=None):
|
||||
"""
|
||||
初始化分词器。加载预训练的SentencePiece模型，并设置一些特殊的token ID。
|
||||
# 测试编码解码
|
||||
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)
|
||||
|
||||
参数:
|
||||
tokenizer_model: str, 可选，分词器模型的路径，如果不指定则使用默认路径 TOKENIZER_MODEL。
|
||||
"""
|
||||
# 如果提供了分词器模型路径，使用该路径；否则使用默认模型路径
|
||||
model_path = tokenizer_model if tokenizer_model else TOKENIZER_MODEL
|
||||
# 确保模型文件存在
|
||||
assert os.path.isfile(model_path), model_path
|
||||
# 测试特殊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)
|
||||
|
||||
# 加载 SentencePiece 模型
|
||||
self.sp_model = SentencePieceProcessor(model_file=model_path)
|
||||
self.model_path = model_path
|
||||
def main():
|
||||
# 配置路径
|
||||
data_path = "your data path"
|
||||
save_dir = "tokenizer_k"
|
||||
|
||||
# 获取分词器的特殊token和词汇表大小
|
||||
self.n_words: int = self.sp_model.vocab_size() # 词汇表大小
|
||||
self.bos_id: int = self.sp_model.bos_id() # 句子开头 (BOS) 的ID
|
||||
self.eos_id: int = self.sp_model.eos_id() # 句子结尾 (EOS) 的ID
|
||||
self.pad_id: int = self.sp_model.pad_id() # 填充 (PAD) 的ID
|
||||
# 训练tokenizer
|
||||
train_tokenizer(
|
||||
data_path=data_path,
|
||||
save_dir=save_dir,
|
||||
vocab_size=6144
|
||||
)
|
||||
|
||||
# 验证分词器词汇表大小是否正确
|
||||
assert self.sp_model.vocab_size() == self.sp_model.get_piece_size()
|
||||
# 评估tokenizer
|
||||
eval_tokenizer(save_dir)
|
||||
|
||||
def encode(self, s: str, bos: bool, eos: bool) -> List[int]:
|
||||
"""
|
||||
将字符串编码为词元ID列表。可以选择是否添加句子开头 (BOS) 和句子结尾 (EOS) 标记。
|
||||
|
||||
参数:
|
||||
s: str, 要编码的字符串。
|
||||
bos: bool, 是否在编码的词元列表前添加 BOS 标记。
|
||||
eos: bool, 是否在编码的词元列表末尾添加 EOS 标记。
|
||||
|
||||
返回:
|
||||
List[int]: 编码后的词元ID列表。
|
||||
"""
|
||||
# 确保输入是字符串类型
|
||||
assert type(s) is str
|
||||
# 使用SentencePiece将字符串编码为词元ID
|
||||
t = self.sp_model.encode(s)
|
||||
# 如果需要BOS标记，将其添加到词元列表开头
|
||||
if bos:
|
||||
t = [self.bos_id] + t
|
||||
# 如果需要EOS标记，将其添加到词元列表末尾
|
||||
if eos:
|
||||
t = t + [self.eos_id]
|
||||
return t
|
||||
|
||||
def decode(self, t: List[int]) -> str:
|
||||
"""
|
||||
将词元ID列表解码为字符串。
|
||||
|
||||
参数:
|
||||
t: List[int], 词元ID列表。
|
||||
|
||||
返回:
|
||||
str: 解码后的字符串。s
|
||||
"""
|
||||
return self.sp_model.decode(t)
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
```
|
||||
|
||||
在这个 `Tokenizer` 类中，我们首先初始化了一些特殊的 token ID，这些特殊 tokens 在自然语言处理任务中有着重要作用，分别用于填充、处理未识别的词汇、表示句子的开头和结尾等。在模型训练和推理过程中，正确处理这些特殊 tokens 对于提升模型性能至关重要。
|
||||
|
||||
Reference in New Issue
Block a user