深度学习笔记之BERT——BERT的基本认识
- 引言
- 回顾:Transformer的策略
- 回顾:Word2vec的策略和局限性
- BERT \text{BERT} BERT的基本理念
- 抽象的双向
- BERT的预训练策略
 
- 预训练与微调
 
引言
从本节开始,将介绍 BERT \text{BERT} BERT系列模型以及其常见的变种形式,主要以逻辑认识为主;并将过去的关于 Transformer \text{Transformer} Transformer的相关内容结合起来,形成通顺逻辑即可。
回顾:Transformer的策略
在Transformer系列文章中介绍了 
     
      
       
       
         Transformer 
        
       
      
        \text{Transformer} 
       
      
    Transformer的模型架构,而它的策略与 
     
      
       
       
         Seq2seq 
        
       
      
        \text{Seq2seq} 
       
      
    Seq2seq基本相同: 
      
       
        
        
          t 
         
        
       
         t 
        
       
     t时刻状态下,解码器最终预测 
      
       
        
        
          t 
         
        
          + 
         
        
          1 
         
        
       
         t +1 
        
       
     t+1时刻词汇的概率分布,并选择我概率最高的词作为输出:
  
      
       
        
        
          P 
         
        
          ( 
         
         
         
           o 
          
          
          
            t 
           
          
            + 
           
          
            1 
           
          
         
        
          ∣ 
         
         
         
           o 
          
         
           1 
          
         
        
          , 
         
         
         
           o 
          
         
           2 
          
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
         
         
           o 
          
         
           t 
          
         
        
          ) 
         
        
       
         \mathcal P(o_{t+1} \mid o_1,o_2,\cdots,o_t) 
        
       
     P(ot+1∣o1,o2,⋯,ot)
 因而需要让预测的概率分布和实际概率分布之间的差异最小化,使用交叉熵( 
     
      
       
       
         Cross Entropy 
        
       
      
        \text{Cross Entropy} 
       
      
    Cross Entropy)损失函数即可实现策略的分类任务。
回顾:Word2vec的策略和局限性
在Word2vec的介绍中,提到了 
     
      
       
       
         Word2vec 
        
       
      
        \text{Word2vec} 
       
      
    Word2vec中两个模型结构: 
     
      
       
       
         Skipgram,CBOW 
        
       
      
        \text{Skipgram,CBOW} 
       
      
    Skipgram,CBOW的构建逻辑。基于长度为 
     
      
       
       
         T 
        
       
      
        \mathcal T 
       
      
    T的语料库 
     
      
       
       
         D 
        
       
         = 
        
       
         { 
        
        
        
          w 
         
        
          1 
         
        
       
         , 
        
        
        
          w 
         
        
          2 
         
        
       
         , 
        
       
         ⋯ 
         
       
         , 
        
        
        
          w 
         
        
          T 
         
        
       
         } 
        
       
      
        \mathcal D = \{w_1,w_2,\cdots,w_{\mathcal T}\} 
       
      
    D={w1,w2,⋯,wT},需要对联合概率分布 
     
      
       
       
         P 
        
       
         ( 
        
        
        
          w 
         
        
          1 
         
        
       
         , 
        
        
        
          w 
         
        
          2 
         
        
       
         , 
        
       
         ⋯ 
         
       
         , 
        
        
        
          w 
         
        
          T 
         
        
       
         ) 
        
       
      
        \mathcal P(w_1,w _2,\cdots,w_{\mathcal T}) 
       
      
    P(w1,w2,⋯,wT)进行建模:
  
      
       
        
        
          P 
         
        
          ( 
         
         
         
           w 
          
         
           1 
          
         
        
          , 
         
         
         
           w 
          
         
           2 
          
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
         
         
           w 
          
         
           T 
          
         
        
          ) 
         
        
          = 
         
        
          P 
         
        
          ( 
         
         
         
           w 
          
         
           t 
          
         
        
          ∣ 
         
         
         
           w 
          
         
           1 
          
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
         
         
           w 
          
          
          
            t 
           
          
            − 
           
          
            1 
           
          
         
        
          , 
         
         
         
           w 
          
          
          
            t 
           
          
            + 
           
          
            1 
           
          
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
         
         
           w 
          
         
           T 
          
         
        
          ) 
         
        
          ⋅ 
         
        
          P 
         
        
          ( 
         
         
         
           w 
          
         
           1 
          
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
         
         
           w 
          
          
          
            t 
           
          
            − 
           
          
            1 
           
          
         
        
          , 
         
         
         
           w 
          
          
          
            t 
           
          
            + 
           
          
            1 
           
          
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
         
         
           w 
          
         
           T 
          
         
        
          ) 
         
         
        
          t 
         
        
          ∈ 
         
        
          { 
         
        
          1 
         
        
          , 
         
        
          2 
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
        
          T 
         
        
          } 
         
        
       
         \mathcal P(w_1,w_2,\cdots,w_{\mathcal T}) = \mathcal P(w_t \mid w_1,\cdots,w_{t-1},w_{t+1},\cdots,w_{\mathcal T}) \cdot \mathcal P(w_1,\cdots,w_{t-1},w_{t+1},\cdots,w_{\mathcal T}) \quad t \in \{1,2,\cdots, \mathcal T\} 
        
       
     P(w1,w2,⋯,wT)=P(wt∣w1,⋯,wt−1,wt+1,⋯,wT)⋅P(w1,⋯,wt−1,wt+1,⋯,wT)t∈{1,2,⋯,T}
 很明显作为自然语言处理任务, 
     
      
       
       
         D 
        
       
      
        \mathcal D 
       
      
    D的规模必然是不小的;对应联合概率分布的计算也是既复杂的。针对这种情况,使用 
     
      
       
       
         3 
        
       
      
        3 
       
      
    3个假设对任务进行约束:
