bert – gitweixin

深度学习 4月 5,2022

Word Embedding的几种模型和示例

介绍

人类有能力理解单词并轻松地从中获取含义。然而，在当今世界，大多数任务都是由计算机执行的。例如，如果您想知道今天是晴天还是下雨天，则必须在 Google 中输入文本查询。现在的问题是，机器将如何频繁地理解和处理文本中呈现的如此大量的信息？答案是词嵌入。

Word Embeddings 基本上是向量（文本转换为数字），用于捕获单词的含义、各种上下文和语义关系。嵌入本质上是使用预定义字典将单词映射到其对应向量。

例如，

句子： It will rain heavily today.

字典：{“it”：[1,0,0,0,0]，“will”：[0,1,0,0,0]，“rain”：[0,0,1,0,0] , “ heavily ”: [0,0,0,1,0], “today”: [0,0,0,0,1]}

在这里，每个单词都被分配了一个唯一的向量（例如），以便区分所有单词。

Let the corpus comprise three sentences.

S1 = In monsoon, it will rain.

S2 = rain rain come again.

S3 = sun is visible in summer. In the monsoon, the sun is hidden by clouds.

Let N be the list of unique words = [‘monsoon’, ‘rain’, ‘come’, ‘again’, ‘sun’, ‘visible’, ‘summer’, ‘hidden’, ‘clouds’]

计数矩阵的维度将是 3X9，因为语料库中有 3 个文档和 9 个唯一词。
计数矩阵如下所示：

优点：由于只考虑单词的频率，因此计算成本较低。

缺点：由于计算只是基于计数并且没有考虑单词的上下文，因此该方法证明不太有用。
代码：

#Importing libraries
from sklearn.feature_extraction.text import CountVectorizer
import nltk 
from nltk.corpus import stopwords 
from nltk.tokenize import word_tokenize 

#Downloading stopwords and punkt packages
nltk.download('stopwords') 
nltk.download('punkt') 

#Initialising stopwords for english
set(stopwords.words('english')) 

#sample sentences
text = ["In monsoon, it will rain", "rain rain come again", "sun is visible in summer. In the monsoon, the sun is hidden by clouds"]

#set of stop words
stop_words = set(stopwords.words('english')) 
all_sentences = []

#Logic for removing stop words and obtaining filtered sentences from the list 

for i in range(len(text)):
  word_tokens[i] = word_tokenize(text[i]) 
  tokenized_sentence = []

  for j in word_tokens[i]: 
      if j not in stop_words: 
          tokenized_sentence.append(j) 
  all_sentences.append(" ".join(tokenized_sentence))

#Initialising the CountVectorizer
countvectorizer = CountVectorizer()

#Applying CountVectorizer to the list of sentences
X = countvectorizer.fit_transform(all_sentences)

#Converting output to array
result = X.toarray()

print("Sentences after removing stop words", all_sentences)
print("Count Vector:", result)

2.TF-IDF：

TF-IDF 代表词频-逆文档频率。该方法是对 Count Vector 方法的即兴创作，因为特定单词的频率被考虑在整个语料库中，而不仅仅是单个文档。主要思想是对某些文档非常具体的词给予更多的权重，而对更普遍且在大多数文档中出现的词给予较少的权重。

例如，诸如“is”、“the”、“and”之类的通用词会经常出现，而诸如“Donald Trump”或“Indira Gandhi”之类的词将特定于特定文档。

数学上，

词频 (TF) = 词条在文档中出现的次数 / 文档中词条的总数

逆文档频率 (IDF) = log(N/n) 其中 N 是文档总数，n 是一个术语出现的文档数。

考虑以下示例。
给出了两个文档——D1 和 D2。

TF(Today, Document 1) = 1/8

TF(Today, Document 2) = 1/8

TF(sunny, Document 1) = 4/8

IDF(Today) = log(2/2) = log(1) = 0

IDF(sunny) = log(2/1) = log(2) = 0.301

Therefore,

TF-IDF(Today, Document 1) = 1/8 * 0 = 0

TF-IDF(Today, Document 2) = 1/8 * 0 = 0

TF-IDF(sunny, Document 1) = 4/8 * 0.301 = 0.1505

从上面的计算可以看出，与文档 1 的上下文中的重要词“sunny”相比，常用词“Today”的权重较低。

优点：

它在计算上很容易。
文档中最重要的单词是通过基本计算提取的，不需要太多努力。

缺点：

它无法捕捉单词的语义，只能像词汇级别的特征一样工作。
代码：

from sklearn.feature_extraction.text import TfidfVectorizer 
import pandas as pd

#Declaring the list of sentences
documents = ['Today is sunny day', 'Today is rainy day']

#Initialising Tfidf Vectorizer
vectorizer = TfidfVectorizer()

#Fitting the Vectorizer to the list
X = vectorizer.fit_transform(documents)
print(X)

#Printing the feature names
print(vectorizer.get_feature_names()) 

matrix = X.todense()
tfidf_list = matrix.tolist()
tfidf_df = pd.DataFrame(tfidf_list, columns = vectorizer.get_feature_names())

print(tfidf_df)

3.Word2Vec：

Word2Vec 是一种基于预测的词嵌入方法。与确定性方法不同，它是一个浅层的两层神经网络，能够预测单词之间的语义和相似性。 Word2Vec 是两种不同模型的组合——（i）CBOW（连续词袋）和（ii）Skip-gram。

模型概述 – CBOW（连续词袋）和 Skip-gram。

3.1 CBOW（连续词袋）：

该模型是一个浅层神经网络，可以在给定上下文的情况下预测单词的概率。这里，上下文是指围绕要预测的单词的单词的输入。
CBOW模型的架构：

作为第一步，输入是通过为给定文本形成一个词袋来创建的。
例如，

Sentence 1 = All work and no play make Jack a dull boy.

Sentence 2 = Jack and Jill went up the hill.

Bag of Words: {“All”:1, “work”:1, “no”:1, “play”:1, “makes”:1, “Jack”:2, “dull”:1, “boy”:1, “Jill”:1, “went”:1, “up”:1, “hill”:1} (after removing the stop words)

这个由单词及其出现频率组成的输入作为向量发送到输入层。对于 X 个单词，输入将是 X[1XV] 个向量，其中 V 是向量的最大长度。

接下来，输入隐藏层矩阵由维数 VXN 组成，其中 N 是表示单词的维数。输出隐藏层矩阵由维数 NXV 组成。在这里，这些值是通过将输入乘以隐藏输入权重来计算的。

在输出层，通过将隐藏输入乘以隐藏输出权重来计算输出。在隐藏层和输出层之间计算的权重给出了单词的表示。作为一个连续的中间步骤，通过对输出和目标值之间计算的误差使用反向传播来调整权重。
优点：

与确定性方法相比，概率性方法给出了更好的结果。
由于不需要计算巨大的矩阵，因此内存需求较少。
缺点：

优化非常重要，否则培训将需要很长时间才能完成。

3.2 Skip-gram ：

Skip-gram 模型预测给定单词的上下文，与 CBOW 所做的正好相反。 Skip-gram 模型的架构：

输入层大小：[1XV]，输入隐藏权重矩阵大小：[VXN]，输出隐藏权重矩阵：[NXV]，输出层大小：C[1XV]

模型的输入和直到隐藏层的进一步步骤将类似于 CBOW。输出目标变量的数量取决于上下文窗口的大小。例如，如果上下文窗口的大小为 2，那么将有四个目标变量，两个词在给定词之前，两个词在给定词之后。

将针对四个目标变量计算四个单独的误差，并通过执行元素相加获得最终向量。然后反向传播这个最终向量以更新权重。对于训练，输入和隐藏层之间的权重用于单词表示。

优点：

Skip-gram 模型可以捕获单词的不同上下文信息，因为每个上下文都有不同的向量表示。
对于不常用的术语更准确，并且适用于更大的数据库。
缺点：

它需要更多的内存进行处理。
代码：

要使用 genism 库中预训练的 Word2Vec 模型：

import gensim 
import gensim.downloader as api
from gensim.models.keyedvectors import KeyedVectors

#loading pretrained model
nlp_w2v = api.load("word2vec-google-news-300") 

#save the Word2Vec model
nlp_w2v.wv.save_word2vec_format('model.bin', binary=True)

#load the Word2Vec model 
model = KeyedVectors.load_word2vec_format('model.bin', binary=True)

#Printing the most similar words to New York from vocabulary of pretrained model
model.most_similar('New_York')

从头开始训练 Word2Vec 模型：

import gensim 
'''
Data for training Word2Vec
train: A data frame comprising of text samples
'''

#training data
corpus = train

#creates a list for a list of words for every training sample
w2v_corpus = []
for document in corpus:
   w2v_words = document.split()
   w2v_grams = [" ".join(w2v_words[i:i+1]) 
               for i in range(0, len(w2v_words), 1)]
   w2v_corpus.append(w2v_grams)

#initialising and training the custom Word2Vec model 
'''
size: dimensions of word embeddings 
window: context window for words 
min_count: words which appear less number of times than this count will be ignored 
sg: To choose skip-gram model 
iter: Number of epochs for training
'''

word2vec_model = gensim.models.word2vec.Word2Vec(w2v_corpus, size=300,   
            window=8, min_count=1, sg=1, iter=30)

#vector size of the model
print(word2vec_model.vector_size)

#vocabulary contained by the model
print(len(word2vec_model.wv.vocab))

4.GloVE:

GloVe 代表词表示的全局向量。该算法是对 Word2Vec 方法的改进，因为它考虑全局统计而不是局部统计。在这里，全局统计数据意味着从整个语料库中考虑的单词。 GloVe 基本上试图解释特定单词对在文档中出现的频率。为此，构建了一个共现矩阵，该矩阵将表示特定单词相对于另一个单词的存在。

例如，

Corpus – It is rainy today, tomorrow it will be sunny and the day after will be windy.

上面的矩阵表示一个共现矩阵，其值表示在给定示例语料库中一起出现的每对单词的计数。

