获取数据

由于获取所有问题需要一段时间，我们在本书的 GitHub 存储库中包含了一个github-issues-transformers.jsonl文件，以及一个fetch_issues()您可以用来自己下载它们的函数。

现在我们知道如何获取数据，让我们来看看如何清理它。

准备数据

下载完所有问题后，我们可以使用 Pandas 加载它们：

import pandas as pd

dataset_url = "https://git.io/nlp-with-transformers"
df_issues = pd.read_json(dataset_url, lines=True)
print(f"DataFrame shape: {df_issues.shape}")

DataFrame shape: (9930, 26)

我们的数据集中有近 10,000 个问题，通过查看一行我们可以看到从 GitHub API 检索到的信息包含许多字段，例如 URL、ID、日期、用户、标题、正文以及标签：

cols = ["url", "id", "title", "user", "labels", "state", "created_at", "body"]
df_issues.loc[2, cols].to_frame()

该labels列是我们感兴趣的内容，每一行都包含一个 JSON 对象列表，其中包含有关每个标签的元数据：

[
   {
      "id":2659267025,
      "node_id":"MDU6TGFiZWwyNjU5MjY3MDI1",
      "url":"https://api.github.com/repos/huggingface...",
      "name":"DeepSpeed",
      "color":"4D34F7",
      "default":false,
      "description":""
   }
]

出于我们的目的，我们只对name每个标签对象的字段感兴趣，所以让我们只用标签名称覆盖该labels列：

df_issues["labels"] = (df_issues["labels"]
                       .apply(lambda x: [meta["name"] for meta in x]))
df_issues[["labels"]].head()

现在列中的每一行labels都是 GitHub 标签列表，因此我们可以计算每行的长度以找到每个问题的标签数量：

df_issues["labels"].apply(lambda x : len(x)).value_counts().to_frame().T

这表明大多数问题都有 0 个或 1 个标签，而具有多个标签的问题要少得多。接下来让我们看一下数据集中出现频率最高的 10 个标签。在 Pandas 中，我们可以通过“分解”labels列来做到这一点，以便列表中的每个标签变成一行，然后简单地计算每个标签的出现次数：

df_counts = df_issues["labels"].explode().value_counts()
print(f"Number of labels: {len(df_counts)}")
# Display the top-8 label categories
df_counts.to_frame().head(8).T

Number of labels: 65

我们可以看到数据集中有 65 个唯一标签，并且类别非常不平衡，wontfix并且model card是最常见的标签。为了使分类问题更易于处理，我们将专注于为标签的子集构建标注器。例如，某些标签（例如Good First Issue或Help Wanted）可能很难从问题的描述中预测，而其他标签（例如model card）可以使用检测模型卡何时添加到 Hugging Face Hub 的简单规则进行分类。

以下代码为我们将使用的标签子集过滤数据集，同时对名称进行标准化以使其更易于阅读：

label_map = {"Core: Tokenization": "tokenization",
             "New model": "new model",
             "Core: Modeling": "model training",
             "Usage": "usage",
             "Core: Pipeline": "pipeline",
             "TensorFlow": "tensorflow or tf",
             "PyTorch": "pytorch",
             "Examples": "examples",
             "Documentation": "documentation"}

def filter_labels(x):
    return [label_map[label] for label in x if label in label_map]

df_issues["labels"] = df_issues["labels"].apply(filter_labels)
all_labels = list(label_map.values())

现在让我们看看新标签的分布情况：

df_counts = df_issues["labels"].explode().value_counts()
df_counts.to_frame().T

在本章的后面，我们会发现将未标记的问题视为单独的训练拆分很有用，因此让我们创建一个新列来指示问题是否未标记：

df_issues["split"] = "unlabeled"
mask = df_issues["labels"].apply(lambda x: len(x)) > 0
df_issues.loc[mask, "split"] = "labeled"
df_issues["split"].value_counts().to_frame()

