【1】Tokenize有三种粒度：word/char/subword

以英文文本 Today is sunday为例，切分结果如下：
word: 按照词进行分词，可根据空格或标点进行切分。如: Today is sunday. 切分成[today, is, sunday, .]
char：按照单字符进行分词，就是以char为最小粒度。 如：Today is sunday. 切分成[t,o,d,a,y, ... ,s,u,n,d,a,y, .]
subword：按照词的subword进行分词，将word拆分为子串。如：Today is sunday. 切分成[to, day,is , s,un,day, .]

3.Tokenize的各粒度的优缺对比：

抱抱脸文档：

https://huggingface.co/docs/tokenizers/api/normalizers

【2】subword切分与word,char切分对比

【3】Tokenizer在训练,微调模型中使用代码

import torch
from datasets import load_dataset
from transformers import (
    AutoModelForCausalLM,AutoTokenizer,    
    BitsAndBytesConfig, HfArgumentParser,   
    TrainingArguments,pipeline,logging,        
)
from peft import LoraConfig, PeftModel
from trl import SFTTrainer


base_model = "Llama2-7b-chat-hf"       # 基础模型路径
guanaco_dataset = "guanaco-llama2-1k"  # 数据集路径
new_model = "llama-2-7b-chat-guanaco"  # 微调模型名称
dataset = load_dataset(guanaco_dataset, split="train") # 加载微调数据集

tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True) # 加载tokenizer
tokenizer.pad_token = tokenizer.eos_token    # 序列结束的标记eos_token默认是 [SEP]
tokenizer.padding_side = "right"             # padding_side 设置为right以修复 fp16 的问题
...

#完整微调代码：https://github.com/zzzichen277/LLM_SFT

【4】模拟Tokenizer执行过程代码

#kaggle link：https://www.kaggle.com/code/zichen998/chatglm3-6b-tokenizer

from transformers import AutoTokenizer, AutoModel

model_path = "/kaggle/input/chatglm3-6b/pytorch/6b/6"
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model = AutoModel.from_pretrained(model_path, trust_remote_code=True, device='cuda')
model = model.eval()

text = "你好，我是人工智能助手。"
print(f"1.用户的提问：{text}")

seg_words = tokenizer.tokenize(text)
print(f"2.将用户的提问 分词成token结果：{seg_words}")

seg_word_ids = tokenizer.convert_tokens_to_ids(seg_words)
print(f"3.将用户的提问 分词成token编码ids结果：{seg_word_ids}")


model_inputs = tokenizer([text], return_tensors="pt").to("cuda")
print(f"4.将用户的提问tokenizer后结果：{model_inputs}")

print("###############################################################")

generated_ids = model.generate(model_inputs.input_ids, max_new_tokens=512)
print(f"5.模型返回提问结果 回答token编码ids结果：{generated_ids}")


generated_seg_word = tokenizer.convert_ids_to_tokens(generated_ids[0])
print(f"6.将模型回复编码ids 反编码为token结果：{generated_seg_word}")


response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)
print(f"7.将模型回复反编码ids 反编码为token并合并结果：{response}")

"""
1.用户的提问：你好，我是人工智能助手。
2.将用户的提问 分词成token结果：['▁你', '好', '，', '我是', '人工智能', '助手', '。']
3.将用户的提问 分词成token编码ids结果：[36474, 54591, 31123, 33030, 34797, 42481, 31155]
4.将用户的提问tokenizer后结果：{'input_ids': tensor([[64790, 64792, 36474, 54591, 31123, 33030, 34797, 42481, 31155]],
       device='cuda:0'), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1]], device='cuda:0'), 'position_ids': tensor([[0, 1, 2, 3, 4, 5, 6, 7, 8]], device='cuda:0')}
###############################################################
5.模型返回提问结果 回答token编码ids结果：tensor([[64790, 64792, 36474, 54591, 31123, 33030, 34797, 42481, 31155, 48895,
         38549, 31645, 31404, 42693, 33277, 31639, 40648, 55268, 55353, 36295,
         31514,     2]], device='cuda:0')
6.将模型回复编码ids 反编码为token结果：['[gMASK]', 'sop', '▁你', '好', '，', '我是', '人工智能', '助手', '。', '很高兴', '为您', '服务', '！', '请问', '有什么', '问题', '我可以', '帮', '您', '解答', '？', '']
7.将模型回复反编码ids 反编码为token并合并结果：['[gMASK] sop 你好，我是人工智能助手。很高兴为您服务！请问有什么问题我可以帮您解答？']
"""

