评估¶

sentence_transformers.evaluation 定义了不同的类，可以在训练过程中用于评估模型。

BinaryClassificationEvaluator¶

class sentence_transformers.evaluation.BinaryClassificationEvaluator(sentences1: list[str], sentences2: list[str], labels: list[int], name: str = '', batch_size: int = 32, show_progress_bar: bool = False, write_csv: bool = True, truncate_dim: int | None = None)[源代码][源代码]¶

基于嵌入的相似性评估模型，通过计算识别相似和不相似句子的准确性。指标包括余弦相似度、点积分数、欧几里得距离和曼哈顿距离。返回的分数是使用指定指标的准确性。

结果被写入一个CSV文件。如果CSV文件已存在，则追加值。

标签需要为不相似的配对设置为0，为相似的配对设置为1。

参数:

sentences1 (List[str]) -- 句子的第一列。
sentences2 (List[str]) -- 句子的第二列。
labels (List[int]) -- labels[i] 是配对 (sentences1[i], sentences2[i]) 的标签。必须是 0 或 1。
name (str, optional) -- 输出名称。默认为 ""。
batch_size (int, optional) -- 用于计算嵌入的批量大小。默认为 32。
show_progress_bar (bool, optional) -- 如果为真，则打印进度条。默认为 False。
write_csv (bool, optional) -- 将结果写入CSV文件。默认为True。
truncate_dim (Optional[int], optional) -- 要截断句子嵌入的维度。None 使用模型当前的截断维度。默认为 None。

示例

from sentence_transformers import SentenceTransformer
from sentence_transformers.evaluation import BinaryClassificationEvaluator
from datasets import load_dataset

# Load a model
model = SentenceTransformer('all-mpnet-base-v2')

# Load a dataset with two text columns and a class label column (https://huggingface.co/datasets/sentence-transformers/quora-duplicates)
eval_dataset = load_dataset("sentence-transformers/quora-duplicates", "pair-class", split="train[-1000:]")

# Initialize the evaluator
binary_acc_evaluator = BinaryClassificationEvaluator(
    sentences1=eval_dataset["sentence1"],
    sentences2=eval_dataset["sentence2"],
    labels=eval_dataset["label"],
    name="quora-duplicates-dev",
)
results = binary_acc_evaluator(model)
'''
Binary Accuracy Evaluation of the model on the quora-duplicates-dev dataset:
Accuracy with Cosine-Similarity:           81.60    (Threshold: 0.8352)
F1 with Cosine-Similarity:                 75.27    (Threshold: 0.7715)
Precision with Cosine-Similarity:          65.81
Recall with Cosine-Similarity:             87.89
Average Precision with Cosine-Similarity:  76.03

Accuracy with Dot-Product:           81.60  (Threshold: 0.8352)
F1 with Dot-Product:                 75.27  (Threshold: 0.7715)
Precision with Dot-Product:          65.81
Recall with Dot-Product:             87.89
Average Precision with Dot-Product:  76.03

Accuracy with Manhattan-Distance:           81.50   (Threshold: 12.0727)
F1 with Manhattan-Distance:                 74.97   (Threshold: 15.2269)
Precision with Manhattan-Distance:          63.89
Recall with Manhattan-Distance:             90.68
Average Precision with Manhattan-Distance:  75.66

Accuracy with Euclidean-Distance:           81.60   (Threshold: 0.5741)
F1 with Euclidean-Distance:                 75.27   (Threshold: 0.6760)
Precision with Euclidean-Distance:          65.81
Recall with Euclidean-Distance:             87.89
Average Precision with Euclidean-Distance:  76.03
'''
print(binary_acc_evaluator.primary_metric)
# => "quora-duplicates-dev_max_ap"
print(results[binary_acc_evaluator.primary_metric])
# => 0.760277070888393

所有评估器的基类。值得注意的是，该类引入了 greater_is_better 和 primary_metric 属性。前者是一个布尔值，指示评估分数越高是否越好，如果训练参数中 load_best_model_at_end 设置为 True，则用于选择最佳检查点。

后者是一个字符串，表示评估器的主要指标。每当评估器返回一个指标字典时，都必须定义这一点，主要指标是指标字典中指向主要指标的键，即用于模型选择和/或记录的指标。

