损失函数

sentence_transformers.cross_encoder.losses 定义了可以在训练数据上微调 cross-encoder 模型时使用的不同损失函数。损失函数的选择在微调模型时起着关键作用。它决定了模型在特定下游任务上的表现如何。

不幸的是，没有“万能”的损失函数。合适的损失函数取决于可用的训练数据和目标任务。可以查看损失函数概述来帮助缩小损失函数的选择范围。

BinaryCrossEntropyLoss

class sentence_transformers.cross_encoder.losses.BinaryCrossEntropyLoss(model: CrossEncoder, activation_fn: Module = Identity(), pos_weight: Tensor | None = None, **kwargs)[source]

为 CrossEncoder 模型计算二元交叉熵损失。此损失用于训练模型，使其为正对预测高 logits，为负对预测低 logits。模型应初始化为 num_labels = 1（也即默认值）以预测一个类别。

许多强大的 CrossEncoder MS MARCO Reranker 模型都是使用此损失训练的。

参数:

model (CrossEncoder) – 要训练的 CrossEncoder 模型。
activation_fn (Module) – 在计算损失之前应用于 logits 的激活函数。默认为 Identity。
pos_weight (Tensor, optional) – 正例的权重。必须是一个 torch.Tensor，例如 torch.tensor(4) 表示权重为 4。默认为 None。
**kwargs – 传递给底层 torch.nn.BCEWithLogitsLoss 的其他关键字参数。

参考文献

要求

必须将模型初始化为 num_labels = 1（也即默认值）以预测一个类别。

输入

文本	标签	模型输出标签的数量
(锚点, 正例/负例) 对	正例为 1，负例为 0	1
(句子_A, 句子_B) 对	0 到 1 之间的浮点相似度分数	1

建议

使用 mine_hard_negatives 和 output_format="labeled-pair"，使用难负样本将问答对转换为带有标签 1 或 0 的 (anchor, positive/negative) 对 格式。

示例

from sentence_transformers.cross_encoder import CrossEncoder, CrossEncoderTrainer, losses
from datasets import Dataset

model = CrossEncoder("microsoft/mpnet-base")
train_dataset = Dataset.from_dict({
    "query": ["What are pandas?", "What are pandas?"],
    "response": ["Pandas are a kind of bear.", "Pandas are a kind of fish."],
    "label": [1, 0],
})
loss = losses.BinaryCrossEntropyLoss(model)

trainer = CrossEncoderTrainer(
    model=model,
    train_dataset=train_dataset,
    loss=loss,
)
trainer.train()

CrossEntropyLoss

class sentence_transformers.cross_encoder.losses.CrossEntropyLoss(model: CrossEncoder, activation_fn: Module = Identity(), **kwargs)[source]

为 CrossEncoder 模型计算交叉熵损失。此损失用于训练模型，使其为给定句子对预测正确的类别标签。类别的数量应等于模型输出标签的数量。

参数:

model (CrossEncoder) – 要训练的 CrossEncoder 模型。
activation_fn (Module) – 在计算损失之前应用于 logits 的激活函数。默认为 Identity。
**kwargs – 传递给底层 torch.nn.CrossEntropyLoss 的其他关键字参数。

参考文献

要求

可以将模型初始化为 num_labels > 1 以预测多个类别。
数据集的类别数量应等于模型输出标签的数量 (model.num_labels)。

输入

文本	标签	模型输出标签的数量
(句子_A, 句子_B) 对	类别	num_classes

示例

from sentence_transformers.cross_encoder import CrossEncoder, CrossEncoderTrainer, losses
from datasets import Dataset

model = CrossEncoder("microsoft/mpnet-base", num_labels=2)
train_dataset = Dataset.from_dict({
    "sentence1": ["How can I be a good geologist?", "What is the capital of France?"],
    "sentence2": ["What should I do to be a great geologist?", "What is the capital of Germany?"],
    "label": [1, 0],  # 1: duplicate, 0: not duplicate
})
loss = losses.CrossEntropyLoss(model)

trainer = CrossEncoderTrainer(
    model=model,
    train_dataset=train_dataset,
    loss=loss,
)
trainer.train()

LambdaLoss

