目錄

一、什么是BERT？

二、BERT安裝

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

四、運(yùn)行Fine-Tuning

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

（一） DataProcessor

（二） MrpcProcessor

六、分詞源碼閱讀

（一）FullTokenizer

（二） WordpieceTokenizer

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

八、BertModel類

九、自己進(jìn)行Pretraining

十、性能測試

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

（二）client_batch_size對(duì)速度的影響

（三）num_client?對(duì)并發(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.

劃重點(diǎn)：the first?unsupervised,?deeply bidirectional?system for pre-training NLP.

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

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

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

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

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有兩個(gè)階段：預(yù)訓(xùn)練和微調(diào)。

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

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

• 句子級(jí)別（例如，SST-2）
• 句子對(duì)級(jí)別（例如，MultiNLI）
• 單詞級(jí)別（例如，NER）
• 文本閱讀（例如，SQuAD）

二、BERT安裝

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

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

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

• BERT-Base, Uncased：12層，768隱藏，12頭，110M參數(shù)
• BERT-Large, Uncased：24層，1024個(gè)隱藏，16個(gè)頭，340M參數(shù)
• BERT-Base, Cased：12層，768隱藏，12頭，110M參數(shù)
• BERT-Large, Cased：24層，1024個(gè)隱藏，16個(gè)頭，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ù)處理的時(shí)候都變成了小寫，而cased是保留大小寫。

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

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

四、運(yùn)行Fine-Tuning

對(duì)于大部分情況，不需要重新Pretraining。我們要做的只是根據(jù)具體的任務(wù)進(jìn)行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是模型的詞典，這個(gè)文件會(huì)經(jīng)常要用到，后面會(huì)講到。

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

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

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

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

但是大概率下載不下來，能下載的步驟也很麻煩，建議下載網(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個(gè)用Tab分割的字段，分別表示index，第一個(gè)句子的id，第二個(gè)句子的id，第一個(gè)句子，第二個(gè)句子。也就是輸入兩個(gè)句子，模型判斷它們是否同一個(gè)意思(Paraphrase)。如果是測試數(shù)據(jù)，那么第一列就是index(無意義)，如果是訓(xùn)練數(shù)據(jù)，那么第一列就是0或者1，其中0代表不同的意思而1代表相同意思。接下來就可以運(yùn)行如下命令來進(jìn)行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ù)的含義，在后面的代碼閱讀里讀者可以更加詳細(xì)的了解其意義。

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

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

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

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

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

（一） DataProcessor

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

（二） MrpcProcessor

對(duì)于MRPC任務(wù)，這里定義了MrpcProcessor來基礎(chǔ)DataProcessor。我們來看其中的get_labels和get_train_examples，其余兩個(gè)抽象方法是類似的。首先是get_labels，它非常簡單，這任務(wù)只有兩個(gè)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")

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

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

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

六、分詞源碼閱讀

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

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

（一）FullTokenizer

BERT里分詞主要是由FullTokenizer類來實(shí)現(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)練模型(后面會(huì)介紹)，那么do_lower_case決定了我們的某些是否區(qū)分大小寫。如果我們只是Fine-Tuning，那么這個(gè)參數(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ù)空格等進(jìn)行普通的分詞，而后者會(huì)把前者的結(jié)果再細(xì)粒度的切分為WordPiece。

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

def tokenize(self, text): text = convert_to_unicode(text)text = self._clean_text(text)# 這是2018年11月1日為了支持多語言和中文增加的代碼。這個(gè)代碼也可以用于英語模型，因?yàn)樵? 英語的訓(xùn)練數(shù)據(jù)中基本不會(huì)出現(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，這個(gè)函數(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用于判斷一個(gè)字符是否是控制字符(control character)，所謂的控制字符就是用于控制屏幕的顯示，比如\n告訴(控制)屏幕把光標(biāo)移到下一行的開始。讀者可以參考這里。

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

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

