NLP Transformer 模型中 BPE(byte pair encoding 英文分词)详解 GPT-2 中的实现

简单解释概念 BPE—byte pair encoding：

Transformer NLP 预训练模型都通过 embedding 词典来表征词义，
当遇见没见过的词的时候以前是用"< u nk>"代替，这样会造成对新事物(新词、网络词、简写词)理解能力很差，BPE就是来解决这个问题的。
英文中会有词根和造词现象
例如: “greenhand” 如果你的词典中没有这个词，那么就可以把它拆成 **“green”,“hand”**两个词，这里green 向量 会跟发芽一类的词相近有新生的意思hand有操作手的意思那么就不难推测出greenhand是新手。
这个过程中会参考一个词典，这个词典从上往下是一个个词对，对应的顺序就是它出现的频率 越往上的词越高频率。

对应中文 相当于分词了。

GPT-2 中的实现

"""Byte pair encoding utilities"""

import os
import json
import regex as re
from functools import lru_cache


# 生成把bytes抓华为unicode词典 {97:“a”...}
@lru_cache()
def bytes_to_unicode():
    """
    Returns list of utf-8 byte and a corresponding list of unicode strings.
    The reversible bpe codes work on unicode strings.
    This means you need a large # of unicode characters in your vocab if you want to avoid UNKs.
    When you're at something like a 10B token dataset you end up needing around 5K for decent coverage.
    This is a signficant percentage of your normal, say, 32K bpe vocab.
    To avoid that, we want lookup tables between utf-8 bytes and unicode strings.
    And avoids mapping to whitespace/control characters the bpe code barfs on.
    """
    bs = list(range(ord("!"), ord("~") + 1)) + list(range(ord("¡"), ord("¬") + 1)) + list(range(ord("®"), ord("ÿ") + 1))
    cs = bs[:]
    n = 0
    for b in range(2 ** 8):
        if b not in bs:
            bs.append(b)
            cs.append(2 ** 8 + n)
            n += 1
    cs = [chr(n) for n in cs]
    return dict(zip(bs, cs))


# 把words做成一对一对的 传入"ABCD" 输出（('B', 'C'), ('A', 'B'), ('C', 'D')）
def get_pairs(word):
    """Return set of symbol pairs in a word.

    Word is represented as tuple of symbols (symbols being variable-length strings).
    """
    pairs = set()
    prev_char = word[0]
    for char in word[1:]:
        pairs.add((prev_char, char))
        prev_char = char
    return pairs


