devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Bert代码详解（一）

作者：小蓝xlanll | 2024-04-03 15:43:01

赞

踩

Bert代码详解（一）

这是bert的pytorch版本（与tensorflow一样的，这个更简单些，这个看懂了，tf也能看懂），地址：https://github.com/huggingface/pytorch-pretrained-BERT   主要内容在pytorch_pretrained_bert/modeling文件中。

BertModel 流程详解

从BertModel的forward函数开始

第一步：整理输入

  1. #将attention_mask变成（batch_size, 1, 1, to_seq_length） 
  2. #(to be completed)
  3. extended_attention_mask = extended_attention_mask.to(dtype=next(self.parameters()).dtype) # fp16 compatibility
  4.  
  5. #原本的mask中，1代表有用信息，0代表填充信息。下面的这句代码将其更改为：0代表有用信息，-10000代表填充信息。（为什么？从最后的softmax函数出发考虑）
  6. #（to be completed）
  7. extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0
  1. #将input_ids和token_type_ids输入到embeddings层，构造下一层的输入
  2. embedding_output = self.embeddings(input_ids, token_type_ids)

BertEmbeddings层详细解释

  1. #输入为input_ids和token_type_ids，其维度均为（batch_size, seq_length）
  2. #.....................................................................
  3. #生成positions_ids
  4. #如果一句话的长度是seq_length，那么生成的positions_id就是【0，1，2，......，seq_length - 1】
  5. #positions_id其实就是为了构造论文中提到的Position_Embeddings
  6. position_ids = torch.arange(seq_length, dtype=torch.long, device=input_ids.device)
  7. #变成和input_ids一样的形状
  8. position_ids = position_ids.unsqueeze(0).expand_as(input_ids)
  9. #.....................................................................
  10.  
  11.  
  12. #....................................................................
  13. #如果输入token_type_ids为None的话，则默认整个输入都是a句。（a句的含义请看论文解读）
  14. if token_type_ids is None:
  15.     token_type_ids = torch.zeros_like(input_ids)
  16.  
  17. #....................................................................
  18.  
  19.  
  20. #....................................................................
  21. #此三句的含义是根据相应的输入获得三种embeddings(对应论文的三种embedding)
  22. #word_embeddings是nn的一个内置函数（方法？），其作用是根据输入，产生相应的embedding,网上查其用法，很简单。
  23. words_embeddings = self.word_embeddings(input_ids)
  24. position_embeddings = self.position_embeddings(position_ids)
  25. token_type_embeddings = self.token_type_embeddings(token_type_ids)
  26. #....................................................................
  27.  
  28.  
  29. #.....................................................................
  30. #论文中重要的一步，将三种embedding相加作为这个单词的代表。
  31. embeddings = words_embeddings + position_embeddings + token_type_embeddings
  32. #.....................................................................
  33.  
  34. #.........................................................................
  35. #将结果输入到layer_normer层和dropout层进行处理，得到最后的输出并返回
  36. embeddings = self.LayerNorm(embeddings)
  37. embeddings = self.dropout(embeddings)
  38. return embeddings
  39. #.........................................................................

BertLayerNorm层详细解释

  1. #layerNorm 和batchNorm的区别和作用网上有解释
  2. u = x.mean(-1, keepdim=True)
  3. s = (x - u).pow(2).mean(-1, keepdim=True)
  4. x = (x - u) / torch.sqrt(s + self.variance_epsilon)
  5. return self.weight * x + self.bias
  6. #上述的代码其实就是下面这个公式,其中x是向量，u是标量（均值），分母代表标准差。（参考概率论详解此公式含义）
  7. #关于代码中为什么要添加variance_epsilon,这是一个很小得数，是为了防止分母（平方差）为0.

x−u(x−u)2¯

第二步：进入transformer层，这也是最重要的一层

从embedding从输出后，直接进入encoder层

  1. #从embeddings层得到输出，然后送进encoder层，得到最后的输出encoder_layers
  2. embedding_output = self.embeddings(input_ids, token_type_ids)
  3. encoded_layers = self.encoder(embedding_output, extended_attention_mask,output_all_encoded_layers=output_all_encoded_layers)

