训练概览

为什么要进行微调？

微调 Sentence Transformer 模型通常会极大地提升模型在您的用例上的性能，因为每个任务对相似性的定义都不同。例如，对于新闻文章

“苹果发布新款 iPad”
“NVIDIA 正在为下一代 GPU 做准备”

那么对于以下用例，我们对相似性的概念可能有所不同

一个用于将新闻文章**分类**为经济、体育、科技、政治等的模型，应该为这些文本生成**相似的嵌入**。
一个用于**语义文本相似度**的模型，应该为这些文本生成**不相似的嵌入**，因为它们的含义不同。
一个用于**语义搜索**的模型，**不需要两个文档之间的相似性概念**，因为它只需要比较查询和文档。

另请参阅 训练示例，其中包含大量适用于常见实际应用的训练脚本，您可以直接采用。

训练组件

训练 Sentence Transformer 模型涉及 4 到 6 个组件

了解如何初始化用于训练的模型。了解如何准备用于训练的数据。了解如何准备和选择损失函数。了解哪些训练参数是有用的。了解如何在训练期间和之后进行评估。了解如何开始训练过程。

模型

Sentence Transformer 模型由一系列模块或自定义模块组成，具有很高的灵活性。如果您想进一步微调一个 SentenceTransformer 模型（例如，它有一个 modules.json 文件），那么您不必担心使用了哪些模块

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")

但如果您想从另一个检查点或从头开始训练，那么这些是您可以使用的最常见的架构

Transformers

大多数 Sentence Transformer 模型使用 Transformer 和 Pooling 模块。前者加载一个预训练的 transformer 模型（例如 BERT、RoBERTa、DistilBERT、ModernBERT 等），后者对 transformer 的输出进行池化，为每个输入句子生成一个单一的向量表示。

from sentence_transformers import models, SentenceTransformer

transformer = models.Transformer("google-bert/bert-base-uncased")
pooling = models.Pooling(transformer.get_word_embedding_dimension(), pooling_mode="mean")

model = SentenceTransformer(modules=[transformer, pooling])

这是 Sentence Transformers 中的默认选项，因此使用快捷方式更简单

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("google-bert/bert-base-uncased")

提示

最强大的基础模型通常是“编码器模型”，即那些经过训练能够为输入生成有意义的词元（token）嵌入的模型。您可以在这里找到强有力的候选模型：

填充掩码模型 (fill-mask models) - 为词元嵌入而训练
句子相似度模型 (sentence similarity models) - 为文本嵌入而训练
特征提取模型 (feature-extraction models) - 为文本嵌入而训练

考虑寻找专为您的语言和/或感兴趣领域设计的基础模型。例如，对于土耳其语，FacebookAI/xlm-roberta-base 会比 google-bert/bert-base-uncased 效果更好。

静态

静态嵌入模型（博客文章）使用 StaticEmbedding 模块，它们是不使用缓慢的 transformer 或注意力机制的编码器模型。对于这些模型，计算嵌入非常简单：给定输入词元，返回预先计算好的词元嵌入。这些模型的速度快了几个数量级，但无法捕捉复杂的语义，因为词元嵌入是与上下文分开计算的。

from sentence_transformers import models, SentenceTransformer
from tokenizers import Tokenizer

# Load any Tokenizer from Hugging Face
tokenizer = Tokenizer.from_pretrained("google-bert/bert-base-uncased")
# The `embedding_dim` is the dimensionality (size) of the token embeddings
static_embedding = StaticEmbedding(tokenizer, embedding_dim=512)

model = SentenceTransformer(modules=[static_embedding])

数据集

SentenceTransformerTrainer 使用 datasets.Dataset（单个数据集）或 datasets.DatasetDict 实例（多个数据集，另见多数据集训练）进行训练和评估。

🤗 Hugging Face Hub 上的数据

如果您想从 Hugging Face Datasets 加载数据，那么您应该使用 datasets.load_dataset()