在计算给定“today”、p(rainy/today) 和给定“tomorrow”、p(rainy/tomorrow) 的单词“rainy”的出现概率后，结果是与“rainy”最相关的单词与“明天”相比，“今天”是“今天”。

代码：

#Import statements
from numpy import array
from numpy import asarray
from numpy import zeros
from keras.preprocessing.text import Tokenizer 

#Download the pretrained GloVe data files
!wget http://nlp.stanford.edu/data/glove.6B.zip

#Unzipping the zipped folder
!unzip glove*.zip

#Initialising a tokenizer and fitting it on the training dataset
'''
train: a dataframe comprising of rows containing text data
'''
tokenizer = Tokenizer(num_words=5000)
tokenizer.fit_on_texts(train)

#Creating a dictionary to store the embeddings
embeddings_dictionary = dict()

#Opening GloVe file
glove_file = open('glove.6B.50d.txt', encoding="utf8")

#Filling the dictionary of embeddings by reading data from the GloVe file
for line in glove_file:
    records = line.split()
    word = records[0]
    vector_dimensions = asarray(records[1:], dtype='float32')
    embeddings_dictionary[word] = vector_dimensions
glove_file.close()

#Parsing through all the words in the input dataset and fetching their corresponding vectors from the dictionary and storing them in a matrix 
embedding_matrix = zeros((vocab_size, 50))
for word, index in tokenizer.word_index.items():
    embedding_vector = embeddings_dictionary.get(word)
    if embedding_vector is not None:
        embedding_matrix[index] = embedding_vector

#Displaying embedding matrix 
print(embedding_matrix)

结论：

在这篇博客中，我们回顾了一些方法——Count Vector、TF-IDF、Word2Vec 和 GloVe，用于从原始文本数据创建词嵌入。预处理文本然后发送预处理数据以创建词嵌入总是一个好习惯。作为进一步的步骤，这些词嵌入可以发送到机器学习或深度学习模型，用于各种任务，例如文本分类或机器翻译。

作者 east

深度学习 4月 2,2022

BERT：如何处理长文档

BERT 的问题

BERT，即 Transformers 的双向编码器表示，目前是公众可以使用的最著名的预训练语言模型之一。事实证明，它在包括问答和分类在内的各种任务中非常有用。

但是，BERT 最多只能接受长度为 512 个标记的输入序列。这是一个很大的限制，因为许多常见的文档类型都比 512 个单词长得多。在这一点上，我们将解释和比较一些方法来克服这个限制，并使您更容易使用 BERT 处理更长的输入文档。

为什么 BERT 不能处理长文档？

BERT 继承了转换器的架构，转换器本身使用自注意力、前馈层、残差连接和层规范化作为其基础组件。如果您不熟悉变压器架构，您可以阅读Deep Learning 101: What is a Transformer and Why Should I Care? 在继续读本文之前。

BERT 和长输入文档的问题源于 BERT 架构的几个领域。

Transformer 本身是自回归的，BERT 的创建者指出，当使用超过 512 个令牌的文档时，性能会显着下降。所以，这个限制是为了防止低质量的输出。
自注意力模型的空间复杂度为 O(n²)。像这样的二次复杂性使得这些模式非常耗费资源进行微调。输入的时间越长，微调模型所需的资源就越多。二次复杂度使大多数用户的成本高得令人望而却步。
鉴于上述两点，BERT 使用基于较短输入序列的位置编码进行了预训练。这意味着该模型不能很好地推广到更长的序列，并且为收益递减而进行微调的费用意味着解决这个问题的方法有限。
但是我的文件很长，那我现在该怎么办？

幸运的是，您可以做一些事情来有效地使用 BERT 处理更长的输入文档。这里有一些经过验证的技术可以尝试。

修整输入序列

这可能是处理 BERT 和长输入文档时最常用的技术。鉴于 BERT 对多达 512 个令牌的文档表现良好，只需将较长的文档拆分为 512 个令牌块即可让您将长文档分段传递。

对于较长的连续文档（例如长新闻文章或研究论文），将完整长度的文档切成 512 个字块不会造成任何问题，因为文档本身组织良好并且专注于单个主题。但是，如果您的文本块不太连续（例如聊天机器人脚本或一系列推文），则中间可能有与核心主题无关的块。

平均段输出的投票

另一种常见的技术是将长文档分成相等长度的重叠段，并使用投票机制进行分类。这将缓解诸如对话记录之类的非连续文档所带来的问题。使用来自较大文档的各个块的投票将合并来自整个事物的信息。

这在实践中的工作方式是将文档分成段，并通过 BERT 运行每个段，以获得分类 logits。然后通过组合投票（每段一个），我们可以得到一个平均值，我们将其作为最终分类。

这里的缺点是你不能在任务上微调 BERT，因为损失是不可微的。即使存在重叠，您也会错过每个段之间的一些共享信息。这可能会产生特定于分析管道架构的下游影响。

结论

对长输入文档使用 BERT 取决于您的具体任务。有一些更新的模型——比如 RoBERTa——是为了解决 BERT 的弱点而创建的。我们将在以后的帖子中更多地讨论这些内容。对于需要来自整个文档的信息的复杂任务，或者您使用的是非连续文档，使用像 RoBERTa 这样的 BERT 变体可能是最佳解决方案。

作者 east

深度学习 3月 31,2022

BERT 模型的深度揭秘

2018 年，Google 提出了一种特殊的语言表示模型，称为“BERT”，代表“来自 Transformers 的双向编码器表示”。以前的语言表示模型（例如 OpenAI GPT）使用单向方法（从左到右）来编码序列。然而，这种方法是有限的，因为上下文只能从一个方向学习。

例如，考虑到这句话——“ The man was looking at the cloudy sky. The man witnessed a cloudy state of mind for the whole day 。” 在这里，无论考虑上下文或句子中单词的实际含义，之前的模型都会产生相同的单词“cloudy”嵌入。而对于 BERT 模型，“多云”一词将根据不同的上下文具有不同的嵌入。

该模型在现实生活中的主要应用之一是提高对谷歌搜索引擎的查询理解。早些时候，搜索引擎是基于关键字的，无法考虑可以提出相同问题的各种格式。因此，在搜索引擎中使用 BERT 有助于显着改善查询结果。

需要注意的重要一点是，BERT 不是一种新的架构设计，而是一种新的训练策略。由于 BERT 使用了论文中提出的 Transformer 的编码器部分——Attention Is All You Need，我们将花一些时间首先了解相同的内容，然后再讨论 BERT 不同阶段的详细工作。

变换器 – 编码器

1.1 简单多头注意力机制：

Transformer 中使用的最重要的概念是“注意”机制。让我们看看下面的图片：

当我们第一次看到图像时，我们的大部分注意力都被绿色人物——自由女神像所吸引。

同样，当提供上下文（查询）时，我们不应该对每个输入给予同等的重视，而应该更多地关注一些重要的输入。

在这里，如果查询是关于建筑物的，那么我们的注意力就会放在背景上。

因此，我们将输入一个称为 Z 的新项，而不是普通的原始输入 x 到一个层，这将是所有单个输入 xi 的加权和。

在数学上它表示为，

其中 ai 是决定注意力的个体权重。

为了更好地理解注意力的概念，让我们引入以下变量——Q、K、V。Q 代表 Query，这是我们试图查看的上下文，Value 表示给定的输入（像素或文本特征）， Key 是 Value 的编码表示。

例如，在上图中，如果：

Query = 绿色

Key=建筑

那么价值将是，

因此，为了形成对输入的注意力，我们需要将查询和键相关联并删除不相关的值。

再次考虑这个例子，

| The man was looking at the cloudy sky 。（字数 = 8）

由于有 8 个单词，我们将有 8 个查询、8 个键和 8 个值。

Q = 8X512、K^T = 512X8、V = 8X512 和最后 d_k = 512 的维度。512 是作为输入馈送到编码器的固定维度数。

在等式中，Q 和 K 矩阵之间的点积将导致它们之间的相似度同时生成，而不是单独计算每个单词的相似度。此外，我们在分母中有一个维度数的平方根，以便缩放完整值。这将有助于确保顺利进行训练。

刚才我们理解的是简单的注意力，现在让我们继续理解
multi-head 注意力是什么意思？

多头注意力是转换器使用的一项功能，它为每个查询生成 h 个注意力，而不是一个注意力。使用 h attention 的主要原因是为特定查询获得 h 个不同的视角。考虑这么多角度将大大提高模型的整体准确性。对于输出，将所有 h 个注意力连接起来，然后输入到点积方程中。

1.2 跳过连接和层规范化：

编码器的另一个主要组成部分是跳过连接和归一化层。

跳过连接基本上是通过跳过中间的一些层将一层连接到另一层的残差块。引入跳跃连接的想法是解决深度神经网络中的退化问题（梯度消失）。跳过连接有助于网络的最佳训练。

层归一化类似于批量归一化，除了在层归一化中，归一化发生在同一层中的特征上。

下图展示了编码器的结构，展示了multi-head 注意力、跳过连接和层归一化的使用。

1.3 前馈网络：

如上图所示，层归一化的输出被馈送到一个全连接层、ReLU 层和另一个全连接层。这些操作分别应用于每个位置，因为每个输出都依赖于与其相关的相应注意力。

通过以上部分，您对编码器中存在的不同模块及其使用有了基本的了解。

在下一节中，让我们继续了解 BERT 的强大功能。

BERT 模型：

使用 BERT 的动机是解决这两个主要挑战：

对所有单词的深刻上下文理解。与转换器不同，它尝试实现双向词嵌入策略。
一个可以服务于多种目的的单一模型，因为从头开始为每个单独的任务进行训练，在计算上既昂贵又耗时。

理解输入：

输入包括分成标记的句子——T1、T2、… Tn。一开始，总是有一个 [CLS] 令牌。如果输入中有多个序列，则它们被 [SEP] 标记分割。输出令牌的数量与输入令牌的数量相同。请看下图以更好地理解。

输入嵌入包括三种——令牌嵌入、段嵌入和位置嵌入。

