pytorch--从零实现一个BERT模型
Posted 与 或
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了pytorch--从零实现一个BERT模型相关的知识，希望对你有一定的参考价值。
本文主要从代码的角度一步步来讲解一下BERT模型是如何实现的。(后附完整代码)
关于BERT的理论解析现在随便一搜就可以找到很多，在这里就不在赘述。
BERT源码
模型架构
首先先说一下大佬传授的技巧 😃
写模型代码要注意两点：
1.从整体到局部；
2.数据流动形状；
怎么理解呢？对于一个模型的搭建我们不可能一蹴而就，要先从整体入手，先把大框搭起来，然后在实现每个函数具体的功能。
对于“数据流动形状”，要着重关注这个函数输入输出，比如经过Embedding层，原数据肯定会多一个维度，增加的这个维度后续我们会怎么处理。
先大概说一下我们这个模型要干什么事，先对bert这个模型有个大概一下印象。
- 对文本处理得到原始标签
- 对原始标签做mask
- 做Embedding
- 送入bert
- 对输出部分做处理
a. 第一个字符 < cls>对应的输出接一个linear层做一个二分类即NSP任务;
b.mask对应位置的输出接一个解码层 将768维的Embedding映射成词表大小，然后与真实标签做loss。
再来看一下4.中的bert都干了些什么？
首先将输入文本做一个Embedding(①)，然后送入多头注意力机制中(②)，输出接一个Layer Normalization和残差连接(③)最后送入两个linear层中(④)
这就是上图中一个Encoder做的事情。
到这大家对我们要干什么脑海里应该有了一个模糊的框架。
接下来就是代码部分。完全按照上面描绘的走~
下面代码的一个整体框架,其中make_batch ，model部分是重点
而model中的layers又是重重之中
模型实现
我们先从整体 即“main”入手：
定义超参
if __name__ == '__main__':
# BERT Parameters
maxlen = 30 # 句子的最大长度
batch_size = 6 # 每一组有多少个句子一起送进去模型
max_pred = 5 # max tokens of prediction
n_layers = 6 # number of Encoder of Encoder Layer
n_heads = 12 # number of heads in Multi-Head Attention
d_model = 768 # Embedding Size
d_ff = 3072 # 4*d_model, FeedForward dimension
d_k = d_v = 64 # dimension of K(=Q), V
n_segments = 2 # 用于NSP任务
首先是定义一些超参，具体作用均已标注。
其中需要注意的一个参数是：max_pred 它表示的是一个句子中最多可以有多少个mask，怎么用后面我们会谈到（一个坑，在make_batch()部分会讲到）
文本预处理
因为我们注重的是模型的实现，所以数据部分就自己定义了一些对话语句，在实际应用中往往会是海量的文本。
text = (
'Hello, how are you? I am Romeo.\\n'
'Hello, Romeo My name is Juliet. Nice to meet you.\\n'
'Nice meet you too. How are you today?\\n'
'Great. My baseball team won the competition.\\n'
'Oh Congratulations, Juliet\\n'
'Thanks you Romeo'
)
数据有了，接下来就是对数据进行处理
sentences = re.sub("[.,!?\\\\-]", '', text.lower()).split('\\n') # filter '.', ',', '?', '!'
通过re.sub函数将数据中的特殊字符清除掉 并将大写字符全部转变为小写字符
效果：
word_list = list(set(" ".join(sentences).split()))
word_dict = '[PAD]': 0, '[CLS]': 1, '[SEP]': 2, '[MASK]': 3
for i, w in enumerate(word_list):
word_dict[w] = i + 4
number_dict = i: w for i, w in enumerate(word_dict)
vocab_size = len(word_dict)
word_list：根据“ ”空格切分后的单词列表
word_dict: 加入特殊字符生成的词典
number_dict：将word_dict的键值对调换(预测时候会用到)
效果：
# 把文本转化成数字
token_list = list()
for sentence in sentences:
arr = [word_dict[s] for s in sentence.split()]
token_list.append(arr)
根据刚刚生成好的word_dict 将sentences 中的字符转换成数字 方便后面处理
效果：
文本预处理完~~~~~~
继续往下看就是最重要的数据构建部分了
make_batch()
batch = make_batch() # 最重要的一部分 预训练任务的数据构建部分
input_ids, segment_ids, masked_tokens, masked_pos, isNext = map(torch.LongTensor, zip(*batch))# map把函数依次作用在list中的每一个元素上，得到一个新的list并返回。注意，map不改变原list，而是返回一个新list。
通过 make_batch() 对数据进行处理，
得到 input_ids, segment_ids, masked_tokens, masked_pos, isNext
我们跳到make_batch()函数部分看一下这几个代表的是什么，和它具体是怎么处理的。
def make_batch():
batch = [] # list
positive = negative = 0 # 计数器 为了记录NSP任务中的正样本和负样本的个数，比例最好是在一个batch中接近1：1
while positive != batch_size/2 or negative != batch_size/2:
# 抽出来两句话 先随机sample两个index 再通过index找出样本
tokens_a_index, tokens_b_index= randrange(len(sentences)), randrange(len(sentences)) # 比如tokens_a_index=3，tokens_b_index=1；从整个样本中抽取对应的样本；
tokens_a, tokens_b= token_list[tokens_a_index], token_list[tokens_b_index]## 根据索引获取对应样本：tokens_a=[5, 23, 26, 20, 9, 13, 18] tokens_b=[27, 11, 23, 8, 17, 28, 12, 22, 16, 25]
# 拼接
input_ids = [word_dict['[CLS]']] + tokens_a + [word_dict['[SEP]']] + tokens_b + [word_dict['[SEP]']] ## 加上特殊符号，CLS符号是1，sep符号是2：[1, 5, 23, 26, 20, 9, 13, 18, 2, 27, 11, 23, 8, 17, 28, 12, 22, 16, 25, 2]
segment_ids = [0] * (1 + len(tokens_a) + 1) + [1] * (len(tokens_b) + 1)##分割句子符号：[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
实现的效果：
input_ids 是下图中的Token Embeddings
segment_ids就是下图中的Segment Embeddings
接下来是要对刚刚拼接好的input_ids进行mask处理：
# MASK LM
n_pred = min(max_pred, max(1, int(round(len(input_ids) * 0.15)))) # n_pred=3；整个句子的15%的字符可以被mask掉，这里取和max_pred中的最小值，确保每次计算损失的时候没有那么多字符以及信息充足，有15%做控制就够了；其实可以不用加这个，单个句子少了，就要加上足够的训练样本
# 不让特殊字符参与mask
cand_maked_pos = [i for i, token in enumerate(input_ids)
if token != word_dict['[CLS]'] and token != word_dict['[SEP]']] ## cand_maked_pos=[1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]；整个句子input_ids中可以被mask的符号必须是非cls和sep符号的，要不然没意义
shuffle(cand_maked_pos)## 打乱顺序：cand_maked_pos=[6, 5, 17, 3, 1, 13, 16, 10, 12, 2, 9, 7, 11, 18, 4, 14, 15] 其实取mask对应的位置有很多方法，这里只是一种使用shuffle的方式
在这部分就要用到我们最开始提到的那个值得注意的超参：max_pred（填坑）
为什么需要max_pred？
比如在mask时候，一个句子被mask了3个单词，另一个句子被mask了7个单词。
很难把这两个句子组成一个有效的矩阵。我们之前做了一个最大长度的截断，这max_pred也相当一个截断参数。
cand_maked_pos的作用是去掉特殊字符< CLS > < SEP>,整个句子input_ids中可以被mask的符号必须是非cls和sep符号的，要不然没意义
masked_tokens, masked_pos = [], []
for pos in cand_maked_pos[:n_pred]: # 取其中的三个；masked_pos=[6, 5, 17] 注意这里对应的是position信息；masked_tokens=[13, 9, 16] 注意这里是被mask的元素之前对应的原始单字数字；
masked_pos.append(pos)
masked_tokens.append(input_ids[pos])
if random() < 0.8: # 80%
input_ids[pos] = word_dict['[MASK]'] # make mask
elif random() < 0.5: # 10%
index = randint(0, vocab_size - 1) # random index in vocabulary
input_ids[pos] = word_dict[number_dict[index]] # replace
masked_tokens对应的是被mask元素之前的原始的单字数字,
masked_pos 对应的是position信息
然后对其按照8/1/1比例mask
想要实现的效果：
接下来是补零操作：
# Zero Paddings
n_pad = maxlen - len(input_ids)##maxlen=30；n_pad=10
input_ids.extend([0] * n_pad)
segment_ids.extend([0] * n_pad)# 这里有一个问题，0和之前的重了
# Zero Padding (100% - 15%) tokens 是为了计算一个batch中句子的mlm损失的时候可以组成一个有效矩阵放进去；不然第一个句子预测5个字符，第二句子预测7个字符，第三个句子预测8个字符，组不成一个有效的矩阵；
## 这里非常重要，为什么是对masked_tokens是补零，而不是补其他的字符？
## 我补1可不可以？ 后面会讲到
if max_pred > n_pred:
n_pad = max_pred - n_pred
masked_tokens.extend([0] * n_pad)## masked_tokens= [13, 9, 16, 0, 0] masked_tokens 对应的是被mask的元素的原始真实标签是啥，也就是groundtruth
masked_pos.extend([0] * n_pad)## masked_pos= [6, 5, 17，0，0] masked_pos是记录哪些位置被mask了
if tokens_a_index + 1 == tokens_b_index and positive < batch_size/2:
batch.append([input_ids, segment_ids, masked_tokens, masked_pos, True]) # IsNext
positive += 1
elif tokens_a_index + 1 != tokens_b_index and negative < batch_size/2:
batch.append([input_ids, segment_ids, masked_tokens, masked_pos, False]) # NotNext
negative += 1
return batch
为什么要补零呢？
是为了计算一个batch中句子的mlm损失的时候可以组成一个有效矩阵放进去；不然第一个句子预测5个字符，第二句子预测7个字符，第三个句子预测8个字符，组不成一个有效的矩阵；
还有一个点，为什么补的是零，而不是其他值？
在后面的loss部分会给出解释。
通过 batch.append添加的字段就是我们要得到 input_ids, segment_ids, masked_tokens, masked_pos, isNext
input_ids 是bert输入的Token Embeddings
segment_idsbert输入的Segment Embeddings
masked_tokens对应的是被mask元素之前的原始的单字数字,
masked_pos 对应的是position信息
isNext 代表这两个句子是否是相邻的上下文
make_batch()完~~~~~~
回到main()继续往下看
定义模型，损失函数 和 优化策略
model = BERT()
criterion = nn.CrossEntropyLoss(ignore_index=0) # 只计算mask位置的损失
optimizer = optim.Adam(model.parameters(), lr=0.001)
这里有一个细节是nn.CrossEntropyLoss(ignore_index=0) 我们定义了一个ignore_index为0，
我们可以看到loss 中给出的解释的我们可以指定一个值，这个值不参与计算。也就是说我们后面在计算loss的时候，0不参与计算，即我们对masked_tokens补零后不影响结果。
接下来是main()中的调用部分
for epoch in range(100):
optimizer.zero_grad()
# logits_lm 语言词表的输出
# logits_clsf 二分类的输出
# logits_lm：[batch_size, max_pred, n_vocab]
logits_lm, logits_clsf = model(input_ids, segment_ids, masked_pos)## logits_lm 【6，5，29】 bs*max_pred*voca logits_clsf:[6*2]
model
我们传给model 三个参数input_ids, segment_ids, masked_pos，分别为
input_ids ：bert输入的Token Embeddings
segment_ids ：bert输入的Segment Embeddings
masked_pos ：对应的是选中那15%的position信息
我们刚刚在make_baatch已经说的很清楚了，还是不太明白的可以在回去看一下~
我们来看一下model = BERT()的详细处理过程：
首先是一些定义
class BERT(nn.Module):
def __init__(self):
super(BERT, self).__init__()
self.embedding = Embedding() ## 词向量层，构建词表矩阵
self.layers = nn.ModuleList([EncoderLayer() for _ in range(n_layers)]) ## 把N个encoder堆叠起来，具体encoder实现一会看
self.fc = nn.Linear(d_model, d_model) ## 前馈神经网络-cls
self.activ1 = nn.Tanh() ## 激活函数-cls
self.linear = nn.Linear(d_model, d_model)#-mlm
self.activ2 = gelu ## 激活函数--mlm
self.norm = nn.LayerNorm(d_model)
self.classifier = nn.Linear(d_model, 2)## cls 这是一个分类层，维度是从d_model到2，对应我们架构图中就是这种：
# decoder is shared with embedding layer
# 注意这部分的decoder不是transformer中的decoder 而是将‘mlm任务’输出解码到词表大小的一个映射
embed_weight = self.embedding.tok_embed.weight
n_vocab, n_dim = embed_weight.size()
self.decoder = nn.Linear(n_dim, n_vocab, bias=False)
self.decoder.weight = embed_weight
self.decoder_bias = nn.Parameter(torch.zeros(n_vocab))
其中值得关注的是self.embedding，self.layers 这也是我们要重点讲的
下面是BERT的实现部分
def forward(self, input_ids, segment_ids, masked_pos):
# 将input_ids，segment_ids，pos_embed加和得到input
input = self.embedding(input_ids, segment_ids)
我们将input_ids, segment_ids传给Embedding，那Embedding会进行什么操作呢？
Embedding
class Embedding(nn.Module):
def __init__(self):
super(Embedding, self).__init__()
self.tok_embed = nn.Embedding(vocab_size, d_model) # token embedding
self.pos_embed = nn.Embedding(maxlen, d_model) # position embedding
self.seg_embed = nn.Embedding(n_segments, d_model) # segment(token type) embedding
# self.norm = nn.LayerNorm(d_model)
def forward(self, input_ids, segment_ids)
seq_len = input_ids.size(1) # input_ids：batch_size x len x d_model
pos = torch.arange(seq_len, dtype=torch.long) #生成数组
pos = pos.unsqueeze(0).expand_as(input_ids) # (seq_len,) -> (batch_size, seq_len)
embedding = self.tok_embed(input_ids) + self.pos_embed(pos) + self.seg_embed(segment_ids)
return embedding
首先是在定义部分（ init ）定义了三个映射规则
然后在实现部分（ forward ）通过arange生成一个与input_ids 维度一致的数组(已填充好的)，然后将传入的input_ids, segment_ids和生成的pos 相加得到bert的最终输入，即下图中的input。
arange函数的效果：
Embedding完~~~~~~
回到model部分我们继续往下看
是一个get_attn_pad_mask函数，它的作用是为了得到句子中pad的位置信息，给到模型后面，在计算自注意力和交互注意力的时候去掉pad符号的影响。
##get_attn_pad_mask是为了得到句子中pad的位置信息，给到模型后面，在计算自注意力和交互注意力的时候去掉pad符号的影响
enc_self_attn_pad = get_attn_pad_mask(input_ids, input_ids)
下面我们来具体看一下这个函数
get_attn_pad_mask
def get_attn_pad_mask(seq_q, seq_k): # 在自注意力层q k是一致的
batch_size, len_q = seq_q.size()
batch_size, len_k = seq_k.size()
# eq(zero) is PAD token
# eq(0)表示和0相等的返回True，不相等返回False。
pad_attn_mask = seq_k.data.eq(0).unsqueeze(1) # batch_size x 1 x len_k(=len_q), one is masking
return pad_attn_mask.expand(batch_size, len_q, len_k) # 重复了len_q次 batch_size x len_q x len_k 不懂可以看一下例子
内容不多也很好懂，seq_k.data.eq(0)是将input_ids中=0的置为True 其他置为False，.unsqueeze(1)的作用是增加一维，然后通过.expand函数重复 len_q次 ，最终会return我们想要的 符号矩阵。
.expand函数：
get_attn_pad_mask完~~~~~~
回到model部分我们继续往下看
layers
for layer in self.layers:
output, enc_self_attn = layer(input, enc_self_attn_pad) ## enc_self_attn这里是QK转置相乘之后softmax之后的矩阵值，代表的是每个单词和其他单词相关性；
# output : [batch_size, len, d_model], attn : [batch_size, n_heads, d_mode, d_model]
对于layers是我们在最开始就提到它是整个模型的重中之中，因为我们要在layer部分实现最重要的多头注意力机制和 pos_ffn
class EncoderLayer(nn.Module):
def __init__(self):
super(EncoderLayer, self).__init__()
self.enc_self_attn = MultiHeadAttention()
self.pos_ffn = PoswiseFeedForwardNet()
def forward(self, enc_inputs, enc_self_attn_pad):
enc_outputs, attn = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs, enc_self_attn_pad) # enc_inputs to same Q,K,V enc_self_attn_mask是pad符号矩阵
对于多头注意力机制我们的输入有四个enc_inputs, enc_inputs, enc_inputs, enc_self_attn_pad 分别代表Q K V 和我们之前求出的符号矩阵。
MultiHeadAttention
lass MultiHeadAttention(nn.Module):
def __init__(self):
super(MultiHeadAttention, self).__init__()
## 输入进来的QKV是相等的，使用映射linear做一个映射得到参数矩阵Wq, Wk,Wv
self.W_Q = nn.Linear(d_model, d_k * n_heads)
self.W_K = nn.Linear(d_model, d_k * n_heads)
self.W_V = nn.Linear(d_model, d_v * n_heads)
def forward(self, Q, K, V, attn_pad):
## 这个多头分为这几个步骤，首先映射分头，然后计算atten_scores，然后计算atten_value;
## 输入进来的数据形状： Q: [batch_size x len_q x d_model], K: [batch_size x len_k x d_model], V: [batch_size x len_k x d_model]
# q: [batch_size x len_q x d_model], k: [batch_size x len_k x d_model], v: [batch_size x len_k x d_model]
residual, batch_size = Q, Q.size(0)
# (B, S, D) -proj-> (B, S, D) -split-> (B, S, H, W) -trans-> (B, H, S, W)
##下面这个就是先映射，后分头；一定要注意的是q和k分头之后维度是一致额，所以这里都是dk
q_s = self.W_Q(Q).view(batch_size, -1, n_heads, d_k).transpose(1,2) # q_s: [batch_size x n_heads x len_q x d_k]
k_s = self.W_K(K).view(batch_size, -1, n_heads, d_k).transpose(1,2) # k_s: [batch_size x n_heads x len_k x d_k]
v_s = self.W_V(V).view(batch_size, -1, n_heads, d_v).transpose(1,2) # v_s: [batch_size x n_heads x len_k x d_v]
## 输入进行的attn_pad形状是 batch_size x len_q x len_k，然后经过下面这个代码得到 新的attn_pad : [batch_size x n_heads x len_q x len_k]，就是把pad信息重复了n个头上
attn_pad = attn_pad.unsqueeze(1).repeat(1, n_heads, 1, 1) # repeat 对张量重复扩充
首先使用映射linear做一个映射得到参数矩阵Wq, Wk,Wv 注意这里的参数矩阵的维度是d_k * n_heads 是‘多头’之后的
q_s = self.W_Q(Q).view(batch_size, -1, n_heads, d_k).transpose(1,2)
的意思是先通过映射得到参数矩阵，在通过.view将其“分头”并调整维度顺序
.view函数效果：
然后通过打分函数得到注意力矩阵context, 注意力分数attn（没乘V之前的矩阵）
# context: [batch_size x n_heads x len_q x d_v], attn: [batch_size x n_heads x len_q(=len_k) x len_k(=len_q)]
context, attn = ScaledDotProductAttention()(q_s, k_s, v_s, attn_pad)
context = context.transpose(1, 2).contiguous().view(batch_size, -1, n_heads * d_v) # context: [batch_size x len_q x n_heads * d_v]
output = nn.Linear(n_heads * d_v, d_model)(context)
return nn.LayerNorm(d_model)(output + residual), attn # output: [batch_size x len_q x d_model]
ScaledDotProductAttention部分要实现的就是点积注意力计算公式：
ScaledDotProductAttention
点积注意力计算公式：
class ScaledDotProductAttention(nn.Module):
def __init__(self):
super(ScaledDotProductAttention, self)Pytorch | BERT模型实现，提供转换脚本横扫NLP
pytorch-pretrained-BERT：BERT PyTorch实现，可加载Google BERT预训练模型
循环神经网络 RNN 从零开始实现 动手学深度学习v2 pytorch
横扫各项NLP任务的BERT模型有了PyTorch实现！提供转换脚本