EmbeddingSimilarityEvaluator¶

class sentence_transformers.evaluation.EmbeddingSimilarityEvaluator(sentences1: list[str], sentences2: list[str], scores: list[float], batch_size: int = 16, main_similarity: str | SimilarityFunction | None = None, name: str = '', show_progress_bar: bool = False, write_csv: bool = True, precision: Literal['float32', 'int8', 'uint8', 'binary', 'ubinary'] | None = None, truncate_dim: int | None = None)[源代码][源代码]¶

基于嵌入的相似性评估模型，通过计算与黄金标准标签相比的Spearman和Pearson等级相关性。指标包括余弦相似度以及欧几里得和曼哈顿距离。返回的分数是指定指标的Spearman相关性。

示例

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

# Load a model
model = SentenceTransformer('all-mpnet-base-v2')

# Load the STSB dataset (https://huggingface.co/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",
)
dev_evaluator(model)
'''
EmbeddingSimilarityEvaluator: Evaluating the model on the sts-dev dataset:
Cosine-Similarity :       Pearson: 0.7874 Spearman: 0.8004
Manhattan-Distance:       Pearson: 0.7823 Spearman: 0.7827
Euclidean-Distance:       Pearson: 0.7824 Spearman: 0.7827
Dot-Product-Similarity:   Pearson: 0.7192 Spearman: 0.7126
'''
# => {'sts-dev_pearson_cosine': 0.880607226102985, 'sts-dev_spearman_cosine': 0.881019449484294, ...}

构建一个基于数据集的评估器。

参数:

sentences1 (List[str]) -- 列表中每对的第一句话。
sentences2 (List[str]) -- List with the second sentence in a pair.
scores (List[float]) -- 句子1[i] 和句子2[i] 之间的相似度得分。
batch_size (int, optional) -- 处理句子的批处理大小。默认为 16。
main_similarity (Optional[Union[str, SimilarityFunction]], optional) -- 要使用的主要相似度函数。可以是字符串（例如“cosine”、“dot”）或 SimilarityFunction 对象。默认为 None。
name (str, optional) -- 评估器的名称。默认为 ""。
show_progress_bar (bool, optional) -- 是否在评估期间显示进度条。默认为 False。
write_csv (bool, optional) -- 是否将评估结果写入CSV文件。默认为True。
precision (Optional[Literal["float32", "int8", "uint8", "binary", "ubinary"]], optional) -- 用于嵌入的精度。可以是“float32”、“int8”、“uint8”、“binary”或“ubinary”。默认为None。
truncate_dim (Optional[int], optional) -- 要截断句子嵌入的维度。None 使用模型当前的截断维度。默认为 None。

信息检索评估器¶

class sentence_transformers.evaluation.InformationRetrievalEvaluator(queries: dict[str, str], corpus: dict[str, str], relevant_docs: dict[str, set[str]], corpus_chunk_size: int = 50000, mrr_at_k: list[int] = [10], ndcg_at_k: list[int] = [10], accuracy_at_k: list[int] = [1, 3, 5, 10], precision_recall_at_k: list[int] = [1, 3, 5, 10], map_at_k: list[int] = [100], show_progress_bar: bool = False, batch_size: int = 32, name: str = '', write_csv: bool = True, truncate_dim: int | None = None, score_functions: dict[str, ~typing.Callable[[~torch.Tensor, ~torch.Tensor], ~torch.Tensor]] = {'cosine': <function cos_sim>, 'dot': <function dot_score>}, main_score_function: str | ~sentence_transformers.similarity_functions.SimilarityFunction | None = None)[源代码][源代码]¶

此类评估一个信息检索（IR）设置。

给定一组查询和一个大型语料库集。它将为每个查询检索前k个最相似的文档。它测量平均倒数排名（MRR）、召回率@k和归一化折损累积增益（NDCG）。

示例

import random
from sentence_transformers import SentenceTransformer
from sentence_transformers.evaluation import InformationRetrievalEvaluator
from datasets import load_dataset

# Load a model
model = SentenceTransformer('all-mpnet-base-v2')