class sentence_transformers.cross_encoder.losses.LambdaLoss(model: ~sentence_transformers.cross_encoder.CrossEncoder.CrossEncoder, weighting_scheme: ~sentence_transformers.cross_encoder.losses.LambdaLoss.BaseWeightingScheme | None = NDCGLoss2PPScheme( (ndcg_loss2): NDCGLoss2Scheme() (lambda_rank): LambdaRankScheme() ), k: int | None = None, sigma: float = 1.0, eps: float = 1e-10, reduction_log: ~typing.Literal['natural', 'binary'] = 'binary', activation_fn: ~torch.nn.modules.module.Module | None = Identity(), mini_batch_size: int | None = None)[source]

用于排序指标优化的 LambdaLoss 框架。此损失函数实现了用于排序指标优化的 LambdaLoss 框架，该框架提供了包括 LambdaRank 和 NDCG 变体在内的各种加权方案。该实现经过优化，可以有效地处理填充的文档，仅在模型推理期间处理有效文档。

注意

使用 LambdaLoss 时，每个查询的文档数量可以在样本之间变化。

参数:

model (CrossEncoder) – 要训练的 CrossEncoder 模型
weighting_scheme (BaseWeightingScheme, optional) –
要用于损失函数的加权方案。
- NoWeightingScheme：无加权方案（权重 = 1.0）
- NDCGLoss1Scheme：NDCG Loss1 加权方案
- NDCGLoss2Scheme：NDCG Loss2 加权方案
- LambdaRankScheme：LambdaRank 加权方案
- NDCGLoss2PPScheme：NDCG Loss2++ 加权方案
默认为 NDCGLoss2PPScheme。在原始 LambdaLoss 论文中，NDCGLoss2PPScheme 被证明达到了最强的性能，NDCGloss2Scheme 紧随其后。
k (int, optional) – 计算 NDCG@K 时要考虑的文档数量。默认为 None（使用所有文档）。
sigma (float) – sigmoid 中使用的分数差权重
eps (float) – 用于数值稳定的小常数
reduction_log (str) – 要使用的对数类型 - “natural”：自然对数 (log) - “binary”：二进制对数 (log2)
activation_fn (Module) – 在计算损失之前应用于 logits 的激活函数。默认为 Identity。
mini_batch_size (int, optional) –
每次前向传播处理的样本数量。这对内存消耗和训练过程的速度有显著影响。有三种可能的情况：
- 如果 mini_batch_size 为 None，则 mini_batch_size 被设置为批次大小。
- 如果 mini_batch_size 大于 0，则批次被分割成大小为 mini_batch_size 的小批次。
- 如果 mini_batch_size 小于等于 0，则整个批次一次性处理。
默认为 None。

参考文献

用于排序指标优化的 LambdaLoss 框架： https://marc.najork.org/papers/cikm2018.pdf
带上下文的排序学习与自注意力： https://hugging-face.cn/papers/2005.10084
Cross Encoder > 训练样本 > MS MARCO

要求

包含多个文档的查询（列表式方法）
文档必须具有相关性分数/标签。支持二进制和连续标签。

输入

文本	标签	模型输出标签的数量
(query, [doc1, doc2, …, docN])	[score1, score2, …, scoreN]	1

建议

使用 mine_hard_negatives 和 output_format="labeled-list" 将问答对转换为所需输入格式，并包含难负样本。

关系

LambdaLoss 经验上比具有相同输入格式的其他损失函数表现更好。

示例

from sentence_transformers.cross_encoder import CrossEncoder, CrossEncoderTrainer, losses
from datasets import Dataset

model = CrossEncoder("microsoft/mpnet-base")
train_dataset = Dataset.from_dict({
    "query": ["What are pandas?", "What is the capital of France?"],
    "docs": [
        ["Pandas are a kind of bear.", "Pandas are kind of like fish."],
        ["The capital of France is Paris.", "Paris is the capital of France.", "Paris is quite large."],
    ],
    "labels": [[1, 0], [1, 1, 0]],
})
loss = losses.LambdaLoss(model)

trainer = CrossEncoderTrainer(
    model=model,
    train_dataset=train_dataset,
    loss=loss,
)
trainer.train()

class sentence_transformers.cross_encoder.losses.LambdaLoss.BaseWeightingScheme(*args, **kwargs)[source]: 在 LambdaLoss 中实现加权方案的基类。

class sentence_transformers.cross_encoder.losses.NoWeightingScheme(*args, **kwargs)[source]: 无加权方案的实现（权重 = 1.0）。

class sentence_transformers.cross_encoder.losses.NDCGLoss1Scheme(*args, **kwargs)[source]

NDCG Loss1 加权方案的实现。

它用于优化 NDCG 指标，但此加权方案不被推荐，因为在原始 LambdaLoss 论文中，NDCGLoss2Scheme 和 NDCGLoss2PPScheme 被证明能达到更高的性能。

