目錄

一、什么是BERT？

二、BERT安裝

三、預(yù)訓(xùn)練模型

四、運行Fine-Tuning

五、數(shù)據(jù)讀取源碼閱讀

（一） DataProcessor

（二） MrpcProcessor

六、分詞源碼閱讀

（一）FullTokenizer

（二） WordpieceTokenizer

七、run_classifier.py的main函數(shù)

八、BertModel類

九、自己進行Pretraining

十、性能測試

（一）關(guān)于max_seq_len對速度的影響

（二）client_batch_size對速度的影響

（三）num_client?對并發(fā)性和速度的影響

---

一、什么是BERT？

首先我們先看官方的介紹：

BERT is a method of pre-training language representations, meaning that we train a general-purpose "language understanding" model on a large text corpus (like Wikipedia), and then use that model for downstream NLP tasks that we care about (like question answering). BERT outperforms previous methods because it is the first?unsupervised,?deeply bidirectional?system for pre-training NLP.

劃重點：the first?unsupervised,?deeply bidirectional?system for pre-training NLP.

無監(jiān)督意味著BERT可以僅使用純文本語料庫進行訓(xùn)練，這是非常重要的特性，因為大量純文本數(shù)據(jù)在網(wǎng)絡(luò)上以多種語言公開。

（上面左圖，紅色的是ELMo，右二是BERT）

預(yù)訓(xùn)練方法可以粗略分為不聯(lián)系上下文的詞袋模型等和聯(lián)系上下文的方法。其中聯(lián)系上下文的方法可以進一步分為單向和雙向聯(lián)系上下文兩種。諸如NNLM、Skip-Gram、 Glove等詞袋模型，是一種單層Shallow模型，無法聯(lián)系上下文；而LSTM、Transformer為典型的可以聯(lián)系上下文的深層次網(wǎng)絡(luò)模型。

BERT是在現(xiàn)有預(yù)訓(xùn)練工作的基礎(chǔ)上對現(xiàn)有的技術(shù)的良好整合與一定的創(chuàng)新。現(xiàn)有的這些模型都是單向或淺雙向的。每個單詞僅使用左側(cè)（或右側(cè)）的單詞進行語境化。例如，在句子中

I ?have?fallen?in?love with a girl.

單向表示love僅基于I ?have?fallen?in?但不 基于with a girl。之前有一些模型也有可以聯(lián)系上下文的，但僅以單層"shallow"的方式。BERT能聯(lián)系上下文來表示“l(fā)ove” ----- I ?have?fallen?in ...?with a girl。是一種深層次、雙向的深度神經(jīng)網(wǎng)絡(luò)模型。

使用BERT有兩個階段：預(yù)訓(xùn)練和微調(diào)。

Pre-training?硬件成本相當(dāng)昂貴（4--16個云TPU需4天），但是每種語言都只需要訓(xùn)練一次（目前的模型主要為英語）。為節(jié)省計算資源，谷歌正在發(fā)布一些預(yù)先培訓(xùn)的模型。?

Fine-tuning 硬件成本相對較低。文中的實踐可以在單個云TPU上（最多1小時）或者在GPU（幾小時）復(fù)現(xiàn)出來。BERT的另一個重要方面是它可以適應(yīng)許多類型的NLP任務(wù)：

• 句子級別（例如，SST-2）
• 句子對級別（例如，MultiNLI）
• 單詞級別（例如，NER）
• 文本閱讀（例如，SQuAD）

二、BERT安裝

Google提供的BERT代碼在這里，可以直接git clone下來。注意運行它需要Tensorflow 1.11及其以上的版本，低版本的Tensorflow不能運行。

三、預(yù)訓(xùn)練模型

由于從頭開始(from scratch)訓(xùn)練需要巨大的計算資源，因此Google提供了預(yù)訓(xùn)練的模型(的checkpoint)，目前包括英語、漢語和多語言3類模型：

• BERT-Base, Uncased：12層，768隱藏，12頭，110M參數(shù)
• BERT-Large, Uncased：24層，1024個隱藏，16個頭，340M參數(shù)
• BERT-Base, Cased：12層，768隱藏，12頭，110M參數(shù)
• BERT-Large, Cased：24層，1024個隱藏，16個頭，340M參數(shù)
• BERT-Base, Multilingual Cased (New, recommended)：104種語言，12層，768隱藏，12頭，110M參數(shù)
• BERT-Base, Multilingual Uncased (Orig, not recommended)?（不推薦使用，Multilingual Cased代替使用）：102種語言，12層，768隱藏，12頭，110M參數(shù)
• BERT-Base, Chinese：中文簡體和繁體，12層，768隱藏，12頭，110M參數(shù)

Uncased的意思是在預(yù)處理的時候都變成了小寫，而cased是保留大小寫。

這么多版本應(yīng)該如何選擇呢？

如果我們處理的問題只包含英文，那么我們應(yīng)該選擇英語的版本(模型大效果好但是參數(shù)多訓(xùn)練慢而且需要更多內(nèi)存/顯存)。如果我們只處理中文，那么應(yīng)該使用中文的版本。如果是其他語言就使用多語言的版本。

四、運行Fine-Tuning

對于大部分情況，不需要重新Pretraining。我們要做的只是根據(jù)具體的任務(wù)進行Fine-Tuning，因此我們首先介紹Fine-Tuning。這里我們已GLUE的MRPC為例子，我們首先需要下載預(yù)訓(xùn)練的模型然后解壓，比如作者解壓后的位置是：

/home/chai/data/chinese_L-12_H-768_A-12 # 為了方便我們需要定義環(huán)境變量 export BERT_BASE_DIR=/home/chai/data/chinese_L-12_H-768_A-12

環(huán)境變量BERT_BASE_DIR是BERT Pretraining的目錄，它包含如下內(nèi)容：

~/data/chinese_L-12_H-768_A-12$ ls -1 bert_config.json bert_model.ckpt.data-00000-of-00001 bert_model.ckpt.index bert_model.ckpt.meta vocab.txt

vocab.txt是模型的詞典，這個文件會經(jīng)常要用到，后面會講到。

bert_config.json是BERT的配置(超參數(shù))，比如網(wǎng)絡(luò)的層數(shù)，通常我們不需要修改，但是也會經(jīng)常用到。

bert_model.ckpt*，這是預(yù)訓(xùn)練好的模型的checkpoint

Fine-Tuning模型的初始值就是來自于這些文件，然后根據(jù)不同的任務(wù)進行Fine-Tuning。

接下來我們需要下載GLUE數(shù)據(jù)，這可以使用這個腳本下載，可能需要代理才能下載。

但是大概率下載不下來，能下載的步驟也很麻煩，建議下載網(wǎng)盤的備份版本：
鏈接：https://pan.baidu.com/s/1-b4I3ocYhiuhu3bpSmCJ_Q
提取碼：z6mk

假設(shè)下載后的位置是：

/home/chai/data/glue_data # 同樣為了方便，我們定義如下的環(huán)境變量 export GLUE_DIR=/home/chai/data/glue_data

GLUE有很多任務(wù)，我們來看其中的MRPC任務(wù)。

chai:~/data/glue_data/MRPC$ head test.tsv index #1 ID #2 ID #1 String #2 String 0 1089874 1089925 PCCW 's chief operating officer , Mike Butcher , and Alex Arena , the chief financial officer , will report directly to Mr So . Current Chief Operating Officer Mike Butcher and Group Chief Financial Officer Alex Arena will report to So . 1 3019446 3019327 The world 's two largest automakers said their U.S. sales declined more than predicted last month as a late summer sales frenzy caused more of an industry backlash than expected . Domestic sales at both GM and No. 2 Ford Motor Co. declined more than predicted as a late summer sales frenzy prompted a larger-than-expected industry backlash .

數(shù)據(jù)是tsv(tab分割)文件，每行有4個用Tab分割的字段，分別表示index，第一個句子的id，第二個句子的id，第一個句子，第二個句子。也就是輸入兩個句子，模型判斷它們是否同一個意思(Paraphrase)。如果是測試數(shù)據(jù)，那么第一列就是index(無意義)，如果是訓(xùn)練數(shù)據(jù)，那么第一列就是0或者1，其中0代表不同的意思而1代表相同意思。接下來就可以運行如下命令來進行Fine-Tuning了：

python run_classifier.py \--task_name=MRPC \--do_train=true \--do_eval=true \--data_dir=$GLUE_DIR/MRPC \--vocab_file=$BERT_BASE_DIR/vocab.txt \--bert_config_file=$BERT_BASE_DIR/bert_config.json \--init_checkpoint=$BERT_BASE_DIR/bert_model.ckpt \--max_seq_length=128 \--train_batch_size=8 \--learning_rate=2e-5 \--num_train_epochs=3.0 \--output_dir=/tmp/mrpc_output/

這里簡單的解釋一下參數(shù)的含義，在后面的代碼閱讀里讀者可以更加詳細的了解其意義。

• task_name 任務(wù)的名字，這里我們Fine-Tuning MRPC任務(wù)
• do_train 是否訓(xùn)練，這里為True
• do_eval 是否在訓(xùn)練結(jié)束后驗證，這里為True
• data_dir 訓(xùn)練數(shù)據(jù)目錄，配置了環(huán)境變量后不需要修改，否則填入絕對路徑
• vocab_file BERT模型的詞典
• bert_config_file BERT模型的配置文件
• init_checkpoint Fine-Tuning的初始化參數(shù)
• max_seq_length Token序列的最大長度，這里是128
• train_batch_size batch大小，對于普通8GB的GPU，最大batch大小只能是8，再大就會OOM
• learning_rate
• num_train_epochs 訓(xùn)練的epoch次數(shù)，根據(jù)任務(wù)進行調(diào)整
• output_dir 訓(xùn)練得到的模型的存放目錄

這里最常見的問題就是內(nèi)存不夠，通常我們的GPU只有8G作用的顯存，因此對于小的模型(bert-base)，我們最多使用batchsize=8，而如果要使用bert-large，那么batchsize只能設(shè)置成1。運行結(jié)束后可能得到類似如下的結(jié)果：

***** Eval results ***** eval_accuracy = 0.845588 eval_loss = 0.505248 global_step = 343 loss = 0.505248

這說明在驗證集上的準(zhǔn)確率是0.84左右。

五、數(shù)據(jù)讀取源碼閱讀

（一） DataProcessor

我們首先來看數(shù)據(jù)是怎么讀入的。這是一個抽象基類，定義了get_train_examples、get_dev_examples、get_test_examples和get_labels等4個需要子類實現(xiàn)的方法，另外提供了一個_read_tsv函數(shù)用于讀取tsv文件。下面我們通過一個實現(xiàn)類MrpcProcessor來了解怎么實現(xiàn)這個抽象基類，如果讀者想使用自己的數(shù)據(jù)，那么就需要自己實現(xiàn)一個新的子類。

（二） MrpcProcessor

對于MRPC任務(wù)，這里定義了MrpcProcessor來基礎(chǔ)DataProcessor。我們來看其中的get_labels和get_train_examples，其余兩個抽象方法是類似的。首先是get_labels，它非常簡單，這任務(wù)只有兩個label。

def get_labels(self): return ["0", "1"]

接下來是get_train_examples：

def get_train_examples(self, data_dir):return self._create_examples(self._read_tsv(os.path.join(data_dir, "train.tsv")), "train")

這個函數(shù)首先使用_read_tsv讀入訓(xùn)練文件train.tsv，然后使用_create_examples函數(shù)把每一行變成一個InputExample對象。

def _create_examples(self, lines, set_type):examples = []for (i, line) in enumerate(lines):if i == 0:continueguid = "%s-%s" % (set_type, i)text_a = tokenization.convert_to_unicode(line[3])text_b = tokenization.convert_to_unicode(line[4])if set_type == "test":label = "0"else:label = tokenization.convert_to_unicode(line[0])examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))return examples

