从零开始训练BERT模型

我的许多文章都专注于 BERT——这个模型出现并主导了自然语言处理 (NLP) 的世界，标志着语言模型的新时代。

对于那些之前可能没有使用过 Transformer 模型（例如 BERT 是什么）的人，这个过程看起来有点像这样：

pip 安装Transformer
初始化一个预训练的 Transformer 模型 — from_pretrained。
在一些数据上测试它。
也许微调模型（再训练一些）。

现在，这是一个很好的方法，但如果我们只这样做，我们就会缺乏对创建我们自己的 Transformer 模型的理解。

而且，如果我们不能创建自己的 Transformer 模型——我们必须依赖于一个适合我们问题的预训练模型，但情况并非总是如此：

因此，在本文中，我们将探讨构建我们自己的 Transformer 模型必须采取的步骤——特别是 BERT 的进一步开发版本，称为 RoBERTa。

概述

这个过程有几个步骤，所以在我们深入研究之前，让我们先总结一下我们需要做什么。总的来说，有四个关键部分：

获取数据
构建分词器
创建输入管道
训练模型

一旦我们完成了这些部分中的每一个，我们将使用我们构建的标记器和模型 - 并将它们保存起来，以便我们可以像通常使用 from_pretrained 一样的方式使用它们。

获取数据

与任何机器学习项目一样，我们需要数据。在用于训练 Transformer 模型的数据方面，我们几乎可以使用任何文本数据。

而且，如果我们在互联网上有很多东西——那就是非结构化文本数据。

从互联网上抓取的文本领域中最大的数据集之一是 OSCAR 数据集。

OSCAR 数据集拥有大量不同的语言——从头开始训练最清晰的用例之一是我们可以将 BERT 应用于一些不太常用的语言，例如泰卢固语或纳瓦霍语。

我的语言是英语——但我的女朋友是意大利人，所以她——劳拉，将评估我们讲意大利语的 BERT 模型——FiliBERTo 的结果。

因此，要下载 OSCAR 数据集的意大利语部分，我们将使用 HuggingFace 的数据集库——我们可以使用 pip install datasets 安装它。然后我们下载 OSCAR_IT ：

代码语言：javascript复制

 from datasets import load_dataset
 dataset = load_dataset('oscar', 'unshuffled_deduplicated_it')

我们来看看数据集对象。

现在让我们以一种可以在构建分词器时使用的格式存储我们的数据。我们需要创建一组仅包含数据集中文本特征的纯文本文件，我们将使用换行符 n 拆分每个样本。

代码语言：javascript复制

 from tqdm.auto import tqdm
 
 text_data = []
 file_count = 0
 
 for sample in tqdm(dataset['train']):
     sample = sample['text'].replace('n', '')
     text_data.append(sample)
     if len(text_data) == 10_000:
         # once we git the 10K mark, save to file
         with open(f'../../data/text/oscar_it/text_{file_count}.txt', 'w', encoding='utf-8') as fp:
             fp.write('n'.join(text_data))
         text_data = []
         file_count  = 1
 # after saving in 10K chunks, we will have ~2082 leftover samples, we save those now too
 with open(f'../../data/text/oscar_it/text_{file_count}.txt', 'w', encoding='utf-8') as fp:
     fp.write('n'.join(text_data))

在我们的 data/text/oscar_it 目录中，我们会发现：

构建分词器

接下来是标记器！在使用转换器时，我们通常会加载一个分词器，连同其各自的转换器模型——分词器是该过程中的关键组件。

在构建我们的分词器时，我们将为它提供我们所有的 OSCAR 数据，指定我们的词汇量大小（分词器中的标记数）和任何特殊标记。

现在，RoBERTa 特殊令牌如下所示：

oken	Use
<s>	Beginning of sequence (BOS) or classifier (CLS) token
</s>	End of sequence (EOS) or seperator (SEP) token
<unk>	Unknown token
<pad>	Padding token
<mask>	Masking token

因此，我们确保将它们包含在标记器的 train 方法调用的 special_tokens 参数中。