【5】训练Tokenizer代码

import torch
from datasets import load_dataset
from tokenizers import (decoders,models,normalizers,pre_tokenizers,processors,trainers,Tokenizer,)
from transformers import PreTrainedTokenizerFast

dataset_path = "TurboPascal/tokenizers_example_zh_en"
tokenize_path =  "BPE_tokenizer.json"
# 加载训练数据集
dataset = load_dataset(data_files=dataset_path, cache_dir='./cache/')
def batch_iterator(batch_size=10000):
    for i in range(0, len(dataset), batch_size):
        yield dataset['train'][i: i + batch_size]["text"]

special_tokens = ["[CLS]", "[SEP]", "[PAD]", "[MASK]", "<s>", "</s>", "<t>", "</t>"]
trainer = trainers.BpeTrainer(special_tokens=special_tokens, vocab_size=54000)

# 创建BPE tokenizer对象
tokenizer = Tokenizer(models.BPE())
tokenizer.train_from_iterator(batch_iterator(), trainer=trainer, length=len(dataset['train']))

# 保存trained tokenizer
tokenizer.save(tokenize_path)

# 加载trained tokenizer
tokenizer = Tokenizer.from_file(tokenize_path)
output = tokenizer.encode(samplexxx)
print(output.tokens)   

【1】简要介绍BPE

【2】BPE如何构建词典

1.初始化词典：将每个字符视为一个初始的词。
2.统计词频：对于每个词，统计其在文本中的频率。
3.合并频率最高的词对：在每次迭代中，选择频率最高的词对进行合并。合并的方式是将两个词连接起来。
4.更新词频：更新合并后的词频。对于合并的词，统计其在文本中的频率。
5.重复步骤3和4：重复步骤3和4，直到达到预设的词典大小或者满足其他停止条件。每次迭代都会合并频率最高的词对，并更新词频。

【2】BPE构建词典模拟代码

【2】BPE构建词典模拟代码

import re, collections

def get_vocab(filename):
    vocab = collections.defaultdict(int)
    with open(filename, 'r', encoding='utf-8') as fhand:
        for line in fhand:
            words = line.strip().split()
            for word in words:
                vocab[' '.join(list(word)) + ' </w>'] += 1
    return vocab

def get_stats(vocab):
    pairs = collections.defaultdict(int)
    for word, freq in vocab.items():
        symbols = word.split()
        for i in range(len(symbols)-1):
            pairs[symbols[i],symbols[i+1]] += freq
    return pairs

def merge_vocab(pair, v_in):
    v_out = {}
    bigram = re.escape(' '.join(pair))
    p = re.compile(r'(?<!\S)' + bigram + r'(?!\S)')
    for word in v_in:
        w_out = p.sub(''.join(pair), word)
        v_out[w_out] = v_in[word]
    return v_out

def get_tokens(vocab):
    tokens = collections.defaultdict(int)
    for word, freq in vocab.items():
        word_tokens = word.split()
        for token in word_tokens:
            tokens[token] += freq
    return tokens

vocab = {'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w e s t </w>': 6, 'w i d e s t </w>': 3}

# Get free book from Gutenberg
# wget http://www.gutenberg.org/cache/epub/16457/pg16457.txt
# vocab = get_vocab('pg16457.txt')

print('==========')
print('Tokens Before BPE')
tokens = get_tokens(vocab)
print('Tokens: {}'.format(tokens))
print('Number of tokens: {}'.format(len(tokens)))
print('==========')

num_merges = 5
for i in range(num_merges):
    pairs = get_stats(vocab)
    if not pairs:
        break
    best = max(pairs, key=pairs.get)
    vocab = merge_vocab(best, vocab)
    print('Iter: {}'.format(i))
    print('Best pair: {}'.format(best))
    tokens = get_tokens(vocab)
    print('Tokens: {}'.format(tokens))
    print('Number of tokens: {}'.format(len(tokens)))
    print('==========')


#BPE算法详解：https://www.jianshu.com/p/6415a2e9ec09  

【3】BPE实现编码和解码

# 0)给定单词序列
["the</w>", "highest</w>", "mountain</w>"]
# 1)在BPE构建词典中得到subword 的词表，对该subword词表按照字符个数由多到少排序。
# 长度 6         5           4        4         4       4          2
["errrr</w>", "tain</w>", "moun", "est</w>", "high", "the</w>", "a</w>"]