1、令牌嵌入——为了计算嵌入，输入令牌使用固有词汇表（大小 – 30,000 个令牌）转换为单词片段。例如，“bullying”这个词将被拆分为“bully”和“ing”。
2、Segment Embeddings——这些嵌入确保了每个标记的序列标记，以确定标记属于哪个序列。为了做到这一点，嵌入值添加了一个常量偏移量，其值决定了它所属的序列。
3、位置嵌入——这有助于跟踪令牌的位置。

最终的嵌入将是 Token 嵌入、Segment 嵌入和位置嵌入的总和。

预训练和微调任务：

BERT 模型包括两个阶段——预训练和微调。

在预训练阶段，该模型使用两个 NLP 任务进行训练——(i) 掩蔽语言模型 (MLM) 和 (ii) 下一句预测 (NSP)。使用 Masked LM，解码器生成输入的向量表示，其中包含一些掩码单词。

例如，如果输入句子是——“ my cat is furry ”，那么掩码向量看起来像——“ my cat is [MASK]”。

在这种策略中，80% 的时间单词会被屏蔽。 10% 的情况下，它会被一个随机词替换——“ my cat is human ”。在剩下的 10% 的时间里，这个词保持不变——“ my cat is furry ”。这种学习方法将使模型变得健壮，因为它将提高预测准确性。需要注意的一点是，模型不会被评估预测整个序列，而只会评估缺失的单词。

第二个 NLP 任务是 Next Sentence Prediction (NSP)。输入将包含两个句子——A 和 B。这个想法是预测第二个句子是否是第一个句子的后续。这样，模型将能够学习两个句子之间的关系。模型有 50% 的时间是连续的句子，其余 50% 的序列是随机设置的。查看下图以获取 NSP 任务的示例。

总而言之，这两个训练任务能够丰富学习序列的上下文信息和语义。

BERT 模型可以针对许多不同的任务进行微调——自然语言推理 (NLI)、问答、情感分析、文本分类等。在微调的同时，我们保持完整的架构相同，除了最后一层将在自定义数据上训练模型。添加一个浅层分类器或解码器可以完成这项工作。

预训练模型：

BERT 论文提出了以下预训练模型：-

BERT-Base, Uncased：12 层，768 隐藏，12 注意力头，110M 参数
BERT-Large, Uncased：24 层，1024 隐藏，16 注意力头，340M 参数

BERT-Base，Cased：12 层，768 隐藏，12 注意力头，110M 参数
BERT-Large，Cased：24 层，1024 隐藏，16 注意力头，340M 参数

代码实现：

现在，让我们使用 BERT 实现一个多标签文本分类模型。

多标签文本分类概述

那么，什么是多标签文本分类？它基本上是将文本分类为它所属的一个或多个类别。例如，考虑电影《神奇女侠》的影评——“在一个痴迷于有缺陷的英雄、不受欢迎的英雄和反英雄的娱乐环境中，戴安娜毫无歉意地是一个真正的英雄”。从这段文字可以预测，这部电影属于“奇幻”、“冒险”和“科幻”的类型。

因此，为了解决多标签分类任务，第一步是创建由清洁文本和单热编码目标向量组成的数据。例如，在上述情况下，目标向量可能看起来像 – [0,0,1,0,1,0,1,0,0…] 其中 1 代表类别 – 幻想、冒险和科幻，而 0代表剩余的缺席类别。第二步是创建词嵌入，最后在这些嵌入上训练模型。

使用 BERT 进行多标签文本分类：

第 1 步：安装：

使用以下命令在 google colab 上安装 simpletransformers 库：

!pip install simpletransformers

Simpletransformers 是一个建立在著名的变形金刚库 – Hugging Face 之上的库。这使得只使用几行代码就可以进行预处理、训练和评估。

第 2 步：加载和预处理数据：

我们将致力于有毒评论分类的 kaggle 挑战，其中文本需要分为六个类别——有毒、严重有毒、淫秽、威胁、侮辱和身份仇恨。数据集可以从这里下载。将下载的文件存储在您当前的工作目录中。我们将使用 train.csv 文件来创建训练和评估数据。

# Import statements

import pandas as pd
from sklearn.model_selection import train_test_split
from simpletransformers.classification import MultiLabelClassificationModel

# ’dir’ would be your current working directory
df = pd.read_csv('dir/train.csv') 
# taking nearly 15,000 samples out of nearly 1,50,000 samples
df= df.sample(frac=0.1) 

# Combining all the tags into a single list
df['labels'] = df[df.columns[2:]].values.tolist() 

# Removing '\n' from the text
df['text'] = df['comment_text'].apply(lambda x: x.replace('\n', ' ')) 

# Creating new dataframe consisting of just text and their labels
new_df = df[['text', 'labels']].copy() 

# Splitting the data into training and testing sets, 80% of data is kept for training and 20% for evaluation
train, eval = train_test_split(new_df, test_size=0.2)

第 3 步：加载预训练的 BERT 模型：

在这里，我们将使用 roberta 模型的预训练“roberta-base”版本。 RoBERTa 代表 Robustly Optimized BERT Pretraining Approach。由于原始 BERT 模型的以下变化，RoBERTa 提高了性能——更长的训练、使用更多数据以及更长的训练序列、动态掩码模式以及从预训练任务中删除下一句预测目标。

'''
Description of params:
model_type: type of the model from the following {'bert', 'xlnet', 'xlm', 'roberta', 'distilbert'}

model_name: choose from a list of current pretrained models {roberta-base, roberta-large} roberta-base consists of 12-layer, 768-hidden, 12-heads, 125M parameters.
num_labels: number of labels(categories) in target values

args: hyperparameters for training. max_seq_length truncates the input text to 512. 512 because that is the standard size accepted as input by the model.
'''
model = MultiLabelClassificationModel('roberta', 'roberta-base', num_labels=6, args={'train_batch_size':2, 'gradient_accumulation_steps':16, 'learning_rate': 3e-5, 'num_train_epochs': 2, 'max_seq_length': 512})

步骤4：训练模型

# train_model is an inbuilt function which directly trains the data with the specified parameter args. Output_dir is the location for the model weights to be stored in your directory.

model.train_model(train, multi_label=True, output_dir='/dir/Output')

步骤5：评估模型

'''
Description of params: 

result: Label Ranking Average Precision (LRAP) is reported in the form of a dictionary 
model_outputs: Returns model predictions in the form of probabilities for each sample in the evaluation set
wrong_predictions: Returns a list for each incorrect prediction

'''

# eval_model is an inbuilt method which performs evaluation on the eval dataframe
result, model_outputs, wrong_predictions = model.eval_model(eval) 

# Converting probabilistic scores to binary - 0/1 values using 0.5 as threshold
for i in range(len(model_outputs)):
  for j in range(6):
    if model_outputs[i][j]<0.5:
      model_outputs[i][j] = 0
    else:
      model_outputs[i][j] = 1

第 6 步：预测：

test.csv 文件也将从此处下载到数据集中。它只包含文本，不包含标签。

# Reading the test data for prediction
test_data = pd.read_csv('dir/test.csv')

# Replacing '\n' values in the text
predict_data = test_data.comment_text.apply(lambda x: x.replace('\n', ' '))

# Convert the dataframe to a list as the predict function accepts a list
predict_data = predict_data.tolist()

# Makes predictions for the test data
predictions, outputs = model.predict(predict_data)

结论：

在本文中，我们深入探讨了 BERT 模型。我们还对变压器使用的编码器模块有了基本的了解。 BERT 模型由于其双向编码的特性而被证明比其他以前的模型具有优势。该模型经过预训练，可以针对自然语言推理 (NLI)、情感分析、多类/多标签文本分类等多项任务进行微调。该模型通过大幅减少针对不同目的的不同模型从头开始训练的需求，无疑提高了多个领域的准确性。

作者 east

深度学习 3月 31,2022

为什么google应用bert模型到搜索及如何SEO

随着新BERT算法的实现，谷歌已经在谷歌搜索中出现的结果进行了另一种重要的排序调整。了解BERT算法更新对搜索结果造成的哪些更改，还有哪些方面没有造成改变，对于SEO维护搜索中现有的结果至关重要，以及在搜索中建立新的排名。

谷歌不断调整其超级秘密搜索算法。一般来说，这些调整很小，不足导致大量搜索结果突然变化。但BERT更新并非如此。BERT代表了Google对搜索结果内容策略有了地震般转变，肯定会影响每个公司的内容展示结果和SEO的方法。

随着BERT算法的引入，许多公司将看到搜索结果的突然变化，无论好坏。并考虑到许多公司今天接近内容营销的方式，“更糟糕的”案例可能更有可能。

什么是bert算法？

那么，BERT是什么，为什么现在改变？使用Google的Pandu Nayak，Google Clower和副总裁最近的博客文章的参考，最好回答这个问题，搜索谷歌搜索。来自他的博客文章：“随着我们研究团队的最新进展，在语言理解的科学中 – 通过机器学习使得可以实现重大改进，我们如何理解查询，代表过去五年中最大的飞跃和搜索历史上的最大跳跃之一。“

机器学习，解释模式和语音过程的数学方式和语言语言，正在推进搜索科学。该进步的一个结果是BERT，它代表来自变压器的双向编码器表示。根据Nayak的说法，“[BERT]使任何人能够培养自己的最先进的问题回答系统。”

在这篇文章的剩余部分中，我将更多地挖掘这个主题以及伯特将如何影响您的SEO和内容开发方法。以及这种变化如何改变您的短期和长期可见性和在搜索中的存在。

什么是机器学习？

根据Google的说法，Transformers (the “T” in BERT)是根据句子中的所有其他单词，而不是一个逐个地处理词语的模型。“这意味着BERT机器学习模型现在将通过检查之前和之后的单词来解析查询中的句子或短语的完整上下文。根据Google，这种上下文分析，而不是与主题的特定关键字关联，是了解搜索查询背后的意图的卓越过程。结果是Google的SEO更进一步的方法。

特别是关于以较长的对话为中心的查询，在当今由基于语音的设备驱动的搜索设备中变得越来越常见，如亚马逊的Alexa或Apple的Siri等，机器学习算法将能够更好地了解理解介词用于限定查询的句子的上下文含义和目的。