接下來是調(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，用于切分中文，這里的中文分詞很簡單，就是切分成一個(gè)一個(gè)的漢字。也就是在中文字符的前后加上空格，這樣后續(xù)的分詞流程會(huì)把沒一個(gè)字符當(dāng)成一個(gè)詞。

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ù)，這個(gè)函數(shù)用于判斷一個(gè)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)上的判斷漢字的正則表達(dá)式都只包括4E00-9FA5，但這是不全的，比如???就不再這個(gè)范圍內(nèi)。讀者可以參考這里。

接下來是使用whitespace進(jìn)行分詞，這是通過函數(shù)whitespace_tokenize來實(shí)現(xiàn)的。它直接調(diào)用split函數(shù)來實(shí)現(xiàn)分詞。Python里whitespace包括’\t\n\x0b\x0c\r ‘。然后遍歷每一個(gè)詞，如果需要變成小寫，那么先用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)對(duì)text進(jìn)行歸一化。這個(gè)函數(shù)有什么作用呢？我們先看一下下面的代碼：

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

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

接下來遍歷每一個(gè)codepoint，把category為Mn的去掉，比如前面的U+0301，COMBINING ACUTE ACCENT就會(huì)被去掉。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)點(diǎn)切分。這個(gè)函數(shù)會(huì)對(duì)輸入字符串用標(biāo)點(diǎn)進(jìn)行切分，返回一個(gè)list，list的每一個(gè)元素都是一個(gè)char。比如輸入he’s，則輸出是[[h,e], [’],[s]]。代碼很簡單，這里就不贅述。里面它會(huì)調(diào)用函數(shù)_is_punctuation來判斷一個(gè)字符是否標(biāo)點(diǎn)。

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

（二） WordpieceTokenizer

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

WordpieceTokenizer的代碼為：

def tokenize(self, text):# 把一段文字切分成word piece。這其實(shí)是貪心的最大正向匹配算法。# 比如：# 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

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

接著start=2，看affable在不在，不在再看affabl，…，最后發(fā)現(xiàn)?##aff?在詞典里。注意：##表示這個(gè)詞是接著前面的，這樣使得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，那么會(huì)使用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ù)遍歷每一個(gè)example(InputExample類的對(duì)象)。然后使用convert_single_example函數(shù)把每個(gè)InputExample對(duì)象變成InputFeature。InputFeature就是一個(gè)存放特征的對(duì)象，它包括input_ids、input_mask、segment_ids和label_id，這4個(gè)屬性除了label_id是一個(gè)int之外，其它都是int的列表，因此使用create_int_feature函數(shù)把它變成tf.train.Feature，而label_id需要構(gòu)造一個(gè)只有一個(gè)元素的列表，最后構(gòu)造tf.train.Example對(duì)象，然后寫到TFRecord文件里。后面Estimator的input_fn會(huì)用到它。

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

def convert_single_example(ex_index, example, label_list, max_seq_length,tokenizer):"""把一個(gè)`InputExample`對(duì)象變成`InputFeatures`."""# label_map把label變成id，這個(gè)函數(shù)每個(gè)example都需要執(zhí)行一次，其實(shí)是可以優(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個(gè)特殊Token[CLS], [SEP]和[SEP]# 如果兩個(gè)序列加起來太長，就需要去掉一些。_truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)else:# 沒有b則只需要保留[CLS]和[SEP]兩個(gè)特殊字符# 如果Token太多，就直接截取掉后面的部分。if len(tokens_a) > max_seq_length - 2:tokens_a = tokens_a[0:(max_seq_length - 2)]# BERT的約定是：# (a) 對(duì)于兩個(gè)序列：# 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) 對(duì)于一個(gè)序列：# tokens: [CLS] the dog is hairy . [SEP]# type_ids: 0 0 0 0 0 0 0## 這里"type_ids"用于區(qū)分一個(gè)Token是來自第一個(gè)還是第二個(gè)序列# 對(duì)于type=0和type=1，模型會(huì)學(xué)習(xí)出兩個(gè)Embedding向量。# 雖然理論上這是不必要的，因?yàn)閇SEP]隱式的確定了它們的邊界。# 但是實(shí)際加上type后，模型能夠更加容易的知道這個(gè)詞屬于那個(gè)序列。## 對(duì)于分類任務(wù)，[CLS]對(duì)應(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時(shí)會(huì)通過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