- 假设 
      
       
        
        
          1 
         
        
       
         1 
        
       
     1:中心词 
      
       
        
         
         
           w 
          
         
           t 
          
         
        
          ( 
         
        
          t 
         
        
          = 
         
        
          1 
         
        
          , 
         
        
          2 
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
        
          T 
         
        
          ) 
         
        
       
         w_t(t=1,2,\cdots,\mathcal T) 
        
       
     wt(t=1,2,⋯,T)仅能对其前后 
      
       
        
        
          C 
         
        
       
         \mathcal C 
        
       
     C个上下文词语产生影响。基于该假设,可以对条件概率 
       
        
         
         
           P 
          
         
           ( 
          
          
          
            w 
           
          
            t 
           
          
         
           ∣ 
          
          
          
            w 
           
          
            1 
           
          
         
           , 
          
         
           ⋯ 
           
         
           , 
          
          
          
            w 
           
           
           
             t 
            
           
             − 
            
           
             1 
            
           
          
         
           , 
          
          
          
            w 
           
           
           
             t 
            
           
             + 
            
           
             1 
            
           
          
         
           , 
          
         
           ⋯ 
           
         
           , 
          
          
          
            w 
           
          
            T 
           
          
         
           ) 
          
         
        
          \mathcal P(w_t \mid w_1,\cdots,w_{t-1},w_{t+1},\cdots,w_{\mathcal T}) 
         
        
      P(wt∣w1,⋯,wt−1,wt+1,⋯,wT)进行化简:
 为了数据有意义,同样需要满足:t − C ≥ 0 ; t + C ≤ T t-\mathcal C \geq 0;t+ \mathcal C \leq \mathcal T t−C≥0;t+C≤T
 P ( w t ∣ w 1 , ⋯ , w t − 1 , w t + 1 , ⋯ , w T ) ≈ P ( w t ∣ w t − C , ⋯ , w t − 1 , w t + 1 , ⋯ , w t + C ) \mathcal P(w_t \mid w_1,\cdots,w_{t-1},w_{t+1},\cdots,w_{\mathcal T}) \approx \mathcal P(w_t \mid w_{t-\mathcal C},\cdots,w_{t-1},w_{t+1},\cdots,w_{t+\mathcal C}) P(wt∣w1,⋯,wt−1,wt+1,⋯,wT)≈P(wt∣wt−C,⋯,wt−1,wt+1,⋯,wt+C)