换句话说，Google搜索现在将能够更清楚地了解查询中一串单词的上下文。这意味着用户可以越来越多地搜索感觉自然，谷歌将能够更准确地理解和响应搜索查询。

在他的博客帖子中，谷歌的Nayak使用这个例子：“2019 Brazil traveler to USA needs a Visa。” Nayak指出，“to”这个词及其与其余查询的关系对于了解查询的含义至关重要。这是关于一个前往美国的巴西旅行而不是其他意思。它对官方旅行证件相关，而非对信用卡的需求有关。

Nayak指出，过去的谷歌算法的过去版本将无法使用“to”这个词来接受查询上下文的重要性。因此，使用旧算法，Google可能实际上可以返回关于前往巴西的美国公民的结果列表，而不是想要的展示方式。通过BERT，Google现在能够掌握这种级别的细节 – 使用“to”单词作为限定符 – 并返回查询的更相关的结果。

凭借其对上下文细微差别的新方法，BERT算法改变了SEO的策略，以及SEO的日常惯例，减少了关键字和关键字基于短语的SEO的权重值。关键词和短语在对竞争SEO排名的战略方向和理解方面仍然重要，因为它涉及高级内容策略和内容营销。但是，在改善排名方面，SEO的关键字分析方法现在具有较少的价值和影响。

了解这一变化的影响对于寻求前进的成功至关重要。这是因为BERT了解句子级别的搜索查询的上下文，包括Word Order和同义词。在BERT之前，谷歌依靠精确的关键字和关键字短语关联，以确定搜索排名和相关性。

BERT如何改变SEO策略？

要重申一个关键点，BERT将实心SEO策略的主要焦点从关注关键字和关键字短语的关注转移到主题的关键词。更广泛地关注关于搜索查询的主题相关性。

以下是您应该开始做的一些事情 – 或者应该停止执行 – 解决BERT算法的变化。

1、停止使用低质量的外包内容开发资源。现在，使用外包内容，写出的内容具有很少的知识或专业知识现在将损害您的SEO排名。这是因为搜索引擎不是基于关键字来排名，BERT现在考虑专业知识，权威和信任作为其核心资格排名因素。

2、制定主题重点的资源清单。正式确定您的主题重点，或将来将在未来。这就是：为什么：中小企业更有可能在会话语言中使用相关的行业行业行业和相关的同义词和短语。 BERT能够拿起这种级别的上下文协会，因为它与主题专业知识和权威有关。结果随着时间的推移将是更高且更有利的排名。

3、内容的质量与数量相比。在以前很长时间，内容营销人员已经不断通过更新内容来改善排名。内容新鲜度仍然重要，但现在，内容深度和质量问题超过发布一致性和更新。

BERT会改变我的搜索排名吗？

希望您现在有更好的掌握，现在BERT算法对SEO的当前状态和未来以及整体搜索排名的影响。下一个问题显然是“BERT改变了我在搜索中看到的结果？”

没有真正的“是”或“不”的方式来回答这个问题。真实的反应是“取决于”。

如果您只使用基于关键字的SEO，随着BERT算法的引入就更变旧的游戏规则。原本排名不错的公司突然大幅度下降。（您正在监控您的搜索结果相对竞争对手的排名，不是吗？）

我该怎么SEO？

正如我之前提到的那样，这个问题的答案是“这取决于”。无论您的内容开发计划在哪个阶段，它可能会出现完善的速度。幸运的是，谷歌为我们提供了一些关于如何继续的指导。

让我们圈回电子邮件的E-A-T（专业知识，权威，值得信赖性）Litmus测试，以便在这篇文章中提到的内容。 E-A-T参考谷歌认为对网上合格内容的分类非常重要的三个战略内容柱。

“e”代表专业知识。如果您尚未使用中小企业作为您的内容开发的基石，则需要首先开始这样做。例如，在基于技术的公司中，中小企业可以是开发人员，程序员或产品经理。 “但我公司中的这些类型的人不是作家！”你可能会说。或者，“我们的开发人员没有时间编写2000字的博客帖子关于系统工程机器专有代码的重要性。”

请记住，搜索中的新标准并不是您内容的单词的方式，但它对有多权威和相关性。您的中小企业将适合BERT算法，以便完美地符合Google对内容的基线测试。

所以不是要求这些人自己写作，采访他们并记录谈话。如果他们是大多数中小企业，他们可以轻松地在与您的15分钟对话中生成2,000字的会话风格的博客文章。通过这种方法（关于主题的录制对话），您可以获得相关行业的行业术语，细微差别和上下文情绪，这将符合这个新的搜索时代内容。拍摄专家的访谈并转化为博客文章或新闻稿等。

只需这一步，您不仅处理了专业知识因素，而且通过采访贵公司或行业的权威者，您也在变得更有行业权威，以及符合E-A-T 内容策略。

通过在BERT算法的新时代应用E-A-T方法，您将在途中提高搜索排名，并在您网站的流量增加，而不是您思考的时间。

作者 east

深度学习 3月 29,2022

什么是Google BERT如何对它进行优化

听说过 Google 的新更新 BERT？如果您对搜索引擎优化 (SEO) 很感兴趣，您可能会拥有。在 SEO 世界中对 Google BERT 的炒作是有道理的，因为 BERT 使搜索更多地关注单词背后的语义或含义，而不是单词本身。

换句话说，搜索意图比以往任何时候都更加重要。谷歌最近更新的 BERT 影响了 SEO 世界，影响了十分之一的搜索查询，谷歌预计随着时间的推移，这将随着更多的语言和地区而增加。由于 BERT 将对搜索产生巨大影响，因此拥有高质量的内容比以往任何时候都更加重要。

为了使您的内容能够为 BERT（和搜索意图）发挥最佳效果，在本文中，我们将介绍 BERT 如何与搜索一起工作，以及如何使用 BERT 为您的网站带来更多流量。想与 SEO 专家交谈？与 WebFX 连接！

什么是 BERT？
BERT 代表来自 Transformers 的双向编码器表示。现在，这是一个包含一些非常技术性的机器学习术语的术语！

这是什么意思：

双向：BERT 同时对两个方向的句子进行编码
编码器表示：BERT 将句子翻译成它可以理解的词义表示
Transformers：允许 BERT 使用相对位置对句子中的每个单词进行编码，因为上下文在很大程度上取决于单词顺序（这是一种比准确记住句子如何输入框架更有效的方法）
如果你要改写它，你可以说 BERT 使用转换器来编码目标单词两侧的单词表示。从根本上说，BERT 是一个全新的、从未实现过的、最先进的自然语言处理 (NLP) 算法框架。这种类型的结构为谷歌的人工智能增加了一层机器学习，旨在更好地理解人类语言。

换句话说，通过这次新的更新，谷歌的人工智能算法可以以比以往更高水平的人类语境理解和常识来阅读句子和查询。虽然它对语言的理解程度不如人类，但它仍然是 NLP 在机器语言理解方面向前迈出的一大步。

BERT 不是什么
Google BERT 不会像之前的算法更新（如 Penguin 或 Panda）那样改变网页的判断方式。它不会将页面评为正面或负面。相反，它改进了对话式搜索查询中的搜索结果，因此结果更好地匹配其背后的意图。

BERT 历史
BERT 的存在时间比几个月前推出的 BIG 更新要长。自 2018 年 10 月发表研究论文 BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding 以来，自然学习处理 (NLP) 和机器学习 (ML) 社区一直在讨论它。不久之后，Google 发布了一个突破性的开源 NLP 框架，该框架基于 NLP 社区可以用来研究 NLP 并将其整合到他们的项目中的论文。

从那以后，出现了几个基于或合并了 BERT 的新 NLP 框架，包括谷歌和丰田的组合 ALBERT、Facebook 的 RoBERTa、微软的 MT-DNN 和 IBM 的 BERT-mtl。 BERT 在 NLP 社区引起的波澜占互联网上的大部分提及，但 BERT 在 SEO 世界中的提及正在获得牵引力。这是因为 BERT 专注于长尾查询中的语言以及像人类一样阅读网站，以便为搜索查询提供更好的结果。

BERT 是如何工作的？
Google BERT 是一个非常复杂的框架，理解它需要多年研究 NLP 理论和过程。搜索引擎优化世界不需要那么深入，但了解它在做什么以及为什么对于理解它将如何影响搜索结果从现在开始很有用。

因此，以下是 Google BERT 的工作原理：

谷歌 BERT 解释
以下是 BERT 如何从整体上查看句子或搜索查询的上下文：

BERT 接受查询
逐字逐句分解
查看单词之间所有可能的关系
构建一个双向地图，概述两个方向上的单词之间的关系
当单词彼此配对时，分析单词背后的上下文含义。
好的，为了更好地理解这一点，我们将使用以下示例：

每行代表“pandas”的含义如何改变句子中其他单词的含义，反之亦然。关系是双向的，所以箭头是双向的。当然，这是 BERT 如何看待上下文的一个非常非常简单的例子。

这个例子只检查我们的目标词“pandas ”和句子中其他有意义的片段之间的关系。然而，BERT 分析句子中所有单词的上下文关系。这张图可能更准确一点：

BERT 的类比
BERT 使用 Encoders 和 Decoders 来分析单词之间的关系。想象一下 BERT 如何作为翻译过程发挥作用，提供了一个很好的例子来说明它是如何工作的。您从输入开始，无论您想翻译成另一种语言的任何句子。

假设您想将上面的熊猫句子从英语翻译成韩语。不过，BERT 不懂英语或韩语，所以它使用编码器来翻译“熊猫除了竹子还吃什么？”变成它确实理解的语言。这种语言是它在分析语言的过程中为自己构建的语言（这是编码器表示的来源）。

BERT 根据单词的相对位置和对句子含义的重要性来标记单词。然后它将它们映射到一个抽象向量上，从而创建一种想象的语言。因此，BERT 将我们的英语句子转换为其想象的语言，然后使用解码器将想象的语言转换为韩语。

该过程非常适合翻译，但它也提高了任何基于 BERT 的 NLP 模型正确解析语言歧义的能力，例如：