如果兩個(gè)Token序列的長度太長，那么需要去掉一些，這會(huì)用到_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()

這個(gè)函數(shù)很簡單，如果兩個(gè)序列的長度小于max_length，那么不用truncate，否則在tokens_a和tokens_b中選擇長的那個(gè)序列來pop掉最后面的那個(gè)Token，這樣的結(jié)果是使得兩個(gè)Token序列一樣長(或者最多a比b多一個(gè)Token)。對(duì)于Estimator API來說，最重要的是實(shí)現(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"]# 對(duì)于訓(xùn)練來說，我們會(huì)重復(fù)的讀取和shuffling # 對(duì)于驗(yàn)證和測試，我們不需要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

這個(gè)函數(shù)返回一個(gè)函數(shù)input_fn。這個(gè)input_fn函數(shù)首先從文件得到TFRecordDataset，然后根據(jù)是否訓(xùn)練來shuffle和重復(fù)讀取。然后用applay函數(shù)對(duì)每一個(gè)TFRecord進(jìn)行map_and_batch，調(diào)用_decode_record函數(shù)對(duì)record進(jìn)行parsing。從而把TFRecord的一條Record變成tf.Example對(duì)象，這個(gè)對(duì)象包括了input_ids等4個(gè)用于訓(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è)計(jì)里，features表示輸入(特征)，而labels表示輸出# 但是這里的實(shí)現(xiàn)有點(diǎ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模型。下面我們來看這個(gè)函數(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()# 默認(rèn)參數(shù)下它返回的output_layer是[8, 768]output_layer = model.get_pooled_output()# 默認(rèn)是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的概率會(huì)dropoutoutput_layer = tf.nn.dropout(output_layer, keep_prob=0.9)# 對(duì)[CLS]輸出的768的向量再做一個(gè)線性變換，輸出為label的個(gè)數(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]最后一層的輸出，這是一個(gè)768(默認(rèn)參數(shù)下)的向量，然后就是常規(guī)的接一個(gè)全連接層得到logits，然后softmax得到概率，之后就可以根據(jù)真實(shí)的分類標(biāo)簽計(jì)算loss。我們這時(shí)候發(fā)現(xiàn)關(guān)鍵的代碼是modeling.BertModel。

八、BertModel類

這個(gè)類是最終定義模型的地方，代碼比較多，我們會(huì)按照?qǐng)?zhí)行和調(diào)用的順序逐個(gè)閱讀。因?yàn)槲淖种荒芫€性描述，但是函數(shù)的調(diào)用關(guān)系很復(fù)雜，所以建議讀者對(duì)照源代碼來閱讀。

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

# 假設(shè)輸入已經(jīng)分詞并且變成WordPiece的id了?# 輸入是[2, 3]，表示batch=2，max_seq_length=3input_ids = tf.constant([[31, 51, 99], [15, 5, 0]])# 第一個(gè)例子實(shí)際長度為3，第二個(gè)例子長度為2input_mask = tf.constant([[1, 1, 1], [1, 1, 0]])# 第一個(gè)例子的3個(gè)Token中前兩個(gè)屬于句子1，第三個(gè)屬于句子2# 而第二個(gè)例子的第一個(gè)Token屬于句子1，第二個(gè)屬于句子2(第三個(gè)是padding)token_type_ids = tf.constant([[0, 0, 1], [0, 1, 0]])# 創(chuàng)建一個(gè)BertConfig，詞典大小是32000，Transformer的隱單元個(gè)數(shù)是512# 8個(gè)Transformer block，每個(gè)block有6個(gè)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()# 計(jì)算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` 對(duì)象# is_training: bool 表示訓(xùn)練還是eval，是會(huì)影響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，使用矩陣乘法實(shí)現(xiàn)提取詞的Embedding；否則用tf.embedding_lookup()# 對(duì)于TPU，使用前者更快，對(duì)于GPU和CPU，后者更快。# scope: (可選) 變量的scope。默認(rèn)是"bert"# Raises:# ValueError: 如果config或者輸入tensor的shape有問題就會(huì)拋出這個(gè)異常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計(jì)算，讀者可以對(duì)比之前的Transformer的代碼。attention_mask = create_attention_mask_from_input_mask(input_ids, input_mask)# 多個(gè)Transformer模型stack起來。# all_encoder_layers是一個(gè)list，長度為num_hidden_layers（默認(rèn)12），每一層對(duì)應(yīng)一個(gè)值。# 每一個(gè)值都是一個(gè)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"):# 取最后一層的第一個(gè)時(shí)刻[CLS]對(duì)應(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)# 然后再加一個(gè)全連接層，輸出仍然是[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))

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

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

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

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