代碼非常簡單，line是一個list，line[3]和line[4]分別代表兩個句子，如果是訓(xùn)練集合和驗證集合，那么第一列l(wèi)ine[0]就是真正的label，而如果是測試集合，label就沒有意義，隨便賦值成”0”。然后對于所有的字符串都使用tokenization.convert_to_unicode把字符串變成unicode的字符串。這是為了兼容Python2和Python3，因為Python3的str就是unicode，而Python2的str其實是bytearray，Python2卻有一個專門的unicode類型。感興趣的讀者可以參考其實現(xiàn)，不感興趣的可以忽略。

最終構(gòu)造出一個InputExample對象來，它有4個屬性：guid、text_a、text_b和label，guid只是個唯一的id而已。text_a代表第一個句子，text_b代表第二個句子，第二個句子可以為None，label代表分類標(biāo)簽。

六、分詞源碼閱讀

分詞是我們需要重點關(guān)注的代碼，因為如果想要把BERT產(chǎn)品化，我們需要使用Tensorflow Serving，Tensorflow Serving的輸入是Tensor，把原始輸入變成Tensor一般需要在Client端完成。BERT的分詞是Python的代碼，如果我們使用其它語言的gRPC Client，那么需要用其它語言實現(xiàn)同樣的分詞算法，否則預(yù)測時會出現(xiàn)問題。

這部分代碼需要讀者有Unicode的基礎(chǔ)知識，了解什么是CodePoint，什么是Unicode Block。Python2和Python3的str有什么區(qū)別，Python2的unicode類等價于Python3的str等等。不熟悉的讀者可以參考一些資料。

（一）FullTokenizer

BERT里分詞主要是由FullTokenizer類來實現(xiàn)的。

class FullTokenizer(object): def __init__(self, vocab_file, do_lower_case=True):self.vocab = load_vocab(vocab_file)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):for sub_token in self.wordpiece_tokenizer.tokenize(token):split_tokens.append(sub_token)return split_tokensdef convert_tokens_to_ids(self, tokens):return convert_tokens_to_ids(self.vocab, tokens)

FullTokenizer的構(gòu)造函數(shù)需要傳入?yún)?shù)詞典vocab_file和do_lower_case。如果我們自己從頭開始訓(xùn)練模型(后面會介紹)，那么do_lower_case決定了我們的某些是否區(qū)分大小寫。如果我們只是Fine-Tuning，那么這個參數(shù)需要與模型一致，比如模型是chinese_L-12_H-768_A-12，那么do_lower_case就必須為True。

函數(shù)首先調(diào)用load_vocab加載詞典，建立詞到id的映射關(guān)系。下面是文件chinese_L-12_H-768_A-12/vocab.txt的部分內(nèi)容

馬 高 龍 ? ? ? ！ （ ） ， － ． ／ ： ？ ～ the of and in to

接下來是構(gòu)造BasicTokenizer和WordpieceTokenizer。前者是根據(jù)空格等進行普通的分詞，而后者會把前者的結(jié)果再細粒度的切分為WordPiece。

tokenize函數(shù)實現(xiàn)分詞，它先調(diào)用BasicTokenizer進行分詞，接著調(diào)用WordpieceTokenizer把前者的結(jié)果再做細粒度切分。下面我們來詳細閱讀這兩個類的代碼。我們首先來看BasicTokenizer的tokenize方法。

def tokenize(self, text): text = convert_to_unicode(text)text = self._clean_text(text)# 這是2018年11月1日為了支持多語言和中文增加的代碼。這個代碼也可以用于英語模型，因為在# 英語的訓(xùn)練數(shù)據(jù)中基本不會出現(xiàn)中文字符(但是某些wiki里偶爾也可能出現(xiàn)中文)。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

首先是用convert_to_unicode把輸入變成unicode，這個函數(shù)前面也介紹過了。接下來是_clean_text函數(shù)，它的作用是去除一些無意義的字符。

def _clean_text(self, text):"""去除一些無意義的字符以及whitespace"""output = []for char in text:cp = ord(char)if cp == 0 or cp == 0xfffd or _is_control(char):continueif _is_whitespace(char):output.append(" ")else:output.append(char)return "".join(output)

codepoint為0的是無意義的字符，0xfffd(U+FFFD)顯示為�，通常用于替換未知的字符。_is_control用于判斷一個字符是否是控制字符(control character)，所謂的控制字符就是用于控制屏幕的顯示，比如\n告訴(控制)屏幕把光標(biāo)移到下一行的開始。讀者可以參考這里。

def _is_control(char):"""檢查字符char是否是控制字符"""# 回車換行和tab理論上是控制字符，但是這里我們把它認為是whitespace而不是控制字符if char == "\t" or char == "\n" or char == "\r":return Falsecat = unicodedata.category(char)if cat.startswith("C"):return Truereturn False

這里使用了unicodedata.category這個函數(shù)，它返回這個Unicode字符的Category，這里C開頭的都被認為是控制字符，讀者可以參考這里。

接下來是調(diào)用_is_whitespace函數(shù)，把whitespace變成空格。

def _is_whitespace(char):"""Checks whether `chars` is a whitespace character."""# \t, \n, and \r are technically contorl characters but we treat them# as whitespace since they are generally considered as such.if char == " " or char == "\t" or char == "\n" or char == "\r":return Truecat = unicodedata.category(char)if cat == "Zs":return Truereturn False

這里把category為Zs的字符以及空格、tab、換行和回車當(dāng)成whitespace。然后是_tokenize_chinese_chars，用于切分中文，這里的中文分詞很簡單，就是切分成一個一個的漢字。也就是在中文字符的前后加上空格，這樣后續(xù)的分詞流程會把沒一個字符當(dāng)成一個詞。

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)

這里的關(guān)鍵是調(diào)用_is_chinese_char函數(shù)，這個函數(shù)用于判斷一個unicode字符是否中文字符。

def _is_chinese_char(self, cp):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 Truereturn False

很多網(wǎng)上的判斷漢字的正則表達式都只包括4E00-9FA5，但這是不全的，比如???就不再這個范圍內(nèi)。讀者可以參考這里。

接下來是使用whitespace進行分詞，這是通過函數(shù)whitespace_tokenize來實現(xiàn)的。它直接調(diào)用split函數(shù)來實現(xiàn)分詞。Python里whitespace包括’\t\n\x0b\x0c\r ‘。然后遍歷每一個詞，如果需要變成小寫，那么先用lower()函數(shù)變成小寫，接著調(diào)用_run_strip_accents函數(shù)去除accent。它的代碼為：

def _run_strip_accents(self, text):text = unicodedata.normalize("NFD", text)output = []for char in text:cat = unicodedata.category(char)if cat == "Mn":continueoutput.append(char)return "".join(output)

它首先調(diào)用unicodedata.normalize(“NFD”, text)對text進行歸一化。這個函數(shù)有什么作用呢？我們先看一下下面的代碼：

>>> s1 = 'café' >>> s2 = 'cafe\u0301' >>> s1, s2 ('café', 'café') >>> len(s1), len(s2) (4, 5) >>> s1 == s2 False

我們”看到”的é其實可以有兩種表示方法，一是用一個codepoint直接表示”é”，另外一種是用”e”再加上特殊的codepoint U+0301兩個字符來表示。U+0301是COMBINING ACUTE ACCENT，它跟在e之后就變成了”é”。類似的”a\u0301”顯示出來就是”á”。注意：這只是打印出來一模一樣而已，但是在計算機內(nèi)部的表示它們完全不同的，前者é是一個codepoint，值為0xe9，而后者是兩個codepoint，分別是0x65和0x301。unicodedata.normalize(“NFD”, text)就會把0xe9變成0x65和0x301，比如下面的測試代碼。

接下來遍歷每一個codepoint，把category為Mn的去掉，比如前面的U+0301，COMBINING ACUTE ACCENT就會被去掉。category為Mn的所有Unicode字符完整列表在這里。

s = unicodedata.normalize("NFD", "é") for c in s:print("%#x" %(ord(c)))# 輸出為： 0x65 0x301

處理完大小寫和accent之后得到的Token通過函數(shù)_run_split_on_punc再次用標(biāo)點切分。這個函數(shù)會對輸入字符串用標(biāo)點進行切分，返回一個list，list的每一個元素都是一個char。比如輸入he’s，則輸出是[[h,e], [’],[s]]。代碼很簡單，這里就不贅述。里面它會調(diào)用函數(shù)_is_punctuation來判斷一個字符是否標(biāo)點。

def _is_punctuation(char): cp = ord(char)# 我們把ASCII里非字母數(shù)字都當(dāng)成標(biāo)點。# 在Unicode的category定義里， "^", "$", and "`" 等都不是標(biāo)點，但是我們這里都認為是標(biāo)點。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 Truecat = unicodedata.category(char)# category是P開頭的都是標(biāo)點，參考https://en.wikipedia.org/wiki/Unicode_character_propertyif cat.startswith("P"):return Truereturn False

（二） WordpieceTokenizer

WordpieceTokenizer的作用是把詞再切分成更細粒度的WordPiece。WordPiece(Byte Pair Encoding)是一種解決OOV問題的方法，如果不管細節(jié)，我們把它看成比詞更小的基本單位就行。對于中文來說，WordpieceTokenizer什么也不干，因為之前的分詞已經(jīng)是基于字符的了。有興趣的讀者可以參考這個開源項目。一般情況我們不需要自己重新生成WordPiece，使用BERT模型里自帶的就行。

WordpieceTokenizer的代碼為：

def tokenize(self, text):# 把一段文字切分成word piece。這其實是貪心的最大正向匹配算法。# 比如：# input = "unaffable"# output = ["un", "##aff", "##able"]text = convert_to_unicode(text)output_tokens = []for token in whitespace_tokenize(text):chars = list(token)if len(chars) > self.max_input_chars_per_word:output_tokens.append(self.unk_token)continueis_bad = Falsestart = 0sub_tokens = []while start < len(chars):end = len(chars)cur_substr = Nonewhile start < end:substr = "".join(chars[start:end])if start > 0:substr = "##" + substrif substr in self.vocab:cur_substr = substrbreakend -= 1if cur_substr is None:is_bad = Truebreaksub_tokens.append(cur_substr)start = endif is_bad:output_tokens.append(self.unk_token)else:output_tokens.extend(sub_tokens)return output_tokens

代碼有點長，但是很簡單，就是貪心的最大正向匹配。其實為了加速，是可以把詞典加載到一個Double Array Trie里的。我們用一個例子來看代碼的執(zhí)行過程。比如假設(shè)輸入是”unaffable”。我們跳到while循環(huán)部分，這是start=0，end=len(chars)=9，也就是先看看unaffable在不在詞典里，如果在，那么直接作為一個WordPiece，如果不再，那么end-=1，也就是看unaffabl在不在詞典里，最終發(fā)現(xiàn)”un”在詞典里，把un加到結(jié)果里。

接著start=2，看affable在不在，不在再看affabl，…，最后發(fā)現(xiàn)?##aff?在詞典里。注意：##表示這個詞是接著前面的，這樣使得WordPiece切分是可逆的——我們可以恢復(fù)出“真正”的詞。

七、run_classifier.py的main函數(shù)

main函數(shù)的主要代碼為：