- 假设 
      
       
        
        
          2 
         
        
       
         2 
        
       
     2:各似然结果 
      
       
        
        
          P 
         
        
          ( 
         
         
         
           w 
          
         
           t 
          
         
        
          ∣ 
         
         
         
           w 
          
          
          
            t 
           
          
            − 
           
          
            C 
           
          
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
         
         
           w 
          
          
          
            t 
           
          
            − 
           
          
            1 
           
          
         
        
          , 
         
         
         
           w 
          
          
          
            t 
           
          
            + 
           
          
            1 
           
          
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
         
         
           w 
          
          
          
            t 
           
          
            + 
           
          
            C 
           
          
         
        
          ) 
         
         
        
          t 
         
        
          ∈ 
         
        
          { 
         
        
          1 
         
        
          , 
         
        
          2 
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
        
          T 
         
        
          } 
         
        
       
         \mathcal P(w_t \mid w_{t-\mathcal C},\cdots,w_{t-1},w_{t+1},\cdots,w_{t+\mathcal C}) \quad t \in \{1,2,\cdots,\mathcal T\} 
        
       
     P(wt∣wt−C,⋯,wt−1,wt+1,⋯,wt+C)t∈{1,2,⋯,T}之间相互独立。可以将完整似然结果表示为:
 均值1 T \frac{1}{\mathcal T} T1只会影响似然结果变化的范围,而不会影响趋势;
 1 T ∑ t = 1 T log  P ( w t ∣ w t − C , ⋯ , w t − 1 , w t + 1 , ⋯ , w t + C ) \frac{1}{\mathcal T} \sum_{t=1}^\mathcal T \log \mathcal P(w_t \mid w_{t-\mathcal C},\cdots,w_{t-1},w_{t+1},\cdots,w_{t+\mathcal C}) T1t=1∑TlogP(wt∣wt−C,⋯,wt−1,wt+1,⋯,wt+C)
- 假设 
      
       
        
        
          3 
         
        
       
         3 
        
       
     3:中心词 
      
       
        
         
         
           w 
          
         
           t 
          
         
        
          ( 
         
        
          t 
         
        
          = 
         
        
          1 
         
        
          , 
         
        
          2 
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
        
          T 
         
        
          ) 
         
        
       
         w_{t}(t=1,2,\cdots,\mathcal T) 
        
       
     wt(t=1,2,⋯,T)确定的条件下,作为条件的各词之间同样相互独立。假设 
      
       
        
        
          2 
         
        
       
         2 
        
       
     2中的结果可以继续分解:
 J ( θ ) = 1 T ∑ t = 1 T log  ∏ i = − C ( ≠ 0 ) C P ( w t ∣ w t + i ) = 1 T ∑ t = 1 T ∑ i = − C ( ≠ 0 ) C log  P ( w t ∣ w t + i ) \begin{aligned} \mathcal J(\theta) & = \frac{1}{\mathcal T} \sum_{t=1}^{\mathcal T} \log \prod_{i=-\mathcal C(\neq0)}^{\mathcal C} \mathcal P(w_t \mid w_{t+i}) \\ & = \frac{1}{\mathcal T} \sum_{t=1}^{\mathcal T} \sum_{i=-\mathcal C(\neq 0)}^{\mathcal C} \log \mathcal P(w_t \mid w_{t+i}) \end{aligned} J(θ)=T1t=1∑Tlogi=−C(=0)∏CP(wt∣wt+i)=T1t=1∑Ti=−C(=0)∑ClogP(wt∣wt+i)
