Bert源码阅读

Bertha 。 2021-10-29 13:30 389阅读 0赞

前言

对Google开源出来的bert代码，来阅读下。不纠结于代码组织形式，而只是梳理下其训练集的生成，训练的self-attention和multi-head的具体实现。

训练集的生成

主要实现在create\_pretraining\_data.py和tokenization.py两个脚本里。  
输入文本格式举例，下面是两篇文章外加一篇空文章。两篇文章之间用空格作间隔。

This is a blog about bert code reading.  
It is writed using markdown, which is a markup language that can be written using a plain text editor.  
Hopefuly it will give the reader a deep understanding of bert.

本文是篇关于bert源码阅读的博客。  
它是用markdown写的，markdown是种可以使用普通文本编辑器编写的标记语言。  
希望本文能够给读者以对bert更深层次的理解。

1  
2  
3  
4  
5  
6  
7  
8  
9  
第一步，读取raw文本，按行分词处理后存储all\_documents\[doc\_0, doc\_1, …\]里面，doc\_i=\[line\_0, line\_1, …\], line\_i = \[token\_0, token\_1, …\]，然后shuffle文章。  
第二步，重复dupe\_factor=10次，每篇文章生成样本，\[CLS +A+SEP +B+SEP\]作一条样本。  
注意：上述样本既用于MLM，又用于next-Sentence预测训练。

for \_ in range(dupe\_factor):  
for document\_index in range(len(all\_documents)):  
instances.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))  
1  
2  
3  
4  
5  
6  
create\_instances\_from\_document函数对每篇文章都生成一个训练样本实例。  
从第一条句子循环到最后一条句子i ii，收集segment到current\_chunk列表中，当收集到的总句子长度>=单条样本最长值时，构造A+B。

if i == len(document) - 1 or current\_length >= target\_seq\_length:  
1  
随机截取 current\_chunk的某个位置a\_end，\[0, a\_end\]作为子句A=token\_a。  
B句随机概率选择是Next or Not next，如果是next，则current\_chunk的剩余\[a\_end, :\]作为子句B=token\_b。如果Not next，则随机挑一篇文章，选择某个长度的子句作为B=token\_b。注意，Not next时，循环经过的B句子对应的步幅，要回去(因为这部分句子并没有被真正使用，所以退回去以免浪费)。

num\_unused\_segments = len(current\_chunk) - a\_end  
i -= num\_unused\_segments  
1  
2  
两个句子加和长度超过最大长度怎么办？使用truncate\_seq\_pair在A和B中随机选择一个，随机丢掉首/尾的词，每次丢一个token，直到加和长度<=最大长度。

truncate\_seq\_pair(tokens\_a, tokens\_b, max\_num\_tokens, rng)  
1  
之后根据token\_a和token\_b生成tokens和segment\_ids  
tokens=\[CLS,A0,A1,A2,SEP,B0,B1,B2,SEP\] tokens = \[CLS, A\_0, A\_1, A\_2, SEP, B\_0, B\_1, B\_2, SEP\]tokens=\[CLS,A  
0  
  
,A  
1  
  
,A  
2  
  
,SEP,B  
0  
  
,B  
1  
  
,B  
2  
  
,SEP\]  
segment\_ids=\[0a,0a,0a,0a,0a,1b,1b,1b,1b\] segment\\\_ids =\[0\_a, 0\_a, 0\_a, 0\_a, 0\_a, 1\_b, 1\_b, 1\_b, 1\_b\]segment\_ids=\[0  
a  
  
,0  
a  
  
,0  
a  
  
,0  
a  
  
,0  
a  
  
,1  
b  
  
,1  
b  
  
,1  
b  
  
,1  
b  
  
\]  
再之后，根据tokens生成遮挡替换之后的tokens、遮挡位置masked\_lm\_positions、遮挡位置的真实词masked\_lm\_labels。

