使用 KerasHub 的语义相似性
作者： Anshuman Mishra
创建日期 2023/02/25
上次修改日期 2023/02/25
描述： 使用 KerasHub 中的预训练模型进行语义相似性任务。
简介
语义相似性是指确定两个句子在意义上的相似程度的任务。 我们已经在此示例中看到了如何使用 SNLI（斯坦福自然语言推理）语料库，通过 HuggingFace Transformers 库来预测句子语义相似性。在本教程中，我们将学习如何使用 KerasHub（核心 Keras API 的扩展）来完成相同的任务。此外，我们将发现 KerasHub 如何有效地减少样板代码并简化构建和使用模型的过程。有关 KerasHub 的更多信息，请参阅 KerasHub 的官方文档。
本指南分为以下几个部分
- 设置，任务定义和建立基准。
- 使用 BERT 建立基准。
- 保存和重新加载模型。
- 使用模型执行推理。 5 使用 RoBERTa 提高准确性
设置
以下指南使用 Keras Core 在 tensorflow、jax 或 torch 的任何一个后端中工作。Keras Core 的支持已内置到 KerasHub 中，只需更改下面的 KERAS_BACKEND 环境变量即可更改您想要使用的后端。我们在下面选择 jax 后端，这将为我们提供一个特别快的训练步骤。
!pip install -q --upgrade keras-hub
!pip install -q --upgrade keras # Upgrade to Keras 3.
import numpy as np
import tensorflow as tf
import keras
import keras_hub
import tensorflow_datasets as tfds
为了加载 SNLI 数据集，我们使用 tensorflow-datasets 库，该库总共包含超过 550,000 个样本。但是，为了确保此示例快速运行，我们仅使用 20% 的训练样本。
SNLI 数据集概述
数据集中的每个样本都包含三个组成部分：hypothesis、premise 和 label。premise 表示提供给作者的原始标题，而 hypothesis 指的是作者创建的假设标题。标签由注释者分配，以指示两个句子之间的相似性。
该数据集包含三个可能的相似性标签值：矛盾（Contradiction）、蕴含（Entailment）和中性（Neutral）。矛盾表示完全不相似的句子，而蕴含表示含义相似的句子。最后，中性是指无法在它们之间建立明确的相似性或不相似性的句子。
snli_train = tfds.load("snli", split="train[:20%]")
snli_val = tfds.load("snli", split="validation")
snli_test = tfds.load("snli", split="test")
# Here's an example of how our training samples look like, where we randomly select
# four samples:
sample = snli_test.batch(4).take(1).get_single_element()
sample
{'hypothesis': <tf.Tensor: shape=(4,), dtype=string, numpy=
array([b'A girl is entertaining on stage',
b'A group of people posing in front of a body of water.',
b"The group of people aren't inide of the building.",
b'The people are taking a carriage ride.'], dtype=object)>,
'label': <tf.Tensor: shape=(4,), dtype=int64, numpy=array([0, 0, 0, 0])>,
'premise': <tf.Tensor: shape=(4,), dtype=string, numpy=
array([b'A girl in a blue leotard hula hoops on a stage with balloon shapes in the background.',
b'A group of people taking pictures on a walkway in front of a large body of water.',
b'Many people standing outside of a place talking to each other in front of a building that has a sign that says "HI-POINTE."',
b'Three people are riding a carriage pulled by four horses.'],
dtype=object)>}
预处理
在我们的数据集中，我们发现有些样本缺少或标签错误的数据，这些数据用值 -1 表示。为了确保模型的准确性和可靠性，我们只是从数据集中过滤掉这些样本。
def filter_labels(sample):
return sample["label"] >= 0
这是一个实用函数，可将示例拆分为适合 model.fit() 的 (x, y) 元组。默认情况下，keras_hub.models.BertClassifier 将在训练期间使用 "[SEP]" 标记来标记化和打包原始字符串。因此，此标签拆分是我们唯一需要执行的数据准备工作。
def split_labels(sample):
x = (sample["hypothesis"], sample["premise"])
y = sample["label"]
return x, y
train_ds = (
snli_train.filter(filter_labels)
.map(split_labels, num_parallel_calls=tf.data.AUTOTUNE)
.batch(16)
)
val_ds = (
snli_val.filter(filter_labels)
.map(split_labels, num_parallel_calls=tf.data.AUTOTUNE)
.batch(16)
)
test_ds = (
snli_test.filter(filter_labels)
.map(split_labels, num_parallel_calls=tf.data.AUTOTUNE)
.batch(16)
)
使用 BERT 建立基准。
我们使用 KerasHub 中的 BERT 模型来为我们的语义相似性任务建立基准。keras_hub.models.BertClassifier 类将分类头连接到 BERT 主干，将主干输出映射到适合分类任务的逻辑输出。这大大减少了对自定义代码的需求。
KerasHub 模型具有内置的标记化功能，可以根据所选模型默认处理标记化。但是，用户也可以根据其特定需求使用自定义预处理技术。如果我们传递一个元组作为输入，模型将标记化所有字符串，并使用 "[SEP]" 分隔符将它们连接起来。
我们将此模型与预训练权重一起使用，并且可以使用 from_preset() 方法来使用我们自己的预处理器。对于 SNLI 数据集，我们将 num_classes 设置为 3。
bert_classifier = keras_hub.models.BertClassifier.from_preset(
"bert_tiny_en_uncased", num_classes=3
)
请注意，BERT Tiny 模型只有 4,386,307 个可训练参数。
KerasHub 任务模型带有编译默认值。我们现在可以通过调用 fit() 方法来训练我们刚刚实例化的模型。
bert_classifier.fit(train_ds, validation_data=val_ds, epochs=1)
6867/6867 ━━━━━━━━━━━━━━━━━━━━ 61s 8ms/step - loss: 0.8732 - sparse_categorical_accuracy: 0.5864 - val_loss: 0.5900 - val_sparse_categorical_accuracy: 0.7602
<keras.src.callbacks.history.History at 0x7f4660171fc0>
我们的 BERT 分类器在验证拆分上达到了大约 76% 的准确率。现在，让我们评估其在测试拆分上的性能。
评估训练后的模型在测试数据上的性能。
bert_classifier.evaluate(test_ds)
614/614 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - loss: 0.5815 - sparse_categorical_accuracy: 0.7628
[0.5895748734474182, 0.7618078589439392]
我们的基准 BERT 模型在测试拆分上也获得了大约 76% 的相似准确率。现在，让我们尝试通过使用稍微更高的学习率重新编译模型来提高其性能。
bert_classifier = keras_hub.models.BertClassifier.from_preset(
"bert_tiny_en_uncased", num_classes=3
)
bert_classifier.compile(
loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
optimizer=keras.optimizers.Adam(5e-5),
metrics=["accuracy"],
)
bert_classifier.fit(train_ds, validation_data=val_ds, epochs=1)
bert_classifier.evaluate(test_ds)
6867/6867 ━━━━━━━━━━━━━━━━━━━━ 59s 8ms/step - accuracy: 0.6007 - loss: 0.8636 - val_accuracy: 0.7648 - val_loss: 0.5800
614/614 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - accuracy: 0.7700 - loss: 0.5692
[0.578984260559082, 0.7686278820037842]
仅调整学习率不足以提高性能，性能仍然保持在 76% 左右。让我们再试一次，但这次使用 keras.optimizers.AdamW 和学习率调度器。
class TriangularSchedule(keras.optimizers.schedules.LearningRateSchedule):
"""Linear ramp up for `warmup` steps, then linear decay to zero at `total` steps."""
def __init__(self, rate, warmup, total):
self.rate = rate
self.warmup = warmup
self.total = total
def get_config(self):
config = {"rate": self.rate, "warmup": self.warmup, "total": self.total}
return config
def __call__(self, step):
step = keras.ops.cast(step, dtype="float32")
rate = keras.ops.cast(self.rate, dtype="float32")
warmup = keras.ops.cast(self.warmup, dtype="float32")
total = keras.ops.cast(self.total, dtype="float32")
warmup_rate = rate * step / self.warmup
cooldown_rate = rate * (total - step) / (total - warmup)
triangular_rate = keras.ops.minimum(warmup_rate, cooldown_rate)
return keras.ops.maximum(triangular_rate, 0.0)
bert_classifier = keras_hub.models.BertClassifier.from_preset(
"bert_tiny_en_uncased", num_classes=3
)
# Get the total count of training batches.
# This requires walking the dataset to filter all -1 labels.
epochs = 3
total_steps = sum(1 for _ in train_ds.as_numpy_iterator()) * epochs
warmup_steps = int(total_steps * 0.2)
bert_classifier.compile(
loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
optimizer=keras.optimizers.AdamW(
TriangularSchedule(1e-4, warmup_steps, total_steps)
),
metrics=["accuracy"],
)
bert_classifier.fit(train_ds, validation_data=val_ds, epochs=epochs)
Epoch 1/3
6867/6867 ━━━━━━━━━━━━━━━━━━━━ 59s 8ms/step - accuracy: 0.5457 - loss: 0.9317 - val_accuracy: 0.7633 - val_loss: 0.5825
Epoch 2/3
6867/6867 ━━━━━━━━━━━━━━━━━━━━ 55s 8ms/step - accuracy: 0.7291 - loss: 0.6515 - val_accuracy: 0.7809 - val_loss: 0.5399
Epoch 3/3
6867/6867 ━━━━━━━━━━━━━━━━━━━━ 55s 8ms/step - accuracy: 0.7708 - loss: 0.5695 - val_accuracy: 0.7918 - val_loss: 0.5214
<keras.src.callbacks.history.History at 0x7f45645b3370>
成功！使用学习率调度器和 AdamW 优化器，我们的验证准确率提高到大约 79%。
现在，让我们在测试集上评估我们的最终模型，看看它的表现如何。
bert_classifier.evaluate(test_ds)
614/614 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - accuracy: 0.7956 - loss: 0.5128
[0.5245093703269958, 0.7890879511833191]
我们的 Tiny BERT 模型通过使用学习率调度器在测试集上实现了大约 79% 的准确率。这是对我们之前结果的重大改进。微调预训练的 BERT 模型可能是自然语言处理任务中的强大工具，即使像 Tiny BERT 这样的小型模型也可以取得令人瞩目的结果。
让我们现在保存我们的模型，并继续学习如何使用它执行推理。
保存和重新加载模型
bert_classifier.save("bert_classifier.keras")
restored_model = keras.models.load_model("bert_classifier.keras")
restored_model.evaluate(test_ds)
614/614 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - loss: 0.5128 - sparse_categorical_accuracy: 0.7956
[0.5245093703269958, 0.7890879511833191]
使用模型执行推理。
让我们看看如何使用 KerasHub 模型执行推理
# Convert to Hypothesis-Premise pair, for forward pass through model
sample = (sample["hypothesis"], sample["premise"])
sample
(<tf.Tensor: shape=(4,), dtype=string, numpy=
array([b'A girl is entertaining on stage',
b'A group of people posing in front of a body of water.',
b"The group of people aren't inide of the building.",
b'The people are taking a carriage ride.'], dtype=object)>,
<tf.Tensor: shape=(4,), dtype=string, numpy=
array([b'A girl in a blue leotard hula hoops on a stage with balloon shapes in the background.',
b'A group of people taking pictures on a walkway in front of a large body of water.',
b'Many people standing outside of a place talking to each other in front of a building that has a sign that says "HI-POINTE."',
b'Three people are riding a carriage pulled by four horses.'],
dtype=object)>)
KerasHub 模型中的默认预处理器会自动处理输入标记化，因此我们无需显式执行标记化。
predictions = bert_classifier.predict(sample)
def softmax(x):
return np.exp(x) / np.exp(x).sum(axis=0)
# Get the class predictions with maximum probabilities
predictions = softmax(predictions)
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 711ms/step
使用 RoBERTa 提高准确性
现在我们已经建立了基准，我们可以尝试通过试验不同的模型来改进我们的结果。借助 KerasHub，只需几行代码即可轻松地在同一数据集上微调 RoBERTa 检查点。
# Inittializing a RoBERTa from preset
roberta_classifier = keras_hub.models.RobertaClassifier.from_preset(
"roberta_base_en", num_classes=3
)
roberta_classifier.fit(train_ds, validation_data=val_ds, epochs=1)
roberta_classifier.evaluate(test_ds)
6867/6867 ━━━━━━━━━━━━━━━━━━━━ 2049s 297ms/step - loss: 0.5509 - sparse_categorical_accuracy: 0.7740 - val_loss: 0.3292 - val_sparse_categorical_accuracy: 0.8789
614/614 ━━━━━━━━━━━━━━━━━━━━ 56s 88ms/step - loss: 0.3307 - sparse_categorical_accuracy: 0.8784
[0.33771008253097534, 0.874796450138092]
RoBERTa 基本模型具有比 BERT Tiny 模型多得多的可训练参数，几乎是 BERT Tiny 模型的 30 倍，达到 124,645,635 个参数。因此，在 P100 GPU 上训练大约需要 1.5 个小时。但是，性能的提高是巨大的，验证和测试拆分上的准确率都提高到了 88%。使用 RoBERTa，我们能够在我们的 P100 GPU 上拟合最大批量大小为 16 的数据。
尽管使用了不同的模型，但是使用 RoBERTa 执行推理的步骤与使用 BERT 的步骤相同！
predictions = roberta_classifier.predict(sample)
print(tf.math.argmax(predictions, axis=1).numpy())
1/1 ━━━━━━━━━━━━━━━━━━━━ 4s 4s/step
[0 0 0 0]
我们希望本教程对您有所帮助，它演示了使用 KerasHub 和 BERT 进行语义相似性任务的便捷性和有效性。
在本教程中，我们演示了如何使用预训练的 BERT 模型来建立基准，并通过仅使用几行代码来训练更大的 RoBERTa 模型来提高性能。
KerasHub 工具箱为预处理文本提供了一系列模块化构建块，包括预训练的最新模型和低级 Transformer 编码器层。我们相信，这使得试验自然语言解决方案更加便捷和高效。