# Load the Quora IR dataset (https://huggingface.co/datasets/BeIR/quora, https://huggingface.co/datasets/BeIR/quora-qrels)
corpus = load_dataset("BeIR/quora", "corpus", split="corpus")
queries = load_dataset("BeIR/quora", "queries", split="queries")
relevant_docs_data = load_dataset("BeIR/quora-qrels", split="validation")

# Shrink the corpus size heavily to only the relevant documents + 10,000 random documents
required_corpus_ids = list(map(str, relevant_docs_data["corpus-id"]))
required_corpus_ids += random.sample(corpus["_id"], k=10_000)
corpus = corpus.filter(lambda x: x["_id"] in required_corpus_ids)

# Convert the datasets to dictionaries
corpus = dict(zip(corpus["_id"], corpus["text"]))  # Our corpus (cid => document)
queries = dict(zip(queries["_id"], queries["text"]))  # Our queries (qid => question)
relevant_docs = {}  # Query ID to relevant documents (qid => set([relevant_cids])
for qid, corpus_ids in zip(relevant_docs_data["query-id"], relevant_docs_data["corpus-id"]):
    qid = str(qid)
    corpus_ids = str(corpus_ids)
    if qid not in relevant_docs:
        relevant_docs[qid] = set()
    relevant_docs[qid].add(corpus_ids)

# Given queries, a corpus and a mapping with relevant documents, the InformationRetrievalEvaluator computes different IR metrics.
ir_evaluator = InformationRetrievalEvaluator(
    queries=queries,
    corpus=corpus,
    relevant_docs=relevant_docs,
    name="BeIR-quora-dev",
)
results = ir_evaluator(model)
'''
Information Retrieval Evaluation of the model on the BeIR-quora-dev dataset:
Queries: 5000
Corpus: 17476

Score-Function: cosine
Accuracy@1: 96.26%
Accuracy@3: 99.38%
Accuracy@5: 99.74%
Accuracy@10: 99.94%
Precision@1: 96.26%
Precision@3: 43.01%
Precision@5: 27.66%
Precision@10: 14.58%
Recall@1: 82.93%
Recall@3: 96.28%
Recall@5: 98.38%
Recall@10: 99.55%
MRR@10: 0.9782
NDCG@10: 0.9807
MAP@100: 0.9732
Score-Function: dot
Accuracy@1: 96.26%
Accuracy@3: 99.38%
Accuracy@5: 99.74%
Accuracy@10: 99.94%
Precision@1: 96.26%
Precision@3: 43.01%
Precision@5: 27.66%
Precision@10: 14.58%
Recall@1: 82.93%
Recall@3: 96.28%
Recall@5: 98.38%
Recall@10: 99.55%
MRR@10: 0.9782
NDCG@10: 0.9807
MAP@100: 0.9732
'''
print(ir_evaluator.primary_metric)
# => "BeIR-quora-dev_cosine_map@100"
print(results[ir_evaluator.primary_metric])
# => 0.9732046108457585

初始化 InformationRetrievalEvaluator。

参数:

queries (Dict[str, str]) -- 一个将查询ID映射到查询的字典。
corpus (Dict[str, str]) -- 一个将文档ID映射到文档的字典。
relevant_docs (Dict[str, Set[str]]) -- 一个将查询ID映射到一组相关文档ID的字典。
corpus_chunk_size (int) -- 语料库每个块的大小。默认为 50000。
mrr_at_k (List[int]) -- 一个表示用于MRR计算的k值的整数列表。默认为 [10]。
ndcg_at_k (List[int]) -- 一个表示用于 NDCG 计算的 k 值的整数列表。默认为 [10]。
accuracy_at_k (List[int]) -- 一个表示用于计算准确率的 k 值的整数列表。默认为 [1, 3, 5, 10]。
precision_recall_at_k (List[int]) -- 一个整数列表，表示用于精确率和召回率计算的 k 值。默认为 [1, 3, 5, 10]。
map_at_k (List[int]) -- 一个表示MAP计算中k值的整数列表。默认为 [100]。
show_progress_bar (bool) -- 是否在评估期间显示进度条。默认为 False。
batch_size (int) -- 评估的批量大小。默认为 32。
name (str) -- 评估的名称。默认为 ""。
write_csv (bool) -- 是否将评估结果写入CSV文件。默认为True。
truncate_dim (int, optional) -- 要截断嵌入的维度。默认为 None。
score_functions (Dict[str, Callable[[Tensor, Tensor], Tensor]]) -- 一个将评分函数名称映射到评分函数的字典。默认为 {SimilarityFunction.COSINE.value: cos_sim, SimilarityFunction.DOT_PRODUCT.value: dot_score}。
main_score_function (Union[str, SimilarityFunction], optional) -- 用于评估的主要评分函数。默认为 None。