(tokens, masked\_lm\_positions,  
masked\_lm\_labels) = create\_masked\_lm\_predictions(  
tokens, masked\_lm\_prob, max\_predictions\_per\_seq, vocab\_words, rng)  
1  
2  
3  
15%采样遮挡，对遮挡的处理情况如下：  
a) 80%的概率，遮挡词被替换为\[mask\]。⟶ \\longrightarrow⟶别人看不到我。  
b) 10%的概率，遮挡词被替换为随机词。⟶ \\longrightarrow⟶别人看走眼我。  
c) 10%的概率，遮挡词被替换为原来词。⟶ \\longrightarrow⟶别人能看到我。

masked\_token = None  
\# 80% of the time, replace with \[MASK\]  
if rng.random() < 0.8:  
masked\_token = "\[MASK\]"  
else:  
\# 10% of the time, keep original  
if rng.random() < 0.5:  
masked\_token = tokens\[index\]  
\# 10% of the time, replace with random word  
else:  
masked\_token = vocab\_words\[rng.randint(0, len(vocab\_words) - 1)\]  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
输入和返回结果举例：

input tokens ="The man went to the store . He bought a gallon of milk "  
ouput tokens ="The man went to the \[mask\] . He \[mask\] a gallon of ice"  
output masked\_lm\_positions = \[5, 8, 10, 11\]  
output masked\_lm\_labels = \[store, bought, gallon, milk\]  
1  
2  
3  
4  
位置\#5,\#8被遮挡，\#10被替换为原token，\#11被替换为随机词。注意CLS和SEP不会被遮挡。  
然后保存成TrainingInstance类，同时保留了is\_next标记.

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)  
1  
2  
3  
4  
5  
6  
tokenization.FullTokenizer类用来处理分词，标点符号，unknown词，Unicode转换等操作。注意：中文只有单个字的切分，没有词。

数据存储及读取

存储为TF-Record  
输入sentence变量的处理

input\_ids = tokenizer.convert\_tokens\_to\_ids(instance.tokens) \#\# ID化 \#\#  
input\_mask = \[1\] \* len(input\_ids)  
segment\_ids = segment\_ids  
padding 0 --> max\_seq\_length  
1. 对iput\_ids 补0到句子最大长度  
2. 对input\_mask 补0到句子最大长度  
3. 对segment\_ids 补0到句子最大长度  
1  
2  
3  
4  
5  
6  
7  
注意：input\_mask是样本中有效词句的标识，后面需要用作作attention视野的约束。  
遮挡变量的处理

masked\_lm\_positions = list(instance.masked\_lm\_positions)  
masked\_lm\_ids = tokenizer.convert\_tokens\_to\_ids(instance.masked\_lm\_labels)  
masked\_lm\_weights = \[1.0\] \* len(masked\_lm\_ids)  
\#\# padding 0 --> max\_seq\_length  
1  
2  
3  
4  
注意：

masked\_lm\_ids是有mask的词对应的ID，比如\[120, 911, 234, 0, 0, 0, 0\]；  
masked\_lm\_positions是有mask的词对应的句子中位置，比如\[15, 23, 11, 0, 0, 0, 0\]；  
masked\_lm\_weights记录遮挡词的有效位置，计算masked-loss时使用，比如\[1, 1, 1, 0, 0, 0, 0\]。  
next\_sentense 的标记处理

next\_sentence\_label = 1 if instance.is\_random\_next else 0  
1  
save format 处理

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))  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
读取使用dataset。

input\_ids = features\["input\_ids"\]  
''' tf.data.TFRecordDataset '''  
1  
2  
BertModel

模型实例化 ，注意这里的变量对应。

model = modeling.BertModel(  
config=bert\_config,  
is\_training=is\_training,  
input\_ids=input\_ids,  
input\_mask=input\_mask,  
token\_type\_ids=segment\_ids, \#\# token\_type是句子标记 \#\#  
use\_one\_hot\_embeddings=use\_one\_hot\_embeddings)  
1  
2  
3  
4  
5  
6  
7  
输入token\_ids–>向量化处理, embeding\_lookup返回token\_emb 和查询的table表。