main()bert_config = modeling.BertConfig.from_json_file(FLAGS.bert_config_file)task_name = FLAGS.task_name.lower()processor = processors[task_name]()label_list = processor.get_labels()tokenizer = tokenization.FullTokenizer(vocab_file=FLAGS.vocab_file, do_lower_case=FLAGS.do_lower_case)run_config = tf.contrib.tpu.RunConfig(cluster=tpu_cluster_resolver,master=FLAGS.master,model_dir=FLAGS.output_dir,save_checkpoints_steps=FLAGS.save_checkpoints_steps,tpu_config=tf.contrib.tpu.TPUConfig(iterations_per_loop=FLAGS.iterations_per_loop,num_shards=FLAGS.num_tpu_cores,per_host_input_for_training=is_per_host))train_examples = Nonenum_train_steps = Nonenum_warmup_steps = Noneif FLAGS.do_train:train_examples = processor.get_train_examples(FLAGS.data_dir)num_train_steps = int(len(train_examples) / FLAGS.train_batch_size * FLAGS.num_train_epochs)num_warmup_steps = int(num_train_steps * FLAGS.warmup_proportion)model_fn = model_fn_builder(bert_config=bert_config,num_labels=len(label_list),init_checkpoint=FLAGS.init_checkpoint,learning_rate=FLAGS.learning_rate,num_train_steps=num_train_steps,num_warmup_steps=num_warmup_steps,use_tpu=FLAGS.use_tpu,use_one_hot_embeddings=FLAGS.use_tpu)# 如果沒有TPU，那么會使用GPU或者CPUestimator = tf.contrib.tpu.TPUEstimator(use_tpu=FLAGS.use_tpu,model_fn=model_fn,config=run_config,train_batch_size=FLAGS.train_batch_size,eval_batch_size=FLAGS.eval_batch_size,predict_batch_size=FLAGS.predict_batch_size)if FLAGS.do_train:train_file = os.path.join(FLAGS.output_dir, "train.tf_record")file_based_convert_examples_to_features(train_examples, label_list, FLAGS.max_seq_length, tokenizer, train_file)train_input_fn = file_based_input_fn_builder(input_file=train_file,seq_length=FLAGS.max_seq_length,is_training=True,drop_remainder=True)estimator.train(input_fn=train_input_fn, max_steps=num_train_steps)if FLAGS.do_eval:eval_examples = processor.get_dev_examples(FLAGS.data_dir)eval_file = os.path.join(FLAGS.output_dir, "eval.tf_record")file_based_convert_examples_to_features(eval_examples, label_list, FLAGS.max_seq_length, tokenizer, eval_file)# This tells the estimator to run through the entire set.eval_steps = Noneeval_drop_remainder = True if FLAGS.use_tpu else Falseeval_input_fn = file_based_input_fn_builder(input_file=eval_file,seq_length=FLAGS.max_seq_length,is_training=False,drop_remainder=eval_drop_remainder)result = estimator.evaluate(input_fn=eval_input_fn, steps=eval_steps)if FLAGS.do_predict:predict_examples = processor.get_test_examples(FLAGS.data_dir)predict_file = os.path.join(FLAGS.output_dir, "predict.tf_record")file_based_convert_examples_to_features(predict_examples, label_list,FLAGS.max_seq_length, tokenizer, predict_file)predict_drop_remainder = True if FLAGS.use_tpu else Falsepredict_input_fn = file_based_input_fn_builder(input_file=predict_file,seq_length=FLAGS.max_seq_length,is_training=False,drop_remainder=predict_drop_remainder)result = estimator.predict(input_fn=predict_input_fn)

這里使用的是Tensorflow的Estimator API，這里只介紹訓(xùn)練部分的代碼。

首先是通過file_based_convert_examples_to_features函數(shù)把輸入的tsv文件變成TFRecord文件，便于Tensorflow處理。

train_file = os.path.join(FLAGS.output_dir, "train.tf_record")file_based_convert_examples_to_features(train_examples, label_list, FLAGS.max_seq_length, tokenizer, train_file)def file_based_convert_examples_to_features(examples, label_list, max_seq_length, tokenizer, output_file):writer = tf.python_io.TFRecordWriter(output_file)for (ex_index, example) in enumerate(examples):feature = convert_single_example(ex_index, example, label_list,max_seq_length, tokenizer)def create_int_feature(values):f = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))return ffeatures = collections.OrderedDict()features["input_ids"] = create_int_feature(feature.input_ids)features["input_mask"] = create_int_feature(feature.input_mask)features["segment_ids"] = create_int_feature(feature.segment_ids)features["label_ids"] = create_int_feature([feature.label_id])tf_example = tf.train.Example(features=tf.train.Features(feature=features))writer.write(tf_example.SerializeToString())

file_based_convert_examples_to_features函數(shù)遍歷每一個example(InputExample類的對象)。然后使用convert_single_example函數(shù)把每個InputExample對象變成InputFeature。InputFeature就是一個存放特征的對象，它包括input_ids、input_mask、segment_ids和label_id，這4個屬性除了label_id是一個int之外，其它都是int的列表，因此使用create_int_feature函數(shù)把它變成tf.train.Feature，而label_id需要構(gòu)造一個只有一個元素的列表，最后構(gòu)造tf.train.Example對象，然后寫到TFRecord文件里。后面Estimator的input_fn會用到它。

這里的最關(guān)鍵是convert_single_example函數(shù)，讀懂了它就真正明白BERT把輸入表示成向量的過程，所以請讀者仔細閱讀代碼和其中的注釋。

def convert_single_example(ex_index, example, label_list, max_seq_length,tokenizer):"""把一個`InputExample`對象變成`InputFeatures`."""# label_map把label變成id，這個函數(shù)每個example都需要執(zhí)行一次，其實是可以優(yōu)化的。# 只需要在可以再外面執(zhí)行一次傳入即可。label_map = {}for (i, label) in enumerate(label_list):label_map[label] = itokens_a = tokenizer.tokenize(example.text_a)tokens_b = Noneif example.text_b:tokens_b = tokenizer.tokenize(example.text_b)if tokens_b:# 如果有b，那么需要保留3個特殊Token[CLS], [SEP]和[SEP]# 如果兩個序列加起來太長，就需要去掉一些。_truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)else:# 沒有b則只需要保留[CLS]和[SEP]兩個特殊字符# 如果Token太多，就直接截取掉后面的部分。if len(tokens_a) > max_seq_length - 2:tokens_a = tokens_a[0:(max_seq_length - 2)]# BERT的約定是：# (a) 對于兩個序列：# tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]# type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1# (b) 對于一個序列：# tokens: [CLS] the dog is hairy . [SEP]# type_ids: 0 0 0 0 0 0 0## 這里"type_ids"用于區(qū)分一個Token是來自第一個還是第二個序列# 對于type=0和type=1，模型會學(xué)習(xí)出兩個Embedding向量。# 雖然理論上這是不必要的，因為[SEP]隱式的確定了它們的邊界。# 但是實際加上type后，模型能夠更加容易的知道這個詞屬于那個序列。## 對于分類任務(wù)，[CLS]對應(yīng)的向量可以被看成 "sentence vector"# 注意：一定需要Fine-Tuning之后才有意義tokens = []segment_ids = []tokens.append("[CLS]")segment_ids.append(0)for token in tokens_a:tokens.append(token)segment_ids.append(0)tokens.append("[SEP]")segment_ids.append(0)if tokens_b:for token in tokens_b:tokens.append(token)segment_ids.append(1)tokens.append("[SEP]")segment_ids.append(1)input_ids = tokenizer.convert_tokens_to_ids(tokens)# mask是1表示是"真正"的Token，0則是Padding出來的。在后面的Attention時會通過tricky的技巧讓# 模型不能attend to這些padding出來的Token上。input_mask = [1] * len(input_ids)# padding使得序列長度正好等于max_seq_lengthwhile len(input_ids) < max_seq_length:input_ids.append(0)input_mask.append(0)segment_ids.append(0)label_id = label_map[example.label]feature = InputFeatures(input_ids=input_ids,input_mask=input_mask,segment_ids=segment_ids,label_id=label_id)return feature

如果兩個Token序列的長度太長，那么需要去掉一些，這會用到_truncate_seq_pair函數(shù)：

def _truncate_seq_pair(tokens_a, tokens_b, max_length):while True:total_length = len(tokens_a) + len(tokens_b)if total_length <= max_length:breakif len(tokens_a) > len(tokens_b):tokens_a.pop()else:tokens_b.pop()

這個函數(shù)很簡單，如果兩個序列的長度小于max_length，那么不用truncate，否則在tokens_a和tokens_b中選擇長的那個序列來pop掉最后面的那個Token，這樣的結(jié)果是使得兩個Token序列一樣長(或者最多a比b多一個Token)。對于Estimator API來說，最重要的是實現(xiàn)model_fn和input_fn。我們先看input_fn，它是由file_based_input_fn_builder構(gòu)造出來的。代碼如下：

def file_based_input_fn_builder(input_file, seq_length, is_training,drop_remainder):name_to_features = {"input_ids": tf.FixedLenFeature([seq_length], tf.int64),"input_mask": tf.FixedLenFeature([seq_length], tf.int64),"segment_ids": tf.FixedLenFeature([seq_length], tf.int64),"label_ids": tf.FixedLenFeature([], tf.int64),}def _decode_record(record, name_to_features):# 把record decode成TensorFlow example.example = tf.parse_single_example(record, name_to_features)# tf.Example只支持tf.int64，但是TPU只支持tf.int32.# 因此我們把所有的int64變成int32.for name in list(example.keys()):t = example[name]if t.dtype == tf.int64:t = tf.to_int32(t)example[name] = treturn exampledef input_fn(params): batch_size = params["batch_size"]# 對于訓(xùn)練來說，我們會重復(fù)的讀取和shuffling # 對于驗證和測試，我們不需要shuffling和并行讀取。d = tf.data.TFRecordDataset(input_file)if is_training:d = d.repeat()d = d.shuffle(buffer_size=100)d = d.apply(tf.contrib.data.map_and_batch(lambda record: _decode_record(record, name_to_features),batch_size=batch_size,drop_remainder=drop_remainder))return dreturn input_fn

這個函數(shù)返回一個函數(shù)input_fn。這個input_fn函數(shù)首先從文件得到TFRecordDataset，然后根據(jù)是否訓(xùn)練來shuffle和重復(fù)讀取。然后用applay函數(shù)對每一個TFRecord進行map_and_batch，調(diào)用_decode_record函數(shù)對record進行parsing。從而把TFRecord的一條Record變成tf.Example對象，這個對象包括了input_ids等4個用于訓(xùn)練的Tensor。

接下來是model_fn_builder，它用于構(gòu)造Estimator使用的model_fn。下面是它的主要代碼(一些無關(guān)的log和TPU相關(guān)代碼去掉了)：

def model_fn_builder(bert_config, num_labels, init_checkpoint, learning_rate,num_train_steps, num_warmup_steps, use_tpu,use_one_hot_embeddings): # 注意：在model_fn的設(shè)計里，features表示輸入(特征)，而labels表示輸出# 但是這里的實現(xiàn)有點不好，把label也放到了features里。def model_fn(features, labels, mode, params): input_ids = features["input_ids"]input_mask = features["input_mask"]segment_ids = features["segment_ids"]label_ids = features["label_ids"]is_training = (mode == tf.estimator.ModeKeys.TRAIN)# 創(chuàng)建Transformer模型，這是最主要的代碼。(total_loss, per_example_loss, logits, probabilities) = create_model(bert_config, is_training, input_ids, input_mask, segment_ids, label_ids,num_labels, use_one_hot_embeddings)tvars = tf.trainable_variables()# 從checkpoint恢復(fù)參數(shù)if init_checkpoint: (assignment_map, initialized_variable_names) = modeling.get_assignment_map_from_checkpoint(tvars, init_checkpoint)tf.train.init_from_checkpoint(init_checkpoint, assignment_map)output_spec = None# 構(gòu)造訓(xùn)練的specif mode == tf.estimator.ModeKeys.TRAIN:train_op = optimization.create_optimizer(total_loss, learning_rate, num_train_steps, num_warmup_steps, use_tpu)output_spec = tf.contrib.tpu.TPUEstimatorSpec(mode=mode,loss=total_loss,train_op=train_op,scaffold_fn=scaffold_fn)# 構(gòu)造eval的specelif mode == tf.estimator.ModeKeys.EVAL: def metric_fn(per_example_loss, label_ids, logits):predictions = tf.argmax(logits, axis=-1, output_type=tf.int32)accuracy = tf.metrics.accuracy(label_ids, predictions)loss = tf.metrics.mean(per_example_loss)return {"eval_accuracy": accuracy,"eval_loss": loss,}eval_metrics = (metric_fn, [per_example_loss, label_ids, logits])output_spec = tf.contrib.tpu.TPUEstimatorSpec(mode=mode,loss=total_loss,eval_metrics=eval_metrics,scaffold_fn=scaffold_fn)# 預(yù)測的specelse:output_spec = tf.contrib.tpu.TPUEstimatorSpec(mode=mode,predictions=probabilities,scaffold_fn=scaffold_fn)return output_specreturn model_fn