from datasets import load_dataset

train_dataset = load_dataset("sentence-transformers/all-nli", "pair-class", split="train")
eval_dataset = load_dataset("sentence-transformers/all-nli", "pair-class", split="dev")

print(train_dataset)
"""
Dataset({
    features: ['premise', 'hypothesis', 'label'],
    num_rows: 942069
})
"""

有些数据集（包括 sentence-transformers/all-nli）需要您在数据集名称旁边提供一个“子集”。sentence-transformers/all-nli 有 4 个子集，每个子集都有不同的数据格式：pair、pair-class、pair-score、triplet。

注意

许多与 Sentence Transformers 开箱即用的 Hugging Face 数据集都已标记为 sentence-transformers，您可以通过浏览 https://hugging-face.cn/datasets?other=sentence-transformers 轻松找到它们。我们强烈建议您浏览这些数据集，以找到可能对您的任务有用的训练数据集。

本地数据（CSV、JSON、Parquet、Arrow、SQL）

如果您有常见文件格式的本地数据，那么您可以轻松地使用 datasets.load_dataset() 来加载这些数据

from datasets import load_dataset

dataset = load_dataset("csv", data_files="my_file.csv")

或

from datasets import load_dataset

dataset = load_dataset("json", data_files="my_file.json")

需要预处理的本地数据

如果您有需要额外预处理的本地数据，我建议您使用 datasets.Dataset.from_dict() 和一个列表字典来初始化您的数据集，如下所示

from datasets import Dataset

anchors = []
positives = []
# Open a file, do preprocessing, filtering, cleaning, etc.
# and append to the lists

dataset = Dataset.from_dict({
    "anchor": anchors,
    "positive": positives,
})

字典中的每个键都将成为结果数据集中的一列。

数据集格式

确保您的数据集格式与您的损失函数匹配（或者选择一个与您的数据集格式匹配的损失函数）非常重要。验证数据集格式是否适用于某个损失函数包括两个步骤：

如果您的损失函数根据损失概览表要求一个*标签*，那么您的数据集必须有一个**名为“label”或“score”的列**。该列将自动被视为标签。
根据损失概览表，所有不名为“label”或“score”的列都被视为*输入*。剩余列的数量必须与您所选损失函数的有效输入数量相匹配。这些列的名称**无关紧要**，只有**顺序重要**。

例如，给定一个具有列 ["text1", "text2", "label"] 的数据集，其中“label”列包含 0 到 1 之间的浮点相似度分数，我们可以将其与 CoSENTLoss、AnglELoss 和 CosineSimilarityLoss 一起使用，因为它

有一个“label”列，符合这些损失函数的要求。
有 2 个非标签列，正好是这些损失函数所需的数量。

如果您的数据集列顺序不正确，请务必使用 Dataset.select_columns 重新排序。例如，如果您的数据集有 ["good_answer", "bad_answer", "question"] 这几列，那么理论上这个数据集可以用于需要（锚点、正例、负例）三元组的损失函数，但 good_answer 列将被视为锚点，bad_answer 视为正例，question 视为负例。

此外，如果您的数据集有无关的列（例如 sample_id、metadata、source、type），您应该使用 Dataset.remove_columns 删除它们，否则它们将被用作输入。您也可以使用 Dataset.select_columns 来只保留所需的列。

损失函数

损失函数量化了模型在给定一批数据上的表现，从而允许优化器更新模型权重以产生更优（即更低）的损失值。这是训练过程的核心。

遗憾的是，没有一个单一的损失函数能对所有用例都表现最佳。相反，使用哪种损失函数在很大程度上取决于您可用的数据和您的目标任务。请参阅数据集格式，了解哪些数据集对哪些损失函数有效。此外，损失概览将是您了解各种选项的最佳助手。

大多数损失函数只需使用您正在训练的 SentenceTransformer 以及一些可选参数即可初始化，例如：