# 2)编码时，尝试将每个单词中的子字符串替换为token。

# 3)在迭代所有的tokens后，将所有子字符串替换为tokens。返回迭代结果
"the</w>" -> ["the</w>"]
"highest</w>" -> ["high", "est</w>"]
"mountain</w>" -> ["moun", "tain</w>"]

# 编码序列
["the</w>", "high", "est</w>", "moun", "tain</w>"]
# 解码序列
"the</w> highest</w> mountain</w>"

【4】BPE代码实现-创建BPE Tokenizer

from tokenizers import (decoders,models,normalizers,pre_tokenizers,processors,trainers,Tokenizer,)
from transformers import PreTrainedTokenizerFast
from datasets import Dataset


# Creating Byte-Pair Encoding tokenizer         
raw_tokenizer = Tokenizer(models.BPE(unk_token="[UNK]"))                                                              #设置Tokenizer
raw_tokenizer.normalizer = normalizers.Sequence([normalizers.NFC()] + [normalizers.Lowercase()] if LOWERCASE else []) #normalizers
raw_tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel()                                                              #pre_tokenizers

special_tokens = ["[UNK]", "[PAD]", "[CLS]", "[SEP]", "[MASK]"]
trainer = trainers.BpeTrainer(vocab_size=VOCAB_SIZE, special_tokens=special_tokens)                                   #trainers

dataset = Dataset.from_pandas(test[['text']])                                                                         #Dataset
def train_corp_iter(): 
    for i in range(0, len(dataset), 25):
        yield dataset[i : i + 25]["text"]

raw_tokenizer.train_from_iterator(train_corp_iter(), trainer=trainer)

tokenizer = PreTrainedTokenizerFast(                                                                                  #PreTrainedTokenizerFast
    tokenizer_object=raw_tokenizer,
    unk_token="[UNK]",pad_token="[PAD]",cls_token="[CLS]",sep_token="[SEP]",mask_token="[MASK]",
)

tokenized_texts_test = []
for text in tqdm(test['text'].tolist()):
    tokenized_texts_test.append(tokenizer.tokenize(text))
tokenized_texts_train = []
for text in tqdm(train['text'].tolist()):
    tokenized_texts_train.append(tokenizer.tokenize(text))

【5】BPE代码实现-BPE 构建词典过程

import re, collections

def get_stats(vocab):
    pairs = collections.defaultdict(int)
    for word, freq in vocab.items():
        symbols = word.split()
        for i in range(len(symbols)-1):
            pairs[symbols[i],symbols[i+1]] += freq
    return pairs

def merge_vocab(pair, v_in):
    v_out = {}
    bigram = re.escape(' '.join(pair))
    p = re.compile(r'(?<!\S)' + bigram + r'(?!\S)')
    for word in v_in:
        w_out = p.sub(''.join(pair), word)
        v_out[w_out] = v_in[word]
    return v_out

vocab = {'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w e s t </w>': 6, 'w i d e s t </w>': 3}
num_merges = 1000
for i in range(num_merges):
    pairs = get_stats(vocab)
    if not pairs:
        print(f"第{i}轮合并结束")
        break
        
    best = max(pairs, key=pairs.get)
    vocab = merge_vocab(best, vocab)
    print(f"第{i}轮合并,best-pair值为{best},|||合并后vocab为{vocab}")
    