這里的代碼都是一些boilerplate代碼，沒什么可說的，最重要的是調(diào)用create_model”真正”的創(chuàng)建Transformer模型。下面我們來看這個函數(shù)的代碼：

def create_model(bert_config, is_training, input_ids, input_mask, segment_ids,labels, num_labels, use_one_hot_embeddings): model = modeling.BertModel(config=bert_config,is_training=is_training,input_ids=input_ids,input_mask=input_mask,token_type_ids=segment_ids,use_one_hot_embeddings=use_one_hot_embeddings)# 在這里，我們是用來做分類，因此我們只需要得到[CLS]最后一層的輸出。# 如果需要做序列標(biāo)注，那么可以使用model.get_sequence_output()# 默認參數(shù)下它返回的output_layer是[8, 768]output_layer = model.get_pooled_output()# 默認是768hidden_size = output_layer.shape[-1].valueoutput_weights = tf.get_variable("output_weights", [num_labels, hidden_size],initializer=tf.truncated_normal_initializer(stddev=0.02))output_bias = tf.get_variable("output_bias", [num_labels], initializer=tf.zeros_initializer())with tf.variable_scope("loss"):if is_training:# 0.1的概率會dropoutoutput_layer = tf.nn.dropout(output_layer, keep_prob=0.9)# 對[CLS]輸出的768的向量再做一個線性變換，輸出為label的個數(shù)。得到logitslogits = tf.matmul(output_layer, output_weights, transpose_b=True)logits = tf.nn.bias_add(logits, output_bias)probabilities = tf.nn.softmax(logits, axis=-1)log_probs = tf.nn.log_softmax(logits, axis=-1)one_hot_labels = tf.one_hot(labels, depth=num_labels, dtype=tf.float32)per_example_loss = -tf.reduce_sum(one_hot_labels * log_probs, axis=-1)loss = tf.reduce_mean(per_example_loss)return (loss, per_example_loss, logits, probabilities)

上面代碼調(diào)用modeling.BertModel得到BERT模型，然后使用它的get_pooled_output方法得到[CLS]最后一層的輸出，這是一個768(默認參數(shù)下)的向量，然后就是常規(guī)的接一個全連接層得到logits，然后softmax得到概率，之后就可以根據(jù)真實的分類標(biāo)簽計算loss。我們這時候發(fā)現(xiàn)關(guān)鍵的代碼是modeling.BertModel。

八、BertModel類

這個類是最終定義模型的地方，代碼比較多，我們會按照執(zhí)行和調(diào)用的順序逐個閱讀。因為文字只能線性描述，但是函數(shù)的調(diào)用關(guān)系很復(fù)雜，所以建議讀者對照源代碼來閱讀。

我們首先來看這個類的用法，把它當(dāng)成黑盒。前面的create_model也用到了BertModel，這里我們在詳細的介紹一下。下面的代碼演示了BertModel的使用方法：

# 假設(shè)輸入已經(jīng)分詞并且變成WordPiece的id了?# 輸入是[2, 3]，表示batch=2，max_seq_length=3input_ids = tf.constant([[31, 51, 99], [15, 5, 0]])# 第一個例子實際長度為3，第二個例子長度為2input_mask = tf.constant([[1, 1, 1], [1, 1, 0]])# 第一個例子的3個Token中前兩個屬于句子1，第三個屬于句子2# 而第二個例子的第一個Token屬于句子1，第二個屬于句子2(第三個是padding)token_type_ids = tf.constant([[0, 0, 1], [0, 1, 0]])# 創(chuàng)建一個BertConfig，詞典大小是32000，Transformer的隱單元個數(shù)是512# 8個Transformer block，每個block有6個Attention Head，全連接層的隱單元是1024config = modeling.BertConfig(vocab_size=32000, hidden_size=512,num_hidden_layers=8, num_attention_heads=6, intermediate_size=1024)# 創(chuàng)建BertModelmodel = modeling.BertModel(config=config, is_training=True,input_ids=input_ids, input_mask=input_mask, token_type_ids=token_type_ids)# label_embeddings用于把512的隱單元變換成logitslabel_embeddings = tf.get_variable(...)# 得到[CLS]最后一層輸出，把它看成句子的Embedding(Encoding)pooled_output = model.get_pooled_output()# 計算logitslogits = tf.matmul(pooled_output, label_embeddings)

接下來我們看一下BertModel的構(gòu)造函數(shù)：

def __init__(self,config,is_training,input_ids,input_mask=None,token_type_ids=None,use_one_hot_embeddings=True,scope=None): # Args:# config: `BertConfig` 對象# is_training: bool 表示訓(xùn)練還是eval，是會影響dropout# input_ids: int32 Tensor shape是[batch_size, seq_length]# input_mask: (可選) int32 Tensor shape是[batch_size, seq_length]# token_type_ids: (可選) int32 Tensor shape是[batch_size, seq_length]# use_one_hot_embeddings: (可選) bool# 如果True，使用矩陣乘法實現(xiàn)提取詞的Embedding；否則用tf.embedding_lookup()# 對于TPU，使用前者更快，對于GPU和CPU，后者更快。# scope: (可選) 變量的scope。默認是"bert"# Raises:# ValueError: 如果config或者輸入tensor的shape有問題就會拋出這個異常config = copy.deepcopy(config)if not is_training:config.hidden_dropout_prob = 0.0config.attention_probs_dropout_prob = 0.0input_shape = get_shape_list(input_ids, expected_rank=2)batch_size = input_shape[0]seq_length = input_shape[1]if input_mask is None:input_mask = tf.ones(shape=[batch_size, seq_length], dtype=tf.int32)if token_type_ids is None:token_type_ids = tf.zeros(shape=[batch_size, seq_length], dtype=tf.int32)with tf.variable_scope(scope, default_name="bert"):with tf.variable_scope("embeddings"):# 詞的Embedding lookup (self.embedding_output, self.embedding_table) = embedding_lookup(input_ids=input_ids,vocab_size=config.vocab_size,embedding_size=config.hidden_size,initializer_range=config.initializer_range,word_embedding_name="word_embeddings",use_one_hot_embeddings=use_one_hot_embeddings)# 增加位置embeddings和token type的embeddings，然后是# layer normalize和dropout。self.embedding_output = embedding_postprocessor(input_tensor=self.embedding_output,use_token_type=True,token_type_ids=token_type_ids,token_type_vocab_size=config.type_vocab_size,token_type_embedding_name="token_type_embeddings",use_position_embeddings=True,position_embedding_name="position_embeddings",initializer_range=config.initializer_range,max_position_embeddings=config.max_position_embeddings,dropout_prob=config.hidden_dropout_prob)with tf.variable_scope("encoder"):# 把shape為[batch_size, seq_length]的2D mask變成# shape為[batch_size, seq_length, seq_length]的3D mask# 以便后向的attention計算，讀者可以對比之前的Transformer的代碼。attention_mask = create_attention_mask_from_input_mask(input_ids, input_mask)# 多個Transformer模型stack起來。# all_encoder_layers是一個list，長度為num_hidden_layers（默認12），每一層對應(yīng)一個值。# 每一個值都是一個shape為[batch_size, seq_length, hidden_size]的tensor。self.all_encoder_layers = transformer_model(input_tensor=self.embedding_output,attention_mask=attention_mask,hidden_size=config.hidden_size,num_hidden_layers=config.num_hidden_layers,num_attention_heads=config.num_attention_heads,intermediate_size=config.intermediate_size,intermediate_act_fn=get_activation(config.hidden_act),hidden_dropout_prob=config.hidden_dropout_prob,attention_probs_dropout_prob=config.attention_probs_dropout_prob,initializer_range=config.initializer_range,do_return_all_layers=True)# `sequence_output` 是最后一層的輸出，shape是[batch_size, seq_length, hidden_size]self.sequence_output = self.all_encoder_layers[-1]with tf.variable_scope("pooler"):# 取最后一層的第一個時刻[CLS]對應(yīng)的tensor# 從[batch_size, seq_length, hidden_size]變成[batch_size, hidden_size]# sequence_output[:, 0:1, :]得到的是[batch_size, 1, hidden_size]# 我們需要用squeeze把第二維去掉。first_token_tensor = tf.squeeze(self.sequence_output[:, 0:1, :], axis=1)# 然后再加一個全連接層，輸出仍然是[batch_size, hidden_size]self.pooled_output = tf.layers.dense(first_token_tensor,config.hidden_size,activation=tf.tanh,kernel_initializer=create_initializer(config.initializer_range))

代碼很長，但是其實很簡單。首先是對config(BertConfig對象)深度拷貝一份，如果不是訓(xùn)練，那么把dropout都置為零。如果輸入的input_mask為None，那么構(gòu)造一個shape合適值全為1的input_mask，這表示輸入都是”真實”的輸入，沒有padding的內(nèi)容。如果token_type_ids為None，那么構(gòu)造一個shape合適并且值全為0的tensor，表示所有Token都屬于第一個句子。

然后使用embedding_lookup函數(shù)構(gòu)造詞的Embedding，用embedding_postprocessor函數(shù)增加位置embeddings和token type的embeddings，然后是layer normalize和dropout。

接著用transformer_model函數(shù)構(gòu)造多個Transformer SubLayer然后stack在一起。得到的all_encoder_layers是一個list，長度為num_hidden_layers（默認12），每一層對應(yīng)一個值。 每一個值都是一個shape為[batch_size, seq_length, hidden_size]的tensor。

self.sequence_output是最后一層的輸出，shape是[batch_size, seq_length, hidden_size]。first_token_tensor是第一個Token([CLS])最后一層的輸出，shape是[batch_size, hidden_size]。最后對self.sequence_output再加一個線性變換，得到的tensor仍然是[batch_size, hidden_size]。

embedding_lookup函數(shù)用于實現(xiàn)Embedding，它有兩種方式：使用tf.nn.embedding_lookup和矩陣乘法(one_hot_embedding=True)。前者適合于CPU與GPU，后者適合于TPU。所謂的one-hot方法是把輸入id表示成one-hot的向量，當(dāng)然輸入id序列就變成了one-hot的矩陣，然后乘以Embedding矩陣。而tf.nn.embedding_lookup是直接用id當(dāng)下標(biāo)提取Embedding矩陣對應(yīng)的向量。一般認為tf.nn.embedding_lookup更快一點，但是TPU上似乎不是這樣，作者也不太了解原因是什么，猜測可能是TPU的沒有快捷的辦法提取矩陣的某一行/列？

