BERT(李沐)
从上下文无关到上下文敏感
例如，word2vec和GloVe都将相同的预训练向量分配给同⼀个词，而不考虑词的上下文（如果有的话）。形式上，任何词元\(x\)的上下文无关表示是函数\(f(x)\)，其仅将\(x\)作为其输入。考虑到自然语言中丰富的多义现象和复杂的语义，上下文无关表示具有明显的局限性。例如，在"a crane is flying"（⼀只鹤在飞）和"a crane driver came"（⼀名吊车司机来了）的上下文中，"crane"⼀词有完全不同的含义；因此，同⼀个词可以根据上下文被赋予不同的表示。
这推动了"上下文敏感“词表示的发展，其中词的表征取决于它们的上下文。因此，词元x的上下文敏感表示是函数\(f(x, c(x))\)，其取决于\(x\)及其上下文\(c(x)\)。流行的上下文敏感表示包括TagLM（language-model-augmented
sequence tagger，语言模型增强的序列标记器）(Peters et al., 2017)、CoVe（Context Vectors，上下文向量）(McCann et al., 2017)和ELMo（Embeddings from Language Models，来自语言模型的嵌入）(Peters et al.,2018)。
例如，通过将整个序列作为输入，ELMo是为输入序列中的每个单词分配⼀个表示的函数。具体来说，ELMo将来自预训练的双向长短期记忆网络的所有中间层表示组合为输出表示。然后，ELMo的表示将作为附加特征添加到下游任务的现有监督模型中，例如通过将ELMo的表示和现有模型中词元的原始表示（例如GloVe）连
结起来。一方面，在加入ELMo表示后，冻结了预训练的双向LSTM模型中的所有权重。另一方面，现有的监督模型是专门为给定的任务定制的。利用当时不同任务的不同最佳模型，添加ELMo改进了六种自然语言处理任务的技术水平：情感分析、⾃然语⾔推断、语义⻆⾊标注、共指消解、命名实体识别和问答。
从特定于任务到不可知任务
尽管ELMo显著改进了各种⾃然语⾔处理任务的解决⽅案，但每个解决⽅案仍然依赖于⼀个特定于任务的架构。然⽽，为每⼀个⾃然语⾔处理任务设计⼀个特定的架构实际上并不是⼀件容易的事。GPT（GenerativePre Training，⽣成式预训练）模型为上下⽂的敏感表⽰设计了通⽤的任务⽆关模型 (Radford et al., 2018)。GPT建⽴在Transformer解码器的基础上，预训练了⼀个⽤于表⽰⽂本序列的语⾔模型。当将GPT应⽤于下游任务时，语⾔模型的输出将被送到⼀个附加的线性输出层，以预测任务的标签。与ELMo冻结预训练模型的参数不同，GPT在下游任务的监督学习过程中对预训练Transformer解码器中的所有参数进⾏微调。GPT在⾃然语⾔推断、问答、句⼦相似性和分类等12项任务上进⾏了评估，并在对模型架构进⾏最⼩更改的情况下改善了其中9项任务的最新⽔平。然⽽，由于语⾔模型的⾃回归特性，GPT只能向前看（从左到右）。在“i went to the bank to deposit cash”（我去银⾏存现⾦）和“i went to the bank to sit down”（我去河岸边坐下）的上下⽂中，由于“bank”对其左边的上下⽂敏感，GPT将返回“bank”的相同表⽰，尽管它有不同的含义。
BERT：把两个最好的结合起来
如我们所见，ELMo对上下⽂进⾏双向编码，但使⽤特定于任务的架构；⽽GPT是任务⽆关的，但是从左到右编码上下⽂。BERT（来⾃Transformers的双向编码器表⽰）结合了这两个⽅⾯的优点。它对上下⽂进⾏双向编码，并且对于⼤多数的⾃然语⾔处理任务 (Devlin et al., 2018)只需要最少的架构改变。通过使⽤预训练的Transformer编码器，BERT能够基于其双向上下文表示任何词元。在下游任务的监督学习过程中，BERT在两个⽅⾯与GPT相似。首先，BERT表⽰将被输⼊到⼀个添加的输出层中，根据任务的性质对模型架构进行最小的更改，例如预测每个词元与预测整个序列。其次，对预训练Transformer编码器的所有参数进行微调，而额外的输出层将从头开始训练。图14.8.1 描述了ELMo、GPT和BERT之间的差异。
BERT进⼀步改进了11种⾃然语⾔处理任务的技术⽔平，这些任务分为以下⼏个⼤类：（1）单⼀⽂本分类（如情感分析）、（2）⽂本对分类（如⾃然语⾔推断）、（3）问答、（4）⽂本标记（如命名实体识别）。从上下文敏感的ELMo到任务不可知的GPT和BERT，它们都是在2018年提出的。概念上简单但经验上强⼤的⾃然语⾔深度表⽰预训练已经彻底改变了各种⾃然语⾔处理任务的解决⽅案。
在本章的其余部分，我们将深⼊了解BERT的训练前准备。当在 15节中解释⾃然语⾔处理应⽤时，我们将说明针对下游应⽤的BERT微调。
import torch
from torch import nn
from d2l import torch as d2l
输入表示
在⾃然语⾔处理中，有些任务（如情感分析）以单个文本作为输入，而有些任务（如⾃然语⾔推断）以⼀对文本序列作为输入。BERT输入序列明确地表示单个⽂本和文本对。当输入为单个文本时，BERT输入序列是特殊类别词元<cls>、⽂本序列的标记、以及特殊分隔词元<sep>的连结。当输⼊为文本对时，BERT输
⼊序列是<cls>、第⼀个⽂本序列的标记、<sep>、第⼆个文本序列标记、以及<sep>的连结。我们将始终如⼀地将术语“BERT输⼊序列”与其他类型的“序列”区分开来。例如，⼀个BERT输入序列可以包括⼀个文本序列或两个文本序列。
为了区分文本对，根据输入序列学到的片段嵌入\(e_A\)和\(e_B\)分别被添加到第⼀序列和第二序列的词元嵌入中。对于单文本输入，仅使用\(e_A\)。下面的get_tokens_and_segments将⼀个句子或两个句子作为输入，然后返回BERT输入序列的标记及其相应的片段索引。
def get_tokens_and_segments(tokens_a, tokens_b=None):
"""Get tokens of the BERT input sequence and their segment IDs."""
tokens = ['<cls>'] + tokens_a + ['<sep>']
# 0和1分别标记⽚段A和B
segments = [0] * (len(tokens_a) + 2)
if tokens_b is not None:
tokens += tokens_b + ['<sep>']
segments += [1] * (len(tokens_b) + 1)
return tokens, segments
BERT选择Transformer编码器作为其双向架构。在Transformer编码器中常见是，位置嵌入被加入到输入序列的每个位置。然而，与原始的Transformer编码器不同，BERT使用可学习的位置嵌入。总之，下图表明BERT输入序列的嵌入是词元嵌入、片段嵌入和位置嵌入的和。
下⾯的BERTEncoder类类似于实现的TransformerEncoder类。与TransformerEncoder不同，BERTEncoder使用片段嵌⼊和可学习的位置嵌⼊。
class BERTEncoder(nn.Module):
"""BERT encoder."""
def __init__(self, vocab_size, num_hiddens, norm_shape, ffn_num_input,
ffn_num_hiddens, num_heads, num_layers, dropout,
max_len=1000, key_size=768, query_size=768, value_size=768,
**kwargs):
super(BERTEncoder, self).__init__(**kwargs)
self.token_embedding = nn.Embedding(vocab_size, num_hiddens)
self.segment_embedding = nn.Embedding(2, num_hiddens)
self.blks = nn.Sequential()
for i in range(num_layers):
self.blks.add_module(f"{i}", d2l.EncoderBlock(
key_size, query_size, value_size, num_hiddens, norm_shape,
ffn_num_input, ffn_num_hiddens, num_heads, dropout, True))
# 在BERT中，位置嵌⼊是可学习的，因此我们创建⼀个⾜够⻓的位置嵌⼊参数
self.pos_embedding = nn.Parameter(torch.randn(1, max_len,
num_hiddens))
def forward(self, tokens, segments, valid_lens):
# 在以下代码段中，X的形状保持不变：（批量⼤⼩，最⼤序列⻓度，num_hiddens）
X = self.token_embedding(tokens) + self.segment_embedding(segments)
X = X + self.pos_embedding.data[:, :X.shape[1], :]
for blk in self.blks:
X = blk(X, valid_lens)
return X
假设词表大小为10000，为了演⽰BERTEncoder的前向推断，让我们创建⼀个实例并初始化它的参数。
vocab_size, num_hiddens, ffn_num_hiddens, num_heads = 10000, 768, 1024, 4
norm_shape, ffn_num_input, num_layers, dropout = [768], 768, 2, 0.2
encoder = BERTEncoder(vocab_size, num_hiddens, norm_shape, ffn_num_input,ffn_num_hiddens, num_heads, num_layers, dropout)
我们将tokens定义为长度为8的2个输入序列，其中每个词元是词表的索引。使⽤输入tokens的BERTEncoder的前向推断返回编码结果，其中每个词元由向量表示，其长度由超参数num_hiddens定义。此超参数通常称为Transformer编码器的隐藏大小（隐藏单元数）。
tokens = torch.randint(0, vocab_size, (2, 8))
segments = torch.tensor([[0, 0, 0, 0, 1, 1, 1, 1], [0, 0, 0, 1, 1, 1, 1, 1]])
encoded_X = encoder(tokens, segments, None)
encoded_X.shape
# torch.Size([2, 8, 768])
预训练任务
掩蔽语言模型（Masked Language Modeling）
语言模型使用左侧的上下文预测词元。为了双向编码上下文以表示每个词元，BERT随机掩蔽词元并使用来自双向上下文的词元以自监督的方式预测掩蔽词元。此任务称为掩蔽语言模型。
在这个预训练任务中，将随机选择15%的词元作为预测的掩蔽词元。要预测一个掩蔽词元而不使用标签作弊，一个简单的方法是总是用一个特殊的<mask>替换输入序列中的词元。然而，人造特殊词元<mask>不会出现在微调中。为了避免预训练和微调之间的这种不匹配，如果为预测而屏蔽词元（例如，在“this movie is great”中选择掩蔽和预测“great”），则在输入中将其替换为：
-
80%时间为特殊的
<mask>词元（例如，“this movie is great”变为“this movie is<mask>； -
10%时间为随机词元（例如，“this movie is great”变为“this movie is drink”）；
-
10%时间内为不变的标签词元（例如，“this movie is great”变为“this movie is great”）。
请注意，在15%的时间中，有10%的时间插入了随机词元。这种偶然的噪声鼓励BERT在其双向上下文编码中不那么偏向于掩蔽词元（尤其是当标签词元保持不变时）。
我们实现了下面的MaskLM类来预测BERT预训练的掩蔽语言模型任务中的掩蔽标记。预测使用单隐藏层的多层感知机（self.mlp）。在前向推断中，它需要两个输入：BERTEncoder的编码结果和用于预测的词元位置。输出是这些位置的预测结果。
#@save
class MaskLM(nn.Module):
"""BERT的掩蔽语言模型任务"""
def __init__(self, vocab_size, num_hiddens, num_inputs=768, **kwargs):
super(MaskLM, self).__init__(**kwargs)
self.mlp = nn.Sequential(nn.Linear(num_inputs, num_hiddens),
nn.ReLU(),
nn.LayerNorm(num_hiddens),
nn.Linear(num_hiddens, vocab_size))
def forward(self, X, pred_positions):
num_pred_positions = pred_positions.shape[1]
pred_positions = pred_positions.reshape(-1)
batch_size = X.shape[0]
batch_idx = torch.arange(0, batch_size)
# 假设batch_size=2，num_pred_positions=3
# 那么batch_idx是np.array（[0,0,0,1,1,1]）
batch_idx = torch.repeat_interleave(batch_idx, num_pred_positions)
masked_X = X[batch_idx, pred_positions]
masked_X = masked_X.reshape((batch_size, num_pred_positions, -1))
mlm_Y_hat = self.mlp(masked_X)
return mlm_Y_hat
为了演示MaskLM的前向推断，我们创建了其实例mlm并对其进行了初始化。回想一下，来自BERTEncoder的正向推断encoded_X表示2个BERT输入序列。我们将mlm_positions定义为在encoded_X的任一输入序列中预测的3个指示。mlm的前向推断返回encoded_X的所有掩蔽位置mlm_positions处的预测结果mlm_Y_hat。对于每个预测，结果的大小等于词表的大小。
mlm = MaskLM(vocab_size, num_hiddens)
mlm_positions = torch.tensor([[1, 5, 2], [6, 1, 5]])
mlm_Y_hat = mlm(encoded_X, mlm_positions)
mlm_Y_hat.shape
# torch.Size([2, 3, 10000])
通过掩码下的预测词元mlm_Y的真实标签mlm_Y_hat，我们可以计算在BERT预训练中的遮蔽语言模型任务的交叉熵损失。
mlm_Y = torch.tensor([[7, 8, 9], [10, 20, 30]])
loss = nn.CrossEntropyLoss(reduction='none')
mlm_l = loss(mlm_Y_hat.reshape((-1, vocab_size)), mlm_Y.reshape(-1))
mlm_l.shape
# torch.Size([6])
下一句预测（Next Sentence Prediction）
尽管掩蔽语言建模能够编码双向上下文来表示单词，但它不能显式地建模文本对之间的逻辑关系。为了帮助理解两个文本序列之间的关系，BERT在预训练中考虑了一个二元分类任务——下一句预测。在为预训练生成句子对时，有一半的时间它们确实是标签为“真”的连续句子；在另一半的时间里，第二个句子是从语料库中随机抽取的，标记为“假”。
下面的NextSentencePred类使用单隐藏层的多层感知机来预测第二个句子是否是BERT输入序列中第一个句子的下一个句子。由于Transformer编码器中的自注意力，特殊词元<cls>的BERT表示已经对输入的两个句子进行了编码。因此，多层感知机分类器的输出层（self.output）以X作为输入，其中X是多层感知机隐藏层的输出，而MLP隐藏层的输入是编码后的<cls>词元。
#@save
class NextSentencePred(nn.Module):
"""BERT的下一句预测任务"""
def __init__(self, num_inputs, **kwargs):
super(NextSentencePred, self).__init__(**kwargs)
self.output = nn.Linear(num_inputs, 2)
def forward(self, X):
# X的形状：(batchsize,num_hiddens)
return self.output(X)
encoded_X = torch.flatten(encoded_X, start_dim=1)
# NSP的输入形状:(batchsize，num_hiddens)
nsp = NextSentencePred(encoded_X.shape[-1])
nsp_Y_hat = nsp(encoded_X)
nsp_Y_hat.shape
# torch.Size([2, 2])
整合代码
在预训练BERT时，最终的损失函数是掩蔽语言模型损失函数和下一句预测损失函数的线性组合。现在我们可以通过实例化三个类BERTEncoder、MaskLM和NextSentencePred来定义BERTModel类。前向推断返回编码后的BERT表示encoded_X、掩蔽语言模型预测mlm_Y_hat和下一句预测nsp_Y_hat。
#@save
class BERTModel(nn.Module):
"""BERT模型"""
def __init__(self, vocab_size, num_hiddens, norm_shape, ffn_num_input,
ffn_num_hiddens, num_heads, num_layers, dropout,
max_len=1000, key_size=768, query_size=768, value_size=768,
hid_in_features=768, mlm_in_features=768,
nsp_in_features=768):
super(BERTModel, self).__init__()
self.encoder = BERTEncoder(vocab_size, num_hiddens, norm_shape,
ffn_num_input, ffn_num_hiddens, num_heads, num_layers,
dropout, max_len=max_len, key_size=key_size,
query_size=query_size, value_size=value_size)
self.hidden = nn.Sequential(nn.Linear(hid_in_features, num_hiddens),
nn.Tanh())
self.mlm = MaskLM(vocab_size, num_hiddens, mlm_in_features)
self.nsp = NextSentencePred(nsp_in_features)
def forward(self, tokens, segments, valid_lens=None,
pred_positions=None):
encoded_X = self.encoder(tokens, segments, valid_lens)
if pred_positions is not None:
mlm_Y_hat = self.mlm(encoded_X, pred_positions)
else:
mlm_Y_hat = None
# 用于下一句预测的多层感知机分类器的隐藏层，0是“<cls>”标记的索引
nsp_Y_hat = self.nsp(self.hidden(encoded_X[:, 0, :]))
return encoded_X, mlm_Y_hat, nsp_Y_hat
• word2vec和GloVe等词嵌⼊模型与上下⽂⽆关。它们将相同的预训练向量赋给同⼀个词，⽽不考虑词的
上下⽂（如果有的话）。它们很难处理好⾃然语⾔中的⼀词多义或复杂语义。
• 对于上下⽂敏感的词表⽰，如ELMo和GPT，词的表⽰依赖于它们的上下⽂。
• ELMo对上下⽂进⾏双向编码，但使⽤特定于任务的架构（然⽽，为每个⾃然语⾔处理任务设计⼀个特
定的体系架构实际上并不容易）；⽽GPT是任务⽆关的，但是从左到右编码上下⽂。
• BERT结合了这两个⽅⾯的优点：它对上下⽂进⾏双向编码，并且需要对⼤量⾃然语⾔处理任务进⾏最
⼩的架构更改。
• BERT输⼊序列的嵌⼊是词元嵌⼊、⽚段嵌⼊和位置嵌⼊的和。
• 预训练包括两个任务：掩蔽语⾔模型和下⼀句预测。前者能够编码双向上下⽂来表⽰单词，⽽后者则显式地建模⽂本对之间的逻辑关系。
用于预训练BERT的数据集
为了预训练实现的BERT模型，我们需要以理想的格式生成数据集，以便于两个预训练任务：遮蔽语言模型和下⼀句预测。一方面，最初的BERT模型是在两个庞⼤的图书语料库和英语维基百科的合集上预训练的，但它很难吸引这本书的⼤多数读者。另一方面，现成的预训练BERT模型可能不适合医学等特定领域的应用。因此，在定制的数据集上对BERT进⾏预训练变得越来越流行。为了方便BERT预训练的演示，我们使用了较小的语料库WikiText-2。与预训练word2vec的PTB数据集相⽐，WikiText-2（1）保留了原来的标点符号，适合于下⼀句预测；（2）保留了原来的⼤⼩写和数字；（3）⼤了⼀倍以上。
import os
import random
import torch
from d2l import torch as d2l
在WikiText-2数据集中，每⾏代表⼀个段落，其中在任意标点符号及其前⾯的词元之间插⼊空格。保留⾄少有两句话的段落。为了简单起⻅，我们仅使⽤句号作为分隔符来拆分句⼦。我们将更复杂的句⼦拆分技术的讨论留在本节末尾的练习中。
d2l.DATA_HUB['wikitext-2'] = (
'https://s3.amazonaws.com/research.metamind.io/wikitext/'
'wikitext-2-v1.zip', '3c914d17d80b1459be871a5039ac23e752a53cbe')
def _read_wiki(data_dir):
file_name = os.path.join(data_dir, 'wiki.train.tokens')
with open(file_name,'r',encoding='utf-8') as f:
lines = f.readlines()
# ⼤写字⺟转换为⼩写字⺟
paragraphs = [line.strip().lower().split(' . ')
for line in lines if len(line.split(' . ')) >= 2]
random.shuffle(paragraphs)
return paragraphs
为预训练任务定义辅助函数
在下⽂中，我们⾸先为BERT的两个预训练任务实现辅助函数。这些辅助函数将在稍后将原始⽂本语料库转换为理想格式的数据集时调⽤，以预训练BERT。
生成下一句预测任务的数据
_get_next_sentence函数⽣成⼆分类任务的训练样本。
def _get_next_sentence(sentence, next_sentence, paragraphs):
if random.random() < 0.5:
is_next = True
else:
# paragraphs是三重列表的嵌套
next_sentence = random.choice(random.choice(paragraphs))
is_next = False
return sentence, next_sentence, is_next
下⾯的函数通过调⽤_get_next_sentence函数从输⼊paragraph⽣成⽤于下⼀句预测的训练样本。这⾥paragraph是句⼦列表，其中每个句⼦都是词元列表。⾃变量max_len指定预训练期间的BERT输⼊序列的最⼤⻓度。
def _get_nsp_data_from_paragraph(paragraph, paragraphs, vocab, max_len):
nsp_data_from_paragraph = []
for i in range(len(paragraph) - 1):
tokens_a, tokens_b, is_next = _get_next_sentence(
paragraph[i], paragraph[i + 1], paragraphs)
# 考虑1个'<cls>'词元和2个'<sep>'词元
if len(tokens_a) + len(tokens_b) + 3 > max_len:
continue
tokens, segments = d2l.get_tokens_and_segments(tokens_a, tokens_b)
nsp_data_from_paragraph.append((tokens, segments, is_next))
return nsp_data_from_paragraph
⽣成遮蔽语⾔模型任务的数据
为了从BERT输⼊序列⽣成遮蔽语⾔模型的训练样本，我们定义了以下_replace_mlm_tokens函数。在其输⼊中，tokens是表⽰BERT输⼊序列的词元的列表，candidate_pred_positions是不包括特殊词元的BERT输⼊序列的词元索引的列表（特殊词元在遮蔽语⾔模型任务中不被预测），以及num_mlm_preds指⽰预测的数量
（选择15%要预测的随机词元）。在 14.8.5节中定义遮蔽语⾔模型任务之后，在每个预测位置，输⼊可以由特殊的“掩码”词元或随机词元替换，或者保持不变。最后，该函数返回可能替换后的输⼊词元、发⽣预测的词元索引和这些预测的标签。
def _replace_mlm_tokens(tokens, candidate_pred_positions, num_mlm_preds,
vocab):
# 为遮蔽语⾔模型的输⼊创建新的词元副本，其中输⼊可能包含替换的“<mask>”或随机词元
mlm_input_tokens = [token for token in tokens]
pred_positions_and_labels = []
# 打乱后⽤于在遮蔽语⾔模型任务中获取15%的随机词元进⾏预测
random.shuffle(candidate_pred_positions)
for mlm_pred_position in candidate_pred_positions:
if len(pred_positions_and_labels) >= num_mlm_preds:
break
masked_token = None
if random.random() < 0.8:
# 80%的时间：将词替换为“<mask>”词元
masked_token = '<mask>'
else:
# 10%的时间：保持词不变
if random.random() < 0.5:
masked_token = tokens[mlm_pred_position]
else:
# 10%的时间：⽤随机词替换该词
masked_token = random.randint(0, len(vocab) - 1)
mlm_input_tokens[mlm_pred_position] = masked_token
pred_positions_and_labels.append(
(mlm_pred_position, tokens[mlm_pred_position]))
return mlm_input_tokens, pred_positions_and_labels
通过调⽤前述的_replace_mlm_tokens函数，以下函数将BERT输⼊序列（tokens）作为输⼊，并返回输⼊词元的索引（在 14.8.5节中描述的可能的词元替换之后）、发⽣预测的词元索引以及这些预测的标签索引。
将⽂本转换为预训练数据集
现 在 我 们 ⼏ 乎 准 备 好 为BERT预 训 练 定 制一个Dataset类。 在 此 之 前， 我 们 仍 然 需 要 定 义 辅 助 函
数_pad_bert_inputs来将特殊的<mask>词元附加到输⼊。它的参数examples包含来⾃两个预训练任务的辅助函数_get_nsp_data_from_paragraph和_get_mlm_data_from_tokens的输出。
def _pad_bert_inputs(examples, max_len, vocab):
max_num_mlm_preds = round(max_len * 0.15)
all_token_ids, all_segments, valid_lens, = [], [], []
all_pred_positions, all_mlm_weights, all_mlm_labels = [], [], []
nsp_labels = []
for (token_ids, pred_positions, mlm_pred_label_ids, segments,
is_next) in examples:
all_token_ids.append(torch.tensor(token_ids + [vocab['<pad>']] * (
max_len - len(token_ids)), dtype=torch.long))
all_segments.append(torch.tensor(segments + [0] * (
max_len - len(segments)), dtype=torch.long))
# valid_lens不包括'<pad>'的计数
valid_lens.append(torch.tensor(len(token_ids), dtype=torch.float32))
all_pred_positions.append(torch.tensor(pred_positions + [0] * (
max_num_mlm_preds - len(pred_positions)), dtype=torch.long))
# 填充词元的预测将通过乘以0权重在损失中过滤掉
all_mlm_weights.append(
torch.tensor([1.0] * len(mlm_pred_label_ids) + [0.0] * (
max_num_mlm_preds - len(pred_positions)),
dtype=torch.float32))
all_mlm_labels.append(torch.tensor(mlm_pred_label_ids + [0] * (
max_num_mlm_preds - len(mlm_pred_label_ids)), dtype=torch.long))
nsp_labels.append(torch.tensor(is_next, dtype=torch.long))
return (all_token_ids, all_segments, valid_lens, all_pred_positions,
all_mlm_weights, all_mlm_labels, nsp_labels)
将⽤于⽣成两个预训练任务的训练样本的辅助函数和⽤于填充输⼊的辅助函数放在⼀起，我们定义以下_WikiTextDataset类为⽤于预训练BERT的WikiText-2数据集。通过实现__getitem__函数，我们可以任意访问WikiText-2语料库的⼀对句⼦⽣成的预训练样本（遮蔽语⾔模型和下⼀句预测）样本。最初的BERT模型使⽤词表⼤⼩为30000的WordPiece嵌⼊ (Wu et al., 2016)。WordPiece的词元化⽅法是对14.6.2节中原有的字节对编码算法稍作修改。为简单起⻅，我们使⽤d2l.tokenize函数进⾏词元化。出现次数少于5次的不频繁词元将被过滤掉。
class _WikiTextDataset(torch.utils.data.Dataset):
def __init__(self, paragraphs, max_len):
# 输⼊paragraphs[i]是代表段落的句⼦字符串列表；
# ⽽输出paragraphs[i]是代表段落的句⼦列表，其中每个句⼦都是词元列表
paragraphs = [d2l.tokenize(
paragraph, token='word') for paragraph in paragraphs]
sentences = [sentence for paragraph in paragraphs
for sentence in paragraph]
self.vocab = d2l.Vocab(sentences, min_freq=5, reserved_tokens=[
'<pad>', '<mask>', '<cls>', '<sep>'])
# 获取下⼀句⼦预测任务的数据
examples = []
for paragraph in paragraphs:
examples.extend(_get_nsp_data_from_paragraph(
paragraph, paragraphs, self.vocab, max_len))
# 获取遮蔽语⾔模型任务的数据
examples = [(_get_mlm_data_from_tokens(tokens, self.vocab)
+ (segments, is_next))
for tokens, segments, is_next in examples]
# 填充输⼊
(self.all_token_ids, self.all_segments, self.valid_lens,
self.all_pred_positions, self.all_mlm_weights,
self.all_mlm_labels, self.nsp_labels) = _pad_bert_inputs(
examples, max_len, self.vocab)
def __getitem__(self, idx):
return (self.all_token_ids[idx], self.all_segments[idx],
self.valid_lens[idx], self.all_pred_positions[idx],
self.all_mlm_weights[idx], self.all_mlm_labels[idx],
self.nsp_labels[idx])
def __len__(self):
return len(self.all_token_ids)
通过使⽤_read_wiki函数和_WikiTextDataset类，我们定义了下⾯的load_data_wiki来下载并⽣成WikiText2数据集，并从中⽣成预训练样本。
def load_data_wiki(batch_size, max_len):
"""Load the WikiText-2 dataset."""
num_workers = d2l.get_dataloader_workers()
data_dir = d2l.download_extract('wikitext-2', 'wikitext-2')
paragraphs = _read_wiki(data_dir)
train_set = _WikiTextDataset(paragraphs, max_len)
train_iter = torch.utils.data.DataLoader(train_set, batch_size,
shuffle=True, num_workers=num_workers)
return train_iter, train_set.vocab
将批量⼤⼩设置为512，将BERT输⼊序列的最⼤⻓度设置为64，我们打印出⼩批量的BERT预训练样本的形状。注意，在每个BERT输⼊序列中，为遮蔽语⾔模型任务预测10（64 × 0.15）个位置。
batch_size, max_len = 512, 64
train_iter, vocab = load_data_wiki(batch_size, max_len)
for (tokens_X, segments_X, valid_lens_x, pred_positions_X, mlm_weights_X,
mlm_Y, nsp_y) in train_iter:
print(tokens_X.shape, segments_X.shape, valid_lens_x.shape,
pred_positions_X.shape, mlm_weights_X.shape, mlm_Y.shape,
nsp_y.shape)
break
torch.Size([512, 64]) torch.Size([512, 64]) torch.Size([512]) torch.Size([512, 10]) torch.Size([512, 10]) torch.Size([512, 10]) torch.Size([512])
len(vocab)
# 20256
• 与PTB数据集相⽐，WikiText-2数据集保留了原来的标点符号、⼤⼩写和数字，并且⽐PTB数据集⼤了
两倍多。
• 我们可以任意访问从WikiText-2语料库中的⼀对句⼦⽣成的预训练（遮蔽语⾔模型和下⼀句预测）样
本。
预训练BERT
利⽤BERT模型和WikiText-2数据集⽣成的预训练样本，我们将在本节中在WikiText-2数据集上对BERT进⾏预训练。
import torch
from torch import nn
from d2l import torch as d2l
⾸先，我们加载WikiText-2数据集作为⼩批量的预训练样本，⽤于遮蔽语⾔模型和下⼀句预测。批量⼤⼩是512，BERT输⼊序列的最⼤⻓度是64。注意，在原始BERT模型中，最⼤⻓度是512
batch_size, max_len = 512, 64
train_iter, vocab = d2l.load_data_wiki(batch_size, max_len)
浙公网安备 33010602011771号