代词参考
同义词和同音词
或具有多个定义的单词，例如“运行”
BERT 经过预训练
BERT 是经过预训练的，这意味着它有很多学习内容。但是使 BERT 与以前的 NLP 框架不同的一件事是 BERT 是在纯文本上进行预训练的。其他 NLP 框架需要一个由语言学家精心标记句法的单词数据库来理解单词。

语言学家必须将数据库中的每个单词标记为词性。这是一个严格而苛刻的过程，可能会在语言学家之间引发冗长的激烈辩论。词性可能很棘手，尤其是当词性由于句子中的其他单词而发生变化时。

BERT 自己做这件事，而且它是在无人监督的情况下做的，这使它成为世界上第一个这样做的 NLP 框架。它是使用维基百科训练的。那是超过 25 亿字！

BERT 可能并不总是准确的，但它分析的数据库越多，它的准确度就会越高。

BERT 是双向的
BERT 对句子进行双向编码。简而言之，BERT 在一个句子中取一个目标词，并在任一方向查看围绕它的所有词。 BERT 的深度双向编码器在 NLP 框架中是独一无二的。

早期的 NLP 框架（例如 OpenAI GPT）仅在一个方向上对句子进行编码，在 OpenAI GPT 的情况下是从左到右。后来的模型（如 ELMo）可以在目标词的左侧和右侧进行训练，但这些模型独立地连接编码。这会导致目标词的每一侧之间的上下文断开。

另一方面，BERT 识别目标单词两侧所有单词的上下文，并且同时完成所有操作。这意味着它可以完全看到和理解单词的含义如何影响整个句子的上下文。

单词如何相互关联（意味着它们一起出现的频率）是语言学家所说的搭配。

搭配词是经常一起出现的词——例如，“圣诞节”和“礼物”经常出现在每个词的几个词中。能够识别搭配有助于确定单词的含义。在我们之前的示例图像中，“trunk”可以有多种含义：

the main woody stem of a tree
the torso of a person or animal
a large box for holding travel items
the prehensile nose of an elephant
the storage compartment of a vehicle.

树的主要木质茎
人或动物的躯干
一个装旅行用品的大盒子
大象的鼻子
车辆的储藏室。
确定这句话中所用单词含义的唯一方法是查看周围的搭配。 “低音炮”通常与“汽车”一起出现，“后备箱”也是如此，因此根据上下文，“车辆储物箱”的定义可能是正确的答案。这正是 BERT 在查看句子时所做的。

它通过使用从预训练中学到的单词搭配来识别句子中每个单词的上下文。如果 BERT 单向阅读句子，则可能会错过识别低音炮和后备箱之间“汽车”的共享搭配。双向和整体查看句子的能力解决了这个问题。

BERT 使用变压器
BERT 的双向编码功能与转换器，这是有道理的。如果您还记得，BERT 中的“T”代表变压器。谷歌认为 BERT 是他们在变压器研究方面取得突破的结果。

谷歌将转换器定义为“处理与句子中所有其他单词相关的单词的模型，而不是按顺序一个接一个地处理。” Transformers 使用 Encoders 和 Decoders 来处理句子中单词之间的关系。 BERT 提取句子的每个单词，并赋予它单词含义的表示。每个单词的含义相互关联的强度由线条的饱和度来表示。

在下图的情况下，在左侧，“它”与“the”和“animal”的联系最紧密，在这种情况下识别“it”指的是什么。在右边，“it”与“street”的联系最为紧密。像这样的代词引用曾经是语言模型难以解决的主要问题之一，但 BERT 可以做到这一点

来源如果您是 NLP 爱好者，想知道什么是转换器及其工作原理背后的细节，您可以观看这段基于开创性文章的视频：Attention Is All You Need。

它们是一个很棒的视频和一篇优秀的论文（但老实说，它直接在我脑海中浮现）。对于我们其他麻瓜，BERT 背后的转换器的技术效果转化为更新，谷歌搜索可以更好地理解搜索结果背后的上下文，也就是用户意图。

BERT 使用掩码语言模型 (MLM)
BERT 的训练包括使用 Masked Language Modeling 预测句子中的单词。它的作用是掩盖句子中 15% 的单词，如下所示：

What do [MASK] eat other than bamboo?

然后，BERT 必须预测被掩码的词是什么。这做了两件事：它在单词上下文中训练 BERT，它提供了一种衡量 BERT 学习量的方法。被屏蔽的词阻止 BERT 学习复制和粘贴输入。

其他参数，例如向右移动解码器、下一个句子预测或回答上下文，有时是无法回答的问题也可以这样做。 BERT 提供的输出将表明 BERT 正在学习和实施其关于单词上下文的知识。

BERT 有什么影响？
这对搜索意味着什么？像 BERT 那样使用转换器双向映射查询尤为重要。

这意味着算法正在考虑诸如介词之类的单词背后的细微但有意义的细微差别，这些细微差别可能会极大地改变查询背后的意图。以这两个不同的搜索页面结果为例。我们将继续我们早期的熊猫和竹子主题。

关键字是：What do pandas eat other than bamboo

Panda bamboo

请注意结果页面非常相似？几乎一半的有机结果是相同的，人们也问 (PAA) 部分有一些非常相似的问题。但是，搜索意图非常不同。

“熊猫竹”的范围很广，所以很难确定其意图，但它可能在想熊猫的竹子饮食。搜索页面非常好。另一方面，“熊猫除了竹子还吃什么”的搜索意图非常具体，搜索页面上的结果完全错过了。

唯一接近达到意图的结果可能有两个 PAA 问题：

大熊猫吃什么肉？
只吃竹子的大熊猫如何生存？
可以说是 Quora 的两个问题，其中一个很有趣：

可以训练熊猫吃竹子以外的食物吗？
熊猫吃人吗？
苗条的采摘，确实。在此搜索查询中，“其他”一词在搜索意图的含义中起着重要作用。在 BERT 更新之前，Google 的算法在返回信息时会定期忽略诸如“other than”之类的功能/填充词。

这导致搜索页面无法匹配像这样的搜索意图。由于 BERT 仅影响 10% 的搜索查询，因此在撰写本文时左侧页面并未受到 BERT 的影响也就不足为奇了。 Google 在其 BERT 解释页面上提供的这个示例显示了 BERT 如何影响搜索结果：

精选片段
BERT 将产生的最重要影响之一将是精选片段。精选片段是有机的，并且依赖于机器学习算法，而 BERT 完全符合要求。精选片段结果最常从第一个搜索结果页面中提取，但现在可能会有一些例外。

因为它们是有机的，很多因素都可以使它们发生变化，包括像 BERT 这样的新算法更新。使用 BERT，影响精选片段的算法可以更好地分析搜索查询背后的意图，并更好地将搜索结果与它们匹配。 BERT 也很可能能够获取冗长的结果文本，找到核心概念，并将内容总结为特色片段。

国际搜索
由于语言具有相似的基本语法规则，BERT 可以提高翻译的准确性。 BERT 每次学习翻译一种新语言时，都会获得新的语言技能。这些技能可以转移并帮助 BERT 翻译它从未见过的更高精度的语言。

如何针对 BERT 优化我的网站？
现在我们遇到一个大问题：如何针对 Google BERT 进行优化？简短的回答？

你不能。 BERT 是一个人工智能框架。它利用它获得的每一条新信息进行学习。

它处理信息和做出决策的速度意味着即使是 BERT 的开发人员也无法预测 BERT 将做出的选择。很可能，BERT 甚至不知道它为什么会做出这样的决定。如果它不知道，那么 SEO 就无法直接针对它进行优化。

但是，您可以在搜索页面中进行排名的方法是继续生成符合搜索意图的人性化内容。 BERT 的目的是帮助 Google 了解用户意图，因此针对用户意图进行优化将针对 BERT 进行优化。

所以，做你一直在做的事情。
研究你的目标关键词。
关注用户并生成他们想要看到的内容。
最终，当你写内容时，问问自己：

我的读者能否在我的内容中找到他们正在寻找的内容？

作者 east

深度学习 3月 27,2022

什么是BERT模型和作用?

Google 最近进行了一项重要的算法更新，称为 Google BERT，以更好地理解搜索并为更自然的语言查询生成结果。算法更新还将为他们的人工智能技术提供自然语言和搜索上下文。每天数十亿次的搜索将有助于增强 Google 的 AI 功能，从而改善搜索结果、提高对语音搜索的理解，并帮助 Google 更好地了解消费者行为。

向 Google BERT 打个招呼！

BERT 是谷歌自 2015 年推出 RankBrain 以来最大的搜索算法。事实上，谷歌表示这次更新代表了“过去五年来最大的飞跃，也是搜索领域最大的飞跃之一。” BERT 通过了解用户在更具会话结构的查询中的意图，使搜索更加集中。

让我们更好地了解 BERT，并了解它如何帮助优化您的搜索。

什么是 BERT？
BERT 是一种人工智能 (AI) 系统，代表 Transformers 的双向编码器表示。这种搜索进步是谷歌对转换器研究的结果，转换器是处理与句子中所有其他单词相关的单词的模型，而不是按顺序一个接一个地处理。简而言之，此更新侧重于短语而不是简单的单词。

在排名结果方面，BERT 将影响十分之一的搜索查询。此算法更新也被应用于帮助为世界各地的人们提供更好的搜索。通过从一种语言中学习，相关结果可以应用于许多其他语言。 Google 正在许多国家/地区使用 BERT 模型来改进片段，支持韩语、印地语和葡萄牙语等 70 多种语言。

BERT+
然而，BERT 不仅仅是一种搜索算法。它也是一个机器学习自然语言处理框架、一个不断发展的计算效率工具，以及一个开源研究项目和学术论文，于 2018 年 10 月首次发表，名称为 BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding。

怎么运作
BERT 的美妙之处在于，无论单词的拼写方式或它们在查询中的顺序，它都能计算出您的搜索并显示相关信息。 BERT 能够基于句子中的整个单词集而不是传统的单词序列来训练语言模型，例如从左到右或从左到右和从右到左的组合。谷歌现在可以解决由许多具有多种含义的单词组成的模棱两可的短语。