代码语言：javascript复制

 from pathlib import Path
 paths = [str(x) for x in Path('../../data/text/oscar_it').glob('**/*.txt')]
 from tokenizers import ByteLevelBPETokenizer
 tokenizer = ByteLevelBPETokenizer()
 tokenizer.train(files=paths[:5], vocab_size=30_522, min_frequency=2,
                 special_tokens=['<s>', '<pad>', '</s>', '<unk>', '<mask>'])

我们的分词器现在已经准备好了，我们可以保存它的文件以备后用：

代码语言：javascript复制

 import os
 os.mkdir('./filiberto')
 tokenizer.save_model('filiberto')

现在我们有两个文件定义了我们的新 FiliBERTo 分词器：

代码语言：javascript复制

  merges.txt — 执行文本到标记的初始映射
  vocab.json — 将令牌映射到令牌 ID

有了这些，我们可以继续初始化我们的分词器，以便我们可以像使用任何其他 from_pretrained 分词器一样使用它。

初始化分词器

我们首先使用我们之前构建的两个文件来初始化分词器——使用一个简单的 from_pretrained：

代码语言：javascript复制

 from transformers import RobertaTokenizer
 
 # initialize the tokenizer using the tokenizer we initialized and saved to file
 tokenizer = RobertaTokenizer.from_pretrained('filiberto', max_len=512)

现在我们的标记器已经准备好了，我们可以尝试用它编码一些文本。编码时，我们使用与通常使用的两种方法相同的方法，encode 和 encode_batch。

代码语言：javascript复制

 # test our tokenizer on a simple sentence
 tokens = tokenizer('ciao, come va?')

从编码对象标记中，我们将提取 input_ids 和 attention_mask 张量以与 FiliBERTo 一起使用。

创建输入管道

我们训练过程的输入管道是整个过程中比较复杂的部分。它包括我们获取原始 OSCAR 训练数据，对其进行转换，然后将其加载到准备进行训练的 DataLoader 中。

准备数据

我们将从一个示例开始，然后完成准备逻辑。

首先，我们需要打开我们的文件——我们之前保存为 .txt 文件的相同文件。我们根据换行符 n 拆分每个，因为这表示单个样本。

代码语言：javascript复制

 with open('../../data/text/oscar_it/text_0.txt', 'r', encoding='utf-8') as fp:
     lines = fp.read().split('n')

然后我们使用 encode_batch 方法对我们的数据进行编码。

代码语言：javascript复制

 batch = tokenizer.encode_batch(lines)
 len(batch)

现在我们可以继续创建我们的张量——我们将通过掩码语言建模 (MLM) 来训练我们的模型。所以，我们需要三个张量：

代码语言：javascript复制

  input_ids — 我们的 token_ids，其中约 15% 的令牌使用掩码令牌 <mask> 进行掩码。
  attention_mask——一个 1 和 0 的张量，标记“真实”标记/填充标记的位置——用于注意力计算。
 labels——我们的 token_ids 没有屏蔽。

如果你不熟悉MLM，我以前的文章已经解释了。

我们的 attention_mask 和标签张量只是从我们的批次中提取的。但是input_ids 张量需要更多操作，对于这个张量，我们屏蔽了大约 15% 的标记——为它们分配标记 ID 3。

代码语言：javascript复制

 import torch
 
 labels = torch.tensor([x.ids for x in batch])
 mask = torch.tensor([x.attention_mask for x in batch])
 
 # make copy of labels tensor, this will be input_ids
 input_ids = labels.detach().clone()
 # create random array of floats with equal dims to input_ids
 rand = torch.rand(input_ids.shape)
 # mask random 15% where token is not 0 [PAD], 1 [CLS], or 2 [SEP]
 mask_arr = (rand < .15) * (input_ids != 0) * (input_ids != 1) * (input_ids != 2)
 # loop through each row in input_ids tensor (cannot do in parallel)
 for i in range(input_ids.shape[0]):
     # get indices of mask positions from mask array
     selection = torch.flatten(mask_arr[i].nonzero()).tolist()
     # mask input_ids
     input_ids[i, selection] = 3  # our custom [MASK] token == 3

