原来你是这样的BERT,i了i了! —— 超详细BERT介绍(一)BERT主模型的结构及其组件

时间:2022-03-16 17:34:13

原来你是这样的BERT,i了i了! —— 超详细BERT介绍(一)BERT主模型的结构及其组件

BERTBidirectional Encoder Representations from Transformers)是谷歌在2018年10月推出的深度语言表示模型。

一经推出便席卷整个NLP领域,带来了革命性的进步。

从此,无数英雄好汉竞相投身于这场追剧(芝麻街)运动。

只听得这边G家110亿,那边M家又1750亿,真是好不热闹!

然而大家真的了解BERT的具体构造,以及使用细节吗?

本文就带大家来细品一下。


前言

本系列文章分成三篇介绍BERT,本文主要介绍BERT主模型(BertModel)的结构及其组件相关知识,另有两篇分别介绍BERT预训练相关和如何将BERT应用到不同的下游任务

文章中的一些缩写:NLP(natural language processing)自然语言处理;CV(computer vision)计算机视觉;DL(deep learning)深度学习;NLP&DL 自然语言处理和深度学习的交叉领域;CV&DL 计算机视觉和深度学习的交叉领域。

文章公式中的向量均为行向量,矩阵或张量的形状均按照PyTorch的方式描述。

向量、矩阵或张量后的括号表示其形状。

本系列文章的代码均是基于transformers库(v2.11.0)的代码(基于Python语言、PyTorch框架)。

为便于理解,简化了原代码中不必要的部分,并保持主要功能等价。

在代码最开始的地方,需要导入以下包:

代码
from math import inf, sqrt
import torch as tc
from torch import nn
from torch.nn import functional as F
from transformers import PreTrainedModel

阅读本系列文章需要一些背景知识,包括Word2VecLSTMTransformer-BaseELMoGPT等,由于本文不想过于冗长(其实是懒),以及相信来看本文的读者们也都是冲着BERT来的,所以这部分内容还请读者们自行学习。

本文假设读者们均已有相关背景知识。


目录


1、主模型

BERT的主模型是BERT中最重要组件,BERT通过预训练(pre-training),具体来说,就是在主模型后再接个专门的模块计算预训练的损失(loss),预训练后就得到了主模型的参数(parameter),当应用到下游任务时,就在主模型后接个跟下游任务配套的模块,然后主模型赋上预训练的参数,下游任务模块随机初始化,然后微调(fine-tuning)就可以了(注意:微调的时候,主模型和下游任务模块两部分的参数一般都要调整,也可以冻结一部分,调整另一部分)。

主模型由三部分构成:嵌入层编码器池化层

如图:

原来你是这样的BERT,i了i了! —— 超详细BERT介绍(一)BERT主模型的结构及其组件

其中

  • 输入:一个个小批(mini-batch),小批里是batch_size个序列(句子或句子对),每个序列由若干个离散编码向量组成。
  • 嵌入层:将输入的序列转换成连续分布式表示(distributed representation),即词嵌入(word embedding)或词向量(word vector)。
  • 编码器:对每个序列进行非线性表示。
  • 池化层:取出[CLS]标记(token)的表示(representation)作为整个序列的表示。
  • 输出:编码器最后一层输出的表示(序列中每个标记的表示)和池化层输出的表示(序列整体的表示)。

下面具体介绍这些部分。


1.1、输入

一般来说,输入BERT的可以是一句话:

I'm repairing immortals.

也可以是两句话:

I'm repairing immortals. ||| Me too.

其中|||是分隔两个句子的分隔符。

BERT先用专门的标记器(tokenizer)来标记(tokenize)序列,双句标记后如下(单句类似):

I ' m repair ##ing immortal ##s . ||| Me too .

标记器其实就是先对句子进行基于规则的标记化(tokenization),这一步可以把'm以及句号.等分割开,再进行子词分割(subword segmentation),示例中带##的就是被子词分割开的部分。