此外，日常语言中存在细微差别，计算机并不完全理解人类的行为方式。因此，当搜索包含一个短语时，BERT 将解释它并根据句子的创建方式和发音给出结果。这很重要，因为即使是最简单的短语与单数单词相比也可能具有完全不同的含义。例如，在“纽约到洛杉矶”和“四分之一到九点”这样的短语中，“到”这个词有不同的含义，这可能会导致搜索引擎混淆。 BERT 区分这些细微差别以促进更相关的搜索。

RankBrain 仍在努力
RankBrain 是谷歌第一个用于理解查询的人工智能方法。它同时查看搜索和谷歌索引中的网页内容，以更好地理解单词的含义。 BERT 不会取代 RankBrain，它是更好地理解内容、自然语言和查询的扩展。 RankBrain 仍将被使用，但当 Google 认为在 BERT 的帮助下更适合查询时，搜索将使用新模型。似乎这句谚语是真的……两种搜索算法比一种更好！

更智能的搜索结果
作为谷歌最新的算法更新，BERT 通过更好地理解自然语言来影响搜索，尤其是在会话短语中。 BERT 将影响大约 10% 的查询以及自然排名和精选片段。所以这对谷歌……和我们所有人来说都是一件大事。有这么多问题，找到与我们的“正常”短语查询匹配的相关结果肯定会让我们的搜索体验更加轻松。搜索愉快！

作者 east

深度学习 3月 27,2022

深入了解 BERT 模型的代码-分解 Hugging Face Bert 实现

已经有很多关于如何从头开始创建简化的 Bert 模型及其工作原理的教程。在本文中，我们将做一些稍微不同的事情——我们通过 BERT 的实际 Hugging face 实现分解其所有组件。

介绍
在过去的几年里，Transformer 模型彻底改变了 NLP 领域。 BERT (Bidirectional Encoder Representations from Transformers) 是最成功的 Transformer 之一——由于与 LSTM 的递归结构不同，通过注意力机制和训练时间更好地理解了上下文，它在性能上都优于以前的 SOTA 模型（如 LSTM）， BERT 是可并行的。
现在不用再等了，让我们深入研究代码，看看它是如何工作的。首先我们加载 Bert 模型并输出 BertModel 架构：

# with bertviz package we can output attentions and hidden states 
from bertviz.transformers_neuron_view import BertModel, BertConfig
from transformers import BertTokenizer

max_length = 256
config = BertConfig.from_pretrained("bert-base-cased", output_attentions=True, output_hidden_states=True, return_dict=True)
tokenizer = BertTokenizer.from_pretrained("bert-base-cased")
config.max_position_embeddings = max_length

model = BertModel(config)
model = model.eval()

display(model)
# output : 

BertModel(
  (embeddings): BertEmbeddings(
    (word_embeddings): Embedding(30522, 768, padding_idx=0)
    (position_embeddings): Embedding(256, 768)
    (token_type_embeddings): Embedding(2, 768)
    (LayerNorm): BertLayerNorm()
    (dropout): Dropout(p=0.1, inplace=False)
  )
  (encoder): BertEncoder(
    (layer): ModuleList(
      (0): BertLayer(
        (attention): BertAttention(
          (self): BertSelfAttention(
            (query): Linear(in_features=768, out_features=768, bias=True)
            (key): Linear(in_features=768, out_features=768, bias=True)
            (value): Linear(in_features=768, out_features=768, bias=True)
            (dropout): Dropout(p=0.1, inplace=False)
          )
          (output): BertSelfOutput(
            (dense): Linear(in_features=768, out_features=768, bias=True)
            (LayerNorm): BertLayerNorm()
            (dropout): Dropout(p=0.1, inplace=False)
          )
        )
        (intermediate): BertIntermediate(
          (dense): Linear(in_features=768, out_features=3072, bias=True)
        )
        (output): BertOutput(
          (dense): Linear(in_features=3072, out_features=768, bias=True)
          (LayerNorm): BertLayerNorm()
          (dropout): Dropout(p=0.1, inplace=False)
        )
      )
      (1): BertLayer(
        (attention): BertAttention(
          (self): BertSelfAttention(
            (query): Linear(in_features=768, out_features=768, bias=True)
            (key): Linear(in_features=768, out_features=768, bias=True)
            (value): Linear(in_features=768, out_features=768, bias=True)
            (dropout): Dropout(p=0.1, inplace=False)
          )
          (output): BertSelfOutput(
            (dense): Linear(in_features=768, out_features=768, bias=True)
            (LayerNorm): BertLayerNorm()
            (dropout): Dropout(p=0.1, inplace=False)
          )
        )
        (intermediate): BertIntermediate(
          (dense): Linear(in_features=768, out_features=3072, bias=True)
        )
        (output): BertOutput(
          (dense): Linear(in_features=3072, out_features=768, bias=True)
          (LayerNorm): BertLayerNorm()
          (dropout): Dropout(p=0.1, inplace=False)
        )
      )
      
      ......

      (11): BertLayer(
        (attention): BertAttention(
          (self): BertSelfAttention(
            (query): Linear(in_features=768, out_features=768, bias=True)
            (key): Linear(in_features=768, out_features=768, bias=True)
            (value): Linear(in_features=768, out_features=768, bias=True)
            (dropout): Dropout(p=0.1, inplace=False)
          )
          (output): BertSelfOutput(
            (dense): Linear(in_features=768, out_features=768, bias=True)
            (LayerNorm): BertLayerNorm()
            (dropout): Dropout(p=0.1, inplace=False)
          )
        )
        (intermediate): BertIntermediate(
          (dense): Linear(in_features=768, out_features=3072, bias=True)
        )
        (output): BertOutput(
          (dense): Linear(in_features=3072, out_features=768, bias=True)
          (LayerNorm): BertLayerNorm()
          (dropout): Dropout(p=0.1, inplace=False)
        )
      )
    )
  )
  (pooler): BertPooler(
    (dense): Linear(in_features=768, out_features=768, bias=True)
    (activation): Tanh()
  )
)

我们分别分析了 3 个部分：Embeddings、具有 12 个重复 Bert 层的 Encoder 和 Pooler。最终我们将添加一个分类层。
伯特嵌入：
从原始文本开始，首先要做的是将我们的句子拆分为标记，然后我们可以将其传递给 BertEmbeddings。我们使用基于 WordPiece 的 BertTokenizer——子词标记化可训练算法，有助于平衡词汇量和词汇量外的单词。看不见的词被分成子词，这些子词是在分词器的训练阶段派生的（这里有更多详细信息）。现在让我们从 20newsgroups 数据集中导入几个句子并标记它们

from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')
inputs_tests = tokenizer(newsgroups_train['data'][:3], truncation=True, padding=True, max_length=max_length, return_tensors='pt')

一旦句子被分割成标记，我们就会为每个标记分配一个具有代表性的数字向量，该向量在 n 维空间中表示该标记。每个维度都包含该单词的一些信息，因此如果我们假设特征是 Wealth、Gender、Cuddly，则模型在训练嵌入层之后，将使用以下 3 维向量表示例如单词 king：(0.98, 1, 0.01)和 cat (0.02, 0.5, 1)。然后我们可以使用这些向量来计算单词之间的相似度（使用余弦距离）并做许多其他事情。
注意：实际上，我们无法得出这些特征名称的真正含义，但以这种方式思考它们有助于获得更清晰的画面。
所以 word_embeddings 在这种情况下是一个形状矩阵 (30522, 768)，其中第一个维度是词汇维度，而第二个维度是嵌入维度，即我们用来表示一个单词的特征的数量。对于 base-bert，它是 768，对于更大的型号，它会增加。一般来说，嵌入维度越高，我们可以更好地表示某些单词——这在一定程度上是正确的，在某些时候增加维度不会大大提高模型的准确性，而计算复杂度却可以。

model.embeddings.word_embeddings.weight.shape
output: torch.Size([30522, 768])

需要 position_embeddings 是因为，与 LSTM 模型不同，例如 LSTM 模型顺序处理令牌，因此通过构造具有每个令牌的顺序信息，Bert 模型并行处理令牌并合并每个令牌的位置信息，我们需要从 position_embeddings 矩阵添加此信息 . 它的形状是 (256, 768)，其中前者表示最大句子长度，而后者是词嵌入的特征维度——因此根据每个标记的位置，我们检索相关向量。在这种情况下，我们可以看到这个矩阵是学习的，但还有其他实现是使用正弦和余弦构建的。

model.embeddings.position_embeddings.weight.shapeoutput: torch.Size([256, 768])

token_type_embeddings 在这里是“冗余的”，来自 Bert 训练任务，其中评估了两个句子之间的语义相似性——需要这种嵌入来区分第一句和第二句。我们不需要它，因为我们只有一个用于分类任务的输入句子。
一旦我们为句子中的每个单词提取单词嵌入、位置嵌入和类型嵌入，我们只需将它们相加即可得到完整的句子嵌入。所以对于第一句话，它将是：

f1 = torch.index_select(model.embeddings.word_embeddings.weight, 0, inputs_tests['input_ids'][0])  # words embeddings
  + torch.index_select(model.embeddings.position_embeddings.weight, 0, torch.tensor(range(inputs_tests['input_ids'][0].size(0))).long()) \ # pos embeddings
 + torch.index_select(model.embeddings.token_type_embeddings.weight, 0, inputs_tests['token_type_ids'][0]) # token embeddings

对于我们的 3 个句子的 mini-batch，我们可以通过以下方式获取它们：

n_batch = 3
shape_embs = (inputs_tests['input_ids'].shape) + (model.embeddings.word_embeddings.weight.shape[1], )
w_embs_batch = torch.index_select(model.embeddings.word_embeddings.weight, 0, inputs_tests['input_ids'].reshape(1,-1).squeeze(0)).reshape(shape_embs)
pos_embs_batch = torch.index_select(model.embeddings.position_embeddings.weight, 0, 
                                    torch.tensor(range(inputs_tests['input_ids'][1].size(0))).repeat(1, n_batch).squeeze(0)).reshape(shape_embs)