embedding_lookup函數(shù)用于實(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矩陣對(duì)應(yīng)的向量。一般認(rèn)為tf.nn.embedding_lookup更快一點(diǎn)，但是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 隨機(jī)初始化的范圍 word_embedding_name: string 名字，默認(rèn)是"word_embeddings"use_one_hot_embeddings: bool 如果True，使用one-hot方法實(shí)現(xiàn)embedding；否則使用 `tf.nn.embedding_lookup()`. TPU適合用One hot方法。Returns:float Tensor shape為[batch_size, seq_length, embedding_size]"""# 這個(gè)函數(shù)假設(shè)輸入的shape是[batch_size, seq_length, num_inputs]# 普通的Embeding一般假設(shè)輸入是[batch_size, seq_length]，# 增加num_inputs這一維度的目的是為了一次計(jì)算更多的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]外，它還增加了一個(gè)維度變成[batch_size, seq_length, num_inputs]。如果不關(guān)心細(xì)節(jié)，我們把這個(gè)函數(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):"""對(duì)word embedding之后的tensor進(jìn)行后處理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的個(gè)數(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))# 因?yàn)門oken 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)建一個(gè)[max_position_embeddings, width]的矩陣# 但實(shí)際輸入的序列可能并不會(huì)到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]# 因?yàn)槲恢镁幋a是與輸入內(nèi)容無關(guān)，它的shape總是[seq_length, width]# 我們無法把位置Embedding加到word embedding上# 因此我們需要擴(kuò)展位置編碼為[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])# 默認(rèn)情況下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í)的兩個(gè)參數(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] ]

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