上面对应的是 CBOW \text{CBOW} CBOW架构的策略。很明显: 3 3 3个假设都非常苛刻,并且不合语言常理:
- 关于假设 1 1 1:中心词与上下文之间存在关联这个理念没有错,但是将上下文约束在固定大小的范围(窗口) ( − C , C ) (-\mathcal C,\mathcal C) (−C,C)显得过于生硬;
- 关于假设 2 2 2,假设 3 3 3:窗口内的词、中心词后验概率均相互独立,这本身也是对上下文这个概念的一种破坏。
通常也称 Word2vec \text{Word2vec} Word2vec系列模型为静态模型、无上下文模型。
BERT \text{BERT} BERT的基本理念
抽象的双向
BERT \text{BERT} BERT( Bidirectional Encoder Representation from Transformers \text{Bidirectional Encoder Representation from Transformers} Bidirectional Encoder Representation from Transformers,基于 Transformer \text{Transformer} Transformer的双向编码器表示) 是针对一般语言的理解任务,使用深层双向 Transformer \text{Transformer} Transformer用来做预训练的模型。该模型的优势之处在于:对于预训练好的 BERT \text{BERT} BERT模型,仅需要增加一个额外的输出层,就可以在 NLP \text{NLP} NLP的相关任务中得到一个不错的结果。
BERT \text{BERT} BERT之所以成功的一个重要原因在于:它是一个基于上下文的嵌入模型。和 Transformer \text{Transformer} Transformer相同,它使用自注意力机制去分析完整句子内各词之间的关联关系,而相反 Word2vec \text{Word2vec} Word2vec这种静态模型,即便存在考虑上下文信息的想法,但各种苛刻、不合理的假设,让上下文信息几乎失去了意义。
那么 
     
      
       
       
         BERT 
        
       
      
        \text{BERT} 
       
      
    BERT是如何实现双向表示的呢 
     
      
       
       
         ? 
        
       
      
        ? 
       
      
    ? 提到双向,在 
      
       
        
        
          Seq2seq 
         
        
       
         \text{Seq2seq} 
        
       
     Seq2seq注意力机制执行过程一节中,将编码器部分设置为双向 
      
       
        
        
          GRU 
         
        
       
         \text{GRU} 
        
       
     GRU结构。当然,无论是双向 
     
      
       
       
         GRU 
        
       
      
        \text{GRU} 
       
      
    GRU还是双向 
     
      
       
       
         LSTM 
        
       
      
        \text{LSTM} 
       
      
    LSTM,其本质是两个学习顺序相反的独立结构:
 最终将每个结构产生的特征信息进行拼接,从而得到一个新的融合特征,并基于该特征执行后续步骤。
  
      
       
        
         
         
           h 
          
          
          
            u 
           
          
            p 
           
          
            d 
           
          
            a 
           
          
            t 
           
          
            e 
           
          
         
        
          = 
         
        
          [ 
         
         
         
           h 
          
          
          
            L 
           
          
            ; 
           
          
            1 
           
          
         
        
          , 
         
         
         
           h 
          
          
          
            L 
           
          
            ; 
           
          
            2 
           
          
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
         
         
           h 
          
          
          
            L 
           
          
            ; 
           
          
            T 
           
          
         
        
          ; 
         
         
         
           h 
          
          
          
            L 
           
          
            ; 
           
          
            1 
           
          
         
        
          , 
         
         
         
           h 
          
          
          
            L 
           
          
            ; 
           
          
            2 
           
          
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
         
         
           h 
          
          
          
            L 
           
          
            ; 
           
          
            T 
           
          
         
        
          ] 
         
        
       
         h_{update} = [h_{\mathcal L;1},h_{\mathcal L;2},\cdots,h_{\mathcal L;\mathcal T};h_{\mathcal L;1},h_{\mathcal L;2},\cdots,h_{\mathcal L;\mathcal T}] 
        
       
     hupdate=[hL;1,hL;2,⋯,hL;T;hL;1,hL;2,⋯,hL;T]