BertEncoder层详细解释

  1. #BertEncoder层建立了整个transformer构架
  2. #Transformer构架参考：https://zhuanlan.zhihu.com/p/39034683        （BE CAUTIOUS!）
  3. #现在我假设大家都知道了这个架构，我这里沿袭了上面知乎中某些专有名词的称呼
  4.  
  5. #........................................................................
  6. #Transformer中包含若干层(论文中base为12层，large为24层)encoder,每层encoder在代码中就是一个BertLayer。
  7. #所以下面的代码首先声明了一层layer,然后构造了num_hidden_layers(12 or 24)层相同的layer放在一个列表中，既是self.layer
  8. layer = BertLayer(config)
  9. self.layer = nn.ModuleList([copy.deepcopy(layer) for _ in range(config.num_hidden_layers)])
  10. #........................................................................
  11.  
  12. #........................................................................
  13. #下面看其forward函数
  14. def forward(self, hidden_states, attention_mask, output_all_encoded_layers=True):
  15. #看其输入：
  16. #hidden_states:根据上面所讲，hidden_states就是embedding_output，其维度为[batch_size, seq_lenght, word_dimension],embedding出来后，多了一个dimension
  17. #attention_mask:维度[batch_size, 1, 1, seq_length]
  18. #(to be completed)
  19. #output_all_encoder_layers:此函数的输出模式，下面会详细讲解
  20.  
  21. #这个函数到底做了什么了？其实很简单，就是做了一个循环，将每一个encoder的输出作为输入输给下一层的encoder，直到12（or24）层循环完毕
  22.     all_encoder_layers = []
  23.     #遍历所有的encoder,总共有12层或者24层
  24.     for layer_module in self.layer:
  25.         #每一层的输出hidden_states也是下一层layer_moudle（BertLayer）的输入，这样就连接起来了各层encoder。第一层的输入是embedding_output
  26.         hidden_states = layer_module(hidden_states, attention_mask)
  27.         #如果output_all_encoded_layers == True:则将每一层的结果添加到all_encoder_layers中
  28.         if output_all_encoded_layers:
  29.             all_encoder_layers.append(hidden_states)
  30.     #如果output_all_encoded_layers == False, 则只将最后一层的输出加到all_encoded_layers中
  31.     if not output_all_encoded_layers:
  32.         all_encoder_layers.append(hidden_states)
  33.     return all_encoder_layers
  34. #所以output_all_encoded_layers是用来控制输出模式的。
  35. #这样整个transformer的框架就出来了，下面将讲述框架中的每一层encoder（即BertLayer）是怎么构造的
  36. #........................................................................

BertLayer层详细解释

BertLayer层是最麻烦的一层，因为其中反复调用其他层，需要耐心理清头绪

  1. #每一层BertLayer都是一个encoder，从上面讲解可知，他的输入是hidden_states和attention_mask，并生成下层所需要的输入：一个新的hidden_states。
  2. #那么hidden_states在BertLayers里面到底经历了什么呢？这个要分成三个部分来讲：
  3. #1、经过attention层（传说中的self_attention）
  4. attention_output = self.attention(hidden_states, attention_mask)
  5. #2、一个中间层
  6. #（to be completed）
  7. intermediate_output = self.intermediate(attention_output)
  8. #3、一个输出层，然后返回
  9. #(to be completed)
  10. layer_output = self.output(intermediate_output, attention_output)
  11.  
  12. #下面将详细讲解这三层，首先是传说中的attention层

BertAttention层详细解释