def embedding_lookup(input_ids,vocab_size,embedding_size=128,initializer_range=0.02,word_embedding_name="word_embeddings",use_one_hot_embeddings=False):"""word embeddingArgs:input_ids: int32 Tensor shape為[batch_size, seq_length]，表示W(wǎng)ordPiece的idvocab_size: int 詞典大小，需要于vocab.txt一致 embedding_size: int embedding后向量的大小 initializer_range: float 隨機初始化的范圍 word_embedding_name: string 名字，默認是"word_embeddings"use_one_hot_embeddings: bool 如果True，使用one-hot方法實現(xiàn)embedding；否則使用 `tf.nn.embedding_lookup()`. TPU適合用One hot方法。Returns:float Tensor shape為[batch_size, seq_length, embedding_size]"""# 這個函數(shù)假設(shè)輸入的shape是[batch_size, seq_length, num_inputs]# 普通的Embeding一般假設(shè)輸入是[batch_size, seq_length]，# 增加num_inputs這一維度的目的是為了一次計算更多的Embedding# 但目前的代碼并沒有用到，傳入的input_ids都是2D的，這增加了代碼的閱讀難度。# 如果輸入是[batch_size, seq_length]，# 那么我們把它 reshape成[batch_size, seq_length, 1]if input_ids.shape.ndims == 2:input_ids = tf.expand_dims(input_ids, axis=[-1])# 構(gòu)造Embedding矩陣，shape是[vocab_size, embedding_size]embedding_table = tf.get_variable(name=word_embedding_name,shape=[vocab_size, embedding_size],initializer=create_initializer(initializer_range))if use_one_hot_embeddings:flat_input_ids = tf.reshape(input_ids, [-1])one_hot_input_ids = tf.one_hot(flat_input_ids, depth=vocab_size)output = tf.matmul(one_hot_input_ids, embedding_table)else:output = tf.nn.embedding_lookup(embedding_table, input_ids)input_shape = get_shape_list(input_ids)# 把輸出從[batch_size, seq_length, num_inputs(這里總是1), embedding_size]# 變成[batch_size, seq_length, num_inputs*embedding_size]output = tf.reshape(output,input_shape[0:-1] + [input_shape[-1] * embedding_size])return (output, embedding_table)

Embedding本來很簡單，使用tf.nn.embedding_lookup就行了。但是為了優(yōu)化TPU，它還支持使用矩陣乘法來提取詞向量。另外為了提高效率，輸入的shape除了[batch_size, seq_length]外，它還增加了一個維度變成[batch_size, seq_length, num_inputs]。如果不關(guān)心細節(jié)，我們把這個函數(shù)當(dāng)成黑盒，那么我們只需要知道它的輸入input_ids(可能)是[8, 128]，輸出是[8, 128, 768]就可以了。

函數(shù)embedding_postprocessor的代碼如下，需要注意的部分都有注釋。

def embedding_postprocessor(input_tensor,use_token_type=False,token_type_ids=None,token_type_vocab_size=16,token_type_embedding_name="token_type_embeddings",use_position_embeddings=True,position_embedding_name="position_embeddings",initializer_range=0.02,max_position_embeddings=512,dropout_prob=0.1):"""對word embedding之后的tensor進行后處理Args:input_tensor: float Tensor shape為[batch_size, seq_length, embedding_size]use_token_type: bool 是否增加`token_type_ids`的Embeddingtoken_type_ids: (可選) int32 Tensor shape為[batch_size, seq_length]如果`use_token_type`為True則必須有值token_type_vocab_size: int Token Type的個數(shù)，通常是2token_type_embedding_name: string Token type Embedding的名字use_position_embeddings: bool 是否使用位置Embeddingposition_embedding_name: string，位置embedding的名字 initializer_range: float，初始化范圍 max_position_embeddings: int，位置編碼的最大長度，可以比最大序列長度大，但是不能比它小。dropout_prob: float. Dropout 概率Returns:float tensor shape和`input_tensor`相同。"""input_shape = get_shape_list(input_tensor, expected_rank=3)batch_size = input_shape[0]seq_length = input_shape[1]width = input_shape[2]if seq_length > max_position_embeddings:raise ValueError("The seq length (%d) cannot be greater than ""`max_position_embeddings` (%d)" %(seq_length, max_position_embeddings))output = input_tensorif use_token_type:if token_type_ids is None:raise ValueError("`token_type_ids` must be specified if""`use_token_type` is True.")token_type_table = tf.get_variable(name=token_type_embedding_name,shape=[token_type_vocab_size, width],initializer=create_initializer(initializer_range))# 因為Token Type通常很小(2)，所以直接用矩陣乘法(one-hot)更快flat_token_type_ids = tf.reshape(token_type_ids, [-1])one_hot_ids = tf.one_hot(flat_token_type_ids, depth=token_type_vocab_size)token_type_embeddings = tf.matmul(one_hot_ids, token_type_table)token_type_embeddings = tf.reshape(token_type_embeddings,[batch_size, seq_length, width])output += token_type_embeddingsif use_position_embeddings:full_position_embeddings = tf.get_variable(name=position_embedding_name,shape=[max_position_embeddings, width],initializer=create_initializer(initializer_range))# 位置Embedding是可以學(xué)習(xí)的參數(shù)，因此我們創(chuàng)建一個[max_position_embeddings, width]的矩陣# 但實際輸入的序列可能并不會到max_position_embeddings(512)，為了提高訓(xùn)練速度，# 我們通過tf.slice取出[0, 1, 2, ..., seq_length-1]的部分,。if seq_length < max_position_embeddings:position_embeddings = tf.slice(full_position_embeddings, [0, 0],[seq_length, -1])else:position_embeddings = full_position_embeddingsnum_dims = len(output.shape.as_list())# word embedding之后的tensor是[batch_size, seq_length, width]# 因為位置編碼是與輸入內(nèi)容無關(guān)，它的shape總是[seq_length, width]# 我們無法把位置Embedding加到word embedding上# 因此我們需要擴展位置編碼為[1, seq_length, width]# 然后就能通過broadcasting加上去了。position_broadcast_shape = []for _ in range(num_dims - 2):position_broadcast_shape.append(1)position_broadcast_shape.extend([seq_length, width])# 默認情況下position_broadcast_shape為[1, 128, 768]position_embeddings = tf.reshape(position_embeddings,position_broadcast_shape)# output是[8, 128, 768], position_embeddings是[1, 128, 768]# 因此可以通過broadcasting相加。output += position_embeddingsoutput = layer_norm_and_dropout(output, dropout_prob)return output

create_attention_mask_from_input_mask函數(shù)用于構(gòu)造Mask矩陣。我們先了解一下它的作用然后再閱讀其代碼。比如調(diào)用它時的兩個參數(shù)是是：

input_ids=[[1,2,3,0,0],[1,3,5,6,1] ] input_mask=[[1,1,1,0,0],[1,1,1,1,1] ]

表示這個batch有兩個樣本，第一個樣本長度為3(padding了2個0)，第二個樣本長度為5。在計算Self-Attention的時候每一個樣本都需要一個Attention Mask矩陣，表示每一個時刻可以attend to的范圍，1表示可以attend，0表示是padding的(或者在機器翻譯的Decoder中不能attend to未來的詞)。對于上面的輸入，這個函數(shù)返回一個shape是[2, 5, 5]的tensor，分別代表兩個Attention Mask矩陣。