子词分割有很多好处,比如压缩词汇表、表示未登录词(out of vocabulary words, OOV words)、表示单词内部结构信息等,以后有时间专门写一篇介绍这个。

数据集中的句子长度不一定相等,BERT采用固定输入序列(长则截断,短则填充)的方式来解决这个问题。

首先需要设定一个seq_length超参数(hyperparameter),然后判断整个序列长度是否超出,如果超出:单句截掉最后超出的部分,双句则先删掉较长的那句话的末尾标记,如果两句话长度相等,则轮流删掉两句话末尾的标记,直到总长度达到要求(即等长的两句话删掉的标记数量尽量相等);如果序列长度过小,则在句子最后添加[PAD]标记,使长度达到要求。

然后在序列最开始添加[CLS]标记,以及在每句话末尾添加[SEP]标记。

单句话添加一个[CLS]和一个[SEP],双句话添加一个[CLS]和两个[SEP]

[CLS]标记对应的表示作为整个序列的表示,[SEP]标记是专门用来分隔句子的。

注意:处理长度时需要考虑添加的[CLS][SEP]标记,使得最终总的长度=seq_length[PAD]标记在整个序列的最末尾。

例如seq_length=12,则单句变为:

[CLS] I ' m repair ##ing immortal ##s . [SEP] [PAD] [PAD]

如果seq_length=10,则双句变为:

[CLS] I ' m repair [SEP] Me too . [SEP]

分割完后,每一个空格分割的子字符串(substring)都看成一个标记(token),标记器通过查表将这些标记映射成整数编码。

单句如下:

[101, 146, 112, 182, 6949, 1158, 15642, 1116, 119, 102, 0, 0]

最后整个序列由四种类型的编码向量表示,单句如下:

标记编码:[101, 146, 112, 182, 6949, 1158, 15642, 1116, 119, 102, 0, 0]
位置编码:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
句子位置编码:[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
注意力掩码:[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]

其中,标记编码就是上面的序列中每个标记转成编码后得到的向量;位置编码记录每个标记的位置;句子位置编码记录每个标记属于哪句话,0是第一句话,1是第二句话(注意:[CLS]标记对应的是0);注意力掩码记录某个标记是否是填充的,1表示非填充,0表示填充。

双句如下:

标记编码:[101, 146, 112, 182, 6949, 102, 2508, 1315, 119, 102]
位置编码:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
句子位置编码:[0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
注意力掩码:[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

上面的是英文的情况,中文的话BERT直接用汉字级别表示,即

我在修仙( ̄︶ ̄)

这样的句子分割成

我 在 修 仙 (  ̄ ︶  ̄ )

然后每个汉字(包括中文标点)看成一个标记,应用上述操作即可。


1.2、嵌入层

嵌入层的作用是将序列的离散编码表示转换成连续分布式表示。

离散编码只能表示A和B相等或不等,但是如果将其表示成连续分布式表示(即连续的N维空间向量),就可以计算\(A\)与\(B\)之间的相似度或距离了,从而表达更多信息。

这个是词嵌入或词向量的知识,可以参考Word2Vec相关内容,本文不再赘述了。

嵌入层包含三种组件:嵌入变换(embedding)、层标准化(layer normalization)、随机失活(dropout)。

如图:

原来你是这样的BERT,i了i了! —— 超详细BERT介绍(一)BERT主模型的结构及其组件

1.2.1、嵌入变换

嵌入变换实际上就是一个线性变换(linear transformation)。

传统上,离散标记往往表示成一个独热码(one-hot)向量,也叫标准基向量,即一个长度为\(V\)的向量,其中只有一位为\(1\),其他都为\(0\)。

在NLP&DL领域,\(V\)一般是词汇表的大小。

但是这种向量往往维数很高(词汇表往往比较大)而且很稀疏(每个向量只有一位不为\(0\)),不好处理。

所以可以通过一个线性变换将这个向量转换成低维稠密的向量。

假设\(v\)(\(V\))是标记\(t\)的独热码向量,\(W\)(\(V \times H\))是一个\(V\)行\(H\)列的矩阵,则\(t\)的嵌入\(e\)为:

\[e = v W
\]

实际上\(W\)中每一行都可以看成一个词嵌入,而这个矩阵乘就是把\(v\)中等于\(1\)的那个位置对应的\(W\)中的词嵌入取出来。

在工程实践中,由于独热码向量比较占内存,而且矩阵乘效率也不高,所以往往用一个整数编码来代替独热码向量,然后直接用查表的方式取出对应的词嵌入。

所以假设\(n\)是\(t\)的编码,一般是在词汇表中的编号,那么上面的公式就可以改成:

\[e = W_{n}
\]

其中下标表示取出对应的行。

那么一个标记化后的序列就可以表示成一个编码向量。

假设序列\(T\)的编码向量为\(s\)(\(L\)),\(L\)为序列的长度,即\(T\)中有\(L\)个标记。

如果词嵌入长度为\(H\),那么经过嵌入变换,得到\(T\)的隐状态(hidden state)\(h\)(\(L \times H\))。


1.2.2、层标准化

层标准化类似于批标准化(batch normalization),可以加速模型训练,但其实现方式和批标准化不一样,层标准化是沿着词嵌入(通道)维进行标准化的,不需要在训练时存储统计量来估计整体数据集的均值和方差,训练(training)和评估(evaluation)或推理(inference)阶段的操作是相同的。

另外批标准化对小批大小有限制,而层标准化则没有限制。

假设输入的一个词嵌入为\(e = [x_0, x_1, ..., x_{H-1}]\),\(x_k\)是\(e\)第\(k = 0, 1, ..., (H-1)\) 维的分量,\(H\)是词嵌入长度。

那么层标准化就是

\[y_{k} = \frac{x_{k}-\mu}{\sigma} * \alpha_k + \beta_k
\]

其中,\(y_{k}\)是输出,\(\mu\)和\(\sigma^2\)分别是均值和方差:

\[ \mu = \frac{1}{H} \sum_{k=0}^{H-1} x_{k} \\
\sigma^2 = \frac{1}{H} \sum_{k=0}^{H-1} (x_{k}-\mu)^2 \\
\]

\(\alpha_k\)和\(\beta_k\)是学习得到的参数,用于防止模型表示能力退化。

注意:\(\mu\)和\(\sigma^2\)是针对每个样本每个位置的词嵌入分别计算的,而\(\alpha_k\)和\(\beta_k\)对所有的词嵌入都是共用的;\(\sigma^2\)的计算没有使用贝塞尔校正(Bessel's correction)。


1.2.3、随机失活

随机失活是DL领域非常著名且常用的正则化(regularization)方法(然而被谷歌注册专利了),用来防止模型过拟合(overfitting)。

具体来说,先设置一个超参数\(P \in [0, 1]\),表示按照概率\(P\)随机将值置\(0\)。

然后假设词嵌入中某一维分量是\(x\),按照均匀随机分布产生一个随机数\(r \in [0, 1]\),然后输出值\(y\)为:

\[ y = \left\{
\begin{aligned}
& \frac{x}{1-P} &, & r > P \\
& 0 &, & r \le P \\
\end{aligned}
\right. \]

由于按照概率\(P\)置\(0\),相当于输出值的期望变成原来的\((1-P)\)倍,所以再对输出值除以\((1-P)\),就可以保持期望不变。

以上操作针对训练阶段,在评估阶段,输出值等于输入值:

\[y = x
\]

嵌入层代码如下:

代码
# BERT之嵌入层
class BertEmb(nn.Module):
def __init__(self, config):
super().__init__()
# 标记嵌入,padding_idx=0:编码为0的嵌入始终为零向量
self.tok_emb = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=0)
# 位置嵌入
self.pos_emb = nn.Embedding(config.max_position_embeddings, config.hidden_size)
# 句子位置嵌入
self.sent_pos_emb = nn.Embedding(config.type_vocab_size, config.hidden_size) # 层标准化
self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
# 随机失活
self.dropout = nn.Dropout(config.hidden_dropout_prob) def forward(self,
tok_ids, # 标记编码(batch_size * seq_length)
pos_ids=None, # 位置编码(batch_size * seq_length)
sent_pos_ids=None, # 句子位置编码(batch_size * seq_length)
):
device = tok_ids.device # 设备(CPU或CUDA)
shape = tok_ids.shape # 形状(batch_size * seq_length)
seq_length = shape[1] # 默认:[0, 1, ..., seq_length-1]
if pos_ids is None:
pos_ids = tc.arange(seq_length, dtype=tc.int64, device=device)
pos_ids = pos_ids.unsqueeze(0).expand(shape)
# 默认:[0, 0, ..., 0],即所有标记都属于第一个句子
if sent_pos_ids is None:
sent_pos_ids = tc.zeros(shape, dtype=tc.int64, device=device) # 三种嵌入(batch_size * seq_length * hidden_size)
tok_embs = self.tok_emb(tok_ids)
pos_embs = self.pos_emb(pos_ids)
sent_pos_embs = self.sent_pos_emb(sent_pos_ids) # 三种嵌入相加
embs = tok_embs + pos_embs + sent_pos_embs
# 层标准化嵌入
embs = self.layer_norm(embs)
# 随机失活嵌入
embs = self.dropout(embs)
return embs # 嵌入(batch_size * seq_length * hidden_size)

其中,

config是BERT的配置文件对象,里面记录了各种预先设定的超参数;

vocab_size是词汇表大小;

hidden_size是词嵌入长度,默认是768(bert-base-*)或1024(bert-large-*);

max_position_embeddings是允许的最大标记位置,默认是512;

type_vocab_size是允许的最大句子位置,即最多能输入的句子数量,默认是2;

layer_norm_eps是一个>0并很接近0的小数\(\epsilon\),用来防止计算时发生除0等异常操作;

hidden_dropout_prob是随机失活概率,默认是0.1;

batch_size是小批的大小,即一个小批里的样本个数;

seq_length是输入的编码向量的长度。


1.3、编码器

编码器的作用是对嵌入层输出的隐状态进行非线性表示,提取出其中的特征(feature),它是由num_hidden_layers个结构相同(超参数相同)但参数不同(不共享参数)的隐藏层串连构成的。

如图:

原来你是这样的BERT,i了i了! —— 超详细BERT介绍(一)BERT主模型的结构及其组件

1.3.1、隐藏层

隐藏层包括线性变换、激活函数(activation function)、多头自注意力(multi-head self-attention)、跳跃连接(skip connection),以及上面介绍过的层标准化和随机失活。

如图:

原来你是这样的BERT,i了i了! —— 超详细BERT介绍(一)BERT主模型的结构及其组件

其中,激活函数默认是GELU,线性变换均是逐位置线性变换,即对不同样本不同位置的词嵌入应用相同的线性变换(类似于CV&DL领域的\(1 \times 1\)卷积)。


1.3.1.1、线性变换

线性变换在CV&DL领域也叫全连接层(fully connected layer),即

\[y = x W^T + b
\]

其中,\(x\)(\(A\))是输入向量,\(y\)(\(B\))是输出向量,\(W\)(\(B \times A\))是权重(weight)矩阵,\(b\)(\(B\))是偏置(bias)向量;\(W\)和\(b\)是学习得到的参数。

另外,严格来说,当\(b = \vec 0\)时,上式为线性变换;当\(b \ne \vec 0\)时,上式为仿射变换(affine transformation)。

但是在DL中,人们往往并不那么抠字眼,对于这两种变换,一般都简单地称为线性变换。


1.3.1.2、激活函数

激活函数在DL中非常关键!

因为如果要提高一个神经网络(neural network)的表示能力,往往需要加深网络的深度。

然而如果只叠加多个线性变换的话,这等价于一个线性变换(大家可以推推看)!

所以只有在线性变换后接一个非线性变换(nonlinear transformation),即激活函数,才能逐渐加深网络并提高表示能力。

激活函数有很多,常见的包括sigmoidtanhsoftmaxReLUGELUSwishMish等。

本文只讲和BERT相关的激活函数:tanh、softmax、GELU。


1.3.1.2.1、tanh

激活函数的一个功能是调整输入值的取值范围。

tanh即双曲正切函数,可以将\((-\infty, +\infty)\)的数映射到\((-1, 1)\),并且严格单调。

函数图像如图:

原来你是这样的BERT,i了i了! —— 超详细BERT介绍(一)BERT主模型的结构及其组件

tanh在NLP&DL领域用得比较多。


1.3.1.2.2、softmax

softmax顾名思义,它可以对输入的一组数值根据其大小给出每个数值的概率,数值越大,概率越高,且概率求和为\(1\)。

假设输入\(x_k\),\(k = 0, 1, ..., (N-1)\),则输出值\(y_k\)为:

\[y_k = \frac{exp(x_k)}{\sum_{i=0}^{N-1} exp(x_i)}
\]

实际上,对于任意一个对数几率(logit)\(x \in (-\infty, +\infty)\),\(x\)越大,表示某个事件发生的可能性越大,softmax可以将其转化为概率,即将取值范围映射到\((0, 1)\)。


1.3.1.2.3、GELU

GELUGaussian Error Linear Units)是2016年6月提出的一个激活函数。

GELU相比ReLU曲线更为光滑,允许梯度更好地传播。

GELU的想法类似于随机失活,随机失活是按照0-1分布,又叫两点分布,也叫伯努利分布(Bernoulli distribution),随机通过输入值;而GELU则是将这个概率分布改成正态分布(Normal distribution),也叫高斯分布(Gaussian distribution),然后输出期望。

假设输入值是\(x\),输出值是\(y\),那么GELU就是:

\[y = x P(X \le x)
\]

其中,\(X \sim \mathcal{N}(0, 1)\),\(P\)为概率。

GELU的函数图像如图:

原来你是这样的BERT,i了i了! —— 超详细BERT介绍(一)BERT主模型的结构及其组件

其中蓝线为ReLU函数图像,橙线为GELU函数图像。


1.3.1.3、多头自注意力

多头自注意力是Transformer的一大特色。

多头自注意力的名字可以分成三个词:多头、自、注意力:

  • 注意力:是DL领域近年来最重要的创新之一!可以使模型以不同的方式对待不同的输入(即分配不同的权重),而无视空间(即输入向量排成线形、面形、树形、图形等拓扑结构)的形状、大小、距离。
  • 自:是在普通的注意力基础上修改而来的,可以表示输入与自身的依赖关系。
  • 多头:是对注意力中涉及的向量分别拆分计算,从而提高表示能力。

对于一般的多头注意力,假设计算\(x\)(\(H\))对\(y_i\)(\(H\)),\(i = 0, 1, ..., (L-1)\),的多头注意力,则首先计算\(q\)(H)、\(k_i\)(H)、\(v_i\)(H):

\[ q = x W_q^T + b_q \\
k_i = y_i W_k^T + b_k \\
v_i = y_i W_v^T + b_v \\
\]

其中,\(W_z\)(\(H \times H\))和\(b_z\)(\(H\))分别为权重矩阵和偏置向量,\(z \in \{ q, k, v \}\)。

然后将这三种向量等长度拆分成\(S\)个向量,称为头向量:

\[ q_j = [q_0; q_1; ...; q_{S-1}] \\
k_{ij} = [k_{i0}; k_{i1}; ...; k_{i, S-1}] \\
v_{ij} = [v_{i0}; v_{i1}; ...; v_{i, S-1}] \\
\]

上式中的分号为串连操作,即把多个向量拼接起来组成一个更长的向量。

其中,每个头向量长度都为\(D\),且\(S \times D = H\)。

然后计算\(q_j\)对\(k_{ij}\)的注意力分数\(s_{ij}\):

\[s_{ij} = \frac{q_j k_{ij}^T}{\sqrt{D}}
\]

之后可以添加注意力掩码(也可以不加),即令\(s_{mj} = -\infty\),\(m\)是需要添加掩码的位置。

然后通过softmax计算注意力概率\(p_{ij}\):

\[p_{ij} = \frac{exp(s_{ij})}{\sum_{t=0}^{L-1} exp(s_{tj})}
\]

之后对注意力概率进行随机失活:

\[\hat{p}_{ij} = dropout(p_{ij})
\]

再之后计算输出向量\(r_j\)(\(D\)):

\[r_j = \sum_{i=0}^{L-1} \hat{p}_{ij} v_{ij}
\]

最终的输出向量是把每一头的输出向量串连起来:

\[r = [r_0; r_1; ...; r_{S-1}]
\]

其中\(r\)(\(H\))为最终的输出向量。

如果令\(x = y_n\),\(n \in \{ 0, 1, ..., L-1 \}\),即\(x\)是\(y_i\)中的某一个向量,那么多头注意力就变为多头自注意力。

代码如下:

代码
# BERT之多头自注意力
class BertMultiHeadSelfAtt(nn.Module):
def __init__(self, config):
super().__init__()
# 注意力头数
self.num_heads = config.num_attention_heads
# 注意力头向量长度
self.head_size = config.hidden_size // config.num_attention_heads self.query = nn.Linear(config.hidden_size, config.hidden_size)
self.key = nn.Linear(config.hidden_size, config.hidden_size)
self.value = nn.Linear(config.hidden_size, config.hidden_size) self.dropout = nn.Dropout(config.attention_probs_dropout_prob) # 输入(batch_size * seq_length * hidden_size)
# 输出(batch_size * num_heads * seq_length * head_size)
def shape(self, x):
shape = (*x.shape[:2], self.num_heads, self.head_size)
return x.view(*shape).transpose(1, 2)
# 输入(batch_size * num_heads * seq_length * head_size)
# 输出(batch_size * seq_length * hidden_size)
def unshape(self, x):
x = x.transpose(1, 2).contiguous()
return x.view(*x.shape[:2], -1) def forward(self,
inputs, # 输入(batch_size * seq_length * hidden_size)
att_masks=None, # 注意力掩码(batch_size * seq_length * hidden_size)
):
mixed_querys = self.query(inputs)
mixed_keys = self.key(inputs)
mixed_values = self.value(inputs) querys = self.shape(mixed_querys)
keys = self.shape(mixed_keys)
values = self.shape(mixed_values) # 注意力分数(batch_size * num_heads * seq_length * seq_length)
att_scores = querys.matmul(keys.transpose(2, 3))
# 缩放注意力分数
att_scores = att_scores / sqrt(self.head_size)
# 添加注意力掩码
if att_masks is not None:
att_scores = att_scores + att_masks # 注意力概率(batch_size * num_heads * seq_length * seq_length)
att_probs = att_scores.softmax(dim=-1)
# 随机失活注意力概率
att_probs = self.dropout(att_probs) # 输出(batch_size * num_heads * seq_length * head_size)
outputs = att_probs.matmul(values)
outputs = self.unshape(outputs)
return outputs # 输出(batch_size * seq_length * hidden_size)

其中,

num_attention_heads是注意力头数,默认是12(bert-base-*)或16(bert-large-*);

attention_probs_dropout_prob是注意力概率的随机失活概率,默认是0.1。


1.3.1.4、跳跃连接

跳跃连接也是DL领域近年来最重要的创新之一!

跳跃连接也叫残差连接(residual connection)。

一般来说,传统的神经网络往往是一层接一层串连而成,前一层输出作为后一层输入。

而跳跃连接则是某一层的输出,跳过若干层,直接输入某个更深的层。

例如BERT的每个隐藏层中有两个跳跃连接。

跳跃连接的作用是防止神经网络梯度消失或梯度爆炸,使损失曲面(loss surface)更平滑,从而使模型更容易训练,使神经网络可以设置得更深。

按我个人的理解,一般来说,线性变换是最能保持输入信息的,而非线性变换则往往会损失一部分信息,但是为了网络的表示能力不得不线性变换与非线性变换多次堆叠,这样网络深层接收到的信息与最初输入的信息比可能已经面目全非,而跳跃连接则可以让输入信息原汁原味地传播得更深。


隐藏层代码如下:

代码
# BERT之隐藏层
class BertLayer(nn.Module):
# noinspection PyUnresolvedReferences
def __init__(self, config):
super().__init__()
# 多头自注意力
self.multi_head_self_att = BertMultiHeadSelfAtt(config) self.linear = nn.Linear(config.hidden_size, config.hidden_size)
self.dropout = nn.Dropout(config.hidden_dropout_prob)
self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) # 升维线性变换
self.linear_1 = nn.Linear(config.hidden_size, config.intermediate_size)
# 激活函数,默认:GELU
self.act_fct = F.gelu # 降维线性变换,使向量大小保持不变
self.linear_2 = nn.Linear(config.intermediate_size, config.hidden_size)
self.dropout_1 = nn.Dropout(config.hidden_dropout_prob)
self.layer_norm_1 = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
def forward(self,
inputs, # 输入(batch_size * seq_length * hidden_size)
att_masks=None, # 注意力掩码(batch_size * seq_length * hidden_size)
):
outputs = self.multi_head_self_att(inputs, att_masks=att_masks)
outputs = self.linear(outputs)
outputs = self.dropout(outputs)
att_outputs = self.layer_norm(outputs + inputs) # 跳跃连接 outputs = self.linear_1(att_outputs)
outputs = self.act_fct(outputs) outputs = self.linear_2(outputs)
outputs = self.dropout_1(outputs)
outputs = self.layer_norm_1(outputs + att_outputs) # 跳跃连接
return outputs # 输出(batch_size * seq_length * hidden_size)

其中,

intermediate_size是中间一个升维线性变换升维后的长度,默认是3072(bert-base-*)或4096(bert-large-*)。


编码器代码如下:

代码
# BERT之编码器
class BertEnc(nn.Module):
def __init__(self, config):
super().__init__()
# num_hidden_layers个隐藏层
self.layers = nn.ModuleList([BertLayer(config)
for _ in range(config.num_hidden_layers)])
# noinspection PyTypeChecker
def forward(self,
inputs, # 输入(batch_size * seq_length * hidden_size)
att_masks=None, # 注意力掩码(batch_size * seq_length)
):
# 调整注意力掩码的值和形状
if att_masks is not None:
device = inputs.device # 设备(CPU或CUDA)
dtype = inputs.dtype # 数据类型(float16、float32或float64)
shape = att_masks.shape # 形状(batch_size * seq_length)
t = tc.zeros(shape, dtype=dtype, device=device)
t[att_masks<=0] = -inf # exp(-inf) = 0
t = t[:, None, None, :]
att_masks = t outputs = inputs
for layer in self.layers:
outputs = layer(outputs, att_masks=att_masks)
return outputs # 输出(batch_size * seq_length * hidden_size)

其中,

num_hidden_layers是隐藏层数量,默认是12(bert-base-*)或24(bert-large-*)。


1.4、池化层

池化层是将[CLS]标记对应的表示取出来,并做一定的变换,作为整个序列的表示并返回,以及原封不动地返回所有的标记表示。

如图:

原来你是这样的BERT,i了i了! —— 超详细BERT介绍(一)BERT主模型的结构及其组件

其中,激活函数默认是tanh。

池化层代码如下:

代码
# BERT之池化层
class BertPool(nn.Module):
def __init__(self, config):
super().__init__()
self.linear = nn.Linear(config.hidden_size, config.hidden_size)
self.act_fct = F.tanh
def forward(self,
inputs, # 输入(batch_size * seq_length * hidden_size)
):
# 取[CLS]标记的表示
outputs = inputs[:, 0]
outputs = self.linear(outputs)
outputs = self.act_fct(outputs)
return outputs # 输出(batch_size * hidden_size)

1.5、输出

主模型最后输出所有的标记表示和整体的序列表示,分别用于针对每个标记的预测任务和针对整个序列的预测任务。


主模型代码如下:

代码
# BERT之预训练模型抽象基类
class BertPreTrainedModel(PreTrainedModel):
from transformers import BertConfig
from transformers import BERT_PRETRAINED_MODEL_ARCHIVE_MAP
from transformers import load_tf_weights_in_bert config_class = BertConfig
pretrained_model_archive_map = BERT_PRETRAINED_MODEL_ARCHIVE_MAP
load_tf_weights = load_tf_weights_in_bert
base_model_prefix = 'bert' # 注意力头剪枝
def _prune_heads(self, heads_to_prune):
pass
# 参数初始化
def _init_weights(self, module):
config = self.config
f = lambda x: x is not None and x.requires_grad
if isinstance(module, nn.Embedding):
if f(module.weight):
# 正态分布随机初始化
module.weight.data.normal_(mean=0.0, std=config.initializer_range)
elif isinstance(module, nn.Linear):
if f(module.weight):
# 正态分布随机初始化
module.weight.data.normal_(mean=0.0, std=config.initializer_range)
if f(module.bias):
# 初始为0
module.bias.data.zero_()
elif isinstance(module, nn.LayerNorm):
if f(module.weight):
# 初始为1
module.weight.data.fill_(1.0)
if f(module.bias):
# 初始为0
module.bias.data.zero_()
# BERT之主模型
class BertModel(BertPreTrainedModel):
def __init__(self, config):
super().__init__(config)
self.config = config
# 嵌入层
self.emb = BertEmb(config)
# 编码器
self.enc = BertEnc(config)
# 池化层
self.pool = BertPool(config)
# 参数初始化
self.init_weights() # noinspection PyUnresolvedReferences
def get_input_embeddings(self):
return self.emb.tok_emb
def set_input_embeddings(self, embs):
self.emb.tok_emb = embs def forward(self,
tok_ids, # 标记编码(batch_size * seq_length)
pos_ids=None, # 位置编码(batch_size * seq_length)
sent_pos_ids=None, # 句子位置编码(batch_size * seq_length)
att_masks=None, # 注意力掩码(batch_size * seq_length)
):
outputs = self.emb(tok_ids, pos_ids=pos_ids, sent_pos_ids=sent_pos_ids)
outputs = self.enc(outputs, att_masks=att_masks)
pooled_outputs = self.pool(outputs)
return (
outputs, # 输出(batch_size * seq_length * hidden_size)
pooled_outputs, # 池化输出(batch_size * hidden_size)
)

其中,

BertPreTrainedModel是预训练模型抽象基类,用于完成一些初始化工作。


后记

本文详细地介绍了BERT主模型的结构及其组件,了解它的构造以及代码实现对于理解以及应用BERT有非常大的帮助。

后续两篇文章会分别介绍BERT预训练下游任务相关。

从BERT主模型的结构中,我们可以发现,BERT抛弃了RNN架构,而只用注意力机制来抽取长距离依赖(这个其实是Transformer架构的特点)。

由于注意力可以并行计算,而RNN必须串行计算,这就使得模型计算效率大大提升,于是BERT这类模型也能够堆得很深。

BERT为了能够同时做单句和双句的序列和标记的预测任务,设计了[CLS][SEP]等特殊标记分别作为序列表示以及标记不同的句子边界,整体采用了桶状的模型结构,即输入时隐状态的形状与输出时隐状态的形状相等(只是在每个隐藏层有升维与降维操作,整体上词嵌入长度保持不变)。

由于注意力机制对距离不敏感,所以BERT额外添加了位置特征。