这也将是我们第一次接触 Hugging Face 生态系统中的三个核心库： Datasets、Tokenizers 和 Transformers。如图 2-2所示 ，这些库将允许我们快速从原始文本转换为可用于推断新推文的微调模型。因此，本着 Optimus Prime 的精神，让我们潜入“转型并推出！” 2

图 2-2。使用Datasets、Tokenizers 和Transformers 库训练 Transformer 模型的典型管道

数据集

拥抱人脸数据集初探

from datasets import list_datasetsall_datasets = list_datasets()
print(f"There are {len(all_datasets)} datasets currently available on the Hub")
print(f"The first 10 are: {all_datasets[:10]}")

There are 1753 datasets currently available on the Hub
The first 10 are: ['acronym_identification', 'ade_corpus_v2', 'adversarial_qa',
'aeslc', 'afrikaans_ner_corpus', 'ag_news', 'ai2_arc', 'air_dialogue',
'ajgt_twitter_ar', 'allegro_reviews']

如您所见，对于每种数据格式，我们只需将相关的加载脚本以及指定一个或多个文件的路径或 URLload_dataset()的参数传递给函数 。data_files例如，emotion数据集的源文件实际上托管在 Dropbox 上，因此加载数据集的另一种方法是首先下载其中一个拆分：

dataset_url = "https://www.dropbox.com/s/1pzkadrvffbqw6o/train.txt"!wget {dataset_url}

如果您想知道为什么!前面的 shell 命令中有一个字符，那是因为我们在 Jupyter 笔记本中运行这些命令。如果要在终端中下载和解压缩数据集，只需删除前缀即可。现在，如果我们查看train.txt文件的第一行 ：

!head -n 1 train.txt

i didnt feel humiliated;sadness

我们可以看到这里没有列标题，每条推文和情感都用分号分隔。尽管如此，这与 CSV 文件非常相似，因此我们可以通过使用csv脚本并将data_files参数指向train.txt文件来在本地加载数据集：

emotions_local = load_dataset("csv", data_files="train.txt", sep=";",names=["text", "label"])

dataset_url = "https://www.dropbox.com/s/1pzkadrvffbqw6o/train.txt?dl=1"
emotions_remote = load_dataset("csv", data_files=dataset_url, sep=";",names=["text", "label"])

它将自动为您下载和缓存数据集。如您所见，该load_dataset()功能非常通用。我们建议查看

 数据集文档以获得完整的概述。

从数据集到数据帧

import pandas as pdemotions.set_format(type="pandas")
df = emotions["train"][:]
df.head()

如您所见，列标题已被保留，前几行与我们之前的数据视图相匹配。但是，标签是用整数表示的，所以让我们使用特征的int2str()方法label在我们的新列中创建一个DataFrame具有相应标签名称的新列：

def label_int2str(row):return emotions["train"].features["label"].int2str(row)df["label_name"] = df["label"].apply(label_int2str)
df.head()

使用 Pandas 和 Matplotlib，我们可以快速可视化类分布，如下所示：

import matplotlib.pyplot as pltdf["label_name"].value_counts(ascending=True).plot.barh()
plt.title("Frequency of Classes")
plt.show()

在这种情况下，我们可以看到数据集严重不平衡；love和surprise 类经常出现，而joy和sadness则少 5到 10 倍。有几种方法可以处理不平衡的数据，包括：

• 随机过采样少数类。

• 随机对多数类进行欠采样。

• 从代表性不足的类别中收集更多标记数据。

既然我们已经看过类，让我们看一下推文本身。

我们的推文有多长？

字符标记化

import torch
import torch.nn.functional as Finput_ids = torch.tensor(input_ids)
one_hot_encodings = F.one_hot(input_ids, num_classes=len(token2idx))
one_hot_encodings.shape

torch.Size([38, 20])

对于 38 个输入标记中的每一个，我们现在都有一个 20 维的 one-hot 向量，因为我们的词汇表由 20 个唯一字符组成。

警告

始终num_classes在one_hot()函数中进行设置很重要，否则 one-hot 向量最终可能会比词汇表的长度短（并且需要手动填充零）。在 TensorFlow 中，等效函数是tf.one_hot()，其中depth参数扮演 的角色num_classes。

通过检查第一个向量，我们可以验证 1 出现在 指示的位置input_ids[0]：

print(f"Token: {tokenized_text[0]}")
print(f"Tensor index: {input_ids[0]}")
print(f"One-hot: {one_hot_encodings[0]}")

