论文解读:BERT探索笔记(BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding)
-
论文:BERT:Pre-training of Deep Bidirectional Transformers for Language Understanding
-
官方代码 - https://github.com/ google-research/bert
-
参考学习的代码
- https://github.com/graykode/nlp-tutorial/tree/master/5-2.BERT
本文目的: BERT是如何制作训练样本? 以及如何训练的,重点关注数据处理部分!
如何训练NLP模型,即目标函数是啥?这样的问题一直是NLP的一个重要问题,通常会预测下一个单词(e.g. “The child came home from ___”) 。
下面看一下BERT是如何做数据的预处理,以及目标函数的确立是如何构建,BERT有两种训练策略:
策略一,Masked LM (MLM)
一个句子:The child came home from China
BERT处理成: The child [MASK] home from China,
第一,
The child [MASK] home from China, 以此作为模型的输入,预测的时候,会根据没有被[MASK]的词所提供的有效信息去预测被[MASK]的真实词。 也就是 The child [MASK] home from China。中的[MASK]真实值是什么?
第二,
没有被[MASK]的词,BERT是忽略掉它们的梯度反馈,也就是没有梯度反馈;只有被[MASK]的词,才有梯度反馈,看下文的图,只有w4是有梯度反馈, w1,w2,w3,w5的输出是不计LOSS的。所以论文中也提到,这样的训练方式会导致收敛速度慢,但是只要效果好,再多训练2天,也无所谓。
第三,
制作[MASK]数据,也就是制作训练样本(一个句子,就是一个样本),论文中提到,每一个句子中有15%的词会被MASK,即假设一个句子有20个字,则有3个词会被MASK;拓展一下,这个15%是可以调的参数,改一下,或许又是大力出奇迹。
本来随机抽出来的15%应该是全部打上 [MASK]的,在下文给出的代码中,针对随机出来的15%,还进一步做特殊的随机处理。
80% 直接打上[MASK]标记
10% 不做任何处理,也就是还是原来的真实值
10% 打上其他词,即不是[MASK],也不是真实值。
具体的随机细节,看下面的对应代码:
# cand_maked_pos 是随机出来的15%,将要被打上[MASK]位置, 本来是直接全部打上[MASK]
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
这样处理,效果有提升? 这个我没有去验证,知道的道友,评论区留意指点一下,十分感谢。
往下走,数据流是如何输入和输出,看下图,
- 在Encoder层的输出中,添加一个分类层,用来预测[MASK]的真实值(“The child [MASK] home from China”, 例子中是 came),
- 分类层的输出再乘以embedding matrix
- 最后做 softmax,预测概率得分
(图片来源 | https://towardsdatascience.com/bert-explained-state-of-the-art-language-model-for-nlp-f8b21a9b6270)
策略二,Next Sentence Prediction (NSP)
这个策略,是用来训练模型,判断输入的两个句子是否是相连的?
看下图,图中左边对应着不同的数据编码,分别是Positional Embeddings, Segment Embeddings, Token Embeddings,下面详解介绍一下他们代表着什么意思?
首先,理解一个概念 pairs of sentences(句子对),什么是“句子对”?
假设训练样本为n个句子, 随机选择2个句子做拼接,称之为“句子对”。 比如上图中的
[CLS] my dog E[CLS] Emy Edog is cute [SEP] he likes play ##ing [SEP]
这就是一个“句子对”,训练BERT时,喂进去的就是该样式的数据,其中, [CLS] ,[SEP]是特殊字符。
数据预测处理
# n=6个句子,作为训练样本
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'
)
随机选择2个句子:
Oh Congratulations, Juliet + Thanks you Romeo,两个句子是相邻的“句子对”,论文中称之为正样本
Nice meet you too. How are you today? + Thanks you Romeo 两个句子是不相邻的“句子对”,论文称之为负样本
具体拼接,“句子对”前面加上[CLS],标记正样本或者负样本, 每个句子结尾加上[SEP],如下
[CLS] Oh Congratulations Juliet [SEP] Thanks you Romeo [SEP]
详解介绍数据处理步骤:
第一步,Transformer Positional Embedding
[CLS] Oh Congratulations Juliet [SEP] Thanks you Romeo [SEP] 先做位置编码,这个和Transformer论文一样,对词做sin,con位置编码
第二步,Sentence Embedding
[CLS] Oh Congratulations Juliet [SEP] Thanks you Romeo [SEP] 做句子的01区分,
第一个句子,Oh Congratulations Juliet [SEP], 每个词用0表示:0 0 0 0 ,
第二个句子,Thanks you Romeo [SEP], 每个词用1表示 1 1 1 1,
那[CLS]呢? CLS是标记“句子对”是正样本或者负样本, 取值0或1。 (这里有个问题?取值0或1,与第二步的Sentence Embedding是否冲突,具体需要进一步看代码)。
(图片来源 | 论文解读:Bert原理深入浅出)
第三步, Token Embedding
[CLS] Oh Congratulations Juliet [SEP] Thanks you Romeo [SEP] 每个词做词编码
(图片来源 | 论文解读:Bert原理深入浅出)
3个步骤,需要注意的:
- 特殊字符的编码,[MASK], [CLS], [SEP]
- 第一步和第三步的编码是和Transformer一致,第二步的0-1划分,是区分“句子对”中的不同句子;拓展一下,会不会做3个句子,4个句子的拼接训练呢?
- 最后,叠加上面3个Embedding输出的向量值,就得到 训练BERT时的输入。
(图片来源 | The Illustrated BERT, ELMo, and co. (How NLP Cracked Transfer Learning))
训练
-
训练BERT时,是两个策略Masked LM 和 Next Sentence Prediction一起同时训练,两个loss相加作为梯度反馈。也就是说训练的“句子对”最终是如下样式:
[CLS] Oh Congratulations Juliet [SEP] Thanks [MASK] Romeo [SEP]
而且,作为特殊字符[CLS], [SEP],共3个位置,这3个位置不能被标记为[MASK] 。
-
上文中提到的正样本和负样本,在每一个训练的batch中,各占50%;拓展一下,这个参数又是可调的,说不定可以大力出奇迹。
-
Masked LM Loss, 把做了MASK标记的词,预测出来,也就是预测真实值,这个第一个LOSS。
-
Next Sentence Prediction Loss, 对应的是[CLS]输出值,判断“句子对”中的两个句子是否是相邻,相邻[CLS]输出值接近1,不相邻[CLS]输出值接近0,这是第二个LOSS。
-
两个LOSS相加,就可以了,拓展一下,两个LOSS相加是否带权重呢!
参考文章
- BERT Explained: State of the art language model for NLP
- The Illustrated BERT, ELMo, and co. (How NLP Cracked Transfer Learning)
调试代码
一个简单的BERT代码,主要用来研究学习BERT的基本原理。
## from https://github.com/graykode/nlp-tutorial/tree/master/5-2.BERT
import math
import re
from random import *
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
# sample IsNext and NotNext to be same in small batch size
# sentences 样本库,一个样本就是一个句子
# tokens_a_index,tokens_b_index 随机选择2个句子
# tokens_a, tokens_b 把a,b两个句子转换为 数字,也就是句子用数字来表示,简称 数字句子
# input_ids 把两个数字句子拼接,同时在index=0,设置'[CLS]', 在第一个数字句子设置'[SEP]',在第二个数字句子设置'[SEP]'。 ==》 '[CLS]' + 句子1 + '[SEP]' + 句子2 + '[SEP]'
# segment_ids 分割两个句子, '[CLS]' + 句子1 + '[SEP]' 设置为0, 句子2 + '[SEP]'设置为1
# n_pred 句子中要打mask的个数
# cand_maked_pos 打mask的位置(index)不能是'[CLS]','[SEP]','[SEP]', 打mask的位置(index)是随机的,当然也有很多方式
# masked_tokens, masked_pos, 记录被打mask的真实数字,以及他的位置(index)
# batch ==>[input_ids, segment_ids, masked_tokens, masked_pos, False|True]
def make_batch():
batch = []
positive = negative = 0 ## 为了记录NSP任务中的正样本和负样本的个数,比例最好是在一个batch中接近1:1
while positive != batch_size/2 or negative != batch_size/2:
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]
# MASK LM
n_pred = min(max_pred, max(1, int(round(len(input_ids) * 0.15)))) # n_pred=3;整个句子的15%的字符可以被mask掉,这里取和max_pred中的最小值,确保每次计算损失的时候没有那么多字符以及信息充足,有15%做控制就够了;其实可以不用加这个,单个句子少了,就要加上足够的训练样本
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的方式
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
# Zero Paddings
n_pad = maxlen - len(input_ids)##maxlen=30;n_pad=10
input_ids.extend([0] * n_pad)#在input_ids后面补零
segment_ids.extend([0] * n_pad)# 在segment_ids 后面补零;这里有一个问题,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了
# 如果随机选出来的2个句子是相邻的,作为正样本,反之,负样本
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
# Proprecessing Finished
def get_attn_pad_mask(seq_q, seq_k):
batch_size, len_q = seq_q.size()
batch_size, len_k = seq_k.size()
# eq(zero) is PAD token
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) # batch_size x len_q x len_k
def gelu(x):
"Implementation of the gelu activation function by Hugging Face"
return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))
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, x, seg):
seq_len = x.size(1)
pos = torch.arange(seq_len, dtype=torch.long)
pos = pos.unsqueeze(0).expand_as(x) # (seq_len,) -> (batch_size, seq_len)
embedding = self.tok_embed(x) + self.pos_embed(pos) + self.seg_embed(seg)
return self.norm(embedding)
class ScaledDotProductAttention(nn.Module):
def __init__(self):
super(ScaledDotProductAttention, self).__init__()
def forward(self, Q, K, V, attn_mask):
scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(d_k) # scores : [batch_size x n_heads x len_q(=len_k) x len_k(=len_q)]
scores.masked_fill_(attn_mask, -1e9) # Fills elements of self tensor with value where mask is one.
attn = nn.Softmax(dim=-1)(scores)
context = torch.matmul(attn, V)
return context, attn
class MultiHeadAttention(nn.Module):
def __init__(self):
super(MultiHeadAttention, self).__init__()
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_mask):
# 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_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_mask = attn_mask.unsqueeze(1).repeat(1, n_heads, 1, 1) # attn_mask : [batch_size x n_heads x len_q x len_k]
# 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_mask)
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]
class PoswiseFeedForwardNet(nn.Module):
def __init__(self):
super(PoswiseFeedForwardNet, self).__init__()
self.fc1 = nn.Linear(d_model, d_ff)
self.fc2 = nn.Linear(d_ff, d_model)
def forward(self, x):
# (batch_size, len_seq, d_model) -> (batch_size, len_seq, d_ff) -> (batch_size, len_seq, d_model)
return self.fc2(gelu(self.fc1(x)))
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_mask):
enc_outputs, attn = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs, enc_self_attn_mask) # enc_inputs to same Q,K,V
enc_outputs = self.pos_ffn(enc_outputs) # enc_outputs: [batch_size x len_q x d_model]
return enc_outputs, attn
## 1. 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
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))
def forward(self, input_ids, segment_ids, masked_pos):
output = self.embedding(input_ids, segment_ids)## 生成input_ids对应的embdding;和segment_ids对应的embedding
enc_self_attn_mask = get_attn_pad_mask(input_ids, input_ids)
for layer in self.layers:
output, enc_self_attn = layer(output, enc_self_attn_mask)
# output : [batch_size, len, d_model], attn : [batch_size, n_heads, d_mode, d_model]
# it will be decided by first token(CLS)
h_pooled = self.activ1(self.fc(output[:, 0])) # [batch_size, d_model]
logits_clsf = self.classifier(h_pooled) # [batch_size, 2]
masked_pos = masked_pos[:, :, None].expand(-1, -1, output.size(-1)) # [batch_size, max_pred, d_model] 其中一个 masked_pos= [6, 5, 17,0,0]
# get masked position from final output of transformer.
h_masked = torch.gather(output, 1, masked_pos) # masking position [batch_size, max_pred, d_model]
h_masked = self.norm(self.activ2(self.linear(h_masked)))
logits_lm = self.decoder(h_masked) + self.decoder_bias # [batch_size, max_pred, n_vocab]
return logits_lm, logits_clsf
if __name__ == '__main__':
# BERT Parameters
maxlen = 30 # 句子的最大长度 cover住95% 不要看平均数 或者99% 直接取最大可以吗?当然也可以,看你自己
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
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 '.', ',', '?', '!'
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)
token_list = list()
for sentence in sentences:
arr = [word_dict[s] for s in sentence.split()]
token_list.append(arr)
batch = make_batch()
input_ids, segment_ids, masked_tokens, masked_pos, isNext = map(torch.LongTensor, zip(*batch))
model = BERT()
criterion = nn.CrossEntropyLoss(ignore_index=0)
optimizer = optim.Adam(model.parameters(), lr=0.001)
for epoch in range(100):
optimizer.zero_grad()
logits_lm, logits_clsf = model(input_ids, segment_ids, masked_pos)## logits_lm 【6,5,29】 bs*max_pred*voca logits_clsf:[6*2]
loss_lm = criterion(logits_lm.transpose(1, 2), masked_tokens) # for masked LM ;masked_tokens [6,5]
loss_lm = (loss_lm.float()).mean()
loss_clsf = criterion(logits_clsf, isNext) # for sentence classification
loss = loss_lm + loss_clsf
if (epoch + 1) % 10 == 0:
print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.6f}'.format(loss))
loss.backward()
optimizer.step()
# Predict mask tokens ans isNext
input_ids, segment_ids, masked_tokens, masked_pos, isNext = map(torch.LongTensor, zip(batch[0]))
print(text)
print([number_dict[w.item()] for w in input_ids[0] if number_dict[w.item()] != '[PAD]'])
logits_lm, logits_clsf = model(input_ids, segment_ids, masked_pos)
logits_lm = logits_lm.data.max(2)[1][0].data.numpy()
print('masked tokens list : ',[pos.item() for pos in masked_tokens[0] if pos.item() != 0])
print('predict masked tokens list : ',[pos for pos in logits_lm if pos != 0])
logits_clsf = logits_clsf.data.max(1)[1].data.numpy()[0]
print('isNext : ', True if isNext else False)
print('predict isNext : ',True if logits_clsf else False)
群交流
AIGC,CV,NLP等学习者,技术大佬等交流兰亭之地,不卖书,不卖课。
END