现在让我们看一个例子：

for column in ["title", "body", "labels"]:
    print(f"{column}: {df_issues[column].iloc[26][:500]}\n")

title: Add new CANINE model

body: #  New model addition

## Model description

Google recently proposed a new **C**haracter **A**rchitecture with **N**o
 tokenization **I**n **N**eural **E**ncoders architecture (CANINE). Not only
 the title is exciting:

Pipelined NLP systems have largely been superseded by end-to-end neural
 modeling, yet nearly all commonly-used models still require an explicit
 tokenization step. While recent tokenization approaches based on data-derived
 subword lexicons are less brittle than manually en

labels: ['new model']

在这个例子中，提出了一个新的模型架构，所以new model 标签是有意义的。我们还可以看到title包含对我们的分类器有用的信息，所以让我们将它与body字段中的问题描述连接起来：

df_issues["text"] = (df_issues
                     .apply(lambda x: x["title"] + "\n\n" + x["body"], axis=1))

在我们查看其余数据之前，让我们检查数据中的任何重复项并使用以下drop_duplicates() 方法删除它们：

len_before = len(df_issues)
df_issues = df_issues.drop_duplicates(subset="text")
print(f"Removed {(len_before-len(df_issues))/len_before:.2%} duplicates.")

Removed 1.88% duplicates.

我们可以看到我们的数据集中有一些重复的问题，但它们只占一小部分。正如我们在其他章节中所做的那样，快速查看文本中的单词数量也是一个好主意，看看当我们截断到每个模型的上下文大小时是否会丢失很多信息：

import numpy as np
import matplotlib.pyplot as plt

(df_issues["text"].str.split().apply(len)
 .hist(bins=np.linspace(0, 500, 50), grid=False, edgecolor="C0"))
plt.title("Words per issue")
plt.xlabel("Number of words")
plt.ylabel("Number of issues")
plt.show()

from sklearn.preprocessing import MultiLabelBinarizer

mlb = MultiLabelBinarizer()
mlb.fit([all_labels])
mlb.transform([["tokenization", "new model"], ["pytorch"]])

array([[0, 0, 0, 1, 0, 0, 0, 1, 0],
       [0, 0, 0, 0, 0, 1, 0, 0, 0]])

在这个简单的例子中，我们可以看到第一行有两个对应于tokenization和new model标签，而第二行只有一个命中pytorch。

np.random.seed(0)
all_indices = np.expand_dims(list(range(len(ds["train"]))), axis=1)
indices_pool = all_indices
labels = mlb.transform(ds["train"]["labels"])
train_samples = [8, 16, 32, 64, 128]
train_slices, last_k = [], 0

for i, k in enumerate(train_samples):
    # Split off samples necessary to fill the gap to the next split size
    indices_pool, labels, new_slice, _ = iterative_train_test_split(
        indices_pool, labels, (k-last_k)/len(labels))
    last_k = k
    if i==0: train_slices.append(new_slice)
    else: train_slices.append(np.concatenate((train_slices[-1], new_slice)))

# Add full dataset as last slice
train_slices.append(all_indices), train_samples.append(len(ds["train"]))
train_slices = [np.squeeze(train_slice) for train_slice in train_slices]

请注意，这种迭代方法仅将样本近似拆分为所需的大小，因为在给定的拆分大小下并不总是可以找到平衡的拆分：

print("Target split sizes:")
print(train_samples)
print("Actual split sizes:")
print([len(x) for x in train_slices])

Target split sizes:
[8, 16, 32, 64, 128, 223]
Actual split sizes:
[10, 19, 36, 68, 134, 223]

表 9-2。不同类型的文本数据增强技术

我们将使用 NlpAug 的ContextualWordEmbsAug增强器来利用 DistilBERT 的上下文词嵌入来进行同义词替换。让我们从一个简单的例子开始：

from transformers import set_seed
import nlpaug.augmenter.word as naw