from datasets import load_dataset
from sentence_transformers import SentenceTransformer
from sentence_transformers.losses import CoSENTLoss

# Load a model to train/finetune
model = SentenceTransformer("xlm-roberta-base")

# Initialize the CoSENTLoss
# This loss requires pairs of text and a float similarity score as a label
loss = CoSENTLoss(model)

# Load an example training dataset that works with our loss function:
train_dataset = load_dataset("sentence-transformers/all-nli", "pair-score", split="train")
"""
Dataset({
    features: ['sentence1', 'sentence2', 'label'],
    num_rows: 942069
})
"""

训练参数

SentenceTransformerTrainingArguments 类可用于指定影响训练性能的参数，以及定义跟踪/调试参数。虽然它是可选的，但强烈建议尝试各种有用的参数。

eval_strategy eval_steps save_strategy save_steps save_total_limit report_to run_name log_level logging_steps push_to_hub hub_model_id hub_strategy hub_private_repo

这是一个如何初始化 SentenceTransformerTrainingArguments 的示例

args = SentenceTransformerTrainingArguments(
    # Required parameter:
    output_dir="models/mpnet-base-all-nli-triplet",
    # Optional training parameters:
    num_train_epochs=1,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    learning_rate=2e-5,
    warmup_ratio=0.1,
    fp16=True,  # Set to False if you get an error that your GPU can't run on FP16
    bf16=False,  # Set to True if you have a GPU that supports BF16
    batch_sampler=BatchSamplers.NO_DUPLICATES,  # losses that use "in-batch negatives" benefit from no duplicates
    # Optional tracking/debugging parameters:
    eval_strategy="steps",
    eval_steps=100,
    save_strategy="steps",
    save_steps=100,
    save_total_limit=2,
    logging_steps=100,
    run_name="mpnet-base-all-nli-triplet",  # Will be used in W&B if `wandb` is installed
)

评估器

您可以向 SentenceTransformerTrainer 提供一个 eval_dataset 以在训练期间获取评估损失，但在训练期间获得更具体的指标也可能很有用。为此，您可以使用评估器在训练前、训练中或训练后用有用的指标评估模型的性能。您可以同时使用 eval_dataset 和评估器，或者只使用其中之一，或者都不使用。它们根据 eval_strategy 和 eval_steps 训练参数进行评估。

以下是 Sentence Transformers 自带的已实现评估器

评估器	所需数据
`BinaryClassificationEvaluator`	带类别标签的句子对。
`EmbeddingSimilarityEvaluator`	带相似度分数的句子对。
`InformationRetrievalEvaluator`	查询（qid => 问题）、语料库（cid => 文档）和相关文档（qid => set[cid]）。
`NanoBEIREvaluator`	无需数据。
`MSEEvaluator`	源句子用于教师模型嵌入，目标句子用于学生模型嵌入。可以是相同的文本。
`ParaphraseMiningEvaluator`	ID 到句子的映射以及重复句子的 ID 对。
`RerankingEvaluator`	形如 `{'query': '...', 'positive': [...], 'negative': [...]}` 的字典列表。
`TranslationEvaluator`	两种不同语言的句子对。
`TripletEvaluator`	（锚点、正例、负例）对。

此外，应该使用 SequentialEvaluator 将多个评估器组合成一个评估器，并将其传递给 SentenceTransformerTrainer。

有时您没有所需的评估数据来自己准备这些评估器之一，但您仍然希望跟踪模型在某些常见基准测试上的表现。在这种情况下，您可以使用这些带有 Hugging Face 数据的评估器。

使用 STSb 的 EmbeddingSimilarityEvaluator

from datasets import load_dataset
from sentence_transformers.evaluation import EmbeddingSimilarityEvaluator, SimilarityFunction

