目录
1.BERT的理论
2.代码实现
2.1构建输入数据格式
2.2定义BERT编码器的类
2.3BERT的两个任务
2.3.1任务一：Masked Language Modeling MLM掩蔽语言模型任务
2.3.2 任务二：next sentence prediction
3.整合代码
4.知识点个人理解
1.BERT的理论
BERT全称叫做Bidirectional Encoder Representations from Transformers, 论文地址: [1810.04805] BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding (arxiv.org)
BERT是谷歌AI研究院在2018年10月提出的一种预训练模型. BERT本质上就是Transformer模型的encoder部分, 并且对encoder做了一些改进.
官方代码和预训练模型 Github: https://github.com/google-research/bert
下图中编码器部分即BERT的基本结构.
2.代码实现
import torch
from torch import nn
import dltools
2.1构建输入数据格式
def get_tokens_and_segments(tokens_a, tokens_b=None):#classification 分类#BERT是两句话作为一对句子一同传入的，也可以单独传一句话，若序列长度长，可以补padding#假设先传一句话tokens_atokens = ['<cls>'] + tokens_a + ['<sep>'] #tokens_embedding层的处理segments = [0] * (len(tokens_a) + 2) #判断词元属于哪一句话，加标记，0属于第一句话if tokens_b is not None:tokens += tokens_b + ['sep']segments += [1] * (len(tokens_b) + 1)return tokens, segments#测试上面的函数
get_tokens_and_segments([1, 2, 3], [4, 5, 6])(['<cls>', 1, 2, 3, '<sep>', 4, 5, 6, 'sep'], [0, 0, 0, 0, 0, 1, 1, 1, 1])
2.2定义BERT编码器的类
class BERTEncoder(nn.Module):#由于前馈网络的ffn_num_outputs = num_hiddens,没有初始化传入#__init__()里面的参数，是创建类的时候传入的参数def __init__(self, vocab_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout,max_len=1000, key_size=768, query_size=768, value_size=768, **kwargs):super().__init__(**kwargs)#token_embeddings层self.token_emdedding = nn.Embedding(vocab_size, num_hiddens)#segment_embedding层 (传入两个句子，所以第0维为2)self.segment_embedding = nn.Embedding(2, num_hiddens)#pos_embedding层 :位置嵌入层是可以学习的, 用nn.Parameter（）定义可学习的参数self.pos_embedding = nn.Parameter(torch.randn(1, max_len, num_hiddens))#设置Encoder_block的数量self.blks = nn.Sequential() #为使用的Encoder_block依次编号for i in range(num_layers): #有几层网络循环几层self.blks.add_module(f'{i}', dltools.EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout))#__init__()里面的参数，是创建类的时候传入的参数#foward里面的参数是创建完类对象之后，调用类方法时传入的参数def forward(self, tokens, segments, valid_lens):#X = token_embedding + segment_embedding + pos_embedding#传入的token_embedding，segment_embedding两者的shape相同，可以直接相加X = self.token_emdedding(tokens) + self.segment_embedding(segments)#pos_embedding与前两层的数据shape不相同，不能直接相加#切片让self.pos_embedding的第1维度的数据切片到token_embedding，segment_embedding相加之后的数X = X + self.pos_embedding.data[:, :X.shape[1], :]for blk in self.blks:X = blk(X, valid_lens)return X #测试上面代码#创建BERTEncoder类对象
vocab_size, num_hiddens, ffn_num_hiddens, num_heads = 10000, 768, 1024, 4
norm_shape, ffn_num_input, num_layers, dropout = [768], 768, 2, 0.2
encoder = BERTEncoder(vocab_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)tokens = torch.randint(0, vocab_size, (2, 8)) #生成随机正整数
segments = torch.tensor([[0, 0, 0, 0, 1, 1, 1, 1], [0, 0, 0, 0, 1, 1, 1, 1]])
#调用类方法
encoded_X = encoder(tokens, segments, None)encoded_X.shapetorch.Size([2, 8, 768])
# nn.Sequential()是PyTorch中的一个类，它允许用户将多个计算层按照顺序组合成一个模型。在深度学习中，模型可以是由各种不同类型的层组成的，例如卷积层、池化层、全连接层等。nn.Sequential()方法可以将这些层组合在一起，形成一个整体模型。
2.3BERT的两个任务
2.3.1任务一：Masked Language Modeling MLM掩蔽语言模型任务
class MaskLM(nn.Module):def __init__(self, vocab_size, num_inputs=768, **kwargs):super().__init__(**kwargs)self.mlp = nn.Sequential(nn.Linear(num_inputs, num_hiddens), #全连接层nn.ReLU(), nn.LayerNorm(num_hiddens), nn.Linear(num_hiddens, vocab_size)) #输出层#X表示随机(15%概率)将一些词元换成mask#pred_positions表示已经处理好的80%概率将选中的词换成mask>， 10%概率换成随机词元，10%概率保持原有词元#pred_position是二维数据def forward(self, X, pred_positions): num_pred_positions = pred_positions.shape[1] #索引出80%、10%、10%三个概率选出的需要转换的词位置数量pred_positions = pred_positions.reshape(-1) #变成一维数据batch_size = X.shape[0] #获取批次batch_idx = torch.arange(0, batch_size) #获取批次的编号#将批次编号与元素数量对应起来#例如：batch_size = [0, 1] --> [0, 0, 0, 1, 1, 1]batch_idx = torch.repeat_interleave(batch_idx, num_pred_positions) #将batch_idx中每个元素重复num_pred_positions次#把要预测位置的数据取出来masked_X = X[batch_idx, pred_positions]masked_X = masked_X.reshape(batch_size, num_pred_positions, -1) #还原维度mlm_Y_hat = self.mlp(masked_X)return mlm_Y_hat#测试代码mlm = MaskLM(vocab_size, num_hiddens)
mlm_positions = torch.tensor([[1, 5, 2], [6, 1, 5]])
mlm_Y_hat = mlm(encoded_X, mlm_positions)mlm_Y_hat.shape #2:2个批次， 3：三个需要转换词元的位置 10000：计算的概率数量（在最后会用softmax函数计算分类结果），vocab_size有10000个，torch.Size([2, 3, 10000])
mlm_Y = torch.tensor([[7, 8, 9], [10, 20, 30]]) #假设真实值
loss = nn.CrossEntropyLoss(reduction='none')
mlm_l = loss(mlm_Y_hat.reshape(-1, vocab_size), mlm_Y.reshape(-1)) # mlm_Y_hat的shape=（6， 10000） mlm_Y的shape=（6）
mlm_l.shapetorch.Size([6])
2.3.2 任务二：next sentence prediction
class NextSentencePred(nn.Module):def __init__(self, num_inputs, **kwargs):super().__init__(**kwargs)self.output = nn.Linear(num_inputs, 2) #预测输入的句子是否为下一个句子，预测目标值为“是/否”二分类问题def forward(self, X):#X的形状（batch_size, num_hiddens）return self.output(X)#测试代码encoded_X = torch.flatten(encoded_X, start_dim=1) #将数据展平，相当于reshape
nsp = NextSentencePred(encoded_X.shape[-1])
nsp_Y_hat = nsp(encoded_X)nsp_Y_hat.shapetorch.Size([2, 2])
#计算损失
nsp_y = torch.tensor([0, 1]) #假设真实值
nsp_1 = loss(nsp_Y_hat, nsp_y)
nsp_1.shapetorch.Size([2])
3.整合代码
class BERTModel(nn.Module):def __init__(self, vocab_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout,max_len=1000, key_size=768, query_size=768, value_size=768,hid_in_features=768, mlm_in_features=768, nsp_in_features=768, **kwargs):super().__init__(**kwargs)#初始化编码器对象self.encoder = BERTEncoder(vocab_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout,max_len=max_len, key_size=key_size, query_size=query_size, value_size=value_size)#掩蔽语言模型任务self.mlm = MaskLM(vocab_size, num_hiddens, mlm_in_features)#中间隐藏层的线性转换+激活函数self.hidden = nn.Sequential(nn.Linear(hid_in_features, num_hiddens), nn.Tanh())#预测出下一句self.nsp = NextSentencePred(nsp_in_features)def forward(self, tokens, seqments, valid_lens=None, pred_position=None):encoded_X = self.encoder(tokens, seqments, valid_lens)if pred_position is not None:mlm_Y_hat = self.mlm(encoded_X, pred_position)else:pred_position = None#0表示<cls>标记的索引nsp_Y_hat = self.nsp(self.hidden(encoded_X[:, 0, :]))return encoded_X, mlm_Y_hat, nsp_Y_hat4.知识点个人理解