[[1, 1, 1, 0, 0], #它表示第1個(gè)詞可以attend to 3個(gè)詞[1, 1, 1, 0, 0], #它表示第2個(gè)詞可以attend to 3個(gè)詞[1, 1, 1, 0, 0], #它表示第3個(gè)詞可以attend to 3個(gè)詞[1, 1, 1, 0, 0], #無意義，因?yàn)檩斎氲?個(gè)詞是padding的0[1, 1, 1, 0, 0] #無意義，因?yàn)檩斎氲?個(gè)詞是padding的0 ][[1, 1, 1, 1, 1], # 它表示第1個(gè)詞可以attend to 5個(gè)詞[1, 1, 1, 1, 1], # 它表示第2個(gè)詞可以attend to 5個(gè)詞[1, 1, 1, 1, 1], # 它表示第3個(gè)詞可以attend to 5個(gè)詞[1, 1, 1, 1, 1], # 它表示第4個(gè)詞可以attend to 5個(gè)詞[1, 1, 1, 1, 1] # 它表示第5個(gè)詞可以attend to 5個(gè)詞 ]

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

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]，正是我們需要的兩個(gè)Mask矩陣，讀者可以驗(yàn)證。注意[batch, A, B]*[batch, B, C]=[batch, A, C]，我們可以認(rèn)為是batch個(gè)[A, B]的矩陣乘以batch個(gè)[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隱單元個(gè)數(shù)num_hidden_layers: int. 有多少個(gè)SubLayer num_attention_heads: int. Transformer Attention Head個(gè)數(shù)。intermediate_size: int. 全連接層的隱單元個(gè)數(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，返回最后一層的輸出，是一個(gè)Tensor，shape為[batch_size, seq_length, hidden_size]；否則返回所有層的輸出，是一個(gè)長度為num_hidden_layers的list，list的每一個(gè)元素都是[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))# 因?yàn)樽罱K要輸出hidden_size，總共有num_attention_heads個(gè)Head，因此每個(gè)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]# 因?yàn)樾枰獨(dú)埐钸B接，我們需要把輸入加到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:# 如果有多個(gè)head，那么需要把多個(gè)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))# 然后是用一個(gè)線性變換把大小變回`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

如果對(duì)照Transformer的論文，非常容易閱讀，里面實(shí)現(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)這個(gè)函數(shù)實(shí)現(xiàn)論文"Attentionis all you Need"里的multi-head attention。如果`from_tensor`和`to_tensor`是同一個(gè)tensor，那么就實(shí)現(xiàn)Self-Attention。`from_tensor`的每個(gè)時(shí)刻都會(huì)attends to `to_tensor`，也就是用from的Query去乘以所有to的Key，得到weight，然后把所有to的Value加權(quán)求和起來。這個(gè)函數(shù)首先把`from_tensor`變換成一個(gè)"query" tensor，然后把`to_tensor`變成"key"和"value" tensors。總共有`num_attention_heads`組Query、Key和Value，每一個(gè)Query，Key和Value的shape都是[batch_size(8), seq_length(128), size_per_head(512/8=64)].然后計(jì)算query和key的內(nèi)積并且除以size_per_head的平方根(8)。然后softmax變成概率，最后用概率加權(quán)value得到輸出。因?yàn)橛卸鄠€(gè)Head，每個(gè)Head都輸出[batch_size, seq_length, size_per_head]，最后把8個(gè)Head的結(jié)果concat起來，就最終得到[batch_size(8), seq_length(128), size_per_head*8=512] 實(shí)際上我們是把這8個(gè)Head的Query，Key和Value都放在一個(gè)Tensor里面的，因此實(shí)際通過transpose和reshape就達(dá)到了上面的效果。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，在計(jì)算attention score的時(shí)候，我們會(huì)把0變成負(fù)無窮(實(shí)際是一個(gè)絕對(duì)值很大的負(fù)數(shù))，而1不變，這樣softmax的時(shí)候進(jìn)行exp的計(jì)算，前者就趨近于零，從而間接實(shí)現(xiàn)Mask的功能。num_attention_heads: int. Attention heads的數(shù)量。size_per_head: int. 每個(gè)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ù)傳入也會(huì)被覆蓋。if len(from_shape) == 3:batch_size = from_shape[0]from_seq_length = from_shape[1]to_seq_length = to_shape[1]# 如果是壓縮成2D的，那么一定要傳入這3個(gè)參數(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) 默認(rèn)配置是8# F = `from_tensor` sequence length 默認(rèn)配置是128# T = `to_tensor` sequence length 默認(rèn)配置是128# N = `num_attention_heads` 默認(rèn)配置是12# H = `size_per_head` 默認(rèn)配置是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)# 計(jì)算Query `query_layer` = [B*F, N*H] =[8*128, 12*64]# batch_size=8，共128個(gè)時(shí)刻，12和head，每個(gè)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)# 計(jì)算query和key的內(nèi)積，得到attention scores.# [8, 12, 128, 64]*[8, 12, 64, 128]=[8, 12, 128, 128]# 最后兩維[128, 128]表示from的128個(gè)時(shí)刻attend to到to的128個(gè)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])# 這個(gè)小技巧前面也用到過，如果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# 我們把a(bǔ)dder加到attention_score里，mask是1就相當(dāng)于加0，mask是0就相當(dāng)于加-10000。# 通常attention_score都不會(huì)很大，因此mask為0就相當(dāng)于把a(bǔ)ttention_score設(shè)置為負(fù)無窮# 后面softmax的時(shí)候就趨近于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)# 對(duì)attention_probs進(jìn)行dropout，這雖然有點(diǎn)奇怪，但是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])# 計(jì)算`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