# Load the STSB dataset (https://hugging-face.cn/datasets/sentence-transformers/stsb)
eval_dataset = load_dataset("sentence-transformers/stsb", split="validation")

# Initialize the evaluator
dev_evaluator = EmbeddingSimilarityEvaluator(
    sentences1=eval_dataset["sentence1"],
    sentences2=eval_dataset["sentence2"],
    scores=eval_dataset["score"],
    main_similarity=SimilarityFunction.COSINE,
    name="sts-dev",
)
# You can run evaluation like so:
# results = dev_evaluator(model)

使用 AllNLI 的 TripletEvaluator

from datasets import load_dataset
from sentence_transformers.evaluation import TripletEvaluator, SimilarityFunction

# Load triplets from the AllNLI dataset (https://hugging-face.cn/datasets/sentence-transformers/all-nli)
max_samples = 1000
eval_dataset = load_dataset("sentence-transformers/all-nli", "triplet", split=f"dev[:{max_samples}]")

# Initialize the evaluator
dev_evaluator = TripletEvaluator(
    anchors=eval_dataset["anchor"],
    positives=eval_dataset["positive"],
    negatives=eval_dataset["negative"],
    main_distance_function=SimilarityFunction.COSINE,
    name="all-nli-dev",
)
# You can run evaluation like so:
# results = dev_evaluator(model)

NanoBEIREvaluator

from sentence_transformers.evaluation import NanoBEIREvaluator

# Initialize the evaluator. Unlike most other evaluators, this one loads the relevant datasets
# directly from Hugging Face, so there's no mandatory arguments
dev_evaluator = NanoBEIREvaluator()
# You can run evaluation like so:
# results = dev_evaluator(model)

提示

当在训练期间频繁使用较小的 eval_steps 进行评估时，考虑使用一个很小的 eval_dataset 来最小化评估开销。如果您担心评估集的大小，90-1-9 的训练-评估-测试集划分可以提供一个平衡，为最终评估保留一个合理大小的测试集。训练后，您可以使用 trainer.evaluate(test_dataset) 来评估测试损失，或者用 test_evaluator(model) 初始化一个测试评估器以获取详细的测试指标。

如果您在训练后、保存模型前进行评估，您自动生成的模型卡仍将包含测试结果。

警告

当使用分布式训练时，评估器只在第一个设备上运行，这与在所有设备上共享的训练和评估数据集不同。

训练器

SentenceTransformerTrainer 是所有先前组件汇集的地方。我们只需要为训练器指定模型、训练参数（可选）、训练数据集、评估数据集（可选）、损失函数、评估器（可选），然后就可以开始训练了。让我们看一个所有这些组件都汇集在一起的脚本：

from datasets import load_dataset
from sentence_transformers import (
    SentenceTransformer,
    SentenceTransformerTrainer,
    SentenceTransformerTrainingArguments,
    SentenceTransformerModelCardData,
)
from sentence_transformers.losses import MultipleNegativesRankingLoss
from sentence_transformers.training_args import BatchSamplers
from sentence_transformers.evaluation import TripletEvaluator

# 1. Load a model to finetune with 2. (Optional) model card data
model = SentenceTransformer(
    "microsoft/mpnet-base",
    model_card_data=SentenceTransformerModelCardData(
        language="en",
        license="apache-2.0",
        model_name="MPNet base trained on AllNLI triplets",
    )
)

# 3. Load a dataset to finetune on
dataset = load_dataset("sentence-transformers/all-nli", "triplet")
train_dataset = dataset["train"].select(range(100_000))
eval_dataset = dataset["dev"]
test_dataset = dataset["test"]

# 4. Define a loss function
loss = MultipleNegativesRankingLoss(model)