不幸的是，这个attention层又tm引用了其他层，一环套一环。为了看起来方便，我决定将这引用层的讲解一并放到这个jupyter cell中讲解，而不像之前那样一个model放在一个jupyter cell中。

  1. #............................................
  2. #BertAttention的输入是两个：一个是input_tensor（之前的hidden_states，第一层是embedding_output），维度为[batch_size, seq_length, word_dimension]
  3. #另一个则是attention_mask:其维度为（batch_size, 1, 1, seq_length）
  4. #进入BertAttention层之后，首先进入BertSelfAttention层，再连接一个BertSelfOutput层，然后得到输出
  5. def forward(self, input_tensor, attention_mask):
  6.     self_output = self.self(input_tensor, attention_mask)     #BertSelfAttention层
  7.     attention_output = self.output(self_output, input_tensor)  #BertSelfOutput层
  8.     return attention_output
  9. #............................................
  10.  
  11.  
  12.  
  13. #.....................................................................
  14. #下面则是激动人心的selfattention层，没有单独放在一个jupyter cell中显得很没有排面……
  15. #attention层非常的复杂，以至于我不得不先讲解这层init方法，这层的init涉及很多参数
  16.  
  17.         #num_attention_heads: Number of attention heads for each attention layer in the Transformer encoder
  18.         #头的数目，代码中给定为12，我的理解是12个头就类似于12个transformer（不是encoder）,将每个transformer的结果合并，才是最后的结果
  19.         self.num_attention_heads = config.num_attention_heads
  20.         
  21.         #attention_hidden_size:每个头的大小,有总大小（hidden_size，768）除以总头数获得，既是768/12=64
  22.         self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
  23.         #all_head_size似乎和hidden_size的大小是相同的，不知道为什么要多此一举（都代表着总大小768）
  24.         self.all_head_size = self.num_attention_heads * self.attention_head_size
  25.         
  26.         #这里相当于声明了一个hidden_size * all_head_size大小的矩阵， 既是768*768
  27.         self.query = nn.Linear(config.hidden_size, self.all_head_size)
  28.         self.key = nn.Linear(config.hidden_size, self.all_head_size)
  29.         self.value = nn.Linear(config.hidden_size, self.all_head_size)
  30.         #dropout层
  31.         self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
  32.  
  33. #下面的forward函数是重中之重，attention到底是怎么做的！！！
  34.  
  35.     #首先看输入，hidden_states:(batch_size, seq_length, word_dimension = hidden_size = 768)(仔细看embedding代码，确实输出的维度是hiddensize的)
  36.     #另一个输入：attention_mask(batch_size, 1, 1, seq_length)
  37.     def forward(self, hidden_states, attention_mask):
  38.         
  39.         #简单提一下query, key，value的作用。简单来说query和key用来确定权重，然后乘以value用来得到注意力的大小
  40.         #详细解释还是得看我给的那个网站，下面看代码
  41.         
  42.         #首先是经过简单的矩阵相乘处理（这些矩阵就是我们要训练的东西）
  43.         #下面三行均是[batch_size, seq_length, hidden_states]*[hidden_states, all_head_size]
  44.         #结果是[batch_size, seq_length, all_head_size = 768]
  45.         mixed_query_layer = self.query(hidden_states)
  46.         mixed_key_layer = self.key(hidden_states)
  47.         mixed_value_layer = self.value(hidden_states)
  48.         
  49.         
  50.         #下面也是同样的操作，transpose_for_scores
  51.         #这个操作干了什么呢？把[batch_size, seq_length, all_head_size = 768] 的矩阵变成了
  52.         #[batch_size, num_attention_heads=12, seq_length, attention_head_size=64]
  53.         #具体相应的代码我就不讲了，占空间（我懒）
  54.         query_layer = self.transpose_for_scores(mixed_query_layer)
  55.         key_layer = self.transpose_for_scores(mixed_key_layer)
  56.         value_layer = self.transpose_for_scores(mixed_value_layer)
  57.  
  58.         #下面四行代码（注意是四行代码）是计算权重用的。
  59.         #首先query和key相乘，得到的矩阵形状是[batch_size, num_attention_heads, seq_length, seq_length]
  60.         #看到这个形状，有没有想起什么呢？我来解释一下：
  61.         #首先看后两维A[seq_length, seq_length]，自注意力机制是自己对自己的注意力，假设一个句子长度是seq_length,那么这个二维矩阵代表什么呢？
  62.         #A[0][0]可以看作这句话第0个单词对第0个单词的影响（注意力）权重，A[0][1]代表第1个单词对第0个单词的影响（注意力）权重
  63.         #那么A[i][j]则代表第j个单词对第i的单词的影响（注意力）权重。如果你还不明白，以"I am so handsome"为例(矩阵数值是瞎编的)：
  64.         #                                   I    am    so    handsome
  65.         #                               I   3    4     -10    3
  66.         #                               am  4    6     9      1
  67.         #                               so  2    4     1      2
  68.         #                         handsome  3    12    1      0
  69.         #从这个图看出来am对so的影响权重为4。（A[2][1]）
  70.         #所以后两维的意思懂了吧，那么前面的更好明白。num_attention_heads代表有num_attention_heads个这样的transformer，则就有num_attention_heads
  71.         #个这样的权重矩阵了。batch_size则代表有多少个句子。
  72.         attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
  73.         
  74.         #这个就是对权重因子做一个简单的处理，至于为什么这样做，留给大家思考（其实我不懂……）
  75.         attention_scores = attention_scores / math.sqrt(self.attention_head_size)
  76.         
  77.         #下面又是一个知识点！！！得到的分数又加上了attention_mask，回忆下attention_mask的性质
  78.         #维度：[batch_size,1,1,seq_length]
  79.         #0代表有用的信息，-10000代表无用或者padding信息。
  80.         #(to be completed)
  81.         #相加，再做softmax，算出最后的权重。
  82.         #那么，为什么是-10000呢？
  83.         #以下是我个人拙见
  84.         #我们不妨假设上例中的handsome是padding是填充的，那么这个handsome就是无用信息，attention_mask = [0,0,0,-10000]
  85.         #加到上面的矩阵后，我们发现最后一列都变得很小，分别是-9997，-9999，-9998，-10000，其他三列加的是0，所以值不变。
  86.         #然后用相加的值做softmax（不懂softmax的赶紧度娘），以第一行为例，第一行是（3，4，-10，-9997）
  87.         #然后softmax之后，e的-9997次方接近0，这样handsome对I的影响不就接近为0了吗？而handsome又是padding的，本来
  88.         #对其他单词的就没有什么影响，所以-10000的含义是为了消除padding单词对其他单词的影响！！！！
  89.         attention_scores = attention_scores + attention_mask
  90.         attention_probs = nn.Softmax(dim=-1)(attention_scores)
  91.         
  92.         
  93.         #下面这句是官方吐槽……
  94.         # This is actually dropping out entire tokens to attend to, which might
  95.         # seem a bit unusual, but is taken from the original Transformer paper.
  96.         attention_probs = self.dropout(attention_probs)
  97.         
  98.         
  99.         #得到的结果（权重）再乘以value，就是最后的注意力了！
  100.         #格式变为：[batch_size, num_attention_heads, seq_length, attention_head_size]
  101.         context_layer = torch.matmul(attention_probs, value_layer)
  102.         #下面的三行就是将[batch_size, num_attention_heads, seq_length, attention_head_size]格式转化为
  103.         #[batch_size, seq_leagth, all_head_size],又回到了最初的起点……
  104.         context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
  105.         new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
  106.         context_layer = context_layer.view(*new_context_layer_shape)
  107.         return context_layer
  108. #.....................................................................
  109.  
  110.  
  111.  
  112. #.....................................................................
  113. #如果你看到了这里，那么恭喜你已经看完了bert的核心代码，下面是其他的一些处理。
  114. #从selfattention出来之后，又进入了一个叫BertSelfOutput的层，这个层就非常简单了，主要做了3件事
  115. #1、全连接层 2、dropout层 3、layernormer层
  116. #注意这个layernormer是跟着输入加在一起做的。
  117. #最后输出的维度是[batch_size, seq_leagth, hidden_size=768]
  118. def forward(self, hidden_states, input_tensor):
  119.     hidden_states = self.dense(hidden_states)
  120.     hidden_states = self.dropout(hidden_states)
  121.     hidden_states = self.LayerNorm(hidden_states + input_tensor)
  122.     return hidden_states
  123. #over!!!!!!!!!!
  124. #..................................................................