(self.embedding\_output, self.embedding\_table) = embedding\_lookup(  
input\_ids=input\_ids,  
vocab\_size=config.vocab\_size,  
embedding\_size=config.hidden\_size,  
word\_embedding\_name="word\_embeddings", \#and so on\#)  
1  
2  
3  
4  
5  
加入pos\_emb和type\_emb处理， embedding\_postprocessor  
注意：pos\_emb并不是用sin/cos函数生成的，而是随机生成的。

self.embedding\_output = embedding\_postprocessor(  
input\_tensor=self.embedding\_output,  
use\_token\_type=True, \#\# type\_emb的处理设置 \#\#  
token\_type\_ids=token\_type\_ids,  
token\_type\_vocab\_size=config.type\_vocab\_size,  
use\_position\_embeddings=True, \#\# pos\_emb的处理设置 \#\#  
dropout\_prob=config.hidden\_dropout\_prob, \# and so on \#)  
1  
2  
3  
4  
5  
6  
7  
重要：构造attention可视域的attention\_mask，因为每个样本都经过padding了，视野必须要约束到有效范围词句内。

\# This converts a 2D mask of shape \[batch\_size, seq\_length\] to a 3D  
\# mask of shape \[batch\_size, seq\_length, seq\_length\] which is used for the attention scores.  
attention\_mask = create\_attention\_mask\_from\_input\_mask(input\_ids, input\_mask)  
\#\# 注意：  
\#\# input\_ids 是经过padding后的 \[32,108, 99, 0, 0\]; \#\#  
\#\# input\_mask 是有效词标志 \[1, 1, 1, 0, 0\] \#\#  
def create\_attention\_mask\_from\_input\_mask(from\_tensor, to\_mask):  
"""Create 3D attention mask from a 2D tensor mask.  
from\_tensor: 2D or 3D Tensor of shape \[batch\_size, from\_seq\_length, ...\].  
to\_mask: int32 Tensor of shape \[batch\_size, to\_seq\_length\].  
returns: \[batch\_size, from\_seq\_length, to\_seq\_length\].  
"""  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
Bert.Transformer

\# Run the stacked transformer.  
\# \`sequence\_output\` shape = \[batch\_size, seq\_length, hidden\_size\].  
self.all\_encoder\_layers = transformer\_model(  
input\_tensor=self.embedding\_output, \#\# 输入token\_ids经过 emb + pos\_emb + seg\_emb之后的结果 \#\#  
attention\_mask=attention\_mask, \#\# 根据input\_mask得到的可视域3D表示 \#\#  
num\_attention\_heads=config.num\_attention\_heads, \#\# 多头数量 \#\#  
do\_return\_all\_layers=True, \# and so on \#)  
1  
2  
3  
4  
5  
6  
7  
对Transformer内部，逐层attention  
1）先搞self-attention，注意有效位置的计算attention\_mask。  
2）再对每个位置做前向网络，加个drop层，加个layer-norm层，残差连接2）的输入。  
3）再对每个位置做前向网络，加个drop层，加个layer-norm层，残差连接3）的输入。  
4）输出作下层的输入，直到N层。  
重要：这里根据输入query=\[batch\_size \* seq\_length, emb\_size\]来梳理下计算单层self-attenion过程中的维度变化。

注意：输入词的emb\_size必须跟Transformer 的输出dim=-1的size一样么，必须的，因为有残差连接，必须保持维度一致。但是，head\_nums\_size × \\times× size\_per\_head = emb\_size=hidden\_size不用必须成立【notice，bert代码实现上是将其设为相等的】，query\_layer的最后维度只需是head\_nums × \\times× 任意数。靠近输出的dense包括了drop/layer-norm操作。  
self-attention的矩阵计算示例

再说明下，query–>query\_layer的变换，并不是echo token独享一个转换矩阵，也不是每个位置独享一个矩阵，而是query的emb\_size空间–> query\_layer的hidden\_size空间上的维度变换。  
重要：attention的计算示例  
1）先看下单条样本时，self-attention的计算示例SelfAttentionSingle.py 链接  
2）再看下batch样本时，self-attention的计算示例SelfAttentionBatch.py 链接  
3）最后再看下batch+heads时，self-attention的计算示例SelfAttentionBatchMultiHeads.py 链接

attention\_mask的作用在于，softmax时，对非视野内的做负向大加权，使得attention-score只计算注意在可视域范围内【非补0的地方】的数值。

if attention\_mask is not None:  
\# \`attention\_mask\` = \[B, 1, F, T\]  
attention\_mask = tf.expand\_dims(attention\_mask, axis=\[1\])  
\# Since attention\_mask is 1.0 for positions we want to attend and 0.0 for  
\# masked positions, this operation will create a tensor which is 0.0 for  
\# positions we want to attend and -10000.0 for masked positions.  
adder = (1.0 - tf.cast(attention\_mask, tf.float32)) \* -10000.0  
\# Since we are adding it to the raw scores before the softmax, this is  
\# effectively the same as removing these entirely.  
attention\_scores += adder  
\# Normalize the attention scores to probabilities.  
\# \`attention\_probs\` = \[B, N, F, T\]  
attention\_probs = tf.nn.softmax(attention\_scores)  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
注意，计算完上下文信息后，要转换成\[batch, seq\_length, num\_heads, size\_per\_head\]，再作其他处理。

BertModel.sequence\_output 是取最后attenion层的输出。  
BertModel.pooled\_output 取sequence\_output的第一个token“CLS”的emb，然后加个连接层。

Loss Compute

Masked Language Model的loss计算

(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)  
def get\_masked\_lm\_output(bert\_config, input\_tensor, output\_weights, positions,  
label\_ids, label\_weights):  
\#\# input\_tensor = model.get\_sequence\_output(), model的最后层输出 \#\# \[B, seq\_len, emb\_size\]  
\#\# output\_weights = model.get\_embedding\_table(), vocab\_table \#\# \[vocab\_size, emb\_size\]  
\#\# positions = msked\_lm\_positions 遮挡词的在句子中的位置 \#\# \[B, seq\_len\] \#\# 前几个是位置 \#\# 举例 \[\#pos1, \#pos3, \#pos10, 0, 0, 0\]  
\#\# label\_ids = masked\_lm\_ids \#\# 遮挡词的ID \#\# \[B, seq\_len\] \#\# 前几个是ID \#\# 举例 \[119, 301, 911, 0, 0, 0\]  
\#\# label\_weights = masked\_lm\_weights \#\# 遮挡词权重=1，非遮挡词权重=0 \#\# \[B, seq\_len\] \#\# 举例 \[1, 1, 1, 0, 0, 0\]  
\#\# = pdding(\[1.0\] \* len(masked\_lm\_ids))  
"""Get loss and log probs for the masked LM."""  
input\_tensor = gather\_indexes(input\_tensor, positions)  
\#\# gather\_indexes也会将补0取出来，所以总tensor\_size是不变的, \[B\*seq\_len, emb\_size\]  
\#\# 注意后续的计算，都是在这个尺寸上进行的 \#\#  
\#\# 又单独加了层输出dense，并增加了vocab\_emb\_table的乘积 + bias \#\#

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
注意： label\_weight在最后计算总loss时，乘上，只计算有遮挡的位置的loss。

Next Sentence Predict的loss计算  
注意：此处使用模型最后输出层的第一个token-"CLS"的emb作为输入。

(next\_sentence\_loss, next\_sentence\_example\_loss,  
next\_sentence\_log\_probs) = get\_next\_sentence\_output(  
bert\_config, model.get\_pooled\_output(), next\_sentence\_labels)  
def get\_next\_sentence\_output(bert\_config, input\_tensor, labels):  
\#\# input\_tensor = model.get\_pooled\_output() \#\# 模型最后输出层的第一个token-"CLS"的emb \#\#  
\#\# labels = next\_sentence\_labels \#\#  
"""Get loss and log probs for the next sentence prediction."""  
\#\# 剩下的就是添加个dense层，二元分类 计算loss \#\#  
1  
2  
3  
4  
5  
6  
7  
8  
两个loss加和作总的损失，联合训练。

total\_loss = masked\_lm\_loss + next\_sentence\_loss  
1  
参考

https://github.com/google-research/bert  
\---------------------  
作者：于建民  
来源：CSDN  
原文：https://blog.csdn.net/yujianmin1990/article/details/85175905  
版权声明：本文为博主原创文章，转载请附上博文链接！

转载于:https://www.cnblogs.com/jfdwd/p/11250829.html