type_embs_batch = torch.index_select(model.embeddings.token_type_embeddings.weight, 0, 
                                     inputs_tests['token_type_ids'].reshape(1,-1).squeeze(0)).reshape(shape_embs)
batch_all_embs = w_embs_batch + pos_embs_batch + type_embs_batch
batch_all_embs.shape # (batch_size, n_words, embedding dim)

接下来我们有一个 LayerNorm 步骤，它可以帮助模型更快地训练和更好地泛化。我们通过令牌的均值嵌入和标准差对每个令牌的嵌入进行标准化，使其具有零均值和单位方差。然后，我们应用经过训练的权重和偏差向量，以便可以将其转换为具有不同的均值和方差，以便训练期间的模型可以自动适应。因为我们独立于其他示例计算不同示例的均值和标准差，所以它与批量归一化不同，后者的归一化是跨批次维度的，因此取决于批次中的其他示例。

# single example normalization
ex1 = f1[0, :]
ex1_mean = ex1.mean()
ex1_std = (ex1 - ex1_mean).pow(2).mean()
norm_example = ((ex1- ex1_mean)/torch.sqrt(ex1_std + 1e-12))
norm_example_centered = model.embeddings.LayerNorm.weight * norm_example + model.embeddings.LayerNorm.bias


def layer_norm(x, w, b):
    mean_x = x.mean(-1, keepdim=True)
    std_x = (x - mean_x).pow(2).mean(-1, keepdim=True)
    x_std = (x - mean_x) / torch.sqrt(std_x + 1e-12)
    shifted_x = w * x_std + b
    return shifted_x
  
# batch normalization
norm_embs = layer_norm(batch_all_embs, model.embeddings.LayerNorm.weight, model.embeddings.LayerNorm.bias

让我们最后应用 Dropout，我们用零替换一些具有一定 dropout 概率的值。 Dropout 有助于减少过度拟合，因为我们随机阻止来自某些神经元的信号，因此网络需要找到其他路径来减少损失函数，因此它学会了如何更好地泛化而不是依赖某些路径。我们还可以将 dropout 视为一种模型集成技术，因为在每一步的训练过程中，我们随机停用某些神经元，最终形成“不同”的网络，最终在评估期间集成这些神经元。
注意：因为我们将模型设置为评估模式，我们将忽略所有的 dropout 层，它们仅在训练期间使用。为了完整起见，我们仍将其包括在内。

norm_embs_dropout = model.embeddings.dropout(norm_embs)

我们可以检查我们是否获得了与模型相同的结果：

embs_model = model.embeddings(inputs_tests[‘input_ids’], inputs_tests[‘token_type_ids’])
torch.allclose(embs_model, norm_embs, atol=1e-06) # True

编码器
编码器是最神奇的地方。有 12 个 BertLayers，前一个的输出被馈送到下一个。这是使用注意力来创建与上下文相关的原始嵌入的不同表示的地方。在 BertLayer 中，我们首先尝试理解 BertAttention——在导出每个单词的嵌入之后，Bert 使用 3 个矩阵——Key、Query 和 Value，来计算注意力分数，并根据句子中的其他单词导出单词嵌入的新值；通过这种方式，Bert 是上下文感知的，每个单词的嵌入而不是固定的，上下文独立是基于句子中的其他单词推导出来的，并且在为某个单词推导新嵌入时其他单词的重要性由注意力分数表示。为了导出每个单词的查询和键向量，我们需要将其嵌入乘以经过训练的矩阵（查询和键是分开的）。例如，要导出第一句的第一个词的查询向量：

att_head_size = int(model.config.hidden_size/model.config.num_attention_heads)
n_att_heads = model.config.num_attention_heads
norm_embs[0][0, :] @ model.encoder.layer[0].attention.self.query.weight.T[:, :att_head_size] + \
                      model.encoder.layer[0].attention.self.query.bias[:att_head_size]

我们可以注意到，在整个查询和关键矩阵中，我们只选择了前 64 个 (=att_head_size) 列（原因将在稍后说明）——这是转换后单词的新嵌入维度，它小于原始嵌入维度 768。这样做是为了减少计算负担，但实际上更长的嵌入可能会带来更好的性能。实际上，这是降低复杂性和提高性能之间的权衡。
现在我们可以推导出整个句子的 Query 和 Key 矩阵：

Q_first_head = norm_embs[0] @ model.encoder.layer[0].attention.self.query.weight.T[:, :att_head_size] + \
               model.encoder.layer[0].attention.self.query.bias[:att_head_size] 
K_first_head = norm_embs[0] @ model.encoder.layer[0].attention.self.key.weight.T[:, :att_head_size] + \
               model.encoder.layer[0].attention.self.key.bias[:att_head_size]

为了计算注意力分数，我们将 Query 矩阵乘以 Key 矩阵，并将其标准化为新嵌入维度的平方根 (=64=att_head_size)。我们还添加了一个修改后的注意力掩码。初始注意掩码 (inputs[‘attention_mask’][0]) 是一个 1 和 0 的张量，其中 1 表示该位置有一个标记，0 表示它是一个填充标记。
如果我们从 1 中减去注意力掩码并将其乘以一个高负数，当我们应用 SoftMax 时，我们实际上将那些负值发送到零，然后根据其他值推导出概率。让我们看下面的例子：
如果我们有一个 3 个标记 + 2 个填充的句子，我们会得到以下注意力掩码：[0,0,0, -10000, -10000]
让我们应用 SoftMax 函数：

torch.nn.functional.softmax(torch.tensor([0,0,0, -10000, -10000]).float())# tensor([0.3333, 0.3333, 0.3333, 0.0000, 0.0000])mod_attention = (1.0 – inputs[‘attention_mask’][[0]]) * -10000.0attention_scores = torch.nn.Softmax(dim=-1)((Q_first_head @ K_first_head.T)/ math.sqrt(att_head_size) + mod_attention)

让我们检查一下我们得到的注意力分数是否与我们从模型中得到的相同。我们可以使用以下代码从模型中获取注意力分数：

as we defined output_attentions=True, output_hidden_states=True, return_dict=True we will get last_hidden_state, pooler_output, hidden_states for each layer and attentions for each layer
out_view = model(**inputs_tests)

out_view 包含：
last_hidden_state (batch_size, sequence_length, hidden_size) : 最后一个 BertLayer 输出的隐藏状态
pooler_output (batch_size, hidden_size) : Pooler 层的输出
hidden_states (batch_size, sequence_length, hidden_size)：模型在每个 BertLayer 输出的隐藏状态加上初始嵌入
注意（batch_size、num_heads、sequence_length、sequence_length）：每个 BertLayer 一个。注意力 SoftMax 后的注意力权重

torch.allclose(attention_scores, out_view[-1][0][‘attn’][0, 0, :, :], atol=1e-06)) # True
print(attention_scores[0, :])
tensor([1.0590e-04, 2.1429e-03, .... , 4.8982e-05], grad_fn=<SliceBackward>)

注意分数矩阵的第一行表示，要为第一个标记创建新嵌入，我们需要注意权重 = 1.0590e-04 的第一个标记（对自身），权重 = 2.1429e-03 的第二个标记等等。换句话说，如果我们将这些分数乘以其他标记的向量嵌入，我们会得出第一个标记的新表示，但是，我们将使用下面计算的值矩阵，而不是实际使用嵌入。
值矩阵的推导方式与查询和键矩阵相同：

V_first_head = norm_embs[0] @ model.encoder.layer[0].attention.self.value.weight.T[:, :att_head_size] + \
              model.encoder.layer[0].attention.self.value.bias[:att_head_size]

然后我们将这些值乘以注意力分数以获得新的上下文感知词表示

new_embed_1 = (attention_scores @ V_first_head)

现在您可能想知道，为什么我们要从张量中选择前 64 个 (=att_head_size) 元素。好吧，我们上面计算的是 Bert 注意力层的一个头，但实际上有 12 个。这些注意力头中的每一个都会创建不同的单词表示（new_embed_1 矩阵），例如，给定以下句子“ I like to eat pizza in the Italian restaurants ”，在第一个头中，“pizza”一词可能主要关注前一个单词，单词本身以及后面的单词和剩余单词的注意力将接近于零。在下一个头中，它可能会关注所有动词（like 和 eat），并以这种方式捕捉与第一个头不同的关系。
现在，我们可以以矩阵形式将它们一起推导，而不是单独推导每个头部：

Q = norm_embs @ model.encoder.layer[0].attention.self.query.weight.T + model.encoder.layer[0].attention.self.query.bias
K = norm_embs @ model.encoder.layer[0].attention.self.key.weight.T + model.encoder.layer[0].attention.self.key.bias
V = norm_embs @ model.encoder.layer[0].attention.self.value.weight.T + model.encoder.layer[0].attention.self.value.bias
new_x_shape = Q.size()[:-1] + (n_att_heads, att_head_size)
new_x_shape # torch.Size([3, 55, 12, 64])
Q_reshaped = Q.view(*new_x_shape)
K_reshaped = K.view(*new_x_shape)
V_reshaped = V.view(*new_x_shape)
att_scores = (Q_reshaped.permute(0, 2, 1, 3) @ K_reshaped.permute(0, 2, 1, 3).transpose(-1, -2))
att_scores = (att_scores/ math.sqrt(att_head_size)) + extended_attention_mask
attention_probs = torch.nn.Softmax(dim=-1)(att_scores)

第一个例子和第一个 head 的注意力和我们之前推导出的一样：

example = 0
head = 0
torch.allclose(attention_scores, attention_probs[example][head]) # True

我们现在将 12 个头的结果连接起来，并将它们传递给我们已经在嵌入部分中看到的一堆线性层、归一化层和 dropout，以获得第一层的编码器结果。

att_heads = []
for i in range(12):
  att_heads.append(attention_probs[0][i] @ V_reshaped[0, : , i, :])
output_dense = torch.cat(att_heads, 1) @ model.encoder.layer[0].attention.output.dense.weight.T + \
               model.encoder.layer[0].attention.output.dense.bias