[[1, 1, 1, 0, 0], #它表示第1個詞可以attend to 3個詞[1, 1, 1, 0, 0], #它表示第2個詞可以attend to 3個詞[1, 1, 1, 0, 0], #它表示第3個詞可以attend to 3個詞[1, 1, 1, 0, 0], #無意義，因為輸入第4個詞是padding的0[1, 1, 1, 0, 0] #無意義，因為輸入第5個詞是padding的0 ][[1, 1, 1, 1, 1], # 它表示第1個詞可以attend to 5個詞[1, 1, 1, 1, 1], # 它表示第2個詞可以attend to 5個詞[1, 1, 1, 1, 1], # 它表示第3個詞可以attend to 5個詞[1, 1, 1, 1, 1], # 它表示第4個詞可以attend to 5個詞[1, 1, 1, 1, 1] # 它表示第5個詞可以attend to 5個詞 ]

了解了它的用途之后下面的代碼就很好理解了。

def create_attention_mask_from_input_mask(from_tensor, to_mask):"""Create 3D attention mask from a 2D tensor mask.Args:from_tensor: 2D or 3D Tensor，shape為[batch_size, from_seq_length, ...].to_mask: int32 Tensor， shape為[batch_size, to_seq_length].Returns:float Tensor，shape為[batch_size, from_seq_length, to_seq_length]."""from_shape = get_shape_list(from_tensor, expected_rank=[2, 3])batch_size = from_shape[0]from_seq_length = from_shape[1]to_shape = get_shape_list(to_mask, expected_rank=2)to_seq_length = to_shape[1]to_mask = tf.cast(tf.reshape(to_mask, [batch_size, 1, to_seq_length]), tf.float32)# `broadcast_ones` = [batch_size, from_seq_length, 1]broadcast_ones = tf.ones(shape=[batch_size, from_seq_length, 1], dtype=tf.float32)# Here we broadcast along two dimensions to create the mask.mask = broadcast_ones * to_maskreturn mask

比如前面舉的例子，broadcast_ones的shape是[2, 5, 1]，值全是1，而to_mask是

to_mask=[ [1,1,1,0,0], [1,1,1,1,1] ]

shape是[2, 5]，reshape為[2, 1, 5]。然后broadcast_ones * to_mask就得到[2, 5, 5]，正是我們需要的兩個Mask矩陣，讀者可以驗證。注意[batch, A, B]*[batch, B, C]=[batch, A, C]，我們可以認為是batch個[A, B]的矩陣乘以batch個[B, C]的矩陣。接下來就是transformer_model函數(shù)了，它就是構(gòu)造Transformer的核心代碼。

def transformer_model(input_tensor,attention_mask=None,hidden_size=768,num_hidden_layers=12,num_attention_heads=12,intermediate_size=3072,intermediate_act_fn=gelu,hidden_dropout_prob=0.1,attention_probs_dropout_prob=0.1,initializer_range=0.02,do_return_all_layers=False):"""Multi-headed, multi-layer的Transformer，參考"Attention is All You Need".這基本上是和原始Transformer encoder相同的代碼。原始論文為:https://arxiv.org/abs/1706.03762Also see:https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/models/transformer.pyArgs:input_tensor: float Tensor，shape為[batch_size, seq_length, hidden_size]attention_mask: (可選) int32 Tensor，shape [batch_size, seq_length,seq_length], 1表示可以attend to，0表示不能。 hidden_size: int. Transformer隱單元個數(shù)num_hidden_layers: int. 有多少個SubLayer num_attention_heads: int. Transformer Attention Head個數(shù)。intermediate_size: int. 全連接層的隱單元個數(shù)intermediate_act_fn: 函數(shù). 全連接層的激活函數(shù)。hidden_dropout_prob: float. Self-Attention層殘差之前的Dropout概率attention_probs_dropout_prob: float. attention的Dropout概率initializer_range: float. 初始化范圍(truncated normal的標(biāo)準(zhǔn)差)do_return_all_layers: 返回所有層的輸出還是最后一層的輸出。Returns:如果do_return_all_layers True，返回最后一層的輸出，是一個Tensor，shape為[batch_size, seq_length, hidden_size]；否則返回所有層的輸出，是一個長度為num_hidden_layers的list，list的每一個元素都是[batch_size, seq_length, hidden_size]。"""if hidden_size % num_attention_heads != 0:raise ValueError("The hidden size (%d) is not a multiple of the number of attention ""heads (%d)" % (hidden_size, num_attention_heads))# 因為最終要輸出hidden_size，總共有num_attention_heads個Head，因此每個Head輸出# 為hidden_size / num_attention_headsattention_head_size = int(hidden_size / num_attention_heads)input_shape = get_shape_list(input_tensor, expected_rank=3)batch_size = input_shape[0]seq_length = input_shape[1]input_width = input_shape[2]# 因為需要殘差連接，我們需要把輸入加到Self-Attention的輸出，因此要求它們的shape是相同的。if input_width != hidden_size:raise ValueError("The width of the input tensor (%d) != hidden size (%d)" %(input_width, hidden_size))# 為了避免在2D和3D之間來回reshape，我們統(tǒng)一把所有的3D Tensor用2D來表示。# 雖然reshape在GPU/CPU上很快，但是在TPU上卻不是這樣，這樣做的目的是為了優(yōu)化TPU# input_tensor是[8, 128, 768], prev_output是[8*128, 768]=[1024, 768] prev_output = reshape_to_matrix(input_tensor)all_layer_outputs = []for layer_idx in range(num_hidden_layers):# 每一層都有自己的variable scopewith tf.variable_scope("layer_%d" % layer_idx):layer_input = prev_output# attention層with tf.variable_scope("attention"):attention_heads = []# self attentionwith tf.variable_scope("self"):attention_head = attention_layer(from_tensor=layer_input,to_tensor=layer_input,attention_mask=attention_mask,num_attention_heads=num_attention_heads,size_per_head=attention_head_size,attention_probs_dropout_prob=attention_probs_dropout_prob,initializer_range=initializer_range,do_return_2d_tensor=True,batch_size=batch_size,from_seq_length=seq_length,to_seq_length=seq_length)attention_heads.append(attention_head)attention_output = Noneif len(attention_heads) == 1:attention_output = attention_heads[0]else:# 如果有多個head，那么需要把多個head的輸出concat起來attention_output = tf.concat(attention_heads, axis=-1)# 使用線性變換把前面的輸出變成`hidden_size`，然后再加上`layer_input`(殘差連接)with tf.variable_scope("output"):attention_output = tf.layers.dense(attention_output,hidden_size,kernel_initializer=create_initializer(initializer_range))# dropoutattention_output = dropout(attention_output, hidden_dropout_prob)# 殘差連接再加上layer norm。attention_output = layer_norm(attention_output + layer_input)# 全連接層with tf.variable_scope("intermediate"):intermediate_output = tf.layers.dense(attention_output,intermediate_size,activation=intermediate_act_fn,kernel_initializer=create_initializer(initializer_range))# 然后是用一個線性變換把大小變回`hidden_size`，這樣才能加殘差連接with tf.variable_scope("output"):layer_output = tf.layers.dense(intermediate_output,hidden_size,kernel_initializer=create_initializer(initializer_range))layer_output = dropout(layer_output, hidden_dropout_prob)layer_output = layer_norm(layer_output + attention_output)prev_output = layer_outputall_layer_outputs.append(layer_output)if do_return_all_layers:final_outputs = []for layer_output in all_layer_outputs:final_output = reshape_from_matrix(layer_output, input_shape)final_outputs.append(final_output)return final_outputselse:final_output = reshape_from_matrix(prev_output, input_shape)return final_output

如果對照Transformer的論文，非常容易閱讀，里面實現(xiàn)Self-Attention的函數(shù)就是attention_layer。

def attention_layer(from_tensor,to_tensor,attention_mask=None,num_attention_heads=1,size_per_head=512,query_act=None,key_act=None,value_act=None,attention_probs_dropout_prob=0.0,initializer_range=0.02,do_return_2d_tensor=False,batch_size=None,from_seq_length=None,to_seq_length=None):"""用`from_tensor`(作為Query)去attend to `to_tensor`(提供Key和Value)這個函數(shù)實現(xiàn)論文"Attentionis all you Need"里的multi-head attention。如果`from_tensor`和`to_tensor`是同一個tensor，那么就實現(xiàn)Self-Attention。`from_tensor`的每個時刻都會attends to `to_tensor`，也就是用from的Query去乘以所有to的Key，得到weight，然后把所有to的Value加權(quán)求和起來。這個函數(shù)首先把`from_tensor`變換成一個"query" tensor，然后把`to_tensor`變成"key"和"value" tensors。總共有`num_attention_heads`組Query、Key和Value，每一個Query，Key和Value的shape都是[batch_size(8), seq_length(128), size_per_head(512/8=64)].然后計算query和key的內(nèi)積并且除以size_per_head的平方根(8)。然后softmax變成概率，最后用概率加權(quán)value得到輸出。因為有多個Head，每個Head都輸出[batch_size, seq_length, size_per_head]，最后把8個Head的結(jié)果concat起來，就最終得到[batch_size(8), seq_length(128), size_per_head*8=512] 實際上我們是把這8個Head的Query，Key和Value都放在一個Tensor里面的，因此實際通過transpose和reshape就達到了上面的效果。Args:from_tensor: float Tensor，shape [batch_size, from_seq_length, from_width]to_tensor: float Tensor，shape [batch_size, to_seq_length, to_width].attention_mask: (可選) int32 Tensor, shape[batch_size,from_seq_length,to_seq_length]。值可以是0或者1，在計算attention score的時候，我們會把0變成負無窮(實際是一個絕對值很大的負數(shù))，而1不變，這樣softmax的時候進行exp的計算，前者就趨近于零，從而間接實現(xiàn)Mask的功能。num_attention_heads: int. Attention heads的數(shù)量。size_per_head: int. 每個head的sizequery_act: (可選) query變換的激活函數(shù)key_act: (可選) key變換的激活函數(shù)value_act: (可選) value變換的激活函數(shù)attention_probs_dropout_prob: (可選) float. attention的Dropout概率。initializer_range: float. 初始化范圍 do_return_2d_tensor: bool. 如果True，返回2D的Tensor其shape是[batch_size * from_seq_length, num_attention_heads * size_per_head]；否則返回3D的Tensor其shape為[batch_size, from_seq_length, num_attention_heads * size_per_head].batch_size: (可選) int. 如果輸入是3D的，那么batch就是第一維，但是可能3D的壓縮成了2D的，所以需要告訴函數(shù)batch_size from_seq_length: (可選) 同上，需要告訴函數(shù)from_seq_lengthto_seq_length: (可選) 同上，to_seq_lengthReturns:float Tensor，shape [batch_size,from_seq_length,num_attention_heads * size_per_head]。如果`do_return_2d_tensor`為True，則返回的shape是[batch_size * from_seq_length, num_attention_heads * size_per_head]."""def transpose_for_scores(input_tensor, batch_size, num_attention_heads,seq_length, width):output_tensor = tf.reshape(input_tensor, [batch_size, seq_length, num_attention_heads, width])output_tensor = tf.transpose(output_tensor, [0, 2, 1, 3])return output_tensorfrom_shape = get_shape_list(from_tensor, expected_rank=[2, 3])to_shape = get_shape_list(to_tensor, expected_rank=[2, 3])if len(from_shape) != len(to_shape):raise ValueError("The rank of `from_tensor` must match the rank of `to_tensor`.")# 如果輸入是3D的(沒有壓縮)，那么我們可以推測出batch_size、from_seq_length和to_seq_length# 即使參數(shù)傳入也會被覆蓋。if len(from_shape) == 3:batch_size = from_shape[0]from_seq_length = from_shape[1]to_seq_length = to_shape[1]# 如果是壓縮成2D的，那么一定要傳入這3個參數(shù)，否則拋異常。 elif len(from_shape) == 2:if (batch_size is None or from_seq_length is None or to_seq_length is None):raise ValueError("When passing in rank 2 tensors to attention_layer, the values ""for `batch_size`, `from_seq_length`, and `to_seq_length` ""must all be specified.")# B = batch size (number of sequences) 默認配置是8# F = `from_tensor` sequence length 默認配置是128# T = `to_tensor` sequence length 默認配置是128# N = `num_attention_heads` 默認配置是12# H = `size_per_head` 默認配置是64# 把from和to壓縮成2D的。# [8*128, 768]from_tensor_2d = reshape_to_matrix(from_tensor)# [8*128, 768]to_tensor_2d = reshape_to_matrix(to_tensor)# 計算Query `query_layer` = [B*F, N*H] =[8*128, 12*64]# batch_size=8，共128個時刻，12和head，每個head的query向量是64# 因此最終得到[8*128, 12*64]query_layer = tf.layers.dense(from_tensor_2d,num_attention_heads * size_per_head,activation=query_act,name="query",kernel_initializer=create_initializer(initializer_range))# 和query類似，`key_layer` = [B*T, N*H]key_layer = tf.layers.dense(to_tensor_2d,num_attention_heads * size_per_head,activation=key_act,name="key",kernel_initializer=create_initializer(initializer_range))# 同上，`value_layer` = [B*T, N*H]value_layer = tf.layers.dense(to_tensor_2d,num_attention_heads * size_per_head,activation=value_act,name="value",kernel_initializer=create_initializer(initializer_range))# 把query從[B*F, N*H] =[8*128, 12*64]變成[B, N, F, H]=[8, 12, 128, 64]query_layer = transpose_for_scores(query_layer, batch_size,num_attention_heads, from_seq_length,size_per_head)# 同上，key也變成[8, 12, 128, 64]key_layer = transpose_for_scores(key_layer, batch_size, num_attention_heads,to_seq_length, size_per_head)# 計算query和key的內(nèi)積，得到attention scores.# [8, 12, 128, 64]*[8, 12, 64, 128]=[8, 12, 128, 128]# 最后兩維[128, 128]表示from的128個時刻attend to到to的128個score。# `attention_scores` = [B, N, F, T]attention_scores = tf.matmul(query_layer, key_layer, transpose_b=True)attention_scores = tf.multiply(attention_scores,1.0 / math.sqrt(float(size_per_head)))if attention_mask is not None:# 從[8, 128, 128]變成[8, 1, 128, 128]# `attention_mask` = [B, 1, F, T]attention_mask = tf.expand_dims(attention_mask, axis=[1])# 這個小技巧前面也用到過，如果mask是1，那么(1-1)*-10000=0，adder就是0,# 如果mask是0，那么(1-0)*-10000=-10000。adder = (1.0 - tf.cast(attention_mask, tf.float32)) * -10000.0# 我們把adder加到attention_score里，mask是1就相當(dāng)于加0，mask是0就相當(dāng)于加-10000。# 通常attention_score都不會很大，因此mask為0就相當(dāng)于把attention_score設(shè)置為負無窮# 后面softmax的時候就趨近于0，因此相當(dāng)于不能attend to Mask為0的地方。attention_scores += adder# softmax# `attention_probs` = [B, N, F, T] =[8, 12, 128, 128]attention_probs = tf.nn.softmax(attention_scores)# 對attention_probs進行dropout，這雖然有點奇怪，但是Transformer的原始論文就是這么干的。attention_probs = dropout(attention_probs, attention_probs_dropout_prob)# 把`value_layer` reshape成[B, T, N, H]=[8, 128, 12, 64]value_layer = tf.reshape(value_layer,[batch_size, to_seq_length, num_attention_heads, size_per_head])# `value_layer`變成[B, N, T, H]=[8, 12, 128, 64]value_layer = tf.transpose(value_layer, [0, 2, 1, 3])# 計算`context_layer` = [8, 12, 128, 128]*[8, 12, 128, 64]=[8, 12, 128, 64]=[B, N, F, H]context_layer = tf.matmul(attention_probs, value_layer)# `context_layer` 變換成 [B, F, N, H]=[8, 128, 12, 64]context_layer = tf.transpose(context_layer, [0, 2, 1, 3])if do_return_2d_tensor:# `context_layer` = [B*F, N*V]context_layer = tf.reshape(context_layer,[batch_size * from_seq_length, num_attention_heads * size_per_head])else:# `context_layer` = [B, F, N*V]context_layer = tf.reshape(context_layer,[batch_size, from_seq_length, num_attention_heads * size_per_head])return context_layer

九、自己進行Pretraining

雖然Google提供了Pretraining的模型，但是我們可以也會需要自己通過Mask LM和Next Sentence Prediction進行Pretraining。當(dāng)然如果我們數(shù)據(jù)和計算資源都足夠多，那么我們可以從頭開始Pretraining，如果我們有一些領(lǐng)域的數(shù)據(jù)，那么我們也可以進行Pretraining，但是可以用Google提供的checkpoint作為初始值。

要進行Pretraining首先需要有數(shù)據(jù)，前面講過，數(shù)據(jù)由很多”文檔”組成，每篇文檔的句子之間是有關(guān)系的。如果只能拿到?jīng)]有關(guān)系的句子則是無法訓(xùn)練的。我們的訓(xùn)練數(shù)據(jù)需要變成如下的格式：