class sentence_transformers.cross_encoder.losses.NDCGLoss2Scheme(*args, **kwargs)[source]

NDCG Loss2 加权方案的实现。

该方案比 NDCGLoss1Scheme 使用了更紧密的界限，并在原始 LambdaLoss 论文中被证明能达到更高的性能。它用于优化 NDCG 指标。

class sentence_transformers.cross_encoder.losses.LambdaRankScheme(*args, **kwargs)[source]

LambdaRank 加权方案的实现。

此加权优化了 NDCG 的粗略上限。

class sentence_transformers.cross_encoder.losses.NDCGLoss2PPScheme(mu: float = 10.0)[source]

NDCG Loss2++ 加权方案的实现。

它是一种混合加权方案，结合了 NDCGLoss2 和 LambdaRank 方案。在原始 LambdaLoss 论文中，它被证明达到了最强的性能。

ListMLELoss

class sentence_transformers.cross_encoder.losses.ListMLELoss(model: CrossEncoder, activation_fn: Module | None = Identity(), mini_batch_size: int | None = None, respect_input_order: bool = True)[source]

此损失函数实现了 ListMLE 学习排序算法，该算法基于最大似然估计排列使用列表式方法。它最大化了由真实标签引起的排列的似然度。

注意

使用 ListMLELoss 时，每个查询的文档数量可以在样本之间变化。

参数:

model (CrossEncoder) – 要训练的 CrossEncoder 模型
activation_fn (Module) – 在计算损失之前应用于 logits 的激活函数。默认为 Identity。
mini_batch_size (int, optional) –
每次前向传播处理的样本数量。这对内存消耗和训练过程的速度有显著影响。有三种可能的情况：
- 如果 mini_batch_size 为 None，则 mini_batch_size 被设置为批次大小。
- 如果 mini_batch_size 大于 0，则批次被分割成大小为 mini_batch_size 的小批次。
- 如果 mini_batch_size 小于等于 0，则整个批次一次性处理。
默认为 None。
respect_input_order (bool) – 是否尊重文档的原始输入顺序。如果为 True，则假定输入文档已按相关性排序（最相关的在前）。如果为 False，则按标签值对文档进行排序。默认为 True。

参考文献

列表式学习排序：理论与算法： https://dl.acm.org/doi/abs/10.1145/1390156.1390306
Cross Encoder > 训练样本 > MS MARCO

要求

包含多个文档的查询（列表式方法）
文档必须具有相关性分数/标签。支持二进制和连续标签。
文档必须按定义的排名顺序排序。

输入

文本	标签	模型输出标签的数量
(query, [doc1, doc2, …, docN])	[score1, score2, …, scoreN]	1

建议

使用 mine_hard_negatives 和 output_format="labeled-list" 将问答对转换为所需输入格式，并包含难负样本。

关系

PListMLELoss 是 ListMLELoss 的扩展，允许对损失进行位置加权。 PListMLELoss 通常优于 ListMLELoss，并推荐使用它。
LambdaLoss 接受相同的输入，并且通常优于此损失函数。

示例

from sentence_transformers.cross_encoder import CrossEncoder, CrossEncoderTrainer, losses
from datasets import Dataset

model = CrossEncoder("microsoft/mpnet-base")
train_dataset = Dataset.from_dict({
    "query": ["What are pandas?", "What is the capital of France?"],
    "docs": [
        ["Pandas are a kind of bear.", "Pandas are kind of like fish."],
        ["The capital of France is Paris.", "Paris is the capital of France.", "Paris is quite large."],
    ],
    "labels": [[1, 0], [1, 1, 0]],
})

# Standard ListMLE loss respecting input order
loss = losses.ListMLELoss(model)

trainer = CrossEncoderTrainer(
    model=model,
    train_dataset=train_dataset,
    loss=loss,
)
trainer.train()

PListMLELoss

class sentence_transformers.cross_encoder.losses.PListMLELoss(model: CrossEncoder, lambda_weight: PListMLELambdaWeight | None = PListMLELambdaWeight(), activation_fn: Module | None = Identity(), mini_batch_size: int | None = None, respect_input_order: bool = True)[source]

用于带位置感知加权的排序学习的 PListMLE 损失。此损失函数实现了 ListMLE 排序算法，该算法使用基于最大似然估计排列的列表式方法。它最大化了由具有位置感知加权的真实标签引起的排列的似然度。

