[NLP]——BPE、WordPiece、Unigram and SentencePiece

前言

单词级别的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)\ast p(b))$$
这可以近似理解为合并前后，整个语料的互信息。即，当前选择合并的token对能够让语料的熵最小化->确定性最大化->信息量最小化->在计算机中存储所需要的编码长度最短化

Unigram

发表论文: Subword Regularization: Improving Neural Network Translation Models with Multiple Subword Candidates

用得上的时候再补充…