output_layernorm = layer_norm(output_dense + norm_embs[0], 
                              model.encoder.layer[0].attention.output.LayerNorm.weight, 
                              model.encoder.layer[0].attention.output.LayerNorm.bias)
interm_dense = torch.nn.functional.gelu(output_layernorm @ model.encoder.layer[0].intermediate.dense.weight.T + \
                                        model.encoder.layer[0].intermediate.dense.bias)
out_dense = interm_dense @ model.encoder.layer[0].output.dense.weight.T + model.encoder.layer[0].output.dense.bias
out_layernorm  = layer_norm(out_dense + output_layernorm, 
                            model.encoder.layer[0].output.LayerNorm.weight, 
                            model.encoder.layer[0].output.LayerNorm.bias)

output_dense 我们只是通过线性层传递连接的注意力结果。然后我们需要进行归一化，但我们可以看到，我们不是立即对 output_dense 进行归一化，而是首先将其与我们的初始嵌入相加——这称为残差连接。当我们增加神经网络的深度时，即堆叠越来越多的层时，我们会遇到梯度消失/爆炸的问题，当梯度消失的情况下，模型无法再学习，因为传播的梯度接近于零初始层停止改变权重并改进。当权重因极端更新而最终爆炸（趋于无穷大）而无法稳定时，梯度爆炸的相反问题。现在，正确初始化权重和归一化有助于解决这个问题，但观察到的是，即使网络变得更加稳定，性能也会随着优化的困难而下降。添加这些残差连接有助于提高性能，即使我们不断增加深度，网络也变得更容易优化。 out_layernorm 中也使用了残差连接，它实际上是第一个 BertLayer 的输出。最后要注意的是，当我们计算 interterm_dense 时，在将 AttentionLayer 的输出传递到线性层之后，会应用非线性 GeLU 激活函数。 GeLU 表示为：

查看图表我们可以看到，如果由公式 max(input, 0) 给出的 ReLU 在正域中是单调的、凸的和线性的，那么 GeLU 在正域中是非单调的、非凸的和非线性的正域，因此可以逼近更容易复杂的函数。

我们现在已经成功地复制了整个 BertLayer。该层的输出（与初始嵌入的形状相同）进入下一个 BertLayer，依此类推。总共有 12 个 BertLayers。因此，将所有这些放在一起，我们可以从编码器中获得所有 3 个示例的最终结果：

n_batch = 3
tot_n_layers = 12
tot_n_heads = 12
shape_embs = (inputs_tests['input_ids'].shape) + (model.embeddings.word_embeddings.weight.shape[1], )
w_embs_batch = torch.index_select(model.embeddings.word_embeddings.weight, 
                                  0, inputs_tests['input_ids'].reshape(1,-1).squeeze(0)).reshape(shape_embs)
pos_embs_batch = torch.index_select(model.embeddings.position_embeddings.weight, 0, 
                                    torch.tensor(range(inputs_tests['input_ids'][1].size(0))).repeat(1, n_batch).squeeze(0)).reshape(shape_embs)
type_embs_batch = torch.index_select(model.embeddings.token_type_embeddings.weight, 0, 
                                     inputs_tests['token_type_ids'].reshape(1,-1).squeeze(0)).reshape(shape_embs)
batch_all_embs = w_embs_batch + pos_embs_batch + type_embs_batch
normalized_embs = layer_norm(batch_all_embs, model.embeddings.LayerNorm.weight, model.embeddings.LayerNorm.bias)
extended_attention_mask = inputs['attention_mask'].unsqueeze(1).unsqueeze(2)
extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0
for layer_n in range(tot_n_layers):
 if layer_n == 0:
   # compute Q, K and V matrices
   Q = normalized_embs @ model.encoder.layer[layer_n].attention.self.query.weight.T + \ 
                         model.encoder.layer[layer_n].attention.self.query.bias
   K = normalized_embs @ model.encoder.layer[layer_n].attention.self.key.weight.T + \
                         model.encoder.layer[layer_n].attention.self.key.bias
   V = normalized_embs @ model.encoder.layer[layer_n].attention.self.value.weight.T + \
                         model.encoder.layer[layer_n].attention.self.value.bias
   # reshape
   new_x_shape = Q.size()[:-1] + (n_att_heads, att_head_size)
   Q_reshaped = Q.view(*new_x_shape)
   K_reshaped = K.view(*new_x_shape)
   V_reshaped = V.view(*new_x_shape)
   # compute attention probabilities
   att_scores = (Q_reshaped.permute(0, 2, 1, 3) @ K_reshaped.permute(0, 2, 1, 3).transpose(-1, -2))
   att_scores = (att_scores/ math.sqrt(att_head_size)) + extended_attention_mask
   attention_probs = torch.nn.Softmax(dim=-1)(att_scores)
   # concatenate attention heads
   att_heads = []
   for i in range(tot_n_heads):
    att_heads.append(attention_probs[:, i] @ V_reshaped[:, : , i, :])

   output_dense = torch.cat(att_heads, 2) @ model.encoder.layer[layer_n].attention.output.dense.weight.T + \
                                            model.encoder.layer[layer_n].attention.output.dense.bias
   # normalization + residual connection
   output_layernorm = layer_norm(output_dense + normalized_embs, 
                                 model.encoder.layer[layer_n].attention.output.LayerNorm.weight,
                                 model.encoder.layer[layer_n].attention.output.LayerNorm.bias)
   # linear layer + non linear gelu activation
   interm_dense = torch.nn.functional.gelu(output_layernorm @ model.encoder.layer[layer_n].intermediate.dense.weight.T + \
                                           model.encoder.layer[layer_n].intermediate.dense.bias)
   # linear layer
   out_dense = interm_dense @ model.encoder.layer[layer_n].output.dense.weight.T + model.encoder.layer[layer_n].output.dense.bias
   # normalization + residual connection
   out_layernorm = layer_norm(out_dense + output_layernorm, 
                              model.encoder.layer[layer_n].output.LayerNorm.weight, 
                              model.encoder.layer[layer_n].output.LayerNorm.bias)
 else:
   # compute Q, K and V matrices
   Q = out_layernorm @ model.encoder.layer[layer_n].attention.self.query.weight.T + \
                              model.encoder.layer[layer_n].attention.self.query.bias
   K = out_layernorm @ model.encoder.layer[layer_n].attention.self.key.weight.T + \
                              model.encoder.layer[layer_n].attention.self.key.bias
   V = out_layernorm @ model.encoder.layer[layer_n].attention.self.value.weight.T + \
                              model.encoder.layer[layer_n].attention.self.value.bias
   # reshape
   Q_reshaped = Q.view(*new_x_shape)
   K_reshaped = K.view(*new_x_shape)
   V_reshaped = V.view(*new_x_shape)
   # compute attention probabilities
   att_scores = (Q_reshaped.permute(0, 2, 1, 3) @ K_reshaped.permute(0, 2, 1, 3).transpose(-1, -2))
   att_scores = (att_scores/ math.sqrt(att_head_size)) + extended_attention_mask
   attention_probs = torch.nn.Softmax(dim=-1)(att_scores)
   # concatenate attention heads
   att_heads = []
   for i in range(tot_n_heads):
    att_heads.append(attention_probs[:, i] @ V_reshaped[:, : , i, :])

   output_dense = torch.cat(att_heads, 2) @ model.encoder.layer[layer_n].attention.output.dense.weight.T + \
                                            model.encoder.layer[layer_n].attention.output.dense.bias
   # normalization + residual connection
   output_layernorm = layer_norm(output_dense + out_layernorm, 
                                 model.encoder.layer[layer_n].attention.output.LayerNorm.weight, 
                                 model.encoder.layer[layer_n].attention.output.LayerNorm.bias)

   # linear layer + non linear gelu activation
   interm_dense = torch.nn.functional.gelu(output_layernorm @ model.encoder.layer[layer_n].intermediate.dense.weight.T + \
                                                              model.encoder.layer[layer_n].intermediate.dense.bias)
   # linear layer
   out_dense = interm_dense @ model.encoder.layer[layer_n].output.dense.weight.T + model.encoder.layer[layer_n].output.dense.bias
   # normalization + residual connection
   out_layernorm = layer_norm(out_dense + output_layernorm, 
                              model.encoder.layer[layer_n].output.LayerNorm.weight, 
                              model.encoder.layer[layer_n].output.LayerNorm.bias)

注意 out_layernorm – 每层的输出如何被馈送到下一层。
我们可以看到这与 out_view 中的结果相同


 torch.allclose(out_view[-2][-1], out_layernorm, atol=1e-05) # True

Pooler
现在我们可以获取最后一个 BertLayer 的第一个令牌输出，即 [CLS]，将其通过一个线性层并应用一个 Tanh 激活函数来获得池化输出。使用第一个标记进行分类的原因来自于模型是如何被训练为 Bert state 的作者的：
每个序列的第一个标记始终是一个特殊的分类标记 ([CLS])。与该标记对应的最终隐藏状态用作分类任务的聚合序列表示。


 out_pooler = torch.nn.functional.tanh(out_layernorm[:, 0] @ model.pooler.dense.weight.T + model.pooler.dense.bias)

分类器
最后，我们创建一个简单的类，它将是一个简单的线性层，但您可以向它添加一个 dropout 和其他东西。我们在这里假设一个二元分类问题（output_dim=2），但它可以是任何维度的。

from torch import nn
class Classifier(nn.Module):
    
    def __init__(self, output_dim=2):
        super(Classifier, self).__init__()
        self.classifier = nn.Linear(model.config.hidden_size, output_dim, bias=True)
    
    def forward(self, x):
        return self.classifier(x)
classif = Classifier()
classif(out_pooler)
tensor([[-0.2918, -0.5782],
        [ 0.2494, -0.1955],
        [ 0.1814,  0.3971]], grad_fn=<AddmmBackward>)

引用：

 
https://arxiv.org/pdf/1606.08415v3.pdf
https://arxiv.org/pdf/1810.04805.pdf
https://jalammar.github.io/illustrated-transformer/
https://github.com/huggingface/transformers/

作者 east

标签归档bert