bert源码分析之tokenization

本文主要是介绍bert源码分析之tokenization，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

import collections# 集合模块
import re# 正则模块
import unicodedata#判断字符类别模块
import six#判断版本
import tensorflow as tf
# 用于检查传入的参数do_lower_case和真正的模型是否一致
# do_lower_case: 一个布尔值，表示是否将文本转换为小写
# init_checkpoint: 初始化检查点的路径。检查点通常包含模型在训练过程中的状态，用于后续的训练或推理
def validate_case_matches_checkpoint(do_lower_case, init_checkpoint):
if not init_checkpoint:# 如果检查点为空,直接返回
return
#使用正则表达式从init_checkpoint中提取模型名称。
m = re.match("^.*?([A-Za-z0-9_-]+)/bert_model.ckpt", init_checkpoint)
if m is None:# 如果没提取到,返回
return
model_name = m.group(1)#从正则匹配中获取值
# 定义两个列表 lower_models 和 cased_models，
# 分别包含小写和保留原始大小写的模型名称。
lower_models = [
"uncased_L-24_H-1024_A-16", "uncased_L-12_H-768_A-12",
"multilingual_L-12_H-768_A-12", "chinese_L-12_H-768_A-12"
]

cased_models = [
"cased_L-12_H-768_A-12", "cased_L-24_H-1024_A-16",
"multi_cased_L-12_H-768_A-12"
]
is_bad_config = False
#以下两个都是配置和传参不一致
# 如果模型名称在小写模型列表中，但 do_lower_case 为 False，
# 则配置错误，因为这意味着模型预期输入为小写文本，但实际上并未这样做。
if model_name in lower_models and not do_lower_case:
is_bad_config = True
actual_flag = "False"
case_name = "lowercased"
opposite_flag = "True"
# 如果模型名称在保留原始大小写的模型列表中，但 do_lower_case 为 True，
# 则配置同样错误，因为这意味着模型预期输入保留原始大小写，但实际上输入文本被转换为了小写
if model_name in cased_models and do_lower_case:
is_bad_config = True
actual_flag = "True"
case_name = "cased"
opposite_flag = "False"
# 如果发现配置错误，则抛出一个 ValueError，说明问题所在，并建议如何修复。
if is_bad_config:
raise ValueError(
"传参和模型不一致!"
)
# 将传入的文本转换为utf8 格式
def convert_to_unicode(text):
if six.PY3:
if isinstance(text, str):# 如果本身是字符串实例对象,不做处理
return text
elif isinstance(text, bytes):# 如果是字节实例
return text.decode("utf-8", "ignore")# utf8解码后返回
else:#否则抛出错误
raise ValueError("不支持的数据类型: %s" % (type(text)))
elif six.PY2:# 以下都是python2的检验,python3可以不用看
if isinstance(text, str):
return text.decode("utf-8", "ignore")
elif isinstance(text, unicode):
return text
else:
raise ValueError("不支持的字符串类型!: %s" % (type(text)))
else:
raise ValueError("难道你没运行在python上?")
# 这和上面的处理一模一样,整合到一起都行
def printable_text(text):
if six.PY3:
if isinstance(text, str):
return text
elif isinstance(text, bytes):
return text.decode("utf-8", "ignore")
else:
raise ValueError("不支持的数据类型: %s" % (type(text)))
elif six.PY2:
if isinstance(text, str):
return text
elif isinstance(text, unicode):
return text.encode("utf-8")
else:
raise ValueError("不支持的字符串类型!: %s" % (type(text)))
else:
raise ValueError("难道你没运行在python上?")
#构建词汇字典
#用于从一个词汇表文件中加载词汇，并将其存储为一个有序字典
def load_vocab(vocab_file):
#创建了一个有序字典vocab。有序字典是Python中的一个特殊字典类型
vocab = collections.OrderedDict()
index = 0# 初始化索引
with open(vocab_file, "r",encoding='utf8') as reader:
while True:
token = convert_to_unicode(reader.readline())# 默认一个词汇一行
if not token:# 读完就退出
break
token = token.strip()# 去掉前后可能存在的空白字符
vocab[token] = index# 建立单词和索引间的映射
index += 1#索引递增
return vocab
dic1=load_vocab('bert-base-chinese/vocab.txt')
# 21128个单词
print(len(dic1),dic1)
# 获取指定的真实词汇映射的索引,并返回索引列表
def convert_by_vocab(vocab, items):
output = []#初始化一个列表
for item in items:#遍历原数据或目标词汇集中的每个词汇
output.append(vocab[item])# 把对应索引添加进列表
return output# 返回索引列表
# 啥也没做,就是直接调用上面的方法处理tokens(真实的词汇)
def convert_tokens_to_ids(vocab, tokens):
return convert_by_vocab(vocab, tokens)
# 这是根据索引获取真实文本内容,从键值互换的字典里获取
def convert_ids_to_tokens(inv_vocab, ids):
return convert_by_vocab(inv_vocab, ids)
#获取文本分词的列表形式,以空格为分割符
def whitespace_tokenize(text):
text = text.strip()# 文本去前后空格
if not text:# 如果没字符
return []
tokens = text.split()#以空格分词
return tokens #返回列表
#判断词汇是不是空白字符的方法
def _is_whitespace(char):
# 这里把空格,制表符,换行符,回车符都当成空白字符
if char == " " or char == "\t" or char == "\n" or char == "\r":
return True
# 获取字符的类别,字符类别是ZS,也当成空白符
cat = unicodedata.category(char)
if cat == "Zs":
return True
return False
# 判断控制符
def _is_control(char):
#注意:制表符,换行,回车不是控制符
if char == "\t" or char == "\n" or char == "\r":
return False
cat = unicodedata.category(char)# 获取字符类别
if cat in ("Cc", "Cf"): #如果字符类别是CC,Cf,这些是控制符
return True
return False
# 检查一个字符是否是标点符号
def _is_punctuation(char):
cp = ord(char)# 获取字符对应的unicode码,+-*/也是标点符号
if ((cp >= 33 and cp <= 47) or (cp >= 58 and cp <= 64) or
(cp >= 91 and cp <= 96) or (cp >= 123 and cp <= 126)):
return True
cat = unicodedata.category(char)
if cat.startswith("P"):
return True
return False
# 执行基本的文本分词操作
class BasicTokenizer(object):
# 默认转小写
def __init__(self, do_lower_case=True):
self.do_lower_case = do_lower_case
def tokenize(self, text):
text = convert_to_unicode(text)# 将输入的文本转换为Unicode格式
text = self._clean_text(text)# 清洗后的文本,文本中只有单词,标点符号和空格符,但还是字符串文本
text = self._tokenize_chinese_chars(text) #处理中文字符后的文本,中文字符前后加空格
#上面的处理是为了这个,字符串转列表,空格符分割
orig_tokens = whitespace_tokenize(text)# 获取源分词列表
split_tokens = []
for token in orig_tokens:# 遍历所有分词后词汇
if self.do_lower_case:# 如果要转小写
token = token.lower()# 转小写
token = self._run_strip_accents(token)# 也就是说转小写才过滤重音符
split_tokens.extend(self._run_split_on_punc(token))#追加列表形式的词汇,
output_tokens = whitespace_tokenize(" ".join(split_tokens))#
return output_tokens# 列表形式的词汇
# 过滤掉重音符
# 它接受一个text参数,返回一个新的字符串,删除了原始文本中的所有重音符号
def _run_strip_accents(self, text):#这时的text是一个个的分词
# 这行代码使用 unicodedata.normalize 函数将输入的
# text字符串标准化为分解形式（NFD）。在 NFD 形式中，
#复合字符（如带有重音符号的字符）被分解为基本字符和重音符号
text = unicodedata.normalize("NFD", text)
output = []
#遍历分词中的每个字符
for char in text:
#获取字符类别
cat = unicodedata.category(char)
if cat == "Mn":# 如果是重音符
continue# 跳过
output.append(char)#
return "".join(output)
#这个方法区分开了中文字符,标点符号,英文单词,但是遇到数字和单词连起来的情况却没处理
# 这个方法的作用是把标点符号单独拎出来,把连续数字,英文单词拎出来,以便之后形成列表
def _run_split_on_punc(self, text):#这时的文本,要么是中文字符,要么是其他字符连起来
chars = list(text)# 输入的字符串text转换为一个字符列表chars
i = 0# 索引初始化
start_new_word = True #这时候的分词,中文因为前后有空格,是早被拎出来了
# 英文数字,标点符号还没处理
output = []
while i < len(chars):# 遍历字符列表中的每个字符
char = chars[i]# 获取第i个字符
if _is_punctuation(char):# 如果是标点符号
output.append([char])# 添加标点符号,把标点符号当成单独的词(列表)
start_new_word = True # 这里主要是改状态,不然start_new_word会一直False
else: # 如果不是标点符号
if start_new_word:# 如果是新词
output.append([])# 则向output添加一个空列表,表示开始一个新的子字符串
start_new_word = False#已经给新词分配空间了,标记可以为关
output[-1].append(char) # 在之前的空列表里添加字符
i += 1 #i++
return ["".join(x) for x in output]
#定义处理中文字符的方法,前后加空格
def _tokenize_chinese_chars(self, text):
output = []
for char in text:
cp = ord(char)# 获取字符对应的字符码点
# 如果是中文字符,在字符前后加空格
if self._is_chinese_char(cp):
output.append(" ")
output.append(char)
output.append(" ")
else:# 不是的话,直接加
output.append(char)
return "".join(output)# 连成字符串
# 判断是否是中文字符的方法
def _is_chinese_char(self, cp):
# 16进制
if ((cp >= 0x4E00 and cp <= 0x9FFF) or #
(cp >= 0x3400 and cp <= 0x4DBF) or #
(cp >= 0x20000 and cp <= 0x2A6DF) or #
(cp >= 0x2A700 and cp <= 0x2B73F) or #
(cp >= 0x2B740 and cp <= 0x2B81F) or #
(cp >= 0x2B820 and cp <= 0x2CEAF) or
(cp >= 0xF900 and cp <= 0xFAFF) or #
(cp >= 0x2F800 and cp <= 0x2FA1F)): #
return True
return False
#去除文本中的空字符,替换符,或者控制符,替换文本中的回车,
#换行,制表符,空格符为空格符,这样文本中只有单词,标点符号和空格符,返回字符串文本
def _clean_text(self, text):
output = []# 用于存储清理后的词汇
for char in text:# 遍历文本中的每个单词
cp = ord(char)# 获取单词的Unicode编码
# 检查字符的编码是否为0（空字符）,0xFFFD（Unicode替换字符)
#或者控制符,跳出本次循环,接着遍历
if cp == 0 or cp == 0xfffd or _is_control(char):
continue #跳出当前循环
if _is_whitespace(char):#如果是空白字符
output.append(" ")# 统一当做空格符
else:#
output.append(char)
return output
return "".join(output)
# 基于词汇表的分词,处理未登录词(词汇表中没的)和罕见词
class WordpieceTokenizer(object):
def __init__(self, vocab, unk_token="[UNK]", max_input_chars_per_word=200):
self.vocab = vocab# 词汇表，一个包含所有有效子词的集合
self.unk_token = unk_token #用于标记未知词汇的特殊标记,默认为 "[UNK]"。
#定义每个单词的最大输入字符
self.max_input_chars_per_word = max_input_chars_per_word
def tokenize(self, text):#定义分词方法
text = convert_to_unicode(text)# 先转成unicode编码
output_tokens = []# 用于存储分词后的结果
#遍历词汇列表,whitespace_tokenize,基于空格分割成词汇列表
for token in whitespace_tokenize(text):
chars = list(token)#把词汇转换成字符列表,看分割后几个字符
if len(chars) > self.max_input_chars_per_word:#如果单词字符长度大于给定长度
output_tokens.append(self.unk_token)#那这个单词就被贴上unk,之后加进列表的是[UNK]
continue# 处理过的,就跳出去继续
is_bad = False # 是否是UNK的状态flag
start = 0 #初始化
sub_tokens = [] #用来存储token或者它的一部分
while start < len(chars): #遍历当前分词,start开始等于0
end = len(chars) # 分词字符长度
cur_substr = None #当前子串
while start < end: # 在内循环时,end是在变动的,和上面的len(chars)不一样
#这里得理解很关键,比如vocab里如果没我们这个词汇,只有我,##们这样的词汇
# 但是我们的token却刚好是我们,第一次进来后substr是我们
substr = "".join(chars[start:end])
if start > 0: #如果是第一次进来,start只会是0,不会大于0
substr = "##" + substr #start>0,最少是1,那就在前面加##,
# 加了这个是表示是当前token的一部分
if substr in self.vocab: #如果是第一次进来,substr='我们'
cur_substr = substr #如果可以在词汇表里找到分词,设置当前子串为substr
break #退出内层循环
# 如果没在词汇表找到分词或者分词的子串,减小子串范围
end -= 1
# 每次如果找不到end都会减1,直到减到start,目前还在内循环,start也是在变动的
# 如果找到,就会退出内循环,接着会让外层的start跳过找到的这部分分词,继续找分词的后面的部分
if cur_substr is None: # 如果cur_substr是None,证明没找到这部分分词,就设置成UNK
is_bad = True
break #退出外循环
sub_tokens.append(cur_substr)# 能到这的,cur_substr肯定有值,就在sub_tokens里加进cur_substr
start = end # 跳过找到的部分分词的最大索引
if is_bad: #如果是UNK(包括整个分词,没一部分在词汇里能找到和,即便有一些找到了,但有一个找不到,也是UNK)
output_tokens.append(self.unk_token)
else:#如果is_bad是False的话,就追加进去sub_tokens,注意这里不是cur_substr
output_tokens.extend(sub_tokens)
return output_tokens
#这里很绕,用个小例子验证下推理
#因为分词是基于空格分的,所以text里我故意加了空格,可以知道len('我们是')
#是3个字符,当进入外循环,在内循环,它会先找我们是,找不到,找我们,还找不到
#找我,找到了,设置start=end,end起始是3,被减了两次,这时是1,之后进入外循环
#又进入内循环,找们是,先找们是,会加上##,没在词汇里,end-1,继续,找们,找到了
#退出,这时end=2,之后进外循环,start=2,之后找是,因为start>0,会加##,没找到
#所以is_bad设为True,结果就是UNK,##说明是分词的一部分
vocab = ["我", "是", "学生", "##们", "学习", "英语", "很好"]
text = "我们是学习英语很好"
tokenizer = WordpieceTokenizer(vocab)
tokens = tokenizer.tokenize(text)
print(tokens)
len('我们是')
#总分词类
class FullTokenizer(object):
#词汇文件
def __init__(self, vocab_file, do_lower_case=True):
self.vocab = load_vocab(vocab_file) #词汇字典
#翻转字典,键值对互换
self.inv_vocab = {v: k for k, v in self.vocab.items()}
#进行一些基本的分词
self.basic_tokenizer = BasicTokenizer(do_lower_case=do_lower_case)
#更细粒度的分词类实例
self.wordpiece_tokenizer = WordpieceTokenizer(vocab=self.vocab)
def tokenize(self, text):
split_tokens = []
#基本分词,主要是把真实的文本去掉一些控制符,空字符,把一些空白字符统一变成空格符
for token in self.basic_tokenizer.tokenize(text):
#经过上面的处理,分词基本是英文单词,中文汉字,还有标点符号
# 这里进行更细的分词,词汇表有的直接进列表,没的看它能不能分成几部分,
#能,加进去,如果有一部分不能在词汇表找到,就设置为UNK
for sub_token in self.wordpiece_tokenizer.tokenize(token):
split_tokens.append(sub_token)
return split_tokens
# 文本转索引序列
def convert_tokens_to_ids(self, tokens):
return convert_by_vocab(self.vocab, tokens)
#索引转文本
def convert_ids_to_tokens(self, ids):
return convert_by_vocab(self.inv_vocab, ids)