"""
第0轮合并,best-pair值为('e', 's'),|||合并后vocab为{'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w es t </w>': 6, 'w i d es t </w>': 3}
第1轮合并,best-pair值为('es', 't'),|||合并后vocab为{'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w est </w>': 6, 'w i d est </w>': 3}
第2轮合并,best-pair值为('est', '</w>'),|||合并后vocab为{'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w est</w>': 6, 'w i d est</w>': 3}
第3轮合并,best-pair值为('l', 'o'),|||合并后vocab为{'lo w </w>': 5, 'lo w e r </w>': 2, 'n e w est</w>': 6, 'w i d est</w>': 3}
第4轮合并,best-pair值为('lo', 'w'),|||合并后vocab为{'low </w>': 5, 'low e r </w>': 2, 'n e w est</w>': 6, 'w i d est</w>': 3}
第5轮合并,best-pair值为('n', 'e'),|||合并后vocab为{'low </w>': 5, 'low e r </w>': 2, 'ne w est</w>': 6, 'w i d est</w>': 3}
第6轮合并,best-pair值为('ne', 'w'),|||合并后vocab为{'low </w>': 5, 'low e r </w>': 2, 'new est</w>': 6, 'w i d est</w>': 3}
第7轮合并,best-pair值为('new', 'est</w>'),|||合并后vocab为{'low </w>': 5, 'low e r </w>': 2, 'newest</w>': 6, 'w i d est</w>': 3}
第8轮合并,best-pair值为('low', '</w>'),|||合并后vocab为{'low</w>': 5, 'low e r </w>': 2, 'newest</w>': 6, 'w i d est</w>': 3}
第9轮合并,best-pair值为('w', 'i'),|||合并后vocab为{'low</w>': 5, 'low e r </w>': 2, 'newest</w>': 6, 'wi d est</w>': 3}
第10轮合并,best-pair值为('wi', 'd'),|||合并后vocab为{'low</w>': 5, 'low e r </w>': 2, 'newest</w>': 6, 'wid est</w>': 3}
第11轮合并,best-pair值为('wid', 'est</w>'),|||合并后vocab为{'low</w>': 5, 'low e r </w>': 2, 'newest</w>': 6, 'widest</w>': 3}
第12轮合并,best-pair值为('low', 'e'),|||合并后vocab为{'low</w>': 5, 'lowe r </w>': 2, 'newest</w>': 6, 'widest</w>': 3}
第13轮合并,best-pair值为('lowe', 'r'),|||合并后vocab为{'low</w>': 5, 'lower </w>': 2, 'newest</w>': 6, 'widest</w>': 3}
第14轮合并,best-pair值为('lower', '</w>'),|||合并后vocab为{'low</w>': 5, 'lower</w>': 2, 'newest</w>': 6, 'widest</w>': 3}
第15轮合并结束
"""

假设有语料集经过统计后表示为{'low':5,'lower':2,'newest':6,'widest':3}，其中数字代表的是对应单词在语料中的频数。

输入【语料】：{'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w e s t </w>': 6, 'w i d e s t </w>': 3}。此时词表：{'l' , 'o' ,'w' ,'e' ,'r' ,'n' ,'s' ,'t' ,'i' ,'d' ,'</w>' ,}

Iter 1, 最高频连续字节对"e"和"s"出现了6+3=9次，合并成"es"。输出【新语料】：{'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w es t </w>': 6, 'w i d es t </w>': 3}。【新词表】：{'l' , 'o' ,'w' ,'e' ,'r' ,'n' ,'s' ,'t' ,'i' ,'d' ,'</w>' ,'es' ,}。

Iter 2, 最高频连续字节对"es"和"t"出现了6+3=9次, 合并成"est"。输出【新语料】：{'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w est </w>': 6, 'w i d est </w>': 3}。【新词表】：{'l' , 'o' ,'w' ,'e' ,'r' ,'n' ,'t'  ,'i' ,'d' ,'</w>' ,'es','est' ,}。

Iter 3, 以此类推，最高频连续字节对为"est"和"</w>" 。输出【新语料】：{'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w est</w>': 6, 'w i d est</w>': 3}。【新词表】：{'l' , 'o' ,'w' ,'e' ,'r' ,'n'  ,'i' ,'d' ,'</w>' ,'est' ,'est</w>',}。

……

Iter n, 继续迭代直到达到预设的subword词表大小或下一个最高频的字节对出现频率为1。

注：停止符"</w>"的意义在于表示subword是词后缀。举例来说："st"字词不加"</w>"可以出现在词首如"st ar"，加了"</w>"表明该字词位于词尾，如"wide st</w>"，二者意义截然不同。

BPE的问题是，如果遇到了unicode，基本字符集可能会很大。一种处理方法BBPE是以一个字节为一种“字符”，不管实际字符集用了几个字节来表示一个字符。这样的话，基础字符集的大小就锁定在了256。例如，像GPT-2的词汇表大小为50257 = 256 + <EOS> + 50000 mergers，<EOS>是句子结尾的特殊标记。

【1】简要介绍WordPiece

【2】WordPiece是如何选取子词的

【2】WordPiece是如何选取子词的

【3】WordPiece 与 BPE 的异同点是什么

【3】WordPiece 与 BPE 的异同点是什么