但 
     
      
       
       
         BERT 
        
       
      
        \text{BERT} 
       
      
    BERT中的描述的双向不同于上述结构,它所描述的双向仅是:仅使用 
      
       
        
        
          Transformer 
         
        
       
         \text{Transformer} 
        
       
     Transformer中的编码器部分作为模型的架构。在 
      
       
        
        
          Transformer 
         
        
       
         \text{Transformer} 
        
       
     Transformer模型架构一节中编码器部分的多头注意力机制中,其输出的任意头的注意力矩阵 
      
       
        
         
         
           A 
          
          
          
            ( 
           
          
            i 
           
          
            ) 
           
          
         
        
       
         \mathcal A^{(i)} 
        
       
     A(i),其矩阵內部的信息是完整的。也就是说:句子中的任意一个词,和句子中的其他词(包含自身),均存在相应的注意力映射关系。自然包含某个被 
     
      
       
       
         Mask 
        
       
      
        \text{Mask} 
       
      
    Mask词的前向、后向的词。
 是个有点抽象意义上的双向~
  
      
       
        
        
          { 
         
         
          
           
            
             
              
               
                
                 
                
               
               
                
                 
                  
                 
                   att 
                  
                  
                  
                    [ 
                   
                   
                   
                     Q 
                    
                    
                    
                      ( 
                     
                    
                      i 
                     
                    
                      ) 
                     
                    
                   
                  
                    , 
                   
                   
                   
                     K 
                    
                    
                    
                      ( 
                     
                    
                      i 
                     
                    
                      ) 
                     
                    
                   
                  
                    ] 
                   
                  
                 
                   = 
                  
                  
                   
                    
                    
                      Q 
                     
                     
                     
                       ( 
                      
                     
                       i 
                      
                     
                       ) 
                      
                     
                    
                    
                     
                     
                       [ 
                      
                      
                      
                        K 
                       
                       
                       
                         ( 
                        
                       
                         i 
                        
                       
                         ) 
                        
                       
                      
                     
                       ] 
                      
                     
                    
                      T 
                     
                    
                   
                   
                   
                     d 
                    
                   
                  
                 
                
               
              
              
               
                
                 
                
               
               
                
                 
                  
                  
                  
                    A 
                   
                   
                   
                     ( 
                    
                   
                     i 
                    
                   
                     ) 
                    
                   
                  
                 
                   = 
                  
                 
                   Softmax 
                  
                  
                  
                    { 
                   
                  
                    att 
                   
                   
                   
                     [ 
                    
                    
                    
                      Q 
                     
                     
                     
                       ( 
                      
                     
                       i 
                      
                     
                       ) 
                      
                     
                    
                   
                     , 
                    
                    
                    
                      K 
                     
                     
                     
                       ( 
                      
                     
                       i 
                      
                     
                       ) 
                      
                     
                    
                   
                     ] 
                    
                   
                  
                    } 
                   
                  
                  
                  
                    V 
                   
                   
                   
                     ( 
                    
                   
                     i 
                    
                   
                     ) 
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
         \begin{cases} \begin{aligned} & \text{att} \left[\mathcal Q^{(i)},\mathcal K^{(i)} \right] = \frac{\mathcal Q^{(i)} \left[ \mathcal K^{(i)} \right]^T}{\sqrt{d}} \\ & \mathcal A^{(i)} = \text{Softmax} \left\{ \text{att} \left[\mathcal Q^{(i)},\mathcal K^{(i)}\right] \right\} \mathcal V^{(i)} \end{aligned} \end{cases} 
        
       
     ⎩ 
              ⎨ 
              ⎧att[Q(i),K(i)]=dQ(i)[K(i)]TA(i)=Softmax{att[Q(i),K(i)]}V(i)
既然有双向,那自然也有单向。单向自然指 Transformer \text{Transformer} Transformer中的解码器部分。解码器模块中的 Masked Multi-Head Attention \text{Masked Multi-Head Attention} Masked Multi-Head Attention模块,由于需要预测后一个词的概率分布,所以其对应的注意力矩阵是一个被 mask \text{mask} mask一半的三角矩阵。
BERT的预训练策略
BERT \text{BERT} BERT的预训练策略包含两种:
-  掩码语言模型训练 
 两个示例句子: Paris is a beautiful city I love Paris \text{Paris is a beautiful city \quad I love Paris} Paris is a beautiful city I love Paris
 将两个句子处理成预期格式:
 分词;第一句开头添加[ CLS ] [\text{CLS}] [CLS]每个分句后添加[ SEP ] [\text{SEP}] [SEP]
 tokens = [[CLS], Paris, is, a, beautiful, city, [SEP], I, love, Paris, [SEP]] \text{tokens = [[CLS], Paris, is, a, beautiful, city, [SEP], I, love, Paris, [SEP]]} tokens = [[CLS], Paris, is, a, beautiful, city, [SEP], I, love, Paris, [SEP]]
 在上述 token \text{token} token中随机选择一部分词语进行掩码标记,标记方式为:使用 [ MASK ] [\text{MASK}] [MASK]对被掩码词语进行替换。被选择词语数量与 token \text{token} token长度相关,控制在 token \text{token} token长度的 15 15 15%,这里仅以一个词为例: city \text{city} city。
 tokens = [[CLS], Paris, is, a, beautiful, [MASK], [SEP], I, love, Paris, [SEP]] \text{tokens = [[CLS], Paris, is, a, beautiful, [MASK], [SEP], I, love, Paris, [SEP]]} tokens = [[CLS], Paris, is, a, beautiful, [MASK], [SEP], I, love, Paris, [SEP]]
 在论文中,为了优化 BERT \text{BERT} BERT预训练模式和下游任务微调模式之间由于掩码标记导致不匹配的问题而提出 80-10-10 规则。即: 80 80 80%的 token \text{token} token使用掩码标记进行替换; 10 10 10%的 token \text{token} token使用随机标记替换,即使用词表中的随机词替换被掩码的词语。这里选择用 love \text{love} love 替换 city \text{city} city:
 人为增加噪声提升模型鲁棒性的操作~
 tokens = [[CLS], Paris, is, a, beautiful, love, [SEP], I, love, Paris, [SEP]] \text{tokens = [[CLS], Paris, is, a, beautiful, love, [SEP], I, love, Paris, [SEP]]} tokens = [[CLS], Paris, is, a, beautiful, love, [SEP], I, love, Paris, [SEP]]
 最后 10 10 10%的 token \text{token} token保持不变。将处理好的 token \text{token} token对应的各类 Embedding \text{Embedding} Embedding送入到 BERT \text{BERT} BERT中,对 [ MASK ] [\text{MASK}] [MASK]位置对应的 BERT \text{BERT} BERT输出 R [ MASK ] \mathcal R_{[\text{MASK}]} R[MASK]进行预测:
 R [ MASK ] = P ( [MASK] ∣ Paris,is,a , ⋯ , love,Paris ) \mathcal R_{[\text{MASK}]} = \mathcal P(\text{[MASK]} \mid \text{Paris,is,a},\cdots,\text{love,Paris}) R[MASK]=P([MASK]∣Paris,is,a,⋯,love,Paris)
 这明显是一个多分类任务。使用 Softmax \text{Softmax} Softmax从当前词表中选择一个概率最高的值对 [ MASK ] [\text{MASK}] [MASK]进行预测,因而对应的策略使用交叉熵损失函数。
-  下句预测 
 顾名思义,即 token \text{token} token内的句子之间是否存在前后因果关系。示例 token \text{token} token中自然是满足条件的,具体判断方式是对 [CLS] \text{[CLS]} [CLS]对应的 BERT \text{BERT} BERT输出 R [ CLS ] \mathcal R_{[\text{CLS}]} R[CLS]使用 Softmax \text{Softmax} Softmax进行二分类(有关联/无关联)任务。对应的策略同样是交叉熵损失函数
和 Transformer \text{Transformer} Transformer相比,虽然都是分类任务, Transformer \text{Transformer} Transformer最终求得的后验概率仅包含正向(单向)顺序;而 BERT \text{BERT} BERT不仅是双向顺序,并且是两种策略共同对权重参数进行反向传播更新。
预训练与微调
-  在整个预训练过程中,我们使用未标注的数据对词语的 Embedding \text{Embedding} Embedding进行优化,并获取相应对应预训练的权重; 
 但是这个部分还是交给各个大厂和顶级研究院吧~我们连电费交不起
-  在后期微调时,我们针对一些具体的下游任务,如文本分类、命名实体识别等,我们新建一个 BERT \text{BERT} BERT模型,并且初始化权重参数是之前预训练得到的参数,而数据是我们自己标注过的数据,针对具体任务,对下游神经网络权重、 BERT \text{BERT} BERT內部权重进行进一步调整(微调),从而得到该任务的BERT版本。 
 
     
      
       
       
         Reference 
        
       
      
        \text{Reference} 
       
      
    Reference:
  
      
       
        
        
          BERT 
         
        
       
         \text{BERT} 
        
       
     BERT论文逐段精读
 《BERT基础教程——Transformer大模型实战》

![微信小程序,打开新的项目,调试遇见[ app.json 文件内容错误] app.json: 在项目根目录未找到 app.json](https://i-blog.csdnimg.cn/direct/cdfd4adcb92e440f9bfcc24f4f347958.png)

