Token: T
Tensor index: 5
One-hot: tensor([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

从我们的简单示例中，我们可以看到字符级标记化忽略了文本中的任何结构，并将整个字符串视为字符流。尽管这有助于处理拼写错误和稀有单词，但主要缺点是需要从数据中学习单词等语言结构。这需要大量的计算、内存和数据。出于这个原因，字符标记化在实践中很少使用。相反，在标记化步骤期间会保留文本的某些结构。词标记化是实现这一目标的一种直接方法，所以让我们来看看它是如何工作的。

词标记化

一类简单的词标记器使用空格来标记文本。我们可以通过将 Python 的split()函数直接应用于原始文本来做到这一点（就像我们测量推文长度一样）

tokenized_text = text.split()
print(tokenized_text)

['tokenizing', 'text', 'is', 'a', 'core', 'task', 'of', 'NLP.']

从这里我们可以采取与字符标记器相同的步骤将每个单词映射到一个 ID。但是，我们已经可以看到这种标记化方案的一个潜在问题：没有考虑标点符号，因此NLP.被视为单个标记。鉴于单词可能包括偏角、变位或拼写错误，词汇量很容易增长到数百万！

笔记

一些词标记器对标点符号有额外的规则。还可以应用词干或词形还原，将词规范化到词干（例如，“great”、“greater”和“greatest”都变成“great”），代价是丢失文本中的一些信息。

拥有大量词汇是一个问题，因为它需要神经网络具有大量参数。为了说明这一点，假设我们有 100 万个唯一词，并且想要在我们的神经网络的第一层中将 100 万维输入向量压缩为 1000 维向量。这是大多数 NLP 架构中的标准步骤，第一层的最终权重矩阵将包含 100 万 × 1000 = 10 亿个权重。这已经可以与最大的 GPT-2 模型相媲美了，4总共有大约 15 亿个参数！

自然地，我们希望避免在模型参数上如此浪费，因为模型的训练成本很高，而且更大的模型更难维护。一种常见的方法是通过考虑语料库中最常见的 100,000 个单词来限制词汇并丢弃稀有单词。不属于词汇表的单词被归类为“未知”并映射到共享UNK标记。这意味着我们在词标记化过程中丢失了一些潜在的重要信息，因为模型没有关于与 相关的词的信息UNK。

如果在保留所有输入信息和一些输入结构的字符和单词标记化之间进行折衷，那不是很好 吗？有：子词标记化。

子词标记化

Transformers 提供了一个方便的 AutoTokenizer类，允许您快速加载与预训练模型关联的分词器——我们只需调用它的from_pretrained() 方法，提供 Hub 上模型的 ID 或本地文件路径。让我们从为 DistilBERT 加载分词器开始：

from transformers import AutoTokenizermodel_ckpt = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_ckpt)

from transformers import DistilBertTokenizerdistilbert_tokenizer = DistilBertTokenizer.from_pretrained(model_ckpt)

笔记

当您AutoTokenizer.from_pretrained()第一次运行该方法时，您将看到一个进度条，显示预训练标记器的哪些参数是从 Hugging Face Hub 加载的。当你第二次运行代码时，它会从缓存中加载分词器，通常在~/.cache/huggingface。

让我们通过简单的“标记文本是 NLP 的核心任务”来检查这个标记器是如何工作的。示例文本：

encoded_text = tokenizer(text)
print(encoded_text)

{'input_ids': [101, 19204, 6026, 3793, 2003, 1037, 4563, 4708, 1997, 17953,
2361, 1012, 102], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

tokens = tokenizer.convert_ids_to_tokens(encoded_text.input_ids)
print(tokens)

['[CLS]', 'token', '##izing', 'text', 'is', 'a', 'core', 'task', 'of', 'nl',
'##p', '.', '[SEP]']

tokenizer.vocab_size

30522

以及相应模型的最大上下文大小：

tokenizer.model_max_length

512

另一个需要了解的有趣属性是模型在其前向传递中期望的字段名称：

tokenizer.model_input_names

['input_ids', 'attention_mask']

现在我们对单个字符串的标记化过程有了基本的了解，让我们看看如何标记整个数据集！

警告

使用预训练模型时，确保使用与训练模型相同的标记器非常重要。从模型的角度来看，切换分词器就像打乱词汇表一样。如果您周围的每个人都开始将 “house”之类的随机词替换为“cat”，那么您也很难理解发生了什么！

标记整个数据集

另请注意，除了将编码的推文返回为 之外 input_ids，标记器还会返回一个attention_mask数组列表。这是因为我们不希望模型被额外的填充标记混淆：注意掩码允许模型忽略输入的填充部分。图 2-3提供了如何填充输入 ID 和注意掩码的可视化解释。

图 2-3。对于每个批次，输入序列被填充到批次中的最大序列长度；注意掩码在模型中用于忽略输入张量的填充区域

一旦我们定义了一个处理函数，我们就可以在一行代码中将它应用于语料库中的所有拆分：

emotions_encoded = emotions.map(tokenize, batched=True, batch_size=None)

默认情况下，该map()方法对语料库中的每个示例单独操作，因此设置batched=True将对推文进行批量编码。因为我们已经设置batch_size=None了 ，所以我们的tokenize() 函数将作为一个批次应用于整个数据集。这确保了输入张量和注意力掩码在全局范围内具有相同的形状，我们可以看到这个操作已经向数据集添加了新的input_ids 和attention_mask列：

print(emotions_encoded["train"].column_names)

['attention_mask', 'input_ids', 'label', 'text']

图 2-4。用于使用基于编码器的转换器进行序列分类的架构；它由模型的预训练主体和自定义分类头组成

 首先，文本被标记化并表示为称为 标记编码的单热向量。标记器词汇的​​大小决定了标记编码的维度，它通常由 20k–200k 个唯一标记组成。接下来，这些标记编码被转换为标记嵌入，它们是生活在低维空间中的向量。然后，令牌嵌入通过编码器块层传递，以产生每个输入令牌的隐藏状态。对于语言建模的预训练目标，6每个隐藏状态都被馈送到一个预测掩码输入标记的层。对于分类任务，我们将语言建模层替换为分类层。

笔记

在实践中，PyTorch 跳过了为令牌编码创建 one-hot 向量的步骤，因为将矩阵与 one-hot 向量相乘与从矩阵中选择一列相同。这可以通过从矩阵中获取具有标记 ID 的列来直接完成。当我们使用nn.Embedding类时，我们将在第 3 章看到这一点。

图 2-5。在基于特征的方法中，DistilBERT 模型被冻结，只为分类器提供特征

使用预训练模型

from transformers import TFAutoModeltf_model = TFAutoModel.from_pretrained(model_ckpt)

tf_xlmr = TFAutoModel.from_pretrained("xlm-roberta-base")

你会得到一个错误。在这些情况下，您可以为函数指定一个 from_pt=True参数TfAutoModel.from_pretrained()，该库将自动为您下载并转换 PyTorch 权重

tf_xlmr = TFAutoModel.from_pretrained("xlm-roberta-base", from_pt=True)

如您所见，在 Transformers 中的框架之间切换非常简单！在大多数情况下，您只需在类中添加“TF”前缀，您将获得等效的 TensorFlow 2.0 类。当我们使用"pt"字符串时（例如，在下一节中），它是 PyTorch 的缩写，只需将其替换为 " tf"，它是 TensorFlow 的缩写。

提取最后的隐藏状态

def extract_hidden_states(batch):# Place model inputs on the GPUinputs = {k:v.to(device) for k,v in batch.items()if k in tokenizer.model_input_names}# Extract last hidden stateswith torch.no_grad():last_hidden_state = model(**inputs).last_hidden_state# Return vector for [CLS] tokenreturn {"hidden_state": last_hidden_state[:,0].cpu().numpy()}

这个函数和我们之前的逻辑的唯一区别是最后一步，我们将最终的隐藏状态作为 NumPy 数组放回 CPU。map()当我们使用批量输入时，该方法需要处理函数返回 Python 或 NumPy 对象。

由于我们的模型期望张量作为输入，接下来要做的是将input_ids和attention_mask列转换为"torch" 格式，如下所示

emotions_encoded.set_format("torch",columns=["input_ids", "attention_mask", "label"])

然后我们可以继续并一次性提取所有拆分中的隐藏状态

emotions_hidden = emotions_encoded.map(extract_hidden_states, batched=True)

请注意，在这种情况下我们没有设置batch_size=None，这意味着使用默认值batch_size=1000来代替。正如预期的那样，应用该 extract_​hid⁠den_​states()函数已向hidden_state我们的数据集添加了一个新列：

emotions_hidden["train"].column_names

['attention_mask', 'hidden_​​state', 'input_ids', 'label', 'text']

现在我们已经有了与每条推文相关的隐藏状态，下一步是在它们上训练一个分类器。为此，我们需要一个特征矩阵——让我们来看看。

创建特征矩阵

import numpy as npX_train = np.array(emotions_hidden["train"]["hidden_state"])
X_valid = np.array(emotions_hidden["validation"]["hidden_state"])
y_train = np.array(emotions_hidden["train"]["label"])
y_valid = np.array(emotions_hidden["validation"]["label"])
X_train.shape, X_valid.shape

((16000, 768), (2000, 768))

在我们在隐藏状态上训练模型之前，最好进行快速检查以确保它们提供了我们想要分类的情绪的有用表示。在下一节中，我们将看到可视化功能如何提供实现此目的的快速方法。

可视化训练集

from umap import UMAP
from sklearn.preprocessing import MinMaxScaler# Scale features to [0,1] range
X_scaled = MinMaxScaler().fit_transform(X_train)
# Initialize and fit UMAP
mapper = UMAP(n_components=2, metric="cosine").fit(X_scaled)
# Create a DataFrame of 2D embeddings
df_emb = pd.DataFrame(mapper.embedding_, columns=["X", "Y"])
df_emb["label"] = y_train
df_emb.head()

结果是一个具有相同数量训练样本的数组，但只有 2 个特征，而不是我们开始时的 768 个！让我们进一步研究压缩数据并分别绘制每个类别的点密度

fig, axes = plt.subplots(2, 3, figsize=(7,5))
axes = axes.flatten()
cmaps = ["Greys", "Blues", "Oranges", "Reds", "Purples", "Greens"]
labels = emotions["train"].features["label"].namesfor i, (label, cmap) in enumerate(zip(labels, cmaps)):df_emb_sub = df_emb.query(f"label == {i}")axes[i].hexbin(df_emb_sub["X"], df_emb_sub["Y"], cmap=cmap,gridsize=20, linewidths=(0,))axes[i].set_title(label)axes[i].set_xticks([]), axes[i].set_yticks([])plt.tight_layout()
plt.show()

笔记

这些只是对低维空间的投影。仅仅因为某些类别重叠并不意味着它们在原始空间中不可分离。相反，如果它们在投影空间中是可分离的，那么它们在原始空间中也是可分离的。

sadness从这个图中我们可以看到一些清晰的模式： 、anger和等负面情绪fear都占据相似的区域，但分布略有不同。另一方面，joy又love与负面情绪很好地分开，也共享一个相似的空间。最后，surprise散落一地。尽管我们可能希望有一些分离，但这并不能保证，因为模型没有经过训练来了解这些情绪之间的差异。它只是通过猜测文本中的蒙面词来隐式地学习它们。

现在我们已经对数据集的特征有了一些了解，让我们最终训练一个模型吧！

训练一个简单的分类器

我们已经看到情绪之间的隐藏状态有些不同，尽管其中一些情绪没有明显的界限。让我们使用这些隐藏状态来使用 Scikit-learn 训练逻辑回归模型。训练这样一个简单的模型很快并且不需要 GPU

from sklearn.linear_model import LogisticRegression# We increase `max_iter` to guarantee convergence
lr_clf = LogisticRegression(max_iter=3000)
lr_clf.fit(X_train, y_train)
lr_clf.score(X_valid, y_valid)

0.633

从准确性来看，我们的模型似乎比随机模型好一点——但由于我们正在处理一个不平衡的多类数据集，它实际上要好得多。我们可以通过将它与一个简单的基线进行比较来检查我们的模型是否有任何好处。在 Scikit-learn 中有一个 DummyClassifier可用于构建具有简单启发式的分类器的分类器，例如始终选择多数类或始终绘制随机类。在这种情况下，表现最好的启发式方法是始终选择最频繁的类，这会产生大约 35% 的准确度

from sklearn.dummy import DummyClassifierdummy_clf = DummyClassifier(strategy="most_frequent")
dummy_clf.fit(X_train, y_train)
dummy_clf.score(X_valid, y_valid)

0.352

因此，我们带有 DistilBERT 嵌入的简单分类器明显优于我们的基线。我们可以通过查看分类器的混淆矩阵来进一步研究模型的性能，它告诉我们真实标签和预测标签之间的关系

from sklearn.metrics import ConfusionMatrixDisplay, confusion_matrixdef plot_confusion_matrix(y_preds, y_true, labels):cm = confusion_matrix(y_true, y_preds, normalize="true")fig, ax = plt.subplots(figsize=(6, 6))disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)disp.plot(cmap="Blues", values_format=".2f", ax=ax, colorbar=False)plt.title("Normalized confusion matrix")plt.show()y_preds = lr_clf.predict(X_valid)
plot_confusion_matrix(y_preds, y_valid, labels)

我们可以看到这一点，anger并且fear经常与 混淆 sadness，这与我们在可视化嵌入时所做的观察一致。此外，love并且surprise经常被误认为 joy.

 在下一节中，我们将探讨微调方法，它可以带来出色的分类性能。但是，重要的是要注意，这样做需要更多的计算资源，例如 GPU，而这些资源在您的组织中可能不可用。在这种情况下，基于特征的方法可能是传统机器学习和深度学习之间的一个很好的折衷方案。

微调Transformers

图 2-6。当使用微调方法时，整个 DistilBERT 模型与分类头一起训练

训练作为分类模型输入的隐藏状态将帮助我们避免处理可能不太适合分类任务的数据的问题。相反，初始隐藏状态会在训练期间适应以减少模型损失，从而提高其性能。

我们将使用 Transformers 的TrainerAP来简化训练循环。让我们看看我们需要设置的成分！

加载预训练模型

from transformers import AutoModelForSequenceClassificationnum_labels = 6
model = (AutoModelForSequenceClassification.from_pretrained(model_ckpt, num_labels=num_labels).to(device))

您将看到模型的某些部分被随机初始化的警告。这 是正常的，因为尚未训练分类头。下一步是定义我们将在 微调期间用于评估模型性能的指标。

定义性能指标

preds_output = trainer.predict(emotions_encoded["validation"])

from transformers import TFAutoModelForSequenceClassificationtf_model = (TFAutoModelForSequenceClassification.from_pretrained(model_ckpt, num_labels=num_labels))

接下来，我们将数据集转换为tf.data.Dataset 格式。因为我们已经填充了我们的标记化输入，所以我们可以通过将to_tf_dataset()方法应用于 emotions_encoded

# The column names to convert to TensorFlow tensors
tokenizer_columns = tokenizer.model_input_namestf_train_dataset = emotions_encoded["train"].to_tf_dataset(columns=tokenizer_columns, label_cols=["label"], shuffle=True,batch_size=batch_size)
tf_eval_dataset = emotions_encoded["validation"].to_tf_dataset(columns=tokenizer_columns, label_cols=["label"], shuffle=False,batch_size=batch_size)

在这里，我们还对训练集进行了洗牌，并为其定义了批量大小和验证集。最后要做的是编译和训练模型

import tensorflow as tftf_model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=5e-5),loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),metrics=tf.metrics.SparseCategoricalAccuracy())tf_model.fit(tf_train_dataset, validation_data=tf_eval_dataset, epochs=2)