MSEEvaluator¶

class sentence_transformers.evaluation.MSEEvaluator(source_sentences: list[str], target_sentences: list[str], teacher_model=None, show_progress_bar: bool = False, batch_size: int = 32, name: str = '', write_csv: bool = True, truncate_dim: int | None = None)[源代码][源代码]¶

计算计算出的句子嵌入与某些目标句子嵌入之间的均方误差（乘以100）。

MSE 是在 ||teacher.encode(source_sentences) - student.encode(target_sentences)|| 之间计算的。

对于多语言知识蒸馏（https://arxiv.org/abs/2004.09813），source_sentences 是英文，而 target_sentences 是另一种语言，如德语、中文、西班牙语...

参数:

source_sentences (List[str]) -- 要嵌入教师模型的源句子。
target_sentences (List[str]) -- 目标句子以嵌入学生模型。
teacher_model (SentenceTransformer, optional) -- 用于计算源句子嵌入的教师模型。
show_progress_bar (bool, optional) -- 在计算嵌入时显示进度条。默认为 False。
batch_size (int, optional) -- 计算句子嵌入的批处理大小。默认为 32。
name (str, optional) -- 评估者的名称。默认为 ""。
write_csv (bool, optional) -- 将结果写入CSV文件。默认为True。
truncate_dim (int, optional) -- 要截断句子嵌入的维度。None 使用模型当前的截断维度。默认为 None。

示例

from sentence_transformers import SentenceTransformer
from sentence_transformers.evaluation import MSEEvaluator
from datasets import load_dataset

# Load a model
student_model = SentenceTransformer('paraphrase-multilingual-mpnet-base-v2')
teacher_model = SentenceTransformer('all-mpnet-base-v2')

# Load any dataset with some texts
dataset = load_dataset("sentence-transformers/stsb", split="validation")
sentences = dataset["sentence1"] + dataset["sentence2"]

# Given queries, a corpus and a mapping with relevant documents, the InformationRetrievalEvaluator computes different IR metrics.
mse_evaluator = MSEEvaluator(
    source_sentences=sentences,
    target_sentences=sentences,
    teacher_model=teacher_model,
    name="stsb-dev",
)
results = mse_evaluator(student_model)
'''
MSE evaluation (lower = better) on the stsb-dev dataset:
MSE (*100):  0.805045
'''
print(mse_evaluator.primary_metric)
# => "stsb-dev_negative_mse"
print(results[mse_evaluator.primary_metric])
# => -0.8050452917814255

所有评估器的基类。值得注意的是，该类引入了 greater_is_better 和 primary_metric 属性。前者是一个布尔值，指示评估分数越高是否越好，如果训练参数中 load_best_model_at_end 设置为 True，则用于选择最佳检查点。

后者是一个字符串，表示评估器的主要指标。每当评估器返回一个指标字典时，都必须定义这一点，主要指标是指标字典中指向主要指标的键，即用于模型选择和/或记录的指标。

ParaphraseMiningEvaluator¶

class sentence_transformers.evaluation.ParaphraseMiningEvaluator(sentences_map: dict[str, str], duplicates_list: list[tuple[str, str]] | None = None, duplicates_dict: dict[str, dict[str, bool]] | None = None, add_transitive_closure: bool = False, query_chunk_size: int = 5000, corpus_chunk_size: int = 100000, max_pairs: int = 500000, top_k: int = 100, show_progress_bar: bool = False, batch_size: int = 16, name: str = '', write_csv: bool = True, truncate_dim: int | None = None)[源代码][源代码]¶

给定一组大量的句子，此评估器执行释义（重复）挖掘并识别相似度最高的句子对。它将提取的释义对与一组黄金标签进行比较，并计算F1分数。

示例