# 5. (Optional) Specify training arguments
args = SentenceTransformerTrainingArguments(
    # Required parameter:
    output_dir="models/mpnet-base-all-nli-triplet",
    # Optional training parameters:
    num_train_epochs=1,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    learning_rate=2e-5,
    warmup_ratio=0.1,
    fp16=True,  # Set to False if you get an error that your GPU can't run on FP16
    bf16=False,  # Set to True if you have a GPU that supports BF16
    batch_sampler=BatchSamplers.NO_DUPLICATES,  # MultipleNegativesRankingLoss benefits from no duplicate samples in a batch
    # Optional tracking/debugging parameters:
    eval_strategy="steps",
    eval_steps=100,
    save_strategy="steps",
    save_steps=100,
    save_total_limit=2,
    logging_steps=100,
    run_name="mpnet-base-all-nli-triplet",  # Will be used in W&B if `wandb` is installed
)

# 6. (Optional) Create an evaluator & evaluate the base model
dev_evaluator = TripletEvaluator(
    anchors=eval_dataset["anchor"],
    positives=eval_dataset["positive"],
    negatives=eval_dataset["negative"],
    name="all-nli-dev",
)
dev_evaluator(model)

# 7. Create a trainer & train
trainer = SentenceTransformerTrainer(
    model=model,
    args=args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    loss=loss,
    evaluator=dev_evaluator,
)
trainer.train()

# (Optional) Evaluate the trained model on the test set
test_evaluator = TripletEvaluator(
    anchors=test_dataset["anchor"],
    positives=test_dataset["positive"],
    negatives=test_dataset["negative"],
    name="all-nli-test",
)
test_evaluator(model)

# 8. Save the trained model
model.save_pretrained("models/mpnet-base-all-nli-triplet/final")

# 9. (Optional) Push it to the Hugging Face Hub
model.push_to_hub("mpnet-base-all-nli-triplet")

回调

这个 Sentence Transformers 训练器集成了对各种 transformers.TrainerCallback 子类的支持，例如：

如果安装了 wandb，WandbCallback 可以自动将训练指标记录到 W&B。
如果可以访问 tensorboard，TensorBoardCallback 可以将训练指标记录到 TensorBoard。
如果安装了 codecarbon，CodeCarbonCallback 可以在训练期间跟踪模型的碳排放。
- 注意：这些碳排放量将被包含在您自动生成的模型卡片中。

有关集成回调以及如何编写您自己的回调的更多信息，请参阅 Transformers 回调文档。

多数据集训练

表现最好的模型是使用多个数据集同时训练的。通常，这相当棘手，因为每个数据集的格式都不同。然而，sentence_transformers.trainer.SentenceTransformerTrainer 可以在不将每个数据集转换为相同格式的情况下，使用多个数据集进行训练。它甚至可以对每个数据集应用不同的损失函数。使用多个数据集进行训练的步骤如下：

使用一个 Dataset 实例的字典（或一个 DatasetDict）作为 train_dataset（可选地也作为 eval_dataset）。
（可选）使用一个损失函数字典，将数据集名称映射到损失。仅当您希望为不同的数据集使用不同的损失函数时才需要。

每个训练/评估批次将只包含来自其中一个数据集的样本。从多个数据集中采样批次的顺序由 MultiDatasetBatchSamplers 枚举定义，该枚举可以通过 multi_dataset_batch_sampler 传递给 SentenceTransformerTrainingArguments。有效选项包括：

MultiDatasetBatchSamplers.ROUND_ROBIN：从每个数据集中轮流采样，直到其中一个耗尽。使用此策略，很可能不会使用每个数据集的所有样本，但每个数据集的采样频率是相等的。
MultiDatasetBatchSamplers.PROPORTIONAL (默认): 按比例从每个数据集中采样，与其大小成正比。使用此策略，将使用每个数据集的所有样本，并且会更频繁地从较大的数据集中采样。

这种多任务训练已被证明非常有效，例如，Huang 等人采用了 MultipleNegativesRankingLoss、CoSENTLoss 以及一个不带批内负例、仅带难负例的 MultipleNegativesRankingLoss 变体，从而在中文任务上达到了最先进的性能。他们甚至应用了 MatryoshkaLoss，让模型能够生成套娃嵌入 (Matryoshka Embeddings)。