set_seed(3)
aug = naw.ContextualWordEmbsAug(model_path="distilbert-base-uncased",
                                device="cpu", action="substitute")

text = "Transformers are the most popular toys"
print(f"Original text: {text}")
print(f"Augmented text: {aug.augment(text)}")

Original text: Transformers are the most popular toys
Augmented text: transformers'the most popular toys

在这里，我们可以看到“are”这个词是如何被一个撇号替换的，以生成一个新的合成训练示例。我们可以将这种扩充包装在一个简单的函数中，如下所示：

def augment_text(batch, transformations_per_example=1):
    text_aug, label_ids = [], []
    for text, labels in zip(batch["text"], batch["label_ids"]):
        text_aug += [text]
        label_ids += [labels]
        for _ in range(transformations_per_example):
            text_aug += [aug.augment(text)]
            label_ids += [labels]
    return {"text": text_aug, "label_ids": label_ids}

在本节中，我们将创建一个以 OpenAI API 分类端点为模型的文本分类器。这个想法遵循三个步骤：

1. 使用语言模型嵌入所有带标签的文本。

2. 对存储的嵌入执行最近邻搜索。

3. 聚合最近邻居的标签以获得预测。

该过程如图 9-3 所示，它显示了标记数据如何嵌入模型并与标签一起存储。当需要对新文本进行分类时，它也会被嵌入，并根据最近邻居的标签给出标签。校准要搜索的邻居数量很重要，因为太少可能会产生噪音，而太多可能会混入相邻组。

图 9-3。最近邻嵌入查找的图示

这种方法的优点在于不需要模型微调来利用少数可用的标记数据点。相反，使这种方法发挥作用的主要决定是选择一个合适的模型，该模型理想地在与您的数据集相似的域上进行了预训练。

为了看看它是如何工作的，让我们加载一个 GPT-2 标记器和模型，定义平均池操作，并将整个过程包装在一个简单的embed_text()函数中：

import torch
from transformers import AutoTokenizer, AutoModel

model_ckpt = "miguelvictor/python-gpt2-large"
tokenizer = AutoTokenizer.from_pretrained(model_ckpt)
model = AutoModel.from_pretrained(model_ckpt)

def mean_pooling(model_output, attention_mask):
    # Extract the token embeddings
    token_embeddings = model_output[0]
    # Compute the attention mask
    input_mask_expanded = (attention_mask
                           .unsqueeze(-1)
                           .expand(token_embeddings.size())
                           .float())
    # Sum the embeddings, but ignore masked tokens
    sum_embeddings = torch.sum(token_embeddings * input_mask_expanded, 1)
    sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9)
    # Return the average as a single vector
    return sum_embeddings / sum_mask

def embed_text(examples):
    inputs = tokenizer(examples["text"], padding=True, truncation=True,
                       max_length=128, return_tensors="pt")
    with torch.no_grad():
        model_output = model(**inputs)
    pooled_embeds = mean_pooling(model_output, inputs["attention_mask"])
    return {"embedding": pooled_embeds.cpu().numpy()}

现在我们可以获得每个拆分的嵌入。请注意，GPT 样式的模型没有填充标记，因此我们需要添加一个，然后才能按照前面代码中实现的批处理方式获取嵌入。为此，我们将仅回收字符串结尾标记：

tokenizer.pad_token = tokenizer.eos_token
embs_train = ds["train"].map(embed_text, batched=True, batch_size=16)
embs_valid = ds["valid"].map(embed_text, batched=True, batch_size=16)
embs_test = ds["test"].map(embed_text, batched=True, batch_size=16)

embs_train.add_faiss_index("embedding")

微调Vanilla Transformer

小费

对于许多应用程序，从预训练的类 BERT 模型开始是一个好主意。但是，如果您的语料库的领域与预训练语料库（通常是 Wikipedia）有很大不同，您应该探索 Hugging Face Hub 上可用的许多模型。很可能有人已经在您的域上预训练了模型！