此损失也称为位置感知 ListMLE 或 p-ListMLE。

注意

使用 PListMLELoss 时，每个查询的文档数量可以在样本之间变化。

参数:

model (CrossEncoder) – 要训练的 CrossEncoder 模型
lambda_weight (PListMLELambdaWeight, optional) – 要使用的加权方案。指定时，实现位置感知 ListMLE，它为不同的排名位置应用不同的权重。默认为 None（标准 PListMLE）。
activation_fn (Module) – 在计算损失之前应用于 logits 的激活函数。默认为 Identity。
mini_batch_size (int, optional) –
每次前向传播处理的样本数量。这对内存消耗和训练过程的速度有显著影响。有三种可能的情况：
- 如果 mini_batch_size 为 None，则 mini_batch_size 被设置为批次大小。
- 如果 mini_batch_size 大于 0，则批次被分割成大小为 mini_batch_size 的小批次。
- 如果 mini_batch_size 小于等于 0，则整个批次一次性处理。
默认为 None。
respect_input_order (bool) – 是否尊重文档的原始输入顺序。如果为 True，则假定输入文档已按相关性排序（最相关的在前）。如果为 False，则按标签值对文档进行排序。默认为 True。

参考文献

位置感知 ListMLE：排序的顺序学习过程： https://auai.org/uai2014/proceedings/individuals/164.pdf
Cross Encoder > 训练样本 > MS MARCO

要求

包含多个文档的查询（列表式方法）
文档必须具有相关性分数/标签。支持二进制和连续标签。
文档必须按定义的排名顺序排序。

输入

文本	标签	模型输出标签的数量
(query, [doc1, doc2, …, docN])	[score1, score2, …, scoreN]	1

建议

使用 mine_hard_negatives 和 output_format="labeled-list" 将问答对转换为所需输入格式，并包含难负样本。

关系

PListMLELoss 是 ListMLELoss 的扩展，允许对损失进行位置加权。 PListMLELoss 通常优于 ListMLELoss，并推荐使用它。
LambdaLoss 接受相同的输入，并且通常优于此损失函数。

示例

from sentence_transformers.cross_encoder import CrossEncoder, CrossEncoderTrainer, losses
from datasets import Dataset

model = CrossEncoder("microsoft/mpnet-base")
train_dataset = Dataset.from_dict({
    "query": ["What are pandas?", "What is the capital of France?"],
    "docs": [
        ["Pandas are a kind of bear.", "Pandas are kind of like fish."],
        ["The capital of France is Paris.", "Paris is the capital of France.", "Paris is quite large."],
    ],
    "labels": [[1, 0], [1, 1, 0]],
})

# Either: Position-Aware ListMLE with default weighting
lambda_weight = losses.PListMLELambdaWeight()
loss = losses.PListMLELoss(model, lambda_weight=lambda_weight)

# or: Position-Aware ListMLE with custom weighting function
def custom_discount(ranks): # e.g. ranks: [1, 2, 3, 4, 5]
    return 1.0 / torch.log1p(ranks)
lambda_weight = losses.PListMLELambdaWeight(rank_discount_fn=custom_discount)
loss = losses.PListMLELoss(model, lambda_weight=lambda_weight)

trainer = CrossEncoderTrainer(
    model=model,
    train_dataset=train_dataset,
    loss=loss,
)
trainer.train()

class sentence_transformers.cross_encoder.losses.PListMLELambdaWeight(rank_discount_fn=None)[source]

在位置感知 ListMLE 损失中实现加权方案的基类。

初始化 PListMLE 损失的 lambda 权重。

参数:: rank_discount_fn – 计算每个排名位置折扣的函数。如果为 None，则使用默认折扣 2^(num_docs - rank) - 1。

ListNetLoss

class sentence_transformers.cross_encoder.losses.ListNetLoss(model: CrossEncoder, activation_fn: Module | None = Identity(), mini_batch_size: int | None = None)[source]

ListNet 学习排序损失。此损失函数实现了 ListNet 排序算法，该算法使用列表式方法来学习排序模型。它最小化了预测排名分布与真实排名分布之间的交叉熵。该实现经过优化，可以有效地处理填充的文档，仅在模型推理期间处理有效文档。

注意

使用 ListNetLoss 时，每个查询的文档数量可以在样本之间变化。

参数:

model (CrossEncoder) – 要训练的 CrossEncoder 模型
activation_fn (Module) – 在计算损失之前应用于 logits 的激活函数。默认为 Identity。
mini_batch_size (int, optional) –
每次前向传播处理的样本数量。这对内存消耗和训练过程的速度有显著影响。有三种可能的情况：
- 如果 mini_batch_size 为 None，则 mini_batch_size 被设置为批次大小。
- 如果 mini_batch_size 大于 0，则批次被分割成大小为 mini_batch_size 的小批次。
- 如果 mini_batch_size 小于等于 0，则整个批次一次性处理。
默认为 None。

参考文献

学习排序：从成对方法到列表式方法： https://www.microsoft.com/en-us/research/publication/learning-to-rank-from-pairwise-approach-to-listwise-approach/
带上下文的排序学习与自注意力： https://hugging-face.cn/papers/2005.10084
Cross Encoder > 训练样本 > MS MARCO

要求

包含多个文档的查询（列表式方法）
文档必须具有相关性分数/标签。支持二进制和连续标签。

输入

文本	标签	模型输出标签的数量
(query, [doc1, doc2, …, docN])	[score1, score2, …, scoreN]	1

建议

使用 mine_hard_negatives 和 output_format="labeled-list" 将问答对转换为所需输入格式，并包含难负样本。

关系

LambdaLoss 接受相同的输入，并且通常优于此损失函数。

示例

from sentence_transformers.cross_encoder import CrossEncoder, CrossEncoderTrainer, losses
from datasets import Dataset

model = CrossEncoder("microsoft/mpnet-base")
train_dataset = Dataset.from_dict({
    "query": ["What are pandas?", "What is the capital of France?"],
    "docs": [
        ["Pandas are a kind of bear.", "Pandas are kind of like fish."],
        ["The capital of France is Paris.", "Paris is the capital of France.", "Paris is quite large."],
    ],
    "labels": [[1, 0], [1, 1, 0]],
})
loss = losses.ListNetLoss(model)

trainer = CrossEncoderTrainer(
    model=model,
    train_dataset=train_dataset,
    loss=loss,
)
trainer.train()

MultipleNegativesRankingLoss (多负例排序损失)

class sentence_transformers.cross_encoder.losses.MultipleNegativesRankingLoss(model: CrossEncoder, num_negatives: int | None = 4, scale: int = 10.0, activation_fn: Module | None = Sigmoid())[source]

给定一个 (anchor, positive) 对或 (anchor, positive, negative) 三元组列表，此损失函数优化以下目标

给定一个锚点（例如一个问题），在批次中的每一个正例和负例（例如所有答案）中，为对应的正例（即答案）赋予最高的相似度。

如果您提供可选的负例，它们都将用作额外的选项，模型必须从中选择正确的正例。在合理范围内，这种“选择”越困难，模型就会变得越强大。因此，更高的批量大小会导致更多的批量内负例，从而提高性能（达到一定程度）。

此损失函数非常适合训练检索设置的嵌入，其中您有正向对（例如（查询，答案）），因为它将在每个批量中随机采样 n-1 个负向文档。

此损失函数也称为 InfoNCE 损失、SimCSE 损失、带批内负例的交叉熵损失，或简称为批内负例损失。

参数:

model (CrossEncoder) – 要训练的 CrossEncoder 模型。
num_negatives (int, optional) – 为每个锚点采样的批次内负样本数量。默认为 4。
scale (int, optional) – 相似性函数的输出乘以 scale 值。默认为 10.0。
activation_fn (Module) – 在计算损失之前应用于 logits 的激活函数。默认为 Sigmoid。

注意

当前的默认值在未来可能会发生变化。鼓励进行实验。

参考文献

高效自然语言响应建议用于智能回复，第 4.4 节： https://hugging-face.cn/papers/1705.00652

要求

必须将模型初始化为 num_labels = 1（也即默认值）以预测一个类别。

输入

文本	标签	模型输出标签的数量
(锚点, 正例) 对	无	1
(锚点, 正例, 负例) 三元组	无	1
(anchor, positive, negative_1, ..., negative_n)	无	1

建议

使用 BatchSamplers.NO_DUPLICATES (docs) 来确保批次内的负样本不是锚点或正样本的副本。
使用 mine_hard_negatives 和 output_format="n-tuple" 或 output_format="triplet" 将问答对转换为带有难负样本的 triplet。

关系

CachedMultipleNegativesRankingLoss 等同于此损失，但它使用了缓存，允许使用更大的批次大小（从而获得更好的性能）而无需额外的内存。但是，它的速度稍慢。

示例

from sentence_transformers.cross_encoder import CrossEncoder, CrossEncoderTrainer, losses
from datasets import Dataset