~/codes/bert$ cat sample_text.txt This text is included to make sure Unicode is handled properly: 力加勝北區(qū)?????????? Text should be one-sentence-per-line, with empty lines between documents. This sample text is public domain and was randomly selected from Project Guttenberg.The rain had only ceased with the gray streaks of morning at Blazing Star, and the settlement awoke to a moral sense of cleanliness, and the finding of forgotten knives, tin cups, and smaller camp utensils, where the heavy showers had washed away the debris and dust heaps before the cabin doors. Indeed, it was recorded in Blazing Star that a fortunate early riser had once picked up on the highway a solid chunk of gold quartz which the rain had freed from its incumbering soil, and washed into immediate and glittering popularity. Possibly this may have been the reason why early risers in that locality, during the rainy season, adopted a thoughtful habit of body, and seldom lifted their eyes to the rifted or india-ink washed skies above them. "Cass" Beard had risen early that morning, but not with a view to discovery. ...省略了很多行

數(shù)據(jù)是文本文件，每一行表示一個句子，空行表示一個文檔的結(jié)束(新文檔的開始)，比如上面的例子，總共有2個文檔，第一個文檔只有3個句子，第二個文檔有很多句子。

我們首先需要使用create_pretraining_data.py把文本文件變成TFRecord格式，便于后面的代碼進行Pretraining。由于這個腳本會把整個文本文件加載到內(nèi)存，因此這個文件不能太大。如果讀者有很多文檔要訓(xùn)練，比如1000萬。那么我們可以把這1000萬文檔拆分成1萬個文件，每個文件1000個文檔，從而生成1000個TFRecord文件。

我們先看create_pretraining_data.py的用法：

python create_pretraining_data.py --input_file=./sample_text.txt --output_file=./imdb/tf_examples.tfrecord --vocab_file=./vocab.txt --do_lower_case=True --max_seq_length=128 --max_predictions_per_seq=20 --masked_lm_prob=0.15 --random_seed=12345 --dupe_factor=5

• max_seq_length Token序列的最大長度
• max_predictions_per_seq 最多生成多少個MASK
• masked_lm_prob 多少比例的Token變成MASK
• dupe_factor 一個文檔重復(fù)多少次

首先說一下參數(shù)dupe_factor，比如一個句子”it is a good day”，為了充分利用數(shù)據(jù)，我們可以多次隨機的生成MASK，比如第一次可能生成”it is a [MASK] day”，第二次可能生成”it [MASK] a good day”。這個參數(shù)控制重復(fù)的次數(shù)。

masked_lm_prob就是論文里的參數(shù)15%。max_predictions_per_seq是一個序列最多MASK多少個Token，它通常等于max_seq_length * masked_lm_prob。這么看起來這個參數(shù)沒有必要提供，但是后面的腳本也需要用到這個同樣的值，而后面的腳本并沒有這兩個參數(shù)。

我們先看main函數(shù)。

def main(_): tokenizer = tokenization.FullTokenizer(vocab_file=FLAGS.vocab_file, do_lower_case=FLAGS.do_lower_case)input_files = []# 省略了文件通配符的處理，我們假設(shè)輸入的文件已經(jīng)傳入input_filesrng = random.Random(FLAGS.random_seed)instances = create_training_instances(input_files, tokenizer, FLAGS.max_seq_length, FLAGS.dupe_factor,FLAGS.short_seq_prob, FLAGS.masked_lm_prob, FLAGS.max_predictions_per_seq,rng)output_files = ....write_instance_to_example_files(instances, tokenizer, FLAGS.max_seq_length,FLAGS.max_predictions_per_seq, output_files)

main函數(shù)很簡單，輸入文本文件列表是input_files，通過函數(shù)create_training_instances構(gòu)建訓(xùn)練的instances，然后調(diào)用write_instance_to_example_files以TFRecord格式寫到output_files。

我們先來看一個訓(xùn)練樣本的格式，這是用類TrainingInstance來表示的：

class TrainingInstance(object):def __init__(self, tokens, segment_ids, masked_lm_positions, masked_lm_labels,is_random_next):self.tokens = tokensself.segment_ids = segment_idsself.is_random_next = is_random_nextself.masked_lm_positions = masked_lm_positionsself.masked_lm_labels = masked_lm_labels

假設(shè)原始兩個句子為：”it is a good day”和”I want to go out”，那么處理后的TrainingInstance可能為：

1. tokens = ["[CLS], "it", "is" "a", "[MASK]", "day", "[SEP]", "I", "apple", "to", "go", "out", "[SEP]"] 2. segment_ids=[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1] 3. is_random_next=False 4. masked_lm_positions=[4, 8, 9] 表示Mask后為["[CLS], "it", "is" "a", "[MASK]", "day", "[SEP]", "I", "[MASK]", "to", "go", "out", "[SEP]"] 5. masked_lm_labels=["good", "want", "to"]

is_random_next表示這兩句話是有關(guān)聯(lián)的，預(yù)測句子關(guān)系的分類器應(yīng)該把這個輸入判斷為1。masked_lm_positions記錄哪些位置被Mask了，而masked_lm_labels記錄被Mask之前的詞。

注意：tokens已經(jīng)處理過了，good被替換成[MASK]，而want被替換成apple，而to還是被替換成它自己，原因前面的理論部分已經(jīng)介紹過了。因此根據(jù)masked_lm_positions、masked_lm_labels和tokens是可以恢復(fù)出原始(分詞后的)句子的。

create_training_instances函數(shù)的代碼為：

def create_training_instances(input_files, tokenizer, max_seq_length,dupe_factor, short_seq_prob, masked_lm_prob,max_predictions_per_seq, rng):"""從原始文本創(chuàng)建`TrainingInstance`"""all_documents = [[]]# 輸入文件格式： # (1) 每行一個句子。這應(yīng)該是實際的句子，不應(yīng)該是整個段落或者段落的隨機片段(span)，因為我們需# 要使用句子邊界來做下一個句子的預(yù)測。 # (2) 文檔之間有一個空行。我們會認為同一個文檔的相鄰句子是有關(guān)系的。# 下面的代碼讀取所有文件，然后根據(jù)空行切分Document# all_documents是list的list，第一層list表示document，第二層list表示document里的多個句子。 for input_file in input_files:with tf.gfile.GFile(input_file, "r") as reader:while True:line = tokenization.convert_to_unicode(reader.readline())if not line:breakline = line.strip()# 空行表示舊文檔的結(jié)束和新文檔的開始。if not line:#添加一個新的空文檔all_documents.append([])tokens = tokenizer.tokenize(line)if tokens:all_documents[-1].append(tokens)# 刪除空文檔all_documents = [x for x in all_documents if x]rng.shuffle(all_documents)vocab_words = list(tokenizer.vocab.keys())instances = []# 重復(fù)dup_factor次for _ in range(dupe_factor):# 遍歷所有文檔for document_index in range(len(all_documents)):# 從一個文檔(下標(biāo)為document_index)里抽取多個TrainingInstanceinstances.extend(create_instances_from_document(all_documents, document_index, max_seq_length, short_seq_prob,masked_lm_prob, max_predictions_per_seq, vocab_words, rng))rng.shuffle(instances)return instances

上面的函數(shù)會調(diào)用create_instances_from_document來從一個文檔里抽取多個訓(xùn)練數(shù)據(jù)(TrainingInstance)。普通的語言模型只要求連續(xù)的字符串就行，通常是把所有的文本(比如維基百科的內(nèi)容)拼接成一個很大很大的文本文件，然后訓(xùn)練的時候隨機的從里面抽取固定長度的字符串作為一個”句子”。但是BERT要求我們的輸入是一個一個的Document，每個Document有很多句子，這些句子是連貫的真實的句子，需要正確的分句，而不能隨機的(比如按照固定長度)切分句子。代碼如下：

def create_instances_from_document(all_documents, document_index, max_seq_length, short_seq_prob,masked_lm_prob, max_predictions_per_seq, vocab_words, rng):"""從一個文檔里創(chuàng)建多個`TrainingInstance`。"""document = all_documents[document_index]# 為[CLS], [SEP], [SEP]預(yù)留3個位置。max_num_tokens = max_seq_length - 3# 我們通常希望Token序列長度為最大的max_seq_length，否則padding后的計算是無意義的，浪費計# 算資源。但是有的時候我們有希望生成一些短的句子，因為在實際應(yīng)用中會有短句，如果都是# 長句子，那么就很容易出現(xiàn)Mismatch，所有我們以short_seq_prob == 0.1 == 10%的概率生成# 短句子。target_seq_length = max_num_tokens# 以0.1的概率生成隨機(2-max_num_tokens)的長度。if rng.random() < short_seq_prob:target_seq_length = rng.randint(2, max_num_tokens)# 我們不能把一個文檔的所有句子的Token拼接起來，然后隨機的選擇兩個片段。# 因為這樣很可能這兩個片段是同一個句子(至少很可能第二個片段的開頭和第一個片段的結(jié)尾是同一個# 句子)，這樣預(yù)測是否相關(guān)句子的任務(wù)太簡單，學(xué)習(xí)不到深層的語義關(guān)系。# 這里我們使用"真實"的句子邊界。instances = []current_chunk = []current_length = 0i = 0while i < len(document):segment = document[i]current_chunk.append(segment)current_length += len(segment)if i == len(document) - 1 or current_length >= target_seq_length:if current_chunk:# `a_end`是第一個句子A(在current_chunk里)結(jié)束的下標(biāo) a_end = 1# 隨機選擇切分邊界if len(current_chunk) >= 2:a_end = rng.randint(1, len(current_chunk) - 1)tokens_a = []for j in range(a_end):tokens_a.extend(current_chunk[j])tokens_b = []# 是否Random nextis_random_next = Falseif len(current_chunk) == 1 or rng.random() < 0.5:is_random_next = Truetarget_b_length = target_seq_length - len(tokens_a)# 隨機的挑選另外一篇文檔的隨機開始的句子# 但是理論上有可能隨機到的文檔就是當(dāng)前文檔，因此需要一個while循環(huán)# 這里只while循環(huán)10次，理論上還是有重復(fù)的可能性，但是我們忽略for _ in range(10):random_document_index = rng.randint(0, len(all_documents) - 1)# 不是當(dāng)前文檔，則找到了random_document_indexif random_document_index != document_index:break# 隨機挑選的文檔random_document = all_documents[random_document_index]# 隨機選擇開始句子random_start = rng.randint(0, len(random_document) - 1)# 把Token加到tokens_b里，如果Token數(shù)量夠了(target_b_length)就break。for j in range(random_start, len(random_document)):tokens_b.extend(random_document[j])if len(tokens_b) >= target_b_length:break# 之前我們雖然挑選了len(current_chunk)個句子，但是a_end之后的句子替換成隨機的其它# 文檔的句子，因此我們并沒有使用a_end之后的句子，因此我們修改下標(biāo)i，使得下一次循環(huán)# 可以再次使用這些句子(把它們加到新的chunk里)，避免浪費。num_unused_segments = len(current_chunk) - a_endi -= num_unused_segments# 真實的下一句else:is_random_next = Falsefor j in range(a_end, len(current_chunk)):tokens_b.extend(current_chunk[j])# 如果太多了，隨機去掉一些。 truncate_seq_pair(tokens_a, tokens_b, max_num_tokens, rng)tokens = []segment_ids = []# 處理句子Atokens.append("[CLS]")segment_ids.append(0)for token in tokens_a:tokens.append(token)segment_ids.append(0)# A的結(jié)束tokens.append("[SEP]")segment_ids.append(0)# 處理句子Bfor token in tokens_b:tokens.append(token)segment_ids.append(1)# B的結(jié)束tokens.append("[SEP]")segment_ids.append(1)(tokens, masked_lm_positions,masked_lm_labels) = create_masked_lm_predictions(tokens, masked_lm_prob, max_predictions_per_seq, vocab_words, rng)instance = TrainingInstance(tokens=tokens,segment_ids=segment_ids,is_random_next=is_random_next,masked_lm_positions=masked_lm_positions,masked_lm_labels=masked_lm_labels)instances.append(instance)current_chunk = []current_length = 0i += 1return instances

