大模型tokenizer层再训练（选取Qwen7B试验，重构token层）
最近公司可能想训练一个蛋白质大模型，需要了解一下大模型tokenizer重构，之后可能要训练，这里做了一定的总结。
文章目录
1. 首先查看Qwen2.5 7B基本信息
✅ Tokenizer 加载成功！📌 类型: <class 'transformers.models.qwen2.tokenization_qwen2_fast.Qwen2TokenizerFast'>
📦 所使用的 tokenizer 文件: /home/liuzhao/models/Qwen/Qwen2___5-7B
🧱 词表大小（vocab size）: 151643
🔢 特殊 token id: [PAD]: <|endoftext|> -> id: 151643[BOS]: None -> id: None[EOS]: <|endoftext|> -> id: 151643[UNK]: None -> id: None🧪 示例 token 编码：
Decoded: 你好，蛋白质'ä½łå¥½' -> 108386'ï¼Į' -> 3837'èĽĭçĻ½è´¨' -> 107151
Sliding Window Attention is enabled but not implemented for `sdpa`; unexpected results may be encountered.
Loading checkpoint shards: 100%|█████████████████████████████████████████████████████████████████████████████| 4/4 [00:08<00:00, 2.00s/it]✅ 模型加载成功！
📐 Embedding 层形状: torch.Size([152064, 3584])
🔢 Embedding 参数数量: 544997376📊 模型结构摘要：
Qwen2ForCausalLM((model): Qwen2Model((embed_tokens): Embedding(152064, 3584)(layers): ModuleList((0-27): 28 x Qwen2DecoderLayer((self_attn): Qwen2Attention((q_proj): Linear(in_features=3584, out_features=3584, bias=True)(k_proj): Linear(in_features=3584, out_features=512, bias=True)(v_proj): Linear(in_features=3584, out_features=512, bias=True)(o_proj): Linear(in_features=3584, out_features=3584, bias=False))(mlp): Qwen2MLP((gate_proj): Linear(in_features=3584, out_features=18944, bias=False)(up_proj): Linear(in_features=3584, out_features=18944, bias=False)(down_proj): Linear(in_features=18944, out_features=3584, bias=False)(act_fn): SiLU())(input_layernorm): Qwen2RMSNorm((3584,), eps=1e-06)(post_attention_layernorm): Qwen2RMSNorm((3584,), eps=1e-06)))(norm): Qwen2RMSNorm((3584,), eps=1e-06)(rotary_emb): Qwen2RotaryEmbedding())(lm_head): Linear(in_features=3584, out_features=152064, bias=False)
)📦 模型总参数量: 7,615,616,512
✅ 分析结果
🔹 Tokenizer 分析：
| 项目 | 值 | 说明 |
|---|---|---|
| Tokenizer 类 | Qwen2TokenizerFast | 使用 transformers 中快速实现，基于 tokenizer.model（SentencePiece） |
| 词表大小 | 151643 | 表示 tokenizer 可用的 token 数量 |
| [PAD] token | `< | endoftext |
| [EOS] token | `< | endoftext |
| [BOS] token | None | 未定义，模型可能默认不需要 |
| [UNK] token | None | 未定义，可能使用 fallback 机制 |
| 示例编码 | token 输出乱码 | 因为使用了 byte-level BPE，按字节切分后再 BPE，token 看似乱码但是正确的 UTF-8 字节表示 |
🔹 模型结构分析：
| 项目 | 值 | 说明 |
|---|---|---|
| Embedding 大小 | [152064, 3584] | vocab size（包括 special tokens）为 152064，hidden size 为 3584 |
| 层数 | 28 | Transformer decoder 层数 |
| 隐藏维度（hidden size） | 3584 | 词向量维度，也是注意力/FFN 输入输出维度 |
| Attention 参数 | KV projection 输出维度为 512 | 使用 多头注意力 + 低秩投影（multi-query or grouped attention）优化推理速度 |
| FFN维度（MLP） | 18944 | 表示采用大容量前馈网络，约为 hidden size 的 5.3 倍 |
| LayerNorm 类型 | Qwen2RMSNorm | 自定义 RMSNorm，代替标准 LayerNorm |
| Rotary Embedding | 有 | 支持 RoPE，用于 position encoding |
| 输出层（lm_head）维度 | [3584, 152064] | 最终投影到 vocab 空间用于生成预测 |
tokenizer_89">2. 重构tokenizer整体流程
| 步骤 | 操作 | 工具/说明 |
|---|---|---|
| 1 | 准备生物医药语料（每行一个样本） | protein.txt |
| 2 | 使用 HuggingFace tokenizers 训练 tokenizer | 输出 tokenizer.json / vocab.json / tokenizer_config.json |
| 3 | 替换原模型目录中的 3 个 tokenizer 文件 | cp *.json Qwen2.5-7B/ |
| 4 | 加载 tokenizer，验证 vocab size、分词逻辑 | AutoTokenizer.from_pretrained(…, trust_remote_code=True) |
| 5 | 加载模型，并执行 resize_token_embeddings()，重构embedding以及输出层，保存模型 | 自动调整 embedding + lm_head |
| 6 | 检查 shape：model.get_input_embeddings().weight.shape 和 model.lm_head.weight.shape | 应该都是 (padded_vocab_size, hidden_size) |
2.1 步骤一：准备语料
由于现在没有语料数据，暂时构建伪数据，尝试跑通流程：
/home/liuzhao/tokenizer_construct/fack_data/protein_mock.txt
MVHLTPEEKSAVTALWGKVNVDEVGGEALGRLLVVYPWTQ
MKVIFLGAVIGTILLISYGIR
MGDVEKGKKIFIMKCSQCHTVEKGGKHKTGPNLHGLFGRK
GAVAGVAGAAAKAAAKAAAKAA
MSTAVLGVLIFVGLVGMAAWTSRI
MAAAKAAAEAAAKAKAAAEAA
MEFVHLVYFGLVKGL
MNSFEMLRILGIIAASTLSLTI
MKAVLAGLVAVGLTVLAAAGA
MGGAVILFVLIGTFTALLAG
这 10 条伪序列涵盖了常见氨基酸字母（A、V、G、L、M、K、T、S、F、E…），不包含任何非法字符，适合 BPE/ByteLevel 分词训练。
tokenizer_127">2.2 步骤二：训练 tokenizer
分词算法
分词算法（Tokenization Algorithm）就是把原始文本（如“你好”或蛋白质序列）转换成模型能理解的离散符号（token）序列的过程。
它是大模型理解输入的第一步，决定了：
• 模型看到的“词”是啥？
• 每个 token 的 ID 是多少？
• 最终 embedding 层输入长什么样？
| 分词算法 | 所属模型/特点 | 是否可训练 | 优点 | 缺点 |
|---|---|---|---|---|
| Word-level | 古早模型（Word2Vec） | ❌ 预定义词表 | 简单直观 | 无法处理新词、词表爆炸 |
| Character-level | GPT-Char、汉字模型 | ❌ 固定单字 | 不丢信息，适合小语种 | 序列过长，不压缩 |
| Byte-level | GPT2、Qwen2 | ❌ 固定每个字节 | 跨语言统一处理 | 不压缩子词关系 |
| BPE（Byte Pair Encoding） | GPT2、Qwen2、LLama | ✅ 可训练 | 平衡词频、可学习 | 初始复杂，需 merge 文件 |
| Unigram LM（SentencePiece） | T5、mT5 | ✅ 可训练 | 支持多种粒度 | 训练慢、实现复杂 |
| WordPiece | BERT | ✅ 可训练 | 词干拼接，较紧凑 | 不如 BPE 高效 |
| Tiktoken | GPT-3.5 / 4（OpenAI） | ❌ 固定预定义 | 极度高效 | 封闭，无法训练 |
✅ 举例：
🧬 你的输入语料：
MVHLTPEEKSAVTALWGK...
这是蛋白质序列，由一串大写字母组成，每个字母表示一种氨基酸。
🧩 如果用不同分词算法会变成什么？
| 分词算法 | 分词结果 | 特点 |
|---|---|---|
| Character-level | [‘M’, ‘V’, ‘H’, ‘L’, ‘T’, …] | 每个氨基酸是一个 token |
| Byte-level BPE（你现在用的） | [‘M’, ‘V’, ‘H’, ‘L’, ‘T’, ‘PE’, ‘EKS’, …] | 高频组合被合并为 token，压缩效果更好 |
| Word-level | 整句作为一个 token（不适用） | 无法处理蛋白质 |
| Tiktoken | [‘MV’, ‘HL’, ‘TP’, ‘EE’, …]（预定义） | 可能会错误分割 |
| SentencePiece（Unigram） | [‘MVHL’, ‘TP’, ‘EEKS’] | 基于语言概率构建，合并子序列更灵活 |
✅ 那么，分词算法的作用就是：
把一条「原始蛋白质序列」分解成适合模型使用的 token 序列，再将每个 token 映射成一个 ID，再送入 embedding 层中。
✅ ByteLevel BPE 有什么特别的？
ByteLevel BPE = Byte-level + BPE 合体
| 特性 | 说明 |
|---|---|
| ByteLevel | 文本按字节处理，支持各种字符集（中英文、特殊字符、符号、换行、空格） |
| BPE（可训练） | 高频子词自动 merge，词表更精简，更适合短词/序列建模 |
| 优势 | 对蛋白质这种「结构性、定长、重复性高」的字符序列特别友好 |
所以我们说：
✅ ByteLevel BPE 是当前 LLM 中最通用、兼容性最强、训练效率高的分词方法之一。
✅ 选 ByteLevel BPE 的理由：
| 原因 | 说明 |
|---|---|
| 蛋白质本身是字符序列 | 天然适合 ByteLevel |
| 子串重复率高（如 AVAVAV） | BPE merge 后可以变成一个 token，提升压缩效率 |
| 不需要复杂语义模型 | 不像自然语言，要解析句法 |
| 想替换大模型（Qwen2.5）的 tokenizer | Qwen2 就是用 ByteLevel BPE，所以兼容性满分 ✅ |
✅ 最终总结：
分词算法是模型输入的第一道大门，不同算法决定了模型“看到的单位”是词、子词、字节还是字符；而 ByteLevel BPE 是一种兼具高效、灵活、可训练的主流方法，适用于你构建蛋白质 tokenizer 的任务。
BPE流程
完整可视化 BPE 的合并（merge）过程，包括：
- 初始化状态；
- 每轮统计 + 合并；
- 最终得到词表（vocab）和合并规则（merges）。
✅ 示例文本语料：
我们用这个简单但有重复的英文短语做语料（共 4 条）：
low lower lowest lowly
🧾 Step 1：初始化为字符级 token + <\w> 结尾标记
每个词都拆成字符 + 特殊符号 表示词结束：
| 原始词 | 初始 token 序列 |
|---|---|
| low | l o w |
| lower | l o w e r |
| lowest | l o w e s t |
| lowly | l o w l y |
🔁 Step 2：统计频率最高的相邻 token 对
我们数一下所有相邻字符对出现的次数：
| Token Pair | 出现次数 |
|---|---|
| (l, o) | 4 ✅ |
| (o, w) | 4 ✅ |
| (w, ) | 1 |
| (w, e) | 2 |
| (e, r) | 1 |
| (e, s) | 1 |
| (s, t) | 1 |
| (w, l) | 1 |
| (l, y) | 1 |
🔨 Step 3：合并频次最高的 pair
我们选中 (‘l’, ‘o’) → “lo”，进行第一次 merge。
更新所有词：
| 更新后 token | 合并 |
|---|---|
| lo w | l+o ✅ |
| lo w e r | l+o ✅ |
| lo w e s t | l+o ✅ |
| lo w l y | l+o ✅ |
🔁 Step 4：继续迭代统计 + 合并
第 2 次 merge：
pair: (‘lo’, ‘w’) → “low”
更新后：
| 更新后 token |
|---|
| low |
| low e r |
| low e s t |
| low l y |
第 3 次 merge：
pair: (‘low’, ‘e’) → “lowe”
更新：
low </w>
lowe r </w>
lowe s t </w>
low l y </w>
第 4 次 merge：
pair: (‘lowe’, ‘r’) → “lower”
更新：
low </w>
lower </w>
lower s t </w>
low l y </w>
第 5 次 merge：
pair: (‘lower’, ‘s’) → “lowers”
更新：
low </w>
lower </w>
lowers t </w>
low l y </w>
第 6 次 merge：
pair: (‘lowers’, ‘t’) → “lowest”
更新：
low </w>
lower </w>
lowest </w>
low l y </w>
第 7 次 merge：
pair: (‘low’, ‘l’) → “lowl”
然后再合并 (‘lowl’, ‘y’) → “lowly”
最终分词表：
| 原词 | 最终 token 序列 |
|---|---|
| low → low | |
| lower → lower | |
| lowest → lowest | |
| lowly → lowly |
🎉 每个词都被压缩成一个 token（理想情况），这就是 BPE 的“学习高频组合”的本事。
📦 最终 vocab（词表）示意：
{"l": 0,"o": 1,"w": 2,"e": 3,"r": 4,"s": 5,"t": 6,"y": 7,"</w>": 8,"lo": 9,"low": 10,"lowe": 11,"lower": 12,"lowers": 13,"lowest": 14,"lowl": 15,"lowly": 16
}
🪄 最终 merges.txt：
l o
lo w
low e
lowe r
lower s
lowers t
low l
lowl y
每一行就是一轮 merge 的规则，按顺序合并。
🔎 总结一下流程：
| 步骤 | 说明 |
|---|---|
| 初始化 | 将词拆成字符，加词尾标记 |
| 多轮统计 + 合并 | 每轮合并出现频率最高的相邻 token |
| 构建 merges.txt | 合并记录即为 tokenizer 的“知识” |
| 应用时分词 | 遇到相同子串时就能直接编码为 token，提高效率 |
tokenizer_400">构建tokenizer
import os
import json
from tokenizers.implementations import ByteLevelBPETokenizer
from transformers import GPT2TokenizerFast# === 配置路径 ===
input_file = "/home/liuzhao/tokenizer_construct/fack_data/protein_mock.txt"
output_dir = "/home/liuzhao/tokenizer_construct/new_tokenizer"
vocab_size = 512 # 小语料建议设置小一点# === Step 1: 训练 ByteLevelBPE Tokenizer ===
tokenizer = ByteLevelBPETokenizer()# 特殊 token（你可以根据自己需求添加）
special_tokens = ["<|endoftext|>", "<unk>", "<pad>"]# 训练 tokenizer，生成 vocab.json + merges.txt
tokenizer.train(files=input_file,vocab_size=vocab_size,min_frequency=1,special_tokens=special_tokens,
)# 创建输出目录
os.makedirs(output_dir, exist_ok=True)# 保存 vocab.json / merges.txt
tokenizer.save_model(output_dir)# === Step 2: 写入 tokenizer_config.json，指定 tokenizer 类型为 GPT2 ===
tokenizer_config = {"model_type": "gpt2", # 关键！明示为 GPT2-style，避免 tiktoken 报错"unk_token": "<unk>","eos_token": "<|endoftext|>","pad_token": "<pad>"
}with open(os.path.join(output_dir, "tokenizer_config.json"), "w") as f:json.dump(tokenizer_config, f)# === Step 3: 使用 GPT2TokenizerFast 加载 + 保存 HuggingFace 格式 ===
wrapped_tokenizer = GPT2TokenizerFast.from_pretrained(output_dir)
wrapped_tokenizer.save_pretrained(output_dir)# === Step 4: 打印验证信息 ===
print(f"✅ Tokenizer 构建成功，已保存至 {output_dir}")
print(f"🧱 词表大小: {wrapped_tokenizer.vocab_size}")
print(f"🔤 示例分词: {wrapped_tokenizer.tokenize('MVHLTPEEKS')}")
输出：
(tokenizer) root@420GP-252:/home/liuzhao/tokenizer_construct# python build_tokenizer.py
[00:00:00] Pre-processing files (0 Mo) █████████████████████████████████████████████████████████████████████ 100%
[00:00:00] Tokenize words █████████████████████████████████████████████████████████████████████ 14 / 14
[00:00:00] Count pairs █████████████████████████████████████████████████████████████████████ 14 / 14
[00:00:00] Compute merges █████████████████████████████████████████████████████████████████████ 183 / 183
✅ Tokenizer 构建成功，已保存至 /home/liuzhao/tokenizer_construct/new_tokenizer
🧱 词表大小: 259
🔤 示例分词: ['M', 'V', 'H', 'L', 'T', 'P', 'E', 'E', 'K', 'S']
tokenizer__471">2.3 步骤三：替换原模型目录中的 3 个 tokenizer 文件
将生成的文件替换原来Qwen的tokenizer文件。
tokenizer_479">2.4 步骤四：加载 tokenizer，验证
# check_tokenizer_replacement.pyfrom transformers import AutoTokenizer
import os# 替换后的模型目录
tokenizer_dir = "/home/liuzhao/models/Qwen/Qwen2.5-7B-change"# 加载 tokenizer（关键：信任 remote_code）
tokenizer = AutoTokenizer.from_pretrained(tokenizer_dir,trust_remote_code=True
)# 打印基本信息
print("✅ Tokenizer 加载成功！\n")
print(f"📌 类型: {type(tokenizer)}")
print(f"📦 路径: {tokenizer.name_or_path}")
print(f"🧱 词表大小: {tokenizer.vocab_size}")# 分词验证（用你熟悉的蛋白质序列）
test_text = "MVHLTPEEKS"
tokens = tokenizer.tokenize(test_text)
token_ids = tokenizer.convert_tokens_to_ids(tokens)
decoded = tokenizer.decode(token_ids)print(f"\n🔤 分词结果: {tokens}")
print(f"🔢 Token IDs: {token_ids}")
print(f"🔁 解码还原: {decoded}")
输出：
(tokenizer) root@420GP-252:/home/liuzhao/tokenizer_construct# python check_tokenizer_replacement.py
✅ Tokenizer 加载成功！📌 类型: <class 'transformers.models.gpt2.tokenization_gpt2_fast.GPT2TokenizerFast'>
📦 路径: /home/liuzhao/models/Qwen/Qwen2.5-7B-change
🧱 词表大小: 259🔤 分词结果: ['M', 'V', 'H', 'L', 'T', 'P', 'E', 'E', 'K', 'S']
🔢 Token IDs: [47, 56, 42, 46, 54, 50, 39, 39, 45, 53]
🔁 解码还原: MVHLTPEEKS
2.5 步骤五：加载、重构、保存模型
第 5 步：模型结构调整阶段。
✅ 第五步任务总目标：
让模型结构（特别是 embedding 层和输出层 lm_head）的维度，匹配你新 tokenizer 的词表大小（vocab_size），确保 forward 时不会报错或 shape mismatch。
🎯 第五步重新拆解为 3 个子任务（建议逐步执行）：
加载模型 + 验证当前 embedding 尺寸
| 项 | 内容 |
|---|---|
| ✅ 检查当前 embedding 层 Embedding(num_embeddings, hidden_size) 的维度 | |
| ✅ 检查 lm_head 的输出维度是否一致 | |
| ✅ 打印当前 vocab_size 与 tokenizer vocab 是否对齐 |
✅ 示例输出结构检查：
print(model.model.embed_tokens.weight.shape)
print(model.lm_head.out_features)
resize_token_embeddings(new_vocab_size) 调整维度
model.resize_token_embeddings(new_vocab_size)
| 调整的内容 | 说明 |
|---|---|
| model.model.embed_tokens | embedding 层的 token 数变成新 vocab size（如 259） |
| model.lm_head | 输出维度也会同步调整（transformers 自动处理） |
tokenizer_566">保存新的模型权重 + tokenizer
• 保存为 Qwen2.5-7B-with-protein-tokenizer/
• 之后可以重新加载、微调或推理
model.save_pretrained(output_dir)
tokenizer.save_pretrained(output_dir)
resize_model_embedding.py
import os
from transformers import AutoTokenizer, AutoModelForCausalLM# === 路径配置 ===
model_path = "/home/liuzhao/models/Qwen/Qwen2.5-7B-change"
output_path = "/home/liuzhao/models/Qwen/Qwen2.5-7B-with-protein-tokenizer"# === Step 1: 加载 tokenizer 和模型 ===
print("📦 加载 tokenizer 和模型...")
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(model_path, trust_remote_code=True)print("✅ 加载完成！")
print(f"🔢 当前 tokenizer.vocab_size: {tokenizer.vocab_size}")
print(f"📐 原始 embedding 层形状: {model.model.embed_tokens.weight.shape}")
print(f"📐 原始 lm_head 输出形状: {model.lm_head.out_features}")# === Step 2: 调整 embedding 和输出层大小 ===
print("\n🔧 执行 resize_token_embeddings ...")
model.resize_token_embeddings(tokenizer.vocab_size)# 再次打印新形状
print(f"✅ 新 embedding 层形状: {model.model.embed_tokens.weight.shape}")
print(f"✅ 新 lm_head 输出形状: {model.lm_head.out_features}")# === Step 3: 保存新模型和 tokenizer ===
print(f"\n💾 保存模型和 tokenizer 到: {output_path}")
os.makedirs(output_path, exist_ok=True)
model.save_pretrained(output_path)
tokenizer.save_pretrained(output_path)print("\n🎉 完成！模型已保存并可用于推理或微调。")
输出：
(tokenizer) root@420GP-252:/home/liuzhao/tokenizer_construct# python resize_model_embedding.py
📦 加载 tokenizer 和模型...
Sliding Window Attention is enabled but not implemented for `sdpa`; unexpected results may be encountered.
Loading checkpoint shards: 100%|█████████████████████████████████████████████████████████████████████| 4/4 [00:05<00:00, 1.42s/it]
✅ 加载完成！
🔢 当前 tokenizer.vocab_size: 259
📐 原始 embedding 层形状: torch.Size([152064, 3584])
📐 原始 lm_head 输出形状: 152064🔧 执行 resize_token_embeddings ...
✅ 新 embedding 层形状: torch.Size([259, 3584])
✅ 新 lm_head 输出形状: 259💾 保存模型和 tokenizer 到: /home/liuzhao/models/Qwen/Qwen2.5-7B-with-protein-tokenizer🎉 完成！模型已保存并可用于推理或微调。
2.6 步骤六：检查
首先检查tokenizer以及模型：
✅ Tokenizer 加载成功！📌 类型: <class 'transformers.models.gpt2.tokenization_gpt2_fast.GPT2TokenizerFast'>
📦 所使用的 tokenizer 文件: /home/liuzhao/models/Qwen/Qwen2.5-7B-with-protein-tokenizer
🧱 词表大小（vocab size）: 259
🔢 特殊 token id: [PAD]: <pad> -> id: 2[BOS]: <|endoftext|> -> id: 0[EOS]: <|endoftext|> -> id: 0[UNK]: <unk> -> id: 1🧪 示例 token 编码：
Decoded: 你好，蛋白质'ä' -> 163'½' -> 124'ł' -> 257'å' -> 164'¥' -> 101'½' -> 124'ï' -> 174'¼' -> 123'Į' -> 237'è' -> 167'Ľ' -> 252'ĭ' -> 236'ç' -> 166'Ļ' -> 250'½' -> 124'è' -> 167'´' -> 115'¨' -> 104
Sliding Window Attention is enabled but not implemented for `sdpa`; unexpected results may be encountered.
Loading checkpoint shards: 100%|█████████████████████████████████████████████████████████████████████| 6/6 [00:05<00:00, 1.13it/s]✅ 模型加载成功！
📐 Embedding 层形状: torch.Size([259, 3584])
🔢 Embedding 参数数量: 928256📊 模型结构摘要：
Qwen2ForCausalLM((model): Qwen2Model((embed_tokens): Embedding(259, 3584)(layers): ModuleList((0-27): 28 x Qwen2DecoderLayer((self_attn): Qwen2Attention((q_proj): Linear(in_features=3584, out_features=3584, bias=True)(k_proj): Linear(in_features=3584, out_features=512, bias=True)(v_proj): Linear(in_features=3584, out_features=512, bias=True)(o_proj): Linear(in_features=3584, out_features=3584, bias=False))(mlp): Qwen2MLP((gate_proj): Linear(in_features=3584, out_features=18944, bias=False)(up_proj): Linear(in_features=3584, out_features=18944, bias=False)(down_proj): Linear(in_features=18944, out_features=3584, bias=False)(act_fn): SiLU())(input_layernorm): Qwen2RMSNorm((3584,), eps=1e-06)(post_attention_layernorm): Qwen2RMSNorm((3584,), eps=1e-06)))(norm): Qwen2RMSNorm((3584,), eps=1e-06)(rotary_emb): Qwen2RotaryEmbedding())(lm_head): Linear(in_features=3584, out_features=259, bias=False)
)📦 模型总参数量: 6,527,478,272
test_model_with_protein_tokenizer.py
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch# === 路径配置 ===
model_path = "/home/liuzhao/models/Qwen/Qwen2.5-7B-with-protein-tokenizer"# === Step 6.1: 加载 tokenizer 和模型 ===
print("📦 加载 tokenizer 和模型...")
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(model_path, trust_remote_code=True)
model.eval() # 推理用print("✅ 加载完成！\n")# === Step 6.2: 打印模型结构参数 ===
print(f"📌 Tokenizer 类型: {type(tokenizer)}")
print(f"🧱 词表大小: {tokenizer.vocab_size}")
print(f"📐 Embedding 层形状: {model.model.embed_tokens.weight.shape}")
print(f"📊 Transformer 层数: {len(model.model.layers)}")
print(f"📐 输出层形状 (lm_head): {model.lm_head.weight.shape}\n")# === Step 6.3: 简单推理测试 ===
test_input = "MVHLTPEEKSAVTALWGKVNV" # 一段蛋白质序列
inputs = tokenizer(test_input, return_tensors="pt")print("🔍 输入 token IDs:", inputs["input_ids"][0].tolist())# 推理（限制最大长度防止 OOM）
with torch.no_grad():outputs = model.generate(input_ids=inputs["input_ids"],max_new_tokens=20,do_sample=False)# 解码输出
decoded = tokenizer.decode(outputs[0])
print("\n🧪 推理结果:")
print(decoded)
输出：
(tokenizer) root@420GP-252:/home/liuzhao/tokenizer_construct# CUDA_VISIBLE_DEVICES=5 python test_model_with_protein_tokenizer.py
📦 加载 tokenizer 和模型...
Sliding Window Attention is enabled but not implemented for `sdpa`; unexpected results may be encountered.
Loading checkpoint shards: 100%|█████████████████████████████████████████████████████████████████████| 6/6 [00:05<00:00, 1.03it/s]
✅ 加载完成！📌 Tokenizer 类型: <class 'transformers.models.gpt2.tokenization_gpt2_fast.GPT2TokenizerFast'>
🧱 词表大小: 259
📐 Embedding 层形状: torch.Size([259, 3584])
📊 Transformer 层数: 28
📐 输出层形状 (lm_head): torch.Size([259, 3584])🔍 输入 token IDs: [47, 56, 42, 46, 54, 50, 39, 39, 45, 53, 35, 56, 54, 35, 46, 57, 41, 45, 56, 48, 56]
The attention mask and the pad token id were not set. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.
Setting `pad_token_id` to `eos_token_id`:151643 for open-end generation.
The attention mask is not set and cannot be inferred from input because pad token is same as eos token. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.🧪 推理结果:
MVHLTPEEKSAVTALWGKVNVGVGVGVGVGVGVGVGVGVGV
tokenizer_785">3. 构建tokenizer核心：选择分词算法
通过构建tokenizer的整体流程来看，核心其实是第二步：训练tokenizer。这一步设计到分词算法的选择。
✅ 常用分词算法总览表（用途 × 原理 × 特性 × 模型支持）
| 分词算法 | 是否可训练 | 是否支持 OOV | 压缩能力 | 粒度 | 原理简介 | 常用模型/场景 |
|---|---|---|---|---|---|---|
| Word-level | ❌ 否 | ❌ 差 | ❌ 差 | 词 | 按空格分词，每个词是一个 token | Word2Vec（早期）、GloVe |
| Character-level | ❌ 否 | ✅ 好 | ❌ 差 | 字/字符 | 每个字符是一个 token，无需词表 | 拼音、蛋白质、语音转写 |
| Byte-level | ❌ 否 | ✅ 很好 | ❌ 差 | 字节（UTF-8） | 每个字符拆成 1-4 字节，再用 Byte 作为 token | OpenAI GPT 系列（GPT-3/4）、tiktoken |
| BPE (Byte Pair Encoding) | ✅ 是 | ✅ 良好 | ✅ 高 | 子词 | 高频字符对合并，构造合成词单元 | GPT2、LLama、Qwen、CodeGen |
| WordPiece | ✅ 是 | ✅ 良好 | ✅ 一般 | 子词 | 最大匹配 + 子词合并 | BERT、ALBERT |
| Unigram Language Model | ✅ 是 | ✅ 最好 | ✅ 很高 | 子词 | 训练一个概率模型，保留最优子词集 | T5、mT5、XLM-R、SentencePiece |
| SentencePiece (框架) | ✅ 是 | ✅ 强 | ✅ 强 | 子词/字节 | 支持 Unigram/BPE/Char/Byte 等算法 | Google 系列、跨语种任务 |
| Tiktoken | ❌ 否 | ✅ 固定词表 | ✅ 非常高 | 字节 | OpenAI 内部算法，压缩+速度双优 | GPT-3.5、GPT-4（不可训练） |
3.1 Word-level Tokenizer（词级分词器）
原理：按空格或分隔符将文本切分为完整词语。
优点：
直观易理解
缺点：
词表庞大，难以覆盖 OOV（未登录词）
无法泛化：如“play”和“played”是两个不同词
常见模型：Word2Vec、GloVe（早期传统方法）
3.2 Character-level Tokenizer（字符级）
原理：将每个字符（如汉字、英文字母、氨基酸等）当作一个 token。
优点：
完全无 OOV 问题
极细粒度，适合结构化序列（如蛋白质）
缺点：
序列太长，建模成本高
应用：蛋白质序列、拼音建模、小语种处理
3.3 Byte-level Tokenizer（字节级）
原理：将文本按 UTF-8 字节编码，每个字节为一个 token，共 256 种。
优点：
无语言依赖，支持所有字符
与 GPT2、OpenAI 模型兼容性好
缺点：
不会做词级压缩（每个 token 都很短）
代表实现：GPT2、Qwen2、OpenAI 的 Tiktoken
3.4 BPE (Byte Pair Encoding)
原理：
从字符出发，按频率合并最常出现的 token 对，逐步构造子词
优点：
可训练
高压缩比，子词有语义组合能力
高效通用，适用于各种语种和符号结构
缺点：
只考虑合并频率，缺少语言建模概率
应用模型：GPT2、LLama、Qwen、CodeGen、RoBERTa（BPE with space）
3.5 WordPiece
原理：
按最大匹配方式将词拆解成子词，子词带 ## 前缀表示后缀部分
优点：
控制好拆分与组合平衡，稳定性强
缺点：
构建过程比 BPE 更复杂
常见模型：BERT、ALBERT、DistilBERT、Electra
3.6 Unigram Language Model（概率模型）
原理：
从一大批子词候选集中，选择能最优压缩文本概率的子词集合
每个词有多种拆分路径，选择最优的
优点：
最灵活可控、最适配多语种场景
缺点：
构建耗时较长，训练复杂
常见模型：T5、mT5、XLM-R、Google 系列
3.7 SentencePiece（分词框架）
本质是框架，支持以下算法：
✅ Unigram（默认）
✅ BPE
✅ Character
✅ Byte
支持无空格语言（如中文、日文）
常见于 Google / multilingual 模型
3.8 Tiktoken（OpenAI 专用）
• 原理：压缩优化过的 UTF-8 字节映射 + 快速查表
• 特点：
• 封闭系统，无法训练
• 提供极高推理效率和兼容性
• 常见模型：GPT-3.5、GPT-4（不可替换）
支持自训练的分词算法有哪些？
| 可自训练？ | 算法 |
|---|---|
| ✅ 可以 | BPE, Unigram, WordPiece, SentencePiece |
| ❌ 固定 | Char-level, Byte-level, Tiktoken |