九、自己進(jìn)行Pretraining

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

要進(jìn)行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ù)是文本文件，每一行表示一個(gè)句子，空行表示一個(gè)文檔的結(jié)束(新文檔的開始)，比如上面的例子，總共有2個(gè)文檔，第一個(gè)文檔只有3個(gè)句子，第二個(gè)文檔有很多句子。

我們首先需要使用create_pretraining_data.py把文本文件變成TFRecord格式，便于后面的代碼進(jìn)行Pretraining。由于這個(gè)腳本會(huì)把整個(gè)文本文件加載到內(nèi)存，因此這個(gè)文件不能太大。如果讀者有很多文檔要訓(xùn)練，比如1000萬。那么我們可以把這1000萬文檔拆分成1萬個(gè)文件，每個(gè)文件1000個(gè)文檔，從而生成1000個(gè)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 最多生成多少個(gè)MASK
• masked_lm_prob 多少比例的Token變成MASK
• dupe_factor 一個(gè)文檔重復(fù)多少次

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

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

我們先來看一個(gè)訓(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è)原始兩個(gè)句子為：”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)該把這個(gè)輸入判斷為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) 每行一個(gè)句子。這應(yīng)該是實(shí)際的句子，不應(yīng)該是整個(gè)段落或者段落的隨機(jī)片段(span)，因?yàn)槲覀冃? 要使用句子邊界來做下一個(gè)句子的預(yù)測。 # (2) 文檔之間有一個(gè)空行。我們會(huì)認(rèn)為同一個(gè)文檔的相鄰句子是有關(guān)系的。# 下面的代碼讀取所有文件，然后根據(jù)空行切分Document# all_documents是list的list，第一層list表示document，第二層list表示document里的多個(gè)句子。 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:#添加一個(gè)新的空文檔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)):# 從一個(gè)文檔(下標(biāo)為document_index)里抽取多個(gè)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ù)會(huì)調(diào)用create_instances_from_document來從一個(gè)文檔里抽取多個(gè)訓(xùn)練數(shù)據(jù)(TrainingInstance)。普通的語言模型只要求連續(xù)的字符串就行，通常是把所有的文本(比如維基百科的內(nèi)容)拼接成一個(gè)很大很大的文本文件，然后訓(xùn)練的時(shí)候隨機(jī)的從里面抽取固定長度的字符串作為一個(gè)”句子”。但是BERT要求我們的輸入是一個(gè)一個(gè)的Document，每個(gè)Document有很多句子，這些句子是連貫的真實(shí)的句子，需要正確的分句，而不能隨機(jī)的(比如按照固定長度)切分句子。代碼如下：

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):"""從一個(gè)文檔里創(chuàng)建多個(gè)`TrainingInstance`。"""document = all_documents[document_index]# 為[CLS], [SEP], [SEP]預(yù)留3個(gè)位置。max_num_tokens = max_seq_length - 3# 我們通常希望Token序列長度為最大的max_seq_length，否則padding后的計(jì)算是無意義的，浪費(fèi)計(jì)# 算資源。但是有的時(shí)候我們有希望生成一些短的句子，因?yàn)樵趯?shí)際應(yīng)用中會(huì)有短句，如果都是# 長句子，那么就很容易出現(xiàn)Mismatch，所有我們以short_seq_prob == 0.1 == 10%的概率生成# 短句子。target_seq_length = max_num_tokens# 以0.1的概率生成隨機(jī)(2-max_num_tokens)的長度。if rng.random() < short_seq_prob:target_seq_length = rng.randint(2, max_num_tokens)# 我們不能把一個(gè)文檔的所有句子的Token拼接起來，然后隨機(jī)的選擇兩個(gè)片段。# 因?yàn)檫@樣很可能這兩個(gè)片段是同一個(gè)句子(至少很可能第二個(gè)片段的開頭和第一個(gè)片段的結(jié)尾是同一個(gè)# 句子)，這樣預(yù)測是否相關(guān)句子的任務(wù)太簡單，學(xué)習(xí)不到深層的語義關(guān)系。# 這里我們使用"真實(shí)"的句子邊界。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`是第一個(gè)句子A(在current_chunk里)結(jié)束的下標(biāo) a_end = 1# 隨機(jī)選擇切分邊界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)# 隨機(jī)的挑選另外一篇文檔的隨機(jī)開始的句子# 但是理論上有可能隨機(jī)到的文檔就是當(dāng)前文檔，因此需要一個(gè)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# 隨機(jī)挑選的文檔random_document = all_documents[random_document_index]# 隨機(jī)選擇開始句子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)個(gè)句子，但是a_end之后的句子替換成隨機(jī)的其它# 文檔的句子，因此我們并沒有使用a_end之后的句子，因此我們修改下標(biāo)i，使得下一次循環(huán)# 可以再次使用這些句子(把它們加到新的chunk里)，避免浪費(fèi)。num_unused_segments = len(current_chunk) - a_endi -= num_unused_segments# 真實(shí)的下一句else:is_random_next = Falsefor j in range(a_end, len(current_chunk)):tokens_b.extend(current_chunk[j])# 如果太多了，隨機(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

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

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

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

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