让我们首先加载预训练的分词器，对我们的数据集进行分词，并删除我们不需要进行训练和评估的列：

import torch
from transformers import (AutoTokenizer, AutoConfig,
                          AutoModelForSequenceClassification)

model_ckpt = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_ckpt)

def tokenize(batch):
    return tokenizer(batch["text"], truncation=True, max_length=128)
ds_enc = ds.map(tokenize, batched=True)
ds_enc = ds_enc.remove_columns(['labels', 'text'])

多标签损失函数期望标签是浮点类型，因为它还允许类概率而不是离散标签。因此，我们需要更改列的类型label_ids。由于按元素更改列的格式与 Arrow 的类型格式不兼容，我们将做一些解决方法。首先，我们创建一个带有标签的新列。该列的格式是从第一个元素推断出来的。然后我们删除原始列并重命名新列以代替原始列：

ds_enc.set_format("torch")
ds_enc = ds_enc.map(lambda x: {"label_ids_f": x["label_ids"].to(torch.float)},
                    remove_columns=["label_ids"])
ds_enc = ds_enc.rename_column("label_ids_f", "label_ids")

from transformers import Trainer, TrainingArguments

training_args_fine_tune = TrainingArguments(
    output_dir="./results", num_train_epochs=20, learning_rate=3e-5,
    lr_scheduler_type='constant', per_device_train_batch_size=4,
    per_device_eval_batch_size=32, weight_decay=0.0,
    evaluation_strategy="epoch", save_strategy="epoch",logging_strategy="epoch",
    load_best_model_at_end=True, metric_for_best_model='micro f1',
    save_total_limit=1, log_level='error')

from scipy.special import expit as sigmoid

def compute_metrics(pred):
    y_true = pred.label_ids
    y_pred = sigmoid(pred.predictions)
    y_pred = (y_pred>0.5).astype(float)

    clf_dict = classification_report(y_true, y_pred, target_names=all_labels,
                                     zero_division=0, output_dict=True)
    return {"micro f1": clf_dict["micro avg"]["f1-score"],
            "macro f1": clf_dict["macro avg"]["f1-score"]}

现在我们准备隆隆声了！对于每个训练集切片，我们从头开始训练分类器，在训练循环结束时加载最佳模型，并将结果存储在测试集上：

config = AutoConfig.from_pretrained(model_ckpt)
config.num_labels = len(all_labels)
config.problem_type = "multi_label_classification"

for train_slice in train_slices:
    model = AutoModelForSequenceClassification.from_pretrained(model_ckpt,
                                                               config=config)
    trainer = Trainer(
        model=model, tokenizer=tokenizer,
        args=training_args_fine_tune,
        compute_metrics=compute_metrics,
        train_dataset=ds_enc["train"].select(train_slice),
        eval_dataset=ds_enc["valid"],)

    trainer.train()
    pred = trainer.predict(ds_enc["test"])
    metrics = compute_metrics(pred)
    macro_scores["Fine-tune (vanilla)"].append(metrics["macro f1"])
    micro_scores["Fine-tune (vanilla)"].append(metrics["micro f1"])

plot_metrics(micro_scores, macro_scores, train_samples, "Fine-tune (vanilla)")

首先，我们看到，当我们可以访问大约 64 个示例时，只需对数据集上的普通 BERT 模型进行微调就会产生有竞争力的结果。我们还看到，在此之前，行为有点不稳定，这再次是由于在小样本上训练模型，其中一些标签可能会出现不利的不平衡。在我们使用数据集的未标记部分之前，让我们快速看一下在少样本领域使用语言模型的另一种有前途的方法。

带提示的上下文和小样本学习

微调语言模型

def tokenize(batch):
    return tokenizer(batch["text"], truncation=True,
                     max_length=128, return_special_tokens_mask=True)

ds_mlm = ds.map(tokenize, batched=True)
ds_mlm = ds_mlm.remove_columns(["labels", "text", "label_ids"])