注意，此时仍然身陷在BertLayer层之中，只是从BertLayer层的Attention层逃蹿出来。紧接着便进入BertLayer的第二层：intermediate

当然，这层就非常简单了啦~

  1. #.......................................................................
  2. #从attention出来之后，又进入了一个叫BertIntermediate的层，这个层就非常简单了，主要做了俩件事
  3. #1、一个全连接层 2、一个激活层
  4. #具体地，输入为[batch_size, seq_length, hidden_size = 768]
  5.     
  6.     def forward(self, hidden_states):
  7.         #[batch_size, seq_length, all_head_size = 768] * [hidden_size, intermediate_size = 4*768](论文和代码都是这样的设置的)
  8.         hidden_states = self.dense(hidden_states)
  9.         #下面是激活函数，具体的选取看该类的init方法。
  10.         hidden_states = self.intermediate_act_fn(hidden_states)
  11.         #然后返他妈的回，形状变成了[batch_size, seq_length,intermediate_size=4*768]
  12.         return hidden_states
  13. #.....................................................................

从所谓的intermediate层出来之后，就进入了BertLayer的最后一层BertOutput层，这个和之前的BertSelfOutput层几乎一模一样，只是参数不同，不详细解释了

  1. #输入形状[batch_size, seq_length,intermediate_size=4*768]
  2. #输出是[batch_size, seq_length,hidden_size=768]
  3. class BertOutput(nn.Module):
  4.     def __init__(self, config):
  5.         super(BertOutput, self).__init__()
  6.         self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
  7.         self.LayerNorm = BertLayerNorm(config.hidden_size, eps=1e-12)
  8.         self.dropout = nn.Dropout(config.hidden_dropout_prob)
  9.  
  10.     def forward(self, hidden_states, input_tensor):
  11.         hidden_states = self.dense(hidden_states)
  12.         hidden_states = self.dropout(hidden_states)
  13.         hidden_states = self.LayerNorm(hidden_states + input_tensor)
  14.         return hidden_states