model = CrossEncoder("microsoft/mpnet-base")
train_dataset = Dataset.from_dict({
    "query": ["What are pandas?", "What is the capital of France?"],
    "answer": ["Pandas are a kind of bear.", "The capital of France is Paris."],
})
loss = losses.MultipleNegativesRankingLoss(model)

trainer = CrossEncoderTrainer(
    model=model,
    train_dataset=train_dataset,
    loss=loss,
)
trainer.train()

CachedMultipleNegativesRankingLoss

class sentence_transformers.cross_encoder.losses.CachedMultipleNegativesRankingLoss(model: CrossEncoder, num_negatives: int | None = 4, scale: float = 10.0, activation_fn: Module | None = Sigmoid(), mini_batch_size: int = 32, show_progress_bar: bool = False)[source]

MultipleNegativesRankingLoss 的增强版本，它缓存了 logits 相对于损失的梯度。这允许使用更大的批次大小而不增加额外的内存。但是，它的速度稍慢。

详细来说

它首先进行一个快速预测步骤，不带梯度/计算图，以获取所有 logits；

计算损失，反向传播到 logits，并缓存相对于 logits 的梯度；

第二次带梯度/计算图的预测步骤，并将缓存的梯度连接到反向传播链中。

注意：所有步骤都通过小批次进行。在 GradCache 的原始实现中，(2) 不是通过小批次进行的，当批次大小很大时需要大量内存。根据论文，梯度缓存会牺牲大约 20% 的计算时间。

给定一个 (anchor, positive) 对或 (anchor, positive, negative) 三元组列表，此损失函数优化以下目标

给定一个锚点（例如一个问题），在批次中的每一个正例和负例（例如所有答案）中，为对应的正例（即答案）赋予最高的相似度。

如果您提供可选的负例，它们都将用作额外的选项，模型必须从中选择正确的正例。在合理范围内，这种“选择”越困难，模型就会变得越强大。因此，更高的批量大小会导致更多的批量内负例，从而提高性能（达到一定程度）。

此损失函数非常适合训练检索设置的嵌入，其中您有正向对（例如（查询，答案）），因为它将在每个批量中随机采样 n-1 个负向文档。

此损失也称为 InfoNCE 损失与 GradCache。

参数:

model (CrossEncoder) – 要训练的 CrossEncoder 模型。
num_negatives (int, optional) – 为每个锚点采样的批次内负样本数量。默认为 4。
scale (int, optional) – 相似性函数的输出乘以 scale 值。默认为 10.0。
activation_fn (Module) – 在计算损失之前应用于 logits 的激活函数。默认为 Sigmoid。
mini_batch_size (int, optional) – 前向传播的小批次大小。这会影响内存使用量。默认为 32。
show_progress_bar (bool, optional) – 是否在前向传播期间显示进度条。默认为 False。

注意

当前的默认值在未来可能会发生变化。鼓励进行实验。

参考文献

高效自然语言响应建议用于智能回复，第 4.4 节： https://hugging-face.cn/papers/1705.00652
在内存受限设置下扩展深度对比学习批次大小： https://hugging-face.cn/papers/2101.06983
Cross Encoder > 训练样本 > MS MARCO
Cross Encoder > 训练样本 > Rerankers

要求

必须将模型初始化为 num_labels = 1（也即默认值）以预测一个类别。
应与大的 per_device_train_batch_size 和小的 mini_batch_size 一起使用，以获得卓越的性能，但训练时间比 MultipleNegativesRankingLoss 慢。

输入

文本	标签	模型输出标签的数量
(锚点, 正例) 对	无	1
(锚点, 正例, 负例) 三元组	无	1
(anchor, positive, negative_1, ..., negative_n)	无	1

建议

使用 BatchSamplers.NO_DUPLICATES (docs) 来确保批次内的负样本不是锚点或正样本的副本。
使用 mine_hard_negatives 和 output_format="n-tuple" 或 output_format="triplet" 将问答对转换为带有难负样本的 triplet。

关系

等同于 MultipleNegativesRankingLoss，但增加了缓存，允许使用更大的批次大小（从而获得更好的性能）而不增加额外的内存。此损失的训练速度也比 MultipleNegativesRankingLoss 慢。

示例

from sentence_transformers.cross_encoder import CrossEncoder, CrossEncoderTrainer, losses
from datasets import Dataset