代碼有點長，但是邏輯很簡單，比如有一篇文檔有n個句子：

w11,w12,....., w21,w22,.... wn1,wn2,....

那么算法首先找到一個chunk，它會不斷往chunk加入一個句子的所有Token，使得chunk里的token數(shù)量大于等于target_seq_length。通常我們期望target_seq_length為max_num_tokens(128-3)，這樣padding的盡量少，訓(xùn)練的效率高。但是有時候我們也需要生成一些短的序列，否則會出現(xiàn)訓(xùn)練與實際使用不匹配的問題。

找到一個chunk之后，比如這個chunk有5個句子，那么我們隨機的選擇一個切分點，比如3。把前3個句子當(dāng)成句子A，后兩個句子當(dāng)成句子B。這是兩個句子A和B有關(guān)系的樣本(is_random_next=False)。為了生成無關(guān)系的樣本，我們還以50%的概率把B用隨機從其它文檔抽取的句子替換掉，這樣就得到無關(guān)系的樣本(is_random_next=True)。如果是這種情況，后面兩個句子需要放回去，以便在下一層循環(huán)中能夠被再次利用。

有了句子A和B之后，我們就可以填充tokens和segment_ids，這里會加入特殊的[CLS]和[SEP]。接下來使用create_masked_lm_predictions來隨機的選擇某些Token，把它變成[MASK]。其代碼為：

def create_masked_lm_predictions(tokens, masked_lm_prob,max_predictions_per_seq, vocab_words, rng):# 首先找到可以被替換的下標(biāo)，[CLS]和[SEP]是不能用于MASK的。cand_indexes = []for (i, token) in enumerate(tokens):if token == "[CLS]" or token == "[SEP]":continuecand_indexes.append(i)# 隨機打散rng.shuffle(cand_indexes)output_tokens = list(tokens)# 構(gòu)造一個namedtuple，包括index和label兩個屬性。masked_lm = collections.namedtuple("masked_lm", ["index", "label"])# 需要被模型預(yù)測的Token個數(shù)：min(max_predictions_per_seq(20)，實際Token數(shù)*15%)num_to_predict = min(max_predictions_per_seq,max(1, int(round(len(tokens) * masked_lm_prob))))masked_lms = []covered_indexes = set()# 隨機的挑選num_to_predict個需要預(yù)測的Token# 因為cand_indexes打散過，因此順序的取就行for index in cand_indexes:# 夠了if len(masked_lms) >= num_to_predict:break# 已經(jīng)挑選過了？似乎沒有必要判斷，因為set會去重。 if index in covered_indexes:continuecovered_indexes.add(index)masked_token = None# 80%的概率把它替換成[MASK]if rng.random() < 0.8:masked_token = "[MASK]"else:# 10%的概率保持不變 if rng.random() < 0.5:masked_token = tokens[index]# 10%的概率隨機替換成詞典里的一個詞。 else:masked_token = vocab_words[rng.randint(0, len(vocab_words) - 1)]output_tokens[index] = masked_tokenmasked_lms.append(masked_lm(index=index, label=tokens[index]))# 按照下標(biāo)排序，保證是句子中出現(xiàn)的順序。masked_lms = sorted(masked_lms, key=lambda x: x.index)masked_lm_positions = []masked_lm_labels = []for p in masked_lms:masked_lm_positions.append(p.index)masked_lm_labels.append(p.label)return (output_tokens, masked_lm_positions, masked_lm_labels)

最后是使用函數(shù)write_instance_to_example_files把前面得到的TrainingInstance用TFRecord的個數(shù)寫到文件里，這個函數(shù)的核心代碼是：

def write_instance_to_example_files(instances, tokenizer, max_seq_length,max_predictions_per_seq, output_files):features = collections.OrderedDict()features["input_ids"] = create_int_feature(input_ids)features["input_mask"] = create_int_feature(input_mask)features["segment_ids"] = create_int_feature(segment_ids)features["masked_lm_positions"] = create_int_feature(masked_lm_positions)features["masked_lm_ids"] = create_int_feature(masked_lm_ids)features["masked_lm_weights"] = create_float_feature(masked_lm_weights)features["next_sentence_labels"] = create_int_feature([next_sentence_label])tf_example = tf.train.Example(features=tf.train.Features(feature=features))writers[writer_index].write(tf_example.SerializeToString())

接下來我們使用run_pretraining.py腳本進行Pretraining。用法為：

python run_pretraining.py \--input_file=/tmp/tf_examples.tfrecord \--output_dir=/tmp/pretraining_output \--do_train=True \--do_eval=True \--bert_config_file=$BERT_BASE_DIR/bert_config.json \--init_checkpoint=$BERT_BASE_DIR/bert_model.ckpt \--train_batch_size=32 \--max_seq_length=128 \--max_predictions_per_seq=20 \--num_train_steps=20 \--num_warmup_steps=10 \--learning_rate=2e-5

參數(shù)都比較容易理解，通常我們需要調(diào)整的是num_train_steps、num_warmup_steps和learning_rate。run_pretraining.py的代碼和run_classifier.py很類似，都是用BertModel構(gòu)建Transformer模型，唯一的區(qū)別在于損失函數(shù)不同：

def model_fn(features, labels, mode, params): input_ids = features["input_ids"]input_mask = features["input_mask"]segment_ids = features["segment_ids"]masked_lm_positions = features["masked_lm_positions"]masked_lm_ids = features["masked_lm_ids"]masked_lm_weights = features["masked_lm_weights"]next_sentence_labels = features["next_sentence_labels"]is_training = (mode == tf.estimator.ModeKeys.TRAIN)model = modeling.BertModel(config=bert_config,is_training=is_training,input_ids=input_ids,input_mask=input_mask,token_type_ids=segment_ids,use_one_hot_embeddings=use_one_hot_embeddings)(masked_lm_loss,masked_lm_example_loss, masked_lm_log_probs) = get_masked_lm_output(bert_config, model.get_sequence_output(), model.get_embedding_table(),masked_lm_positions, masked_lm_ids, masked_lm_weights)(next_sentence_loss, next_sentence_example_loss,next_sentence_log_probs) = get_next_sentence_output(bert_config, model.get_pooled_output(), next_sentence_labels)total_loss = masked_lm_loss + next_sentence_loss

get_masked_lm_output函數(shù)用于計算語言模型的Loss(Mask位置預(yù)測的詞和真實的詞是否相同)。

def get_masked_lm_output(bert_config, input_tensor, output_weights, positions,label_ids, label_weights):"""得到masked LM的loss和log概率"""# 只需要Mask位置的Token的輸出。input_tensor = gather_indexes(input_tensor, positions)with tf.variable_scope("cls/predictions"):# 在輸出之前再加一個非線性變換，這些參數(shù)只是用于訓(xùn)練，在Fine-Tuning的時候就不用了。with tf.variable_scope("transform"):input_tensor = tf.layers.dense(input_tensor,units=bert_config.hidden_size,activation=modeling.get_activation(bert_config.hidden_act),kernel_initializer=modeling.create_initializer(bert_config.initializer_range))input_tensor = modeling.layer_norm(input_tensor)# output_weights是復(fù)用輸入的word Embedding，所以是傳入的，# 這里再多加一個bias。output_bias = tf.get_variable("output_bias",shape=[bert_config.vocab_size],initializer=tf.zeros_initializer())logits = tf.matmul(input_tensor, output_weights, transpose_b=True)logits = tf.nn.bias_add(logits, output_bias)log_probs = tf.nn.log_softmax(logits, axis=-1)# label_ids的長度是20，表示最大的MASK的Token數(shù)# label_ids里存放的是MASK過的Token的idlabel_ids = tf.reshape(label_ids, [-1])label_weights = tf.reshape(label_weights, [-1])one_hot_labels = tf.one_hot(label_ids, depth=bert_config.vocab_size, dtype=tf.float32)# 但是由于實際MASK的可能不到20，比如只MASK18，那么label_ids有2個0(padding)# 而label_weights=[1, 1, ...., 0, 0]，說明后面兩個label_id是padding的，計算loss要去掉。per_example_loss = -tf.reduce_sum(log_probs * one_hot_labels, axis=[-1])numerator = tf.reduce_sum(label_weights * per_example_loss)denominator = tf.reduce_sum(label_weights) + 1e-5loss = numerator / denominatorreturn (loss, per_example_loss, log_probs)

get_next_sentence_output函數(shù)用于計算預(yù)測下一個句子的loss，代碼為：

def get_next_sentence_output(bert_config, input_tensor, labels):"""預(yù)測下一個句子是否相關(guān)的loss和log概率"""# 簡單的2分類，0表示真的下一個句子，1表示隨機的。這個分類器的參數(shù)在實際的Fine-Tuning# 會丟棄掉。 with tf.variable_scope("cls/seq_relationship"):output_weights = tf.get_variable("output_weights",shape=[2, bert_config.hidden_size],initializer=modeling.create_initializer(bert_config.initializer_range))output_bias = tf.get_variable("output_bias", shape=[2], initializer=tf.zeros_initializer())logits = tf.matmul(input_tensor, output_weights, transpose_b=True)logits = tf.nn.bias_add(logits, output_bias)log_probs = tf.nn.log_softmax(logits, axis=-1)labels = tf.reshape(labels, [-1])one_hot_labels = tf.one_hot(labels, depth=2, dtype=tf.float32)per_example_loss = -tf.reduce_sum(one_hot_labels * log_probs, axis=-1)loss = tf.reduce_mean(per_example_loss)return (loss, per_example_loss, log_probs)

十、性能測試

本節(jié)主要對BERT在工業(yè)部署情況的性能測評。性能測試部分主要參考肖涵大神的本篇文章（github上bert-as-service的作者）。因個人硬件配置有限，后續(xù)有機會再進行測試補充。

（一）關(guān)于max_seq_len對速度的影響

從性能上來講，過大的max_seq_len?會拖慢計算速度，并很有可能造成內(nèi)存 OOM。

（二）client_batch_size對速度的影響

出于性能考慮，請盡可能每次傳入較多的句子而非一次只傳一個。比如，使用下列方法調(diào)用：

#?prepare?your?sent?in?advance bc?=?BertClient() my_sentences?=?[s?for?s?in?my_corpus.iter()] #?doing?encoding?in?one-shot vec?=?bc.encode(my_sentences)

而不要使用：

bc?=?BertClient() vec?=?[] for?s?in?my_corpus.iter():vec.append(bc.encode(s))

如果把 bc = BertClient() 放在了循環(huán)之內(nèi)，則性能會更差。

當(dāng)然在一些時候，一次僅傳入一個句子無法避免，尤其是在小流量在線環(huán)境中。

?

（三）num_client?對并發(fā)性和速度的影響

可以看到一個客戶端、一塊 GPU 的處理速度是每秒 381 個句子（句子的長度為 40），兩個客戶端、兩個 GPU 是每秒 402 個，四個客戶端、四個 GPU 的速度是每秒 413 個。當(dāng) GPU 的數(shù)量增多時，服務(wù)對每個客戶端請求的處理速度保持穩(wěn)定甚至略有增高（因為空隙時刻被更有效地利用）。

?

總結(jié)

以上是生活随笔為你收集整理的一本读懂BERT(实践篇)的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。