from datasets import load_dataset
from sentence_transformers.SentenceTransformer import SentenceTransformer
from sentence_transformers.evaluation import ParaphraseMiningEvaluator

# Load a model
model = SentenceTransformer('all-mpnet-base-v2')

# Load the Quora Duplicates Mining dataset
questions_dataset = load_dataset("sentence-transformers/quora-duplicates-mining", "questions", split="dev")
duplicates_dataset = load_dataset("sentence-transformers/quora-duplicates-mining", "duplicates", split="dev")

# Create a mapping from qid to question & a list of duplicates (qid1, qid2)
qid_to_questions = dict(zip(questions_dataset["qid"], questions_dataset["question"]))
duplicates = list(zip(duplicates_dataset["qid1"], duplicates_dataset["qid2"]))

# Initialize the paraphrase mining evaluator
paraphrase_mining_evaluator = ParaphraseMiningEvaluator(
    sentences_map=qid_to_questions,
    duplicates_list=duplicates,
    name="quora-duplicates-dev",
)
results = paraphrase_mining_evaluator(model)
'''
Paraphrase Mining Evaluation of the model on the quora-duplicates-dev dataset:
Number of candidate pairs: 250564
Average Precision: 56.51
Optimal threshold: 0.8325
Precision: 52.76
Recall: 59.19
F1: 55.79
'''
print(paraphrase_mining_evaluator.primary_metric)
# => "quora-duplicates-dev_average_precision"
print(results[paraphrase_mining_evaluator.primary_metric])
# => 0.5650940787776353

初始化 ParaphraseMiningEvaluator。

参数:

sentences_map (Dict[str, str]) -- 一个将句子ID映射到句子的字典。例如，sentences_map[id] => 句子。
duplicates_list (List[Tuple[str, str]], optional) -- 一个包含id对的列表[(id1, id2), (id1, id5)]，用于标识句子映射中的重复/释义。默认为None。
duplicates_dict (Dict[str, Dict[str, bool]], optional) -- 一个默认的字典映射 [id1][id2] 为 true，如果 id1 和 id2 是重复的。必须是对称的，即，如果 [id1][id2] => True，那么 [id2][id1] => True。默认为 None。
add_transitive_closure (bool, optional) -- 如果为真，则添加一个传递闭包，即如果 dup[a][b] 和 dup[b][c]，则 dup[a][c]。默认为 False。
query_chunk_size (int, optional) -- 为了识别释义，将计算所有句子对之间的余弦相似度。由于这可能需要大量内存，我们将执行批量计算。将比较 query_chunk_size 个句子与最多 corpus_chunk_size 个句子。在默认设置中，5000 个句子将被分组在一起，并与另外 100k 个句子进行比较。默认为 5000。
corpus_chunk_size (int, optional) -- 语料库将被分批处理，以减少内存需求。默认值为 100000。
max_pairs (int, optional) -- 我们只会提取最多 max_pairs 个潜在的释义候选。默认为 500000。
top_k (int, optional) -- 对于每个查询，我们提取 top_k 个最相似的配对并将其添加到一个排序列表中。也就是说，对于一个句子，我们无法找到超过 top_k 个的释义。默认为 100。
show_progress_bar (bool, optional) -- 输出进度条。默认为 False。
batch_size (int, optional) -- 用于计算句子嵌入的批处理大小。默认为 16。
name (str, optional) -- 实验名称。默认为 ""。
write_csv (bool, optional) -- 将结果写入CSV文件。默认为True。
truncate_dim (Optional[int], optional) -- 要截断句子嵌入的维度。None 使用模型当前的截断维度。默认为 None。

RerankingEvaluator¶

class sentence_transformers.evaluation.RerankingEvaluator(samples, at_k: int = 10, name: str = '', write_csv: bool = True, similarity_fct: ~typing.Callable[[~torch.Tensor, ~torch.Tensor], ~torch.Tensor] = <function cos_sim>, batch_size: int = 64, show_progress_bar: bool = False, use_batched_encoding: bool = True, truncate_dim: int | None = None, mrr_at_k: int | None = None)[源代码][源代码]¶

此类评估用于重新排序任务的 SentenceTransformer 模型。