model = CrossEncoder("microsoft/mpnet-base")
train_dataset = Dataset.from_dict({
    "query": ["What are pandas?", "What is the capital of France?"],
    "answer": ["Pandas are a kind of bear.", "The capital of France is Paris."],
})
loss = losses.CachedMultipleNegativesRankingLoss(model, mini_batch_size=32)

trainer = CrossEncoderTrainer(
    model=model,
    train_dataset=train_dataset,
    loss=loss,
)
trainer.train()

MSELoss

class sentence_transformers.cross_encoder.losses.MSELoss(model: CrossEncoder, activation_fn: Module = Identity(), **kwargs)[source]

计算计算出的查询-段落分数与目标查询-段落分数之间的 MSE 损失。此损失用于从教师 cross-encoder 模型或黄金标签中蒸馏 cross-encoder 模型。

参数:

model (CrossEncoder) – 要训练的 CrossEncoder 模型。
activation_fn (Module) – 在计算损失之前应用于 logits 的激活函数。
**kwargs – 传递给底层 torch.nn.MSELoss 的其他关键字参数。

注意

请注意标签的幅度和模型产生的幅度的量级。如果教师模型产生带有 Sigmoid 的 logits 以将它们限制在 [0, 1] 范围内，那么您可能希望在损失中使用 Sigmoid 激活函数。

参考文献

通过交叉架构知识蒸馏改进高效神经排序模型： https://hugging-face.cn/papers/2010.02666
Cross Encoder > 训练样本 > 蒸馏

要求

必须将模型初始化为 num_labels = 1（也即默认值）以预测一个类别。
通常在知识蒸馏设置中使用微调的 CrossEncoder 教师 M。

输入

文本	标签	模型输出标签的数量
(句子_A, 句子_B) 对	相似性分数	1

关系

MarginMSELoss 与此损失类似，但通过负对具有边距。

示例

from sentence_transformers.cross_encoder import CrossEncoder, CrossEncoderTrainer, losses
from datasets import Dataset

student_model = CrossEncoder("microsoft/mpnet-base")
teacher_model = CrossEncoder("cross-encoder/ms-marco-MiniLM-L12-v2")
train_dataset = Dataset.from_dict({
    "query": ["What are pandas?", "What is the capital of France?"],
    "answer": ["Pandas are a kind of bear.", "The capital of France is Paris."],
})

def compute_labels(batch):
    return {
        "label": teacher_model.predict(list(zip(batch["query"], batch["answer"])))
    }

train_dataset = train_dataset.map(compute_labels, batched=True)
loss = losses.MSELoss(student_model)

trainer = CrossEncoderTrainer(
    model=student_model,
    train_dataset=train_dataset,
    loss=loss,
)
trainer.train()

MarginMSELoss

class sentence_transformers.cross_encoder.losses.MarginMSELoss(model: CrossEncoder, activation_fn: Module = Identity(), **kwargs)[source]

计算 |sim(Query, Pos) - sim(Query, Neg)| 与 |gold_sim(Query, Pos) - gold_sim(Query, Neg)| 之间的 MSE 损失。此损失常用于从教师 cross-encoder 模型或黄金标签中蒸馏 cross-encoder 模型。

与 MultipleNegativesRankingLoss 不同，两个段落不必严格为正例和负例，对于给定的查询，两者都可以是相关的或不相关的。这可能是 MarginMSELoss 相对于 MultipleNegativesRankingLoss 的一个优势。

注意

请注意标签的幅度和模型产生的幅度的量级。如果教师模型产生带有 Sigmoid 的 logits 以将它们限制在 [0, 1] 范围内，那么您可能希望在损失中使用 Sigmoid 激活函数。

参数:

model (CrossEncoder) – 要训练的 CrossEncoder 模型。
activation_fn (Module) – 在计算损失之前应用于 logits 的激活函数。
**kwargs – 传递给底层 torch.nn.MSELoss 的其他关键字参数。

参考文献

通过交叉架构知识蒸馏改进高效神经排序模型： https://hugging-face.cn/papers/2010.02666
Cross Encoder > 训练样本 > 蒸馏

要求

必须将模型初始化为 num_labels = 1（也即默认值）以预测一个类别。
通常在知识蒸馏设置中使用微调的 CrossEncoder 教师 M。

输入

文本	标签	模型输出标签的数量
(查询, 段落_一, 段落_二) 三元组	gold_sim(查询, 段落_一) - gold_sim(查询, 段落_二)	1
(查询, 段落_一, 段落_二) 三元组	[gold_sim(query, passage_one), gold_sim(query, passage_two)]	1
(查询, 正例, 负例_1, ..., 负例_n)	[gold_sim(查询, 正例) - gold_sim(查询, 负例_i) for i in 1..n]	1
(查询, 正例, 负例_1, ..., 负例_n)	[gold_sim(query, positive), gold_sim(query, negative_1), …, gold_sim(query, negative_n)]	1