【4】WordPiece代码实现-Creating WordPiece Tokenizer

【4】WordPiece代码实现-Creating WordPiece Tokenizer

from tokenizers import (decoders,models,normalizers,pre_tokenizers,processors,trainers,Tokenizer,)
from transformers import PreTrainedTokenizerFast
from datasets import Dataset


# Creating WordPiece tokenizer         
raw_tokenizer = Tokenizer(models.WordPiece())                                                                         #models
raw_tokenizer.normalizer = normalizers.Sequence([normalizers.NFC()] + [normalizers.Lowercase()] if LOWERCASE else []) #normalizers
raw_tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel()                                                              #pre_tokenizers
special_tokens = ["[UNK]", "[PAD]", "[CLS]", "[SEP]", "[MASK]"]

trainer = trainers.BpeTrainer(vocab_size=VOCAB_SIZE, special_tokens=special_tokens)                                   #trainers
...

推荐阅读：

【1】简要介绍ULM

【1】简要介绍ULM

与BPE和WordPiece不同，Unigram算法是从预分词器分的词+所有高频的子词构成的大词汇表出发，再逐步删除其中重要性较低的subword，直到满足预定义size。

【2】ULM如何来构造词表以及求解分词概率

【1】简要介绍SentencePiece

【1】简要介绍SentencePiece

...
class TextTokenizer:
    def __init__(self, model_path):
        self.sp = spm.SentencePieceProcessor()
        self.sp.Load(model_path)
        self.num_tokens = self.sp.vocab_size()

    def encode(self, text):
        return self.sp.EncodeAsIds(text)

    def decode(self, ids: List[int]):
        return self.sp.DecodeIds(ids)
...

#https://huggingface.co/THUDM/chatglm-6b/blob/main/tokenization_chatglm.py#L21

【1】SentencePiece特性

【1】SentencePiece 特性

【2】使用SentencePiece训练分词器

【2】使用Sentencepiece训练分词器

##v1 Train a BPE Model
import sentencepiece as spm

# train sentencepiece model from our blog corpus
spm.SentencePieceTrainer.train(input='blog_test.txt'，model_prefix=bpe --vocab_size=500， user_defined_symbols=['foo', 'bar'])

# makes segmenter instance and loads the BPE model file (bpe.model)
sp_bpe = spm.SentencePieceProcessor()
sp_bpe.load('bpe.model')
####################################################################################
##v2 Train a Unigram Model
import sentencepiece as spm

# train sentencepiece model from our blog corpus
spm.SentencePieceTrainer.train(input='blog_test.txt'，model_prefix=bpe --vocab_size=500， user_defined_symbols=['foo', 'bar'])

# makes segmenter instance and loads the BPE model file (bpe.model)
sp_uni = spm.SentencePieceProcessor()
sp_uni.load('uni.model')
####################################################################################
## 比较一下两个分词器结果
print("BPE: {}".format(sp_bpe.encode_as_pieces('This is a test')))
print("UNI: {}".format(sp_uni.encode_as_pieces('This is a test')))
BPE: ['▁This', '▁is', '▁a', '▁t', 'est']
UNI: ['▁Thi', 's', '▁is', '▁a', '▁t', 'est']

#https://zhuanlan.zhihu.com/p/620508648

【3】使用SentencePiece加载和使用词表模型文件tokenizer.model

from sentencepiece import SentencePieceProcessor
model_path = "/kaggle/input/chatglm3-6b/pytorch/6b/6/tokenizer.model"
sp_model = SentencePieceProcessor(model_file=model_path)
text = "你好，你是谁？"

tokens = sp_model.EncodeAsPieces(text)
print(f"1.句子转为tokens结果： {tokens}")

ids = sp_model.EncodeAsIds(text)
print(f"2.句子转为ids结果： {ids}")
decode_text = sp_model.Decode(ids)
print(f"3.ids转为句子结果：{decode_text}")

#1.句子转为tokens结果： ['▁你', '好', '，', '你是', '谁', '？']
#2.句子转为ids结果： [36474, 54591, 31123, 34607, 55622, 31514]
#3.ids转为句子结果：你好，你是谁？

【4】使用SentencePiece对LLM词表扩充

#0.从 C++ 源构建和安装 SentencePiece 命令行工具
>sudo apt-get install cmake build-essential pkg-config libgoogle-perftools-dev
>git clone https://github.com/google/sentencepiece.git 
>cd sentencepiece | mkdir build|  cd build  | cmake ..   |  make -j $(nproc)  | make install   |   ldconfig -v 