给定一个查询和一组文档，它会计算所有可能文档的分数 [query, doc_i] 并按降序排列。然后，计算 MRR@10、NDCG@10 和 MAP 来衡量排序的质量。

参数:

samples (list) -- 一个字典列表，其中每个字典代表一个样本，并具有以下键： - 'query'：搜索查询。 - 'positive'：相关文档列表。 - 'negative'：不相关文档列表。
at_k (int, optional) -- 仅考虑每个查询中最相似的前 k 个文档进行评估。默认为 10。
name (str, optional) -- 评估者的名称。默认为 ""。
write_csv (bool, optional) -- 将结果写入CSV文件。默认为True。
similarity_fct (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], optional) -- 句子嵌入之间的相似度函数。默认情况下，使用余弦相似度。默认为 cos_sim。
batch_size (int, optional) -- 计算句子嵌入的批处理大小。默认为 64。
show_progress_bar (bool, optional) -- 在计算嵌入时显示进度条。默认为 False。
use_batched_encoding (bool, optional) -- 是否对查询和文档进行批量编码以提高速度，还是逐个编码以节省内存。默认为 True。
truncate_dim (Optional[int], optional) -- 要截断句子嵌入的维度。None 使用模型当前的截断维度。默认为 None。
mrr_at_k (Optional[int], optional) -- 已弃用的参数。请改用 at_k。默认为 None。

所有评估器的基类。值得注意的是，该类引入了 greater_is_better 和 primary_metric 属性。前者是一个布尔值，指示评估分数越高是否越好，如果训练参数中 load_best_model_at_end 设置为 True，则用于选择最佳检查点。

后者是一个字符串，表示评估器的主要指标。每当评估器返回一个指标字典时，都必须定义这一点，主要指标是指标字典中指向主要指标的键，即用于模型选择和/或记录的指标。

SentenceEvaluator¶

class sentence_transformers.evaluation.SentenceEvaluator[源代码][源代码]¶

所有评估器的基类

扩展此类并实现 call 以创建自定义评估器。

所有评估器的基类。值得注意的是，该类引入了 greater_is_better 和 primary_metric 属性。前者是一个布尔值，指示评估分数越高是否越好，如果训练参数中 load_best_model_at_end 设置为 True，则用于选择最佳检查点。

后者是一个字符串，表示评估器的主要指标。每当评估器返回一个指标字典时，都必须定义这一点，主要指标是指标字典中指向主要指标的键，即用于模型选择和/或记录的指标。

SequentialEvaluator¶

class sentence_transformers.evaluation.SequentialEvaluator(evaluators: ~typing.Iterable[~sentence_transformers.evaluation.SentenceEvaluator.SentenceEvaluator], main_score_function=<function SequentialEvaluator.<lambda>>)[源代码][源代码]¶

此评估器允许传递多个子评估器。当模型被评估时，数据会依次传递给所有子评估器。

所有分数都传递给 'main_score_function'，该函数导出一个最终的分数值

初始化一个 SequentialEvaluator 对象。

参数:

evaluators (Iterable[SentenceEvaluator]) -- SentenceEvaluator 对象的集合。
main_score_function (function, optional) -- 一个接受分数列表并返回主要分数的函数。默认选择列表中的最后一个分数。

示例

evaluator1 = BinaryClassificationEvaluator(...)
evaluator2 = InformationRetrievalEvaluator(...)
evaluator3 = MSEEvaluator(...)
seq_evaluator = SequentialEvaluator([evaluator1, evaluator2, evaluator3])

TranslationEvaluator¶

class sentence_transformers.evaluation.TranslationEvaluator(source_sentences: list[str], target_sentences: list[str], show_progress_bar: bool = False, batch_size: int = 16, name: str = '', print_wrong_matches: bool = False, write_csv: bool = True, truncate_dim: int | None = None)[源代码][源代码]¶

给定两组不同语言的句子，例如 (en_1, en_2, en_3...) 和 (fr_1, fr_2, fr_3, ...)，并假设 fr_i 是 en_i 的翻译。检查 vec(en_i) 是否与 vec(fr_i) 具有最高的相似度。计算两个方向的准确率。

示例

from sentence_transformers import SentenceTransformer
from sentence_transformers.evaluation import TranslationEvaluator
from datasets import load_dataset