class Encoder:
    def __init__(self, encoder, bpe_merges, errors='replace'):
        self.encoder = encoder   #外部embedding词典
        self.decoder = {v: k for k, v in self.encoder.items()}
        self.errors = errors  # how to handle errors in decoding
        self.byte_encoder = bytes_to_unicode()
        self.byte_decoder = {v: k for k, v in self.byte_encoder.items()}

        self.bpe_ranks = dict(
            zip(bpe_merges,
                range(len(bpe_merges))))  # bpe_merges 是一个类似（Ġ t）（这里的这两个元素 是未来要用的 a b ） 元组 然后在用0123..的常用频率压缩起来成一个{（Ġ t）:1}
        # bpe_merges里面是各种零散词的常用程度排名
        self.cache = {}

        # Should haved added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
        self.pat = re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""")

    # 用来识别未见过的词语 把词拆成各个词源 例如:输入greenhand 输出"green hand"
    def bpe(self, token):
        # 如果dict（self.cache）中有token的key 那就返回对应的值(有缓存结果)
        if token in self.cache:
            return self.cache[token]

        word = tuple(token)  # 把list 转成 tuple
        # 下面就是把一个词，拆散了 输入（fiend） 输出(（f,i）,(i,e),(e,n),(n,d)) 注意返回set无序
        pairs = get_pairs(word)

        # 词很短 拆不了 直接返回 token
        if not pairs:
            return token

        # 迭代所有的pairs 中的词对
        while True:  # lambda 迭代对象:对应表达式
            # 将输入的pairs 按照.bpe文件 （常用排名）排序 这里的pair 就是 55行提到 a b
            # 找到最常用的哪个 pair float('inf') 表示无穷大 找不到的话 就返回无限大的值 以免被选上
            bigram = min(pairs, key=lambda pair: self.bpe_ranks.get(pair, float('inf')))  # MIN MAX 中key 相当于依据什么排序

            # 组合不在bpe表格中 pairs中不能再拆了 循环结束
            if bigram not in self.bpe_ranks:
                break

            # 拿到第一个词 第二个词
            first, second = bigram  # 拿到拆开的的对里 在表格里最常用的那一对
            
            new_word = []
            
            i = 0
            #  查找子串
            while i < len(word):

                try:
                    j = word.index(first, i)  # i指的是从第I个开始查找  #查找list.index(x,起始位置,终止位置) #从传入的word里 查找第一个单词
                    # 这里的意思是 因为pair 是无序的 要找到其在输入词中的顺序
                    new_word.extend(word[i:j])  # 将这个子串 first=word[i:j] 放入new_word变量中
                    i = j  # 移动指针
                except:
                    new_word.extend(word[i:])  # 当J越界时候 直接将 i: 切片放进去
                    break

                # 这里的意思是 如果first 和 second 这两个是连着的话 加到new_word时候 是一个整体
                if word[i] == first and i < len(word) - 1 and word[i + 1] == second:
                    new_word.append(first + second)
                    i += 2
                    # 否则的话 只加入word[i] ？？这块有点迷 后续更新一下
                else:
                    new_word.append(word[i])
                    i += 1
                    
            #类似于递归查找
            new_word = tuple(new_word)
            word = new_word
            
            #串不能再拆了
            if len(word) == 1:
                break
            else:
                #拆开再找一遍
                pairs = get_pairs(word)
        #用空格链接所有的词 
        word = ' '.join(word)
        #增加这个词的缓存，以后再碰到就不用运算了
        self.cache[token] = word
        return word

    # 不在self.encoder词典的词 编码过程
    def encode(self, text):
        bpe_tokens = []
        #self.pat .findall text 的意思是从text 中 把self.pat这里pattern找出来 其实就是she's 变成 she s两个单词
        for token in re.findall(self.pat, text):
            token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8'))
            #上面一句大致等价于 token = unicode(token, "utf-8") #将文字转成utf-8后 用self.byte_encoder——bytes_to_unicode()产生的dict 转回字符形式 然后将其连城字符串
            bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' '))
            #将拆完的词 在传入的embedding字典中查找，返回这个列表
        return bpe_tokens

    def decode(self, tokens):
        text = ''.join([self.decoder[token] for token in tokens])
        text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors=self.errors)
        return text


def get_encoder(model_name, models_dir):
    with open(os.path.join(models_dir, model_name, 'encoder.json'), 'r') as f:
        encoder = json.load(f)
    with open(os.path.join(models_dir, model_name, 'vocab.bpe'), 'r', encoding="utf-8") as f:
        bpe_data = f.read()
    bpe_merges = [tuple(merge_str.split()) for merge_str in bpe_data.split('\n')[1:-1]]
    return Encoder(
        encoder=encoder,
        bpe_merges=bpe_merges,
    )

gpt-2 代码解读

	gpt-2是OpenAI 旗下的 transformer 型NLP模型，对英文有着巨大的理解能力，目前最强参数达到了1.5Gb，有兴趣盆友可以上openAI看看.
	gpt-2跟bert应该差不多，这里建议大家学习transformer语言模型就行。如果很多人喜欢的话后面会出一个中文版的GPT-2代码解读，跟下面的原版会不太一样。基本都是代码加注释的。

下面是我找到觉得比较有用的资源
GPT-2代码详解文章:
代码详解
BPE:参考视频连接 ：油管搜"BERT Research - Ep. 2 - WordPiece Embeddings" 7:32部分开始