pytorch–从零实现一个BERT模型

本文主要从代码的角度一步步来讲解一下BERT模型是如何实现的。(后附完整代码)
关于BERT的理论解析现在随便一搜就可以找到很多,在这里就不在赘述。

模型架构

首先先说一下大佬传授的技巧 ?
写模型代码要注意两点:
1.从整体到局部;
2.数据流动形状;
怎么理解呢?对于一个模型的搭建我们不可能一蹴而就,要先从整体入手,先把大框搭起来,然后在实现每个函数具体的功能。
对于“数据流动形状”,要着重关注这个函数输入输出,比如经过Embedding层,原数据肯定会多一个维度,增加的这个维度后续我们会怎么处理。

先大概说一下我们这个模型要干什么事,先对bert这个模型有个大概一下印象。
在这里插入图片描述

  1. 对文本处理得到原始标签
  2. 对原始标签做mask
  3. 做Embedding
  4. 送入bert
  5. 对输出部分做处理
    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, Julietn'
        '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).__init__()

    def forward(self, Q, K, V, attn_pad):
        ## 输入进来的维度分别是 [batch_size x n_heads x len_q x d_k]  K: [batch_size x n_heads x len_k x d_k]  V: [batch_size x n_heads x len_k x d_v]
        ##首先经过matmul函数得到的scores形状是 : [batch_size x n_heads x len_q x len_k]
        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)]
        ## 然后关键词地方来了,下面这个就是用到了我们之前重点讲的attn_pad,把被pad的地方置为无限小,softmax之后基本就是0,对q的单词不起作用
        scores.masked_fill_(attn_pad, -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

其中一个值的注意的点是我们通过scores.masked_fill_(attn_pad, -1e9) 将符号矩阵对应的位置 置为无穷小,这样经过softmax后它就不会对q的单词起作用。也就实现了我们想要的去除掉pad对其他单词影响的效果。

MultiHeadAttention完~~~~~~
回到layers我们继续看

       enc_outputs = self.pos_ffn(enc_outputs) # enc_outputs: [batch_size x len_q x d_model]
       return enc_outputs, attn

将刚刚通过多头注意力机制得到的enc_outputs 送入PoswiseFeedForwardNet ,得到layers最终的结果

PoswiseFeedForwardNet

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)))

这部分就是一个两层的linear层,没什么好说的,对每个字的增强语义向量再做两次线性变换,以增强整个模型的表达能力。这里,变换后的向量与原向量保持长度相同。
pos_ffn完~~~~~~

layers 完~~~~~~

回到model部分我们继续往下看

        h_pooled = self.activ1(self.fc(output[:, 0])) # [batch_size, d_model] cls 对应的位置 可以看一下例子
        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) #在output取出一维对应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

通过output[:, 0]切片的方式得到cls对应位置的信息 将其送入一个linear层得到h_pooled 再将其送入一个二分类的linear 得到nsp任务的结果:logits_clsf
通过torch.gather 在output中取出一维masked_pos 对应的数据 h_masked 再将其送入linear层 并解码(decoder)得到mlm任务的结果: logits_lm

model 完~~~~~~
model的返回值
logits_lm, 代表 mask对应位置的输出
logits_clsf,为nsp任务的输出。

回到main()部分我们继续往下看

Loss

        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()

BERT 的损失函数由两部分组成,第一部分是来自 Mask-LM 的「单词级别分类任务」,另一部分是「句子级别的分类任务」。通过这两个任务的联合学习,可以使得 BERT 学习到的表征既有 token 级别信息,同时也包含了句子级别的语义信息。

最后再来看一下我们一开始提到的模型框架图,是不是很轻松就能理解了 ?
在这里插入图片描述

总结:

BERT文章作者提出了两个预训练任务:Masked LM和Next Sentence Prediction
BERT的第一个任务是采用 MaskLM 的方式来训练语言模型,通俗地说就是在输入一句话的时
候,随机地选一些要预测的词,然后用一个特殊的符号[MASK]来代替它们,因为我们知道被盖起来的部分是什么,但BERT不知道,所以BERT学习的目标就是 :输出跟盖起来的越接近越好。思想来源于 「完形填空」 的 任 务 。 具体来说 , 文章作者在一句话中随机选择 15% 的 词汇用于预 测 。 对于在原句中被 抹 去 的 词 汇 :
80% 情况下采用 一 个特殊符号 [MASK] 替 换 ,
10% 情况下采用 一 个任意词替换,
剩余 10% 情况下保持原词汇不变
这样做的好处是,BERT 并不知道[MASK]替换的是这 15%个 Token 中的哪一个词(「注意:这里意思是输入的时候不知道[MASK] 替换的是哪一个词,但是输出还是知道要预测哪个词的」)

Next Sentence Prediction 的任务描述为:给定一篇文章中的两句话,判断第二句话在文本中是否紧跟在第一句话之后。
这个类似于 「段落重排序」 的任务
只考虑两句话,判断是否是一篇文章中的前后句。在实际预训练过程中,
文章作者从文本语料库中随机选择 50% 正确语句对和 50% 错误语句对进行训练,在第一个句子的首部会加上一个[CLS] token,在两个句子中间以及最后一个句子的尾部会加上一个[SEP] token。
这样能让模型去学习一下句子层面的信息。
本文完~~~~~~

完整源码

"""
orginal 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

# 数据预处理
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]

        # 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的方式
        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])  # 回到ppt看一下
            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)
        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
# 符号矩阵
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 不懂可以看一下例子
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)))

#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):# x对应input_ids, seg对应segment_ids
        seq_len = input_ids.size(1)
        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 self.norm(embedding)

# 注意力打分函数
class ScaledDotProductAttention(nn.Module):
    def __init__(self):
        super(ScaledDotProductAttention, self).__init__()

    def forward(self, Q, K, V, attn_pad):
        ## 输入进来的维度分别是 [batch_size x n_heads x len_q x d_k]  K: [batch_size x n_heads x len_k x d_k]  V: [batch_size x n_heads x len_k x d_v]
        ##首先经过matmul函数得到的scores形状是 : [batch_size x n_heads x len_q x len_k]
        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)]
        ## 然后关键词地方来了,下面这个就是用到了我们之前重点讲的attn_pad,把被pad的地方置为无限小,softmax之后基本就是0,对q的单词不起作用
        scores.masked_fill_(attn_pad, -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__()
        ## 输入进来的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 对张量重复扩充
        # 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]

#基于位置的前馈神经网络
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)))

#Encoder
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_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):
        input = self.embedding(input_ids, segment_ids) # 将input_ids,segment_ids,pos_embed加和

        ##get_attn_pad_mask是为了得到句子中pad的位置信息,给到模型后面,在计算自注意力和交互注意力的时候去掉pad符号的影响,去看一下这个函数 4.
        enc_self_attn_pad = get_attn_pad_mask(input_ids, input_ids)
        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]
        h_pooled = self.activ1(self.fc(output[:, 0])) # [batch_size, d_model] cls 对应的位置 可以看一下例子
        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) #在output取出一维对应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
# 1.从整体到局部
# 2.数据流动形状(输入 输出)
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

    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, Julietn'
        '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))# map把函数依次作用在list中的每一个元素上,得到一个新的list并返回。注意,map不改变原list,而是返回一个新list。

    model = BERT()
    criterion = nn.CrossEntropyLoss(ignore_index=0) # 只计算mask位置的损失
    optimizer = optim.Adam(model.parameters(), lr=0.001)


    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]
        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()

特别鸣谢:

DASOU

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>