错误分析

# Convert our dataset back to PyTorch tensors
emotions_encoded.set_format("torch",columns=["input_ids", "attention_mask", "label"])
# Compute loss values
emotions_encoded["validation"] = emotions_encoded["validation"].map(forward_pass_with_label, batched=True, batch_size=16)

最后，我们DataFrame使用文本、损失和预测/真实标签创建一个

emotions_encoded.set_format("pandas")
cols = ["text", "label", "predicted_label", "loss"]
df_test = emotions_encoded["validation"][:][cols]
df_test["label"] = df_test["label"].apply(label_int2str)
df_test["predicted_label"] = (df_test["predicted_label"].apply(label_int2str))

我们现在可以轻松地emotions_encoded按升序或降序对损失进行排序。本练习的目标是检测以下情况之一：

trainer.push_to_hub(commit_message="Training completed!")

我们还可以使用微调模型对新推文进行预测。由于我们已经将模型推送到 Hub，我们现在可以将它与pipeline()函数一起使用，就像我们在 第 1 章中所做的那样。首先，让我们加载管道

from transformers import pipeline# Change `transformersbook` to your Hub username
model_id = "transformersbook/distilbert-base-uncased-finetuned-emotion"
classifier = pipeline("text-classification", model=model_id)

然后让我们使用示例推文测试管道

custom_tweet = "I saw a movie today and it was really good."
preds = classifier(custom_tweet, return_all_scores=True)