#1.spm_train进行模型训练 spm_train --input=训练语料文件 --model_prefix=输出模型名称前缀 --vocab_size=训练后的词表大小 --character_coverage=模型覆盖的字符数量 --model_type=模型类型如bpe
>spm_train --input=/workspace/data/book/hongluomeng_clean.txt --model_prefix=/workspace/model/book/hongluomeng-tokenizer --vocab_size=4000 --character_coverage=0.9995 --model_type=bpe

#2.模型输出文件(词表及模型权重)
>ls -al /workspace/model/book

#3.查看词表：
>head -n20 /workspace/model/book/hongluomeng-tokenizer.vocab

#4.基于命令行使用模型，将原始文本编码成句子片段(token)。
> echo "白日依山尽，黄河入海流。" | spm_encode --model=/workspace/model/book/hongluomeng-tokenizer.model  #▁ 白 日 依 山 尽 , 黄 河 入 海 流 。
> echo "白日依山尽，黄河入海流。" | spm_encode --model=/workspace/model/book/hongluomeng-tokenizer.model --output_format=id  #60 254 70 333 468 400 14 733 1476 317 603 510 15

#将句子片段(token) id 解码为原始文本。
> echo "60 254 70 333 468 400 14 733 1476 317 603 510 15" | spm_decode --model=/workspace/model/book/hongluomeng-tokenizer.model --input_format=id  #白日依山尽,黄河入海流。

#5.spm_export_vocab基于模型文件导出词汇表。# spm_export_vocab --model=<模型文件> --output=<输出文件>
> spm_export_vocab --model=/workspace/model/book/hongluomeng-tokenizer.model --output=/workspace/output/hongluomeng.vocab

import sentencepiece as spm

sp = spm.SentencePieceProcessor()

text="这贾雨村原系胡州人氏，也是诗书仕宦之族，因他生于末世，父母祖宗根基已尽，人口衰丧，只剩得他一身一口，在家乡无益，因进京求取功名，再整基业。"

sp.Load("hongluomeng-tokenizer.model")

print(sp.EncodeAsPieces(text))
['▁', '这', '贾', '雨', '村', '原', '系', '胡', '州', '人', '氏', ',', '也', '是', '诗', '书', '仕', '宦', '之', '族', ',', '因', '他', '生', '于', '末', '世', ',', '父', '母', '祖', '宗', '根', '基', '已', '尽', ',', '人', '口', '衰', '丧', ',', '只', '剩', '得', '他', '一', '身', '一', '口', ',', '在', '家', '乡', '无', '益', ',', '因', '进', '京', '求', '取', '功', '名', ',', '再', '整', '基', '业', '。']

from sentencepiece import sentencepiece_model_pb2

m = sentencepiece_model_pb2.ModelProto()
with open('chatglm-6b/ice_text.model', 'rb') as f:
    m.ParseFromString(f.read())
print('ChatGLM tokenizer\n\n'+str(m.trainer_spec))

"""
ChatGLM tokenizer
input: "/root/train_cn_en.json"
model_prefix: "new_ice_unigram"
vocab_size: 130000
character_coverage: 0.9998999834060669
split_digits: true
user_defined_symbols: "<n>"
byte_fallback: true
pad_id: 3
train_extremely_large_corpus: true
"""

可以看到 byte_fallback: true。同样的方法，可以验证LLaMA, ChatGLM-6B, Baichuan这些大模型都是基于sentencepiece实现的BPE的分词算法，并且采用byte回退。

【6】和SentencePiece类似的工具

【★】1.SentencePiece:https://arxiv.org/pdf/1808.06226.pdf

【★】2.Github:https://github.com/google/sentencepiece

【★】3.大模型分词：sentencepiece vs titoken-知乎@王几行【202404】：https://zhuanlan.zhihu.com/p/691609961

【★】4.大模型词表扩充必备工具SentencePiece-掘金@吃果冻【202305】：https://zhuanlan.zhihu.com/p/630696264     

【X】简要介绍常用Tokenizer的原理和区别

1.BPE构建词典从字符级词表开始，不断在语料库中找词频最高且连续的token合并加入词表，直到达到目标词数。生成大小可控的开放词汇表。

【X】BBPE和BPE的区别