在最终输出中，我们可以看到编码的 input_ids 张量的一部分。第一个令牌 ID 是 1 — [CLS] 令牌。在张量周围，我们有几个 3 个令牌 ID——这些是我们新添加的 [MASK] 令牌。

构建dataloader

接下来，我们定义我们的 Dataset 类——我们用它来将我们的三个编码张量初始化为 PyTorch torch.utils.data.Dataset 对象。

代码语言：javascript复制

 encodings = {'input_ids': input_ids, 'attention_mask': mask, 'labels': labels}
 class Dataset(torch.utils.data.Dataset):
     def __init__(self, encodings):
         # store encodings internally
         self.encodings = encodings
 
     def __len__(self):
         # return the number of samples
         return self.encodings['input_ids'].shape[0]
 
     def __getitem__(self, i):
         # return dictionary of input_ids, attention_mask, and labels for index i
         return {key: tensor[i] for key, tensor in self.encodings.items()}
 
 dataset = Dataset(encodings)
 
 loader = torch.utils.data.DataLoader(dataset, batch_size=16, shuffle=True)

最后，我们的数据集被加载到 PyTorch DataLoader 对象中——我们使用它在训练期间将数据加载到我们的模型中。

训练模型

我们需要两件东西来训练，我们的 DataLoader 和一个模型。我们拥有的 DataLoader — 但没有模型。

初始化模型

对于训练，我们需要一个原始的（未预训练的）BERTLMHeadModel。要创建它，我们首先需要创建一个 RoBERTa 配置对象来描述我们想要用来初始化 FiliBERTo 的参数。

代码语言：javascript复制

 from transformers import RobertaConfig
 
 config = RobertaConfig(
     vocab_size=30_522,  # we align this to the tokenizer vocab_size
     max_position_embeddings=514,
     hidden_size=768,
     num_attention_heads=12,
     num_hidden_layers=6,
     type_vocab_size=1
 )

然后，我们使用语言建模 (LM) 头导入并初始化我们的 RoBERTa 模型。

代码语言：javascript复制

 from transformers import RobertaForMaskedLM
 
 model = RobertaForMaskedLM(config)

训练准备

在进入我们的训练循环之前，我们需要设置一些东西。首先，我们设置 GPU/CPU 使用率。然后我们激活我们模型的训练模式——最后，初始化我们的优化器。

代码语言：javascript复制

 device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
 # and move our model over to the selected device
 model.to(device)
 
 from transformers import AdamW
 
 # activate training mode
 model.train()
 # initialize optimizer
 optim = AdamW(model.parameters(), lr=1e-4)

训练

最后——训练时间！我们按照通常通过 PyTorch 进行培训时的方式进行训练。

代码语言：javascript复制

 epochs = 2
 
 for epoch in range(epochs):
     # setup loop with TQDM and dataloader
     loop = tqdm(loader, leave=True)
     for batch in loop:
         # initialize calculated gradients (from prev step)
         optim.zero_grad()
         # pull all tensor batches required for training
         input_ids = batch['input_ids'].to(device)
         attention_mask = batch['attention_mask'].to(device)
         labels = batch['labels'].to(device)
         # process
         outputs = model(input_ids, attention_mask=attention_mask,
                         labels=labels)
         # extract loss
         loss = outputs.loss
         # calculate loss for every parameter that needs grad update
         loss.backward()
         # update parameters
         optim.step()
         # print relevant info to progress bar
         loop.set_description(f'Epoch {epoch}')
         loop.set_postfix(loss=loss.item())

代码语言：javascript复制

 model.save_pretrained('./filiberto')  # and don't forget to save filiBERTo!

如果我们继续使用 Tensorboard，随着时间的推移，我们会发现我们的损失——它看起来很有希望。

最终测试

现在是进行真正测试的时候了。我们建立了一个MLM管道——并请劳拉评估结果。

我们首先使用“fill-mask”参数初始化一个管道对象。然后像这样开始测试我们的模型：

代码语言：javascript复制

 from transformers import pipeline
 fill = pipeline('fill-mask', model='filiberto', tokenizer='filiberto')
 fill(f'ciao {fill.tokenizer.mask_token} va?')