NLP 中Tranformer模型的BPE詳解（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部分開始