损失

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 重排器模型。

参数:

model (CrossEncoder) – 要训练的 CrossEncoder 模型。
activation_fn (Module) – 在计算损失之前应用于 logits 的激活函数。默认为 Identity。
pos_weight (Tensor, optional) – 正样本的权重。必须是类似 torch.tensor(4) 的 torch.Tensor，表示权重为 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) pairs 格式。

示例

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）对	类别	类别数量

示例

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, 可选) –
用于损失的加权方案。
- 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, 可选) –
每次前向传播中要处理的样本数量。这对训练过程的内存消耗和速度有显著影响。有三种情况可能：
- 如果 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://arxiv.org/abs/2005.10084
Cross Encoder > 训练示例 > MS MARCO

要求

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

输入

文本	标签	模型输出标签数量
（查询，[文档1，文档2，…，文档N]）	[分数1，分数2，…，分数N]	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, 可选) –
每次前向传播中要处理的样本数量。这对训练过程的内存消耗和速度有显著影响。有三种情况可能：
- 如果 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

要求

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

输入

文本	标签	模型输出标签数量
（查询，[文档1，文档2，…，文档N]）	[分数1，分数2，…，分数N]	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, 可选) – 要使用的加权方案。指定时，实现位置感知 ListMLE，它将不同的权重应用于不同的排名位置。默认为 None（标准 PListMLE）。
activation_fn (Module) – 在计算损失之前应用于 logits 的激活函数。默认为 Identity。
mini_batch_size (int, 可选) –
每次前向传播中要处理的样本数量。这对训练过程的内存消耗和速度有显著影响。有三种情况可能：
- 如果 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

要求

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

输入

文本	标签	模型输出标签数量
（查询，[文档1，文档2，…，文档N]）	[分数1，分数2，…，分数N]	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^(文档数量 - 排名) - 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, 可选) –
每次前向传播中要处理的样本数量。这对训练过程的内存消耗和速度有显著影响。有三种情况可能：
- 如果 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://arxiv.org/abs/2005.10084
Cross Encoder > 训练示例 > MS MARCO

要求

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

输入

文本	标签	模型输出标签数量
（查询，[文档1，文档2，…，文档N]）	[分数1，分数2，…，分数N]	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]

给定 (锚点, 正样本) 对或 (锚点, 正样本, 负样本) 三元组列表，此损失优化以下目标：

给定一个锚点（例如，一个问题），在批次中的每个正样本和负样本（例如，所有答案）中，将最高相似度分配给相应的正样本（即答案）。

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

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

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

参数:

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

注意

当前默认值未来可能会更改。鼓励进行实验。

参考

智能回复的有效自然语言回复建议，第 4.4 节：https://arxiv.org/pdf/1705.00652.pdf

要求

您的模型必须使用 num_labels = 1（即默认值）进行初始化，以预测一个类别。

输入

文本	标签	模型输出标签数量
（锚点，正样本）对	无	1
（锚点，正样本，负样本）三元组	无	1
（锚点，正样本，负样本_1，…，负样本_n）	无	1

建议

使用 BatchSamplers.NO_DUPLICATES （文档）以确保批内负样本不是锚点或正样本的重复。
使用 mine_hard_negatives 并设置 output_format="n-tuple" 或 output_format="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% 的计算时间。

给定 (锚点, 正样本) 对或 (锚点, 正样本, 负样本) 三元组列表，此损失优化以下目标：

给定一个锚点（例如，一个问题），在批次中的每个正样本和负样本（例如，所有答案）中，将最高相似度分配给相应的正样本（即答案）。

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

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

此损失也称为带 GradCache 的 InfoNCE 损失。

参数:

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

注意

当前默认值未来可能会更改。鼓励进行实验。

参考

智能回复的有效自然语言回复建议，第 4.4 节：https://arxiv.org/pdf/1705.00652.pdf
内存受限设置下深度对比学习批次大小的扩展：https://arxiv.org/pdf/2101.06983.pdf
Cross Encoder > 训练示例 > MS MARCO
Cross Encoder > 训练示例 > 重排器

要求

您的模型必须使用 num_labels = 1（即默认值）进行初始化，以预测一个类别。
应与大的 per_device_train_batch_size 和小的 mini_batch_size 结合使用，以获得更优异的性能，但训练时间会比 MultipleNegativesRankingLoss 慢。

输入

文本	标签	模型输出标签数量
（锚点，正样本）对	无	1
（锚点，正样本，负样本）三元组	无	1
（锚点，正样本，负样本_1，…，负样本_n）	无	1

建议

使用 BatchSamplers.NO_DUPLICATES （文档）以确保批内负样本不是锚点或正样本的重复。
使用 mine_hard_negatives 并设置 output_format="n-tuple" 或 output_format="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://arxiv.org/abs/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(查询, 正样本) - sim(查询, 负样本)| 和 |gold_sim(查询, 正样本) - gold_sim(查询, 负样本)| 之间的 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://arxiv.org/abs/2010.02666
Cross Encoder > 训练示例 > 蒸馏

要求

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

输入

文本	标签	模型输出标签数量
（查询，段落一，段落二）三元组	gold_sim(查询，段落一) - gold_sim(查询，段落二)	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: ~torch.nn.modules.module.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, 可选) – 每次前向传播中要处理的样本数量。这对训练过程的内存消耗和速度有显著影响。有三种情况可能：- 如果 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

要求

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

输入

文本	标签	模型输出标签数量
（查询，[文档1，文档2，…，文档N]）	[分数1，分数2，…，分数N]	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()