关系

MSELoss 与此损失类似，但没有通过负对实现边距。

示例

from sentence_transformers.cross_encoder import CrossEncoder, CrossEncoderTrainer, losses
from datasets import Dataset

student_model = CrossEncoder("microsoft/mpnet-base")
teacher_model = CrossEncoder("cross-encoder/ms-marco-MiniLM-L12-v2")
train_dataset = Dataset.from_dict({
    "query": ["What are pandas?", "What is the capital of France?"],
    "positive": ["Pandas are a kind of bear.", "The capital of France is Paris."],
    "negative": ["Pandas are a kind of fish.", "The capital of France is Berlin."],
})

def compute_labels(batch):
    positive_scores = teacher_model.predict(list(zip(batch["query"], batch["positive"])))
    negative_scores = teacher_model.predict(list(zip(batch["query"], batch["negative"])))
    return {
        "label": positive_scores - negative_scores
    }

train_dataset = train_dataset.map(compute_labels, batched=True)
loss = losses.MarginMSELoss(student_model)

trainer = CrossEncoderTrainer(
    model=student_model,
    train_dataset=train_dataset,
    loss=loss,
)
trainer.train()

RankNetLoss

class sentence_transformers.cross_encoder.losses.RankNetLoss(model: CrossEncoder, k: int | None = None, sigma: float = 1.0, eps: float = 1e-10, reduction_log: Literal['natural', 'binary'] = 'binary', activation_fn: Module | None = Identity(), mini_batch_size: int | None = None)[source]

RankNet 学习排序损失实现。此损失函数实现了 RankNet 算法，该算法通过使用神经网络优化文档的成对比较来学习排序函数。该实现经过优化，可以有效地处理填充的文档，仅在模型推理期间处理有效文档。

参数:

model (CrossEncoder) – 要训练的 CrossEncoder 模型
sigma (float) – sigmoid 中使用的分数差权重（默认：1.0）
eps (float) – 用于数值稳定的小常数（默认：1e-10）
activation_fn (Module) – 在计算损失之前应用于 logits 的激活函数。默认为 Identity。
mini_batch_size (int, optional) – 每次前向传播处理的样本数量。这对内存消耗和训练过程的速度有显著影响。有三种可能的情况： - 如果 mini_batch_size 为 None，则 mini_batch_size 被设置为批次大小。 - 如果 mini_batch_size 大于 0，则批次被分割成大小为 mini_batch_size 的小批次。 - 如果 mini_batch_size 小于等于 0，则整个批次一次性处理。默认为 None。

参考文献

使用梯度下降进行学习排序： https://icml.cc/Conferences/2015/wp-content/uploads/2015/06/icml_ranking.pdf
Cross Encoder > 训练样本 > MS MARCO

要求

包含多个文档的查询（成对方法）
文档必须具有相关性分数/标签。支持二进制和连续标签。

输入

文本	标签	模型输出标签的数量
(query, [doc1, doc2, …, docN])	[score1, score2, …, scoreN]	1

建议

使用 mine_hard_negatives 和 output_format="labeled-list" 将问答对转换为所需输入格式，并包含难负样本。

关系

LambdaLoss 可以看作是此损失的扩展，其中每个分数对都进行了加权。或者，此损失可以看作是 LambdaLoss 在没有加权方案的特殊情况。
LambdaLoss 及其默认的 NDCGLoss2++ 加权方案，经验上比具有相同输入格式的其他损失函数表现更好。

示例

from sentence_transformers.cross_encoder import CrossEncoder, CrossEncoderTrainer, losses
from datasets import Dataset

model = CrossEncoder("microsoft/mpnet-base")
train_dataset = Dataset.from_dict({
    "query": ["What are pandas?", "What is the capital of France?"],
    "docs": [
        ["Pandas are a kind of bear.", "Pandas are kind of like fish."],
        ["The capital of France is Paris.", "Paris is the capital of France.", "Paris is quite large."],
    ],
    "labels": [[1, 0], [1, 1, 0]],
})
loss = losses.RankNetLoss(model)

trainer = CrossEncoderTrainer(
    model=model,
    train_dataset=train_dataset,
    loss=loss,
)
trainer.train()