在多个数据集上训练看起来像这样：

from datasets import load_dataset
from sentence_transformers import SentenceTransformer, SentenceTransformerTrainer
from sentence_transformers.losses import CoSENTLoss, MultipleNegativesRankingLoss, SoftmaxLoss

# 1. Load a model to finetune
model = SentenceTransformer("bert-base-uncased")

# 2. Load several Datasets to train with
# (anchor, positive)
all_nli_pair_train = load_dataset("sentence-transformers/all-nli", "pair", split="train[:10000]")
# (premise, hypothesis) + label
all_nli_pair_class_train = load_dataset("sentence-transformers/all-nli", "pair-class", split="train[:10000]")
# (sentence1, sentence2) + score
all_nli_pair_score_train = load_dataset("sentence-transformers/all-nli", "pair-score", split="train[:10000]")
# (anchor, positive, negative)
all_nli_triplet_train = load_dataset("sentence-transformers/all-nli", "triplet", split="train[:10000]")
# (sentence1, sentence2) + score
stsb_pair_score_train = load_dataset("sentence-transformers/stsb", split="train[:10000]")
# (anchor, positive)
quora_pair_train = load_dataset("sentence-transformers/quora-duplicates", "pair", split="train[:10000]")
# (query, answer)
natural_questions_train = load_dataset("sentence-transformers/natural-questions", split="train[:10000]")

# We can combine all datasets into a dictionary with dataset names to datasets
train_dataset = {
    "all-nli-pair": all_nli_pair_train,
    "all-nli-pair-class": all_nli_pair_class_train,
    "all-nli-pair-score": all_nli_pair_score_train,
    "all-nli-triplet": all_nli_triplet_train,
    "stsb": stsb_pair_score_train,
    "quora": quora_pair_train,
    "natural-questions": natural_questions_train,
}

# 3. Load several Datasets to evaluate with
# (anchor, positive, negative)
all_nli_triplet_dev = load_dataset("sentence-transformers/all-nli", "triplet", split="dev")
# (sentence1, sentence2, score)
stsb_pair_score_dev = load_dataset("sentence-transformers/stsb", split="validation")
# (anchor, positive)
quora_pair_dev = load_dataset("sentence-transformers/quora-duplicates", "pair", split="train[10000:11000]")
# (query, answer)
natural_questions_dev = load_dataset("sentence-transformers/natural-questions", split="train[10000:11000]")

# We can use a dictionary for the evaluation dataset too, but we don't have to. We could also just use
# no evaluation dataset, or one dataset.
eval_dataset = {
    "all-nli-triplet": all_nli_triplet_dev,
    "stsb": stsb_pair_score_dev,
    "quora": quora_pair_dev,
    "natural-questions": natural_questions_dev,
}

# 4. Load several loss functions to train with
# (anchor, positive), (anchor, positive, negative)
mnrl_loss = MultipleNegativesRankingLoss(model)
# (sentence_A, sentence_B) + class
softmax_loss = SoftmaxLoss(model, model.get_sentence_embedding_dimension(), 3)
# (sentence_A, sentence_B) + score
cosent_loss = CoSENTLoss(model)

# Create a mapping with dataset names to loss functions, so the trainer knows which loss to apply where.
# Note that you can also just use one loss if all of your training/evaluation datasets use the same loss
losses = {
    "all-nli-pair": mnrl_loss,
    "all-nli-pair-class": softmax_loss,
    "all-nli-pair-score": cosent_loss,
    "all-nli-triplet": mnrl_loss,
    "stsb": cosent_loss,
    "quora": mnrl_loss,
    "natural-questions": mnrl_loss,
}

