前言
单词级别的tokenizer有以下缺点:
- 单词变体算做不同单词,无法体现它们的关联
本文从代码层次解析四种常用的tokenizer(放弃了)
Byte Pair Encoding(BPE)
提出论文:Neural machine translation of rare words with subword units
以下讲解基本参考:Byte Pair Encoding
假设拥有一个含有很多单词的语料,首先统计各个单词出现的次数,以单词字符串为键、次数为值。预测同时,要对单词字符串进行两个操作:1. 首先给这个单词字符串后面加上一个结束符号"</w>", 2. 然后把单词字符串分成一个一个的字符。
比如我们有一个语料:['low','lower','newest','widest']
经过上述操作得到:{'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}
然后正试开始迭代,每一次迭代,遍历上述字典的所有键,把字符串按照空格分割成字符序列,统计所有字符对出现的次数,比如'es'
这个字符对出现了6+3=9次,而它也是出现次数最多的,所以将它合并。
这是第一次迭代的结果:{'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}
接下去的迭代一摸一样。需要注意的是,在第一次迭代以前,'e'
和's'
都作为单个token出现在语料中,在第一次迭代以后,所有的's'
都通过合并而消失了,而由于l o w e r
中还有'e'
,所以'e'
依然作为一个token存在。另外,别忘了,新增了一个'es'
token,总token数不变。
那么很容易想到每一轮的token数变化情况,有以下四种(假设当前轮是要去合并a和b这两个token):
- token数不变
- 所有的a都出现在b前面,合并之后a消失;而b前面不仅仅出现过a,合并之后b依然存在
- 所有的b都出现在a后面,合并之后b消失;而a后面不仅仅出现过b,合并之后a依然存在
- token数-1:a和b仅以对的形式出现,合并之后a和b消失,新增一个ab,总数-1
- token数+1:a后面不仅仅出现过b,同样的,b前面也不仅仅出现过a,原来token数不变,又新增一个ab,总数+1
token总数可能呈现这样的变化趋势:一开始的token出现形式多样,token总数会上升;随着不断地迭代合并,token数量增加,但token出现的形式减少,token总数会慢慢减少。
下面是代码部分:
import re, collections
def get_vocab(corpus):
vocab = collections.defaultdict(int)
for word in corpus:
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
corpus = ['low','lower','newest','widest']
vocab = get_vocab(corpus)
print('==========')
print('Tokens Before BPE')
tokens = get_tokens(vocab)
print('Tokens: {}'.format(tokens))
print('Number of tokens: {}'.format(len(tokens)))
print('==========')
num_merges = 3
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('==========')
输出:
==========
Tokens Before BPE
Tokens: defaultdict(<class 'int'>, {
'l': 2, 'o': 2, 'w': 4, '</w>': 4, 'e': 4, 'r': 1, 'n': 1, 's': 2, 't': 2, 'i': 1, 'd': 1})
Number of tokens: 11
==========
Iter: 0
Best pair: ('l', 'o')
Tokens: defaultdict(<class 'int'>, {
'lo': 2, 'w': 4, '</w>': 4, 'e': 4, 'r': 1, 'n': 1, 's': 2, 't': 2, 'i': 1, 'd': 1})
Number of tokens: 10
==========
Iter: 1
Best pair: ('lo', 'w')
Tokens: defaultdict(<class 'int'>, {
'low': 2, '</w>': 4, 'e': 4, 'r': 1, 'n': 1, 'w': 2, 's': 2, 't': 2, 'i': 1, 'd': 1})
Number of tokens: 10
==========
Iter: 2
Best pair: ('e', 's')
Tokens: defaultdict(<class 'int'>, {
'low': 2, '</w>': 4, 'e': 2, 'r': 1, 'n': 1, 'w': 2, 'es': 2, 't': 2, 'i': 1, 'd': 1})
Number of tokens: 10
==========
说明几个python相关:
- collections.defaultdict() 跟dict的区别就是,不存在的键也可以直接加进去
- re.escape() 把所有可能是正则的符号进行转义
- re.compile(r’(?<!\S)’ + bigram + r’(?!\S)’) 首尾不是非空字符–>首尾要么啥也没有,如果有,只能是空字符。比如要合并e和s,如果不加这一句,'e sd’会被合并成 ‘esd’
- best = max(pairs, key=pairs.get) 以字典中的值为关键字,选择值(出现次数)最大的键(token对)
接下来是解码和编码。所谓解码,就是把一个subword序列,拼回一个string,比如[“the</w>”, “high”, “est</w>”, “moun”, “tain</w>”]
—解码—>the</w> highest</w> mountain</w>
。这好做,下面将编码。
所谓编码,就是把一个string转换成subword序列,具体步骤为: 把迭代完的token集按照长度排序,长的在前,对于每一个string,从大大小遍历token集,一旦发现一个token出现在这个string中一次或者多次,出现这个token的地方保留下来,其它地方递归查询。特别的,假设目前匹配到的token在这个token集中的100个,那么string的其它地方只需要在第101开始的更短的token集中进行搜索。如果当前递归层的string,遍历了所有的token都没有任何匹配,就把它转成一个unknown token(’</u>‘)
下面是代码部分:
import re, collections
def get_vocab(corpus):
vocab = collections.defaultdict(int)
for word in corpus:
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_from_vocab(vocab):
tokens_frequencies = collections.defaultdict(int)
vocab_tokenization = {
}
for word, freq in vocab.items():
word_tokens = word.split()
for token in word_tokens:
tokens_frequencies[token] += freq
vocab_tokenization[''.join(word_tokens)] = word_tokens
return tokens_frequencies, vocab_tokenization
def measure_token_length(token):
if token[-4:] == '</w>':
return len(token[:-4]) + 1
else:
return len(token)
def tokenize_word(string, sorted_tokens, unknown_token='</u>'):
# Ilikeeatingapples
if string == '':
return []
if sorted_tokens == []:
return [unknown_token]
string_tokens = []
flag = 0
for i in range(len(sorted_tokens)):
token = sorted_tokens[i]
token_reg = re.escape(token.replace('.', '[.]'))
matched_positions = [(m.start(0), m.end(0)) for m in re.finditer(token_reg, string)]
if len(matched_positions) == 0:
continue
flag = 1
substring_end_positions = [matched_position[0] for matched_position in matched_positions]
substring_start_position = 0
for substring_end_position in substring_end_positions:
substring = string[substring_start_position:substring_end_position]
string_tokens += tokenize_word(string=substring, sorted_tokens=sorted_tokens[i+1:], unknown_token=unknown_token)
string_tokens += [token]
substring_start_position = substring_end_position + len(token)
remaining_substring = string[substring_start_position:]
string_tokens += tokenize_word(string=remaining_substring, sorted_tokens=sorted_tokens[i+1:], unknown_token=unknown_token)
break
if flag == 0:
return [unknown_token]
return string_tokens
corpus = ['low','lower','newest','widest']
vocab = get_vocab(corpus)
print('==========')
print('Tokens Before BPE')
tokens_frequencies, vocab_tokenization = get_tokens_from_vocab(vocab)
print('All tokens: {}'.format(tokens_frequencies.keys()))
print('Number of tokens: {}'.format(len(tokens_frequencies.keys())))
print('==========')
num_merges = 10
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_frequencies, vocab_tokenization = get_tokens_from_vocab(vocab)
# print('All tokens: {}'.format(tokens_frequencies.keys()))
# print('Number of tokens: {}'.format(len(tokens_frequencies.keys())))
# print('==========')
# Let's check how tokenization will be for a known word
word_given_known = 'newest</w>'
word_given_unknown = 'Ilikeeatingapples!</w>'
sorted_tokens_tuple = sorted(tokens_frequencies.items(), key=lambda item: (measure_token_length(item[0]), item[1]), reverse=True)
sorted_tokens = [token for (token, freq) in sorted_tokens_tuple]
print(sorted_tokens)
print(vocab_tokenization)
word_given = word_given_known
print('Tokenizing word: {}...'.format(word_given))
if word_given in vocab_tokenization:
print('Tokenization of the known word:')
print(vocab_tokenization[word_given])
print('Tokenization treating the known word as unknown:')
print(tokenize_word(string=word_given, sorted_tokens=sorted_tokens, unknown_token='</u>'))
else:
print('Tokenizating of the unknown word:')
print(tokenize_word(string=word_given, sorted_tokens=sorted_tokens, unknown_token='</u>'))
word_given = word_given_unknown
print('Tokenizing word: {}...'.format(word_given))
if word_given in vocab_tokenization:
print('Tokenization of the known word:')
print(vocab_tokenization[word_given])
print('Tokenization treating the known word as unknown:')
print(tokenize_word(string=word_given, sorted_tokens=sorted_tokens, unknown_token='</u>'))
else:
print('Tokenizating of the unknown word:')
print(tokenize_word(string=word_given, sorted_tokens=sorted_tokens, unknown_token='</u>'))
输出(有个问题:’</w>'会被匹配到,但在大规模语料上训练了,应该不会有这个问题):
==========
Tokens Before BPE
All tokens: dict_keys(['l', 'o', 'w', '</w>', 'e', 'r', 'n', 's', 't', 'i', 'd'])
Number of tokens: 11
==========
['lower</w>', 'est</w>', 'low</w>', 'ne', 'w', 'i', 'd']
{
'low</w>': ['low</w>'], 'lower</w>': ['lower</w>'], 'newest</w>': ['ne', 'w', 'est</w>'], 'widest</w>': ['w', 'i', 'd', 'est</w>']}
Tokenizing word: newest</w>...
Tokenization of the known word:
['ne', 'w', 'est</w>']
Tokenization treating the known word as unknown:
['ne', 'w', 'est</w>']
Tokenizing word: Ilikeeatingapples!</w>...
Tokenizating of the unknown word:
['</u>', 'i', '</u>', 'i', '</u>', 'w', '</u>']
另外,tokenize_word函数中关于flag的判断是我自己加的。
WordPiece
发表论文:Japanese and korean voice search.
参考:NLP三大Subword模型详解:BPE、WordPiece、ULM
信息论(1)——熵、互信息、相对熵
wordpiece和BPE的差异在于合并时对token对的选择:BPE是选择出现次数最大的,wordpiece衡量的是token对和单独的两个token之间的概率差,选择概率差最大的进行合并。
考虑token a和b,以及合并之后的token ab,概率差的公式如下:
p ( a , b ) / ( p ( a ) ∗ p ( b ) ) p(a,b) / (p(a) * p(b)) p(a,b)/(p(a)∗p(b))
这可以近似理解为合并前后,整个语料的互信息。即,当前选择合并的token对能够让语料的熵最小化->确定性最大化->信息量最小化->在计算机中存储所需要的编码长度最短化
Unigram
发表论文: Subword Regularization: Improving Neural Network Translation Models with Multiple Subword Candidates
用得上的时候再补充…