从掩码语言建模开始，缺少的是在输入序列中掩码标记并在输出中包含目标标记的机制。我们可以解决这个问题的一种方法是设置一个函数来屏蔽随机标记并为这些序列创建标签。但这会使数据集的大小翻倍，因为我们还将目标序列存储在数据集中，这意味着我们将在每个 epoch 使用相同的序列掩码。

一个更优雅的解决方案是使用数据整理器。请记住，数据整理器是在数据集和模型调用之间建立桥梁的函数。从数据集中抽取一个批次，数据整理者准备批次中的元素以将它们提供给模型。在我们遇到的最简单的情况下，它只是将每个元素的张量连接成一个张量。在我们的例子中，我们可以使用它来动态进行遮罩和标签生成。这样我们就不需要存储标签，并且每次采样时都会得到新的掩码。此任务的数据整理器称为 DataCollatorForLanguageModeling。我们使用模型的标记器和我们想要通过mlm_probability参数屏蔽的标记部分对其进行初始化。我们将使用这个整理器来屏蔽 15% 的令牌，这遵循 BERT 论文中的过程：

from transformers import DataCollatorForLanguageModeling, set_seed

data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer,
                                                mlm_probability=0.15)

set_seed(3)
data_collator.return_tensors = "np"
inputs = tokenizer("Transformers are awesome!", return_tensors="np")
outputs = data_collator([{"input_ids": inputs["input_ids"][0]}])

pd.DataFrame({
    "Original tokens": tokenizer.convert_ids_to_tokens(inputs["input_ids"][0]),
    "Masked tokens": tokenizer.convert_ids_to_tokens(outputs["input_ids"][0]),
    "Original input_ids": original_input_ids,
    "Masked input_ids": masked_input_ids,
    "Labels": outputs["labels"][0]}).T

我们看到感叹号对应的token已经被替换为mask token了。此外，数据整理器返回了一个标签数组，原始标记为 –100，掩码标记为标记 ID。正如我们之前看到的，在计算损失时忽略包含 –100 的条目。让我们将数据整理器的格式切换回 PyTorch：

data_collator.return_tensors = "pt"

微调分类器

model_ckpt = f'{model_ckpt}-issues-128'
config = AutoConfig.from_pretrained(model_ckpt)
config.num_labels = len(all_labels)
config.problem_type = "multi_label_classification"

for train_slice in train_slices:
    model = AutoModelForSequenceClassification.from_pretrained(model_ckpt,
                                                               config=config)
    trainer = Trainer(
        model=model,
        tokenizer=tokenizer,
        args=training_args_fine_tune,
        compute_metrics=compute_metrics,
        train_dataset=ds_enc["train"].select(train_slice),
        eval_dataset=ds_enc["valid"],
    )

    trainer.train()
    pred = trainer.predict(ds_enc['test'])
    metrics = compute_metrics(pred)
    # DA refers to domain adaptation
    macro_scores['Fine-tune (DA)'].append(metrics['macro f1'])
    micro_scores['Fine-tune (DA)'].append(metrics['micro f1'])

 将结果与基于 vanilla BERT 的微调进行比较，我们发现我们获得了优势，尤其是在低数据领域。在有更多标记数据可用的情况下，我们还获得了几个百分点：

plot_metrics(micro_scores, macro_scores, train_samples, "Fine-tune (DA)")

这突出表明，域适应可以通过未标记的数据和很少的努力稍微提高模型的性能。自然，您拥有的未标记数据越多和标记数据越少，您使用此方法获得的影响就越大。在结束本章之前，我们将向您展示更多利用未标记数据的技巧。

高级方法

在调整分类头之前微调语言模型是提高性能的一种简单而可靠的方法。然而，有一些复杂的方法可以进一步利用未标记的数据。我们在这里总结了其中一些方法，如果您需要更高的性能，它们应该提供一个很好的起点。