# 5. Define a simple trainer, although it's recommended to use one with args & evaluators
trainer = SentenceTransformerTrainer(
    model=model,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    loss=losses,
)
trainer.train()

# 6. save the trained model and optionally push it to the Hugging Face Hub
model.save_pretrained("bert-base-all-nli-stsb-quora-nq")
model.push_to_hub("bert-base-all-nli-stsb-quora-nq")

已弃用的训练

在 Sentence Transformers v3.0 发布之前，模型会使用 SentenceTransformer.fit() 方法和 InputExample 的 DataLoader 进行训练，看起来像这样：

from sentence_transformers import SentenceTransformer, InputExample, losses
from torch.utils.data import DataLoader

# Define the model. Either from scratch of by loading a pre-trained model
model = SentenceTransformer("distilbert/distilbert-base-uncased")

# Define your train examples. You need more than just two examples...
train_examples = [
    InputExample(texts=["My first sentence", "My second sentence"], label=0.8),
    InputExample(texts=["Another pair", "Unrelated sentence"], label=0.3),
]

# Define your train dataset, the dataloader and the train loss
train_dataloader = DataLoader(train_examples, shuffle=True, batch_size=16)
train_loss = losses.CosineSimilarityLoss(model)

# Tune the model
model.fit(train_objectives=[(train_dataloader, train_loss)], epochs=1, warmup_steps=100)

自 v3.0 发布以来，使用 SentenceTransformer.fit() 仍然是可能的，但它会在幕后初始化一个 SentenceTransformerTrainer。建议直接使用 Trainer，因为您可以通过 SentenceTransformerTrainingArguments 进行更多控制，但依赖 SentenceTransformer.fit() 的现有训练脚本应该仍然可以工作。

如果更新后的 SentenceTransformer.fit() 出现问题，您也可以通过调用 SentenceTransformer.old_fit() 来获得完全相同的旧行为，但该方法计划在未来完全弃用。

最佳基础嵌入模型

您的文本嵌入模型的质量取决于您选择的 transformer 模型。遗憾的是，我们不能从一个模型在 GLUE 或 SuperGLUE 等基准测试上的更好性能，就推断出该模型也能产生更好的表示。

为了测试 transformer 模型的适用性，我使用 training_nli_v2.py 脚本，在 560k 个（锚点、正例、负例）三元组上训练 1 个 epoch，批大小为 64。然后我在来自不同领域的 14 个多样化的文本相似性任务（聚类、语义搜索、重复检测等）上进行评估。

在下表中，您可以看到不同模型在此基准测试上的性能表现：

模型	性能（14 个句子相似度任务）
microsoft/mpnet-base	60.99
nghuyong/ernie-2.0-en	60.73
microsoft/deberta-base	60.21
roberta-base	59.63
t5-base	59.21
bert-base-uncased	59.17
distilbert-base-uncased	59.03
nreimers/TinyBERT_L-6_H-768_v2	58.27
google/t5-v1_1-base	57.63
nreimers/MiniLMv2-L6-H768-distilled-from-BERT-Large	57.31
albert-base-v2	57.14
microsoft/MiniLM-L12-H384-uncased	56.79
microsoft/deberta-v3-base	54.46

与 CrossEncoder 训练的比较

训练 SentenceTransformer 模型与训练 CrossEncoder 模型非常相似，但有一些关键区别：

与将 score、scores、label 和 labels 列都视为“标签列”不同，这里只有 score 和 label 被视为标签列。正如您在损失概览文档中所见，某些损失函数要求在具有这些名称之一的列中提供特定的标签/分数。
对于 CrossEncoder 训练，您可以在一列中使用（可变大小的）文本列表。而在 SentenceTransformer 训练中，您不能在训练/评估数据集的列中使用输入列表（例如文本）。简而言之：不支持使用可变数量的负例进行训练。

有关训练 CrossEncoder 模型的更多详细信息，请参阅 Cross Encoder > 训练概览文档。