至此，Bertlayer层已经全部解释完毕了。从输入到输出，之间的每一层都有解释。然后我们就终于从Transformer中逃了出来，至此，进入了第三步

第三步：整理输出

  1. #此时，我们终于可以将视线再次转回到BertModel模块了。
  2. #回忆一下这句代码，我们得到的输出和output_all_encoded_layes相关
  3. #如果output_all_encoded_layes==True，我们得到所有层encoder的输出
  4. #如果output_all_encoded_layes==False，我们得到最后一层encoder的输出
  5. encoded_layers = self.encoder(embedding_output, extended_attention_mask,output_all_encoded_layers=output_all_encoded_layers)
  6. #
  7.  
  8. #取出最后一层的输出
  9. sequence_output = encoded_layers[-1]
  10. #最后一层的输出经过pooler层，得到pooled_output，那么这个pooled_output有啥用呢？下面讲pooler层时会说明
  11. pooled_output = self.pooler(sequence_output)
  12. if not output_all_encoded_layers:
  13.     encoded_layers = encoded_layers[-1]
  14. return encoded_layers, pooled_output

BertPooler层详细解释

  1. #由上面的讲解可知，pooler层的输入是transformer最后一层的输出，[batch_size, seq_length, hidden_size]
  2. def forward(self, hidden_states):
  3.         # We "pool" the model by simply taking the hidden state corresponding
  4.         # to the first token.
  5.         
  6.         #取出每一句的第一个单词，做全连接和激活。得到的输出可以用来分类等下游任务（即将每个句子的第一个单词的表示作为整个句子的表示）
  7.         first_token_tensor = hidden_states[:, 0]
  8.         pooled_output = self.dense(first_token_tensor)
  9.         pooled_output = self.activation(pooled_output)
  10.         return pooled_output

至此，BertModel已经全部解释完毕

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/356087
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号