有了句子A和B之后，我們就可以填充tokens和segment_ids，這里會(huì)加入特殊的[CLS]和[SEP]。接下來使用create_masked_lm_predictions來隨機(jī)的選擇某些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)# 隨機(jī)打散rng.shuffle(cand_indexes)output_tokens = list(tokens)# 構(gòu)造一個(gè)namedtuple，包括index和label兩個(gè)屬性。masked_lm = collections.namedtuple("masked_lm", ["index", "label"])# 需要被模型預(yù)測的Token個(gè)數(shù)：min(max_predictions_per_seq(20)，實(shí)際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()# 隨機(jī)的挑選num_to_predict個(gè)需要預(yù)測的Token# 因?yàn)閏and_indexes打散過，因此順序的取就行for index in cand_indexes:# 夠了if len(masked_lms) >= num_to_predict:break# 已經(jīng)挑選過了？似乎沒有必要判斷，因?yàn)閟et會(huì)去重。 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%的概率隨機(jī)替換成詞典里的一個(gè)詞。 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的個(gè)數(shù)寫到文件里，這個(gè)函數(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腳本進(jìn)行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ù)用于計(jì)算語言模型的Loss(Mask位置預(yù)測的詞和真實(shí)的詞是否相同)。

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"):# 在輸出之前再加一個(gè)非線性變換，這些參數(shù)只是用于訓(xùn)練，在Fine-Tuning的時(shí)候就不用了。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，所以是傳入的，# 這里再多加一個(gè)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)# 但是由于實(shí)際MASK的可能不到20，比如只MASK18，那么label_ids有2個(gè)0(padding)# 而label_weights=[1, 1, ...., 0, 0]，說明后面兩個(gè)label_id是padding的，計(jì)算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ù)用于計(jì)算預(yù)測下一個(gè)句子的loss，代碼為：

def get_next_sentence_output(bert_config, input_tensor, labels):"""預(yù)測下一個(gè)句子是否相關(guān)的loss和log概率"""# 簡單的2分類，0表示真的下一個(gè)句子，1表示隨機(jī)的。這個(gè)分類器的參數(shù)在實(shí)際的Fine-Tuning# 會(huì)丟棄掉。 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é)主要對(duì)BERT在工業(yè)部署情況的性能測評(píng)。性能測試部分主要參考肖涵大神的本篇文章（github上bert-as-service的作者）。因個(gè)人硬件配置有限，后續(xù)有機(jī)會(huì)再進(jìn)行測試補(bǔ)充。

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

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

（二）client_batch_size對(duì)速度的影響

出于性能考慮，請(qǐng)盡可能每次傳入較多的句子而非一次只傳一個(gè)。比如，使用下列方法調(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)，則性能會(huì)更差。

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

?

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

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

?

總結(jié)

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

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