# Load a model
model = SentenceTransformer('paraphrase-multilingual-mpnet-base-v2')

# Load a parallel sentences dataset
dataset = load_dataset("sentence-transformers/parallel-sentences-news-commentary", "en-nl", split="train[:1000]")

# Initialize the TranslationEvaluator using the same texts from two languages
translation_evaluator = TranslationEvaluator(
    source_sentences=dataset["english"],
    target_sentences=dataset["non_english"],
    name="news-commentary-en-nl",
)
results = translation_evaluator(model)
'''
Evaluating translation matching Accuracy of the model on the news-commentary-en-nl dataset:
Accuracy src2trg: 90.80
Accuracy trg2src: 90.40
'''
print(translation_evaluator.primary_metric)
# => "news-commentary-en-nl_mean_accuracy"
print(results[translation_evaluator.primary_metric])
# => 0.906

构建一个基于数据集的评估器

标签需要表明句子之间的相似性。

参数:

source_sentences (List[str]) -- toctree 是一个 reStructuredText :dfn:指令 ，这是一个非常多功能的标记。指令可以有参数、选项和内容。
target_sentences (List[str]) -- 目标语言中的句子列表。
show_progress_bar (bool) -- 在计算嵌入时是否显示进度条。默认为 False。
batch_size (int) -- 用于计算句子嵌入的批处理大小。默认为 16。
name (str) -- 评估器的名称。默认为空字符串。
print_wrong_matches (bool) -- 是否打印不正确的匹配项。默认为 False。
write_csv (bool) -- 是否将评估结果写入CSV文件。默认为True。
truncate_dim (int, optional) -- 要截断句子嵌入的维度。如果为 None，则将使用模型的当前截断维度。默认为 None。

TripletEvaluator¶

class sentence_transformers.evaluation.TripletEvaluator(anchors: list[str], positives: list[str], negatives: list[str], main_distance_function: str | SimilarityFunction | None = None, name: str = '', batch_size: int = 16, show_progress_bar: bool = False, write_csv: bool = True, truncate_dim: int | None = None)[源代码][源代码]¶

基于三元组 (句子, 正例, 负例) 评估模型。检查是否距离(句子, 正例) < 距离(句子, 负例)。

示例

from sentence_transformers import SentenceTransformer
from sentence_transformers.evaluation import TripletEvaluator
from datasets import load_dataset

# Load a model
model = SentenceTransformer('all-mpnet-base-v2')

# Load a dataset with (anchor, positive, negative) triplets
dataset = load_dataset("sentence-transformers/all-nli", "triplet", split="dev")

# Initialize the TripletEvaluator using anchors, positives, and negatives
triplet_evaluator = TripletEvaluator(
    anchors=dataset[:1000]["anchor"],
    positives=dataset[:1000]["positive"],
    negatives=dataset[:1000]["negative"],
    name="all-nli-dev",
)
results = triplet_evaluator(model)
'''
TripletEvaluator: Evaluating the model on the all-nli-dev dataset:
Accuracy Cosine Distance:        95.60
Accuracy Dot Product:            4.40
Accuracy Manhattan Distance:     95.40
Accuracy Euclidean Distance:     95.60
'''
print(triplet_evaluator.primary_metric)
# => "all-nli-dev_max_accuracy"
print(results[triplet_evaluator.primary_metric])
# => 0.956

初始化一个 TripletEvaluator 对象。

参数:

anchors (List[str]) -- 要检查相似性的句子。（例如，一个查询）
positives (List[str]) -- 积极句子的列表
negatives (List[str]) -- 负面句子的列表
main_distance_function (Union[str, SimilarityFunction], optional) -- 要使用的距离函数。如果未指定，则使用余弦相似度、点积、欧几里得和曼哈顿距离。默认为 None。
name (str) -- 输出名称。默认为 ""。
batch_size (int) -- 用于计算嵌入的批处理大小。默认为16。
show_progress_bar (bool) -- 如果为真，则打印进度条。默认为 False。
write_csv (bool) -- 将结果写入CSV文件。默认为True。
truncate_dim (int, optional) -- 要截断句子嵌入的维度。None 使用模型当前的截断维度。默认为 None。