util

sentence_transformers.util 定义了各种用于处理文本嵌入的实用函数。

辅助函数

sentence_transformers.util.community_detection(embeddings: Tensor | ndarray, threshold: float = 0.75, min_community_size: int = 10, batch_size: int = 1024, show_progress_bar: bool = False) → list[list[int]][source]

用于快速社区检测的函数。

在嵌入中查找所有社区，即相互接近（比阈值更接近）的嵌入。仅返回大于 min_community_size 的社区。社区按降序返回。每个列表中的第一个元素是社区的中心点。

参数:

  • embeddings (torch.Tensor or numpy.ndarray) – 输入嵌入。

  • threshold (float) – 用于确定两个嵌入是否接近的阈值。默认为 0.75。

  • min_community_size (int) – 要考虑的社区的最小规模。默认为 10。

  • batch_size (int) – 计算余弦相似度分数时的批处理大小。默认为 1024。

  • show_progress_bar (bool) – 计算期间是否显示进度条。默认为 False。

返回:

一个社区列表，其中每个社区都表示为一个索引列表。

返回类型:

List[List[int]]

sentence_transformers.util.http_get(url: str, path: str) → None[source]

将 URL 下载到磁盘上的给定路径。

参数:

  • url (str) – 要下载的 URL。

  • path (str) – 保存下载文件的路径。

引发:

requests.HTTPError – 如果 HTTP 请求返回非 200 状态码。

返回:

无

sentence_transformers.util.is_training_available() → bool[source]

如果已安装训练 Sentence Transformers 模型所需的依赖项（即 Huggingface datasets 和 Huggingface accelerate），则返回 True。

sentence_transformers.util.mine_hard_negatives(dataset: Dataset, model: SentenceTransformer, anchor_column_name: str | None = None, positive_column_name: str | None = None, corpus: list[str] | None = None, cross_encoder: CrossEncoder | None = None, range_min: int = 0, range_max: int | None = None, max_score: float | None = None, min_score: float | None = None, absolute_margin: float | None = None, relative_margin: float | None = None, num_negatives: int = 3, sampling_strategy: Literal['random', 'top'] = 'top', query_prompt_name: str | None = None, query_prompt: str | None = None, corpus_prompt_name: str | None = None, corpus_prompt: str | None = None, include_positives: bool = False, output_format: Literal['triplet', 'n-tuple', 'labeled-pair', 'labeled-list'] = 'triplet', batch_size: int = 32, faiss_batch_size: int = 16384, use_faiss: bool = False, use_multi_process: list[str] | bool = False, verbose: bool = True, cache_folder: str | None = None, as_triplets: bool | None = None, margin: float | None = None) → Dataset[source]

向 (锚点, 正例) 对数据集添加困难负样本，以创建 (锚点, 正例, 负例) 三元组或 (锚点, 正例, 负例_1, …, 负例_n) 元组。

困难负样本挖掘是一种通过添加困难负样本来提高数据集质量的技术，这些困难负样本是指可能与锚点相似但实际上不是的文本。使用困难负样本可以提高在数据集上训练的模型的性能。

此函数使用 SentenceTransformer 模型嵌入数据集中的句子，然后查找数据集中每个锚点句子的最接近匹配项。然后，它从最接近的匹配项中抽取负样本，可以选择使用 CrossEncoder 模型对候选样本重新评分。

支持预期特定指令式输入的模型的提示格式化。

您可以以各种方式影响候选负样本选择

  • range_min：考虑为负样本的最接近匹配项的最小排名：用于跳过最相似的文本，以避免将实际为正样本的文本标记为负样本。

  • range_max：考虑为负样本的最接近匹配项的最大排名：用于限制从中抽取负样本的候选样本数量。较低的值可以加快处理速度，但可能导致满足裕度或 max_score 条件的候选负样本减少。

  • max_score：视为负样本的最大分数：用于跳过与锚点过于相似的候选样本。

  • min_score：视为负样本的最小分数：用于跳过与锚点过于不同的候选样本。

  • absolute_margin：困难负样本挖掘的绝对裕度，即正样本相似度与负样本相似度之间的最小距离。值为 0 可强制负样本始终比正样本离锚点更远。默认为 None。

  • relative_margin：困难负样本挖掘的相对裕度，即正样本相似度与负样本相似度之间的最大比率。值为 0.05 意味着负样本与锚点的相似度最多为正样本的 95%。默认为 None。

  • sampling_strategy：负样本采样策略：“top” 或 “random”。“top” 总是将前 n 个候选样本作为负样本，而 “random” 将从满足裕度或 max_score 条件的候选样本中随机抽取 n 个负样本。

提示

优秀的 NV-Retriever 论文是理解困难负样本挖掘细节及其有效使用方法的极佳资源。值得注意的是，它在使用这些设置时达到了最强性能

dataset = mine_hard_negatives(
    dataset=dataset,
    model=model,
    relative_margin=0.05,         # 0.05 means that the negative is at most 95% as similar to the anchor as the positive
    num_negatives=num_negatives,  # 10 or less is recommended
    sampling_strategy="top",      # "top" means that we sample the top candidates as negatives
    batch_size=batch_size,        # Adjust as needed
    use_faiss=True,               # Optional: Use faiss/faiss-gpu for faster similarity search
)

这与 TopK-PercPos (95%) 挖掘方法相对应。

示例

>>> from sentence_transformers.util import mine_hard_negatives
>>> from sentence_transformers import SentenceTransformer
>>> from datasets import load_dataset
>>> # Load a Sentence Transformer model
>>> model = SentenceTransformer("all-MiniLM-L6-v2")
>>>
>>> # Load a dataset to mine hard negatives from
>>> dataset = load_dataset("sentence-transformers/natural-questions", split="train")
>>> dataset
Dataset({
    features: ['query', 'answer'],
    num_rows: 100231
})
>>> dataset = mine_hard_negatives(
...     dataset=dataset,
...     model=model,
...     range_min=10,
...     range_max=50,
...     max_score=0.8,
...     relative_margin=0.05,
...     num_negatives=5,
...     sampling_strategy="random",
...     batch_size=128,
...     use_faiss=True,
... )
Batches: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 588/588 [00:32<00:00, 18.07it/s]
Batches: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 784/784 [00:08<00:00, 96.41it/s]
Querying FAISS index: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:06<00:00,  1.06it/s]
Metric       Positive       Negative     Difference
Count         100,231        487,865
Mean           0.6866         0.4194         0.2752
Median         0.7010         0.4102         0.2760
Std            0.1125         0.0719         0.1136
Min            0.0303         0.1702         0.0209
25%            0.6221         0.3672         0.1899
50%            0.7010         0.4102         0.2760
75%            0.7667         0.4647         0.3590
Max            0.9584         0.7621         0.7073
Skipped 427,503 potential negatives (8.36%) due to the relative_margin of 0.05.
Skipped 978 potential negatives (0.02%) due to the max_score of 0.8.
Could not find enough negatives for 13290 samples (2.65%). Consider adjusting the range_max, range_min, relative_margin and max_score parameters if you'd like to find more valid negatives.
>>> dataset
Dataset({
    features: ['query', 'answer', 'negative'],
    num_rows: 487865
})
>>> dataset[0]
{
    'query': 'when did richmond last play in a preliminary final',
    'answer': "Richmond Football Club Richmond began 2017 with 5 straight wins, a feat it had not achieved since 1995. A series of close losses hampered the Tigers throughout the middle of the season, including a 5-point loss to the Western Bulldogs, 2-point loss to Fremantle, and a 3-point loss to the Giants. Richmond ended the season strongly with convincing victories over Fremantle and St Kilda in the final two rounds, elevating the club to 3rd on the ladder. Richmond's first final of the season against the Cats at the MCG attracted a record qualifying final crowd of 95,028; the Tigers won by 51 points. Having advanced to the first preliminary finals for the first time since 2001, Richmond defeated Greater Western Sydney by 36 points in front of a crowd of 94,258 to progress to the Grand Final against Adelaide, their first Grand Final appearance since 1982. The attendance was 100,021, the largest crowd to a grand final since 1986. The Crows led at quarter time and led by as many as 13, but the Tigers took over the game as it progressed and scored seven straight goals at one point. They eventually would win by 48 points – 16.12 (108) to Adelaide's 8.12 (60) – to end their 37-year flag drought.[22] Dustin Martin also became the first player to win a Premiership medal, the Brownlow Medal and the Norm Smith Medal in the same season, while Damien Hardwick was named AFL Coaches Association Coach of the Year. Richmond's jump from 13th to premiers also marked the biggest jump from one AFL season to the next.",
    'negative': "2018 NRL Grand Final The 2018 NRL Grand Final was the conclusive and premiership-deciding game of the 2018 National Rugby League season and was played on Sunday September 30 at Sydney's ANZ Stadium.[1] The match was contested between minor premiers the Sydney Roosters and defending premiers the Melbourne Storm. In front of a crowd of 82,688, Sydney won the match 21–6 to claim their 14th premiership title and their first since 2013. Roosters five-eighth Luke Keary was awarded the Clive Churchill Medal as the game's official man of the match."
}
>>> dataset.push_to_hub("natural-questions-hard-negatives", "triplet-all")
参数:

  • dataset (Dataset) – 一个包含（锚点，正例）对的数据集。

  • model (SentenceTransformer) – 用于嵌入句子的 SentenceTransformer 模型。

  • anchor_column_name (str, optional) – 数据集中包含锚点/查询的列名。默认为 None，在这种情况下，将使用数据集中的第一列。

  • positive_column_name (str, optional) – 数据集中包含正例候选的列名。默认为 None，在这种情况下，将使用数据集中的第二列。

  • corpus (List[str], optional) – 一个包含文档字符串的列表，除了数据集中的第二列外，这些文档也将用作负样本候选。默认为 None，在这种情况下，数据集中的第二列将专门用作负样本候选语料库。

  • cross_encoder (CrossEncoder, optional) – 用于对候选样本进行重新评分的 CrossEncoder 模型。默认为 None。

  • range_min (int) – 考虑为负样本的最接近匹配项的最小排名。默认为 0。

  • range_max (int, optional) – 考虑为负样本的最接近匹配项的最大排名。默认为 None。

  • max_score (float, optional) – 考虑为负样本的最大分数。默认为 None。

  • min_score (float, optional) – 考虑为负样本的最小分数。默认为 None。

  • absolute_margin (float, optional) – 困难负样本挖掘的绝对裕度，即正样本相似度与负样本相似度之间的最小距离。默认为 None。

  • relative_margin (float, optional) – 困难负样本挖掘的相对裕度，即正样本相似度与负样本相似度之间的最大比率。值为 0.05 意味着负样本与锚点的相似度最多为正样本的 95%。默认为 None。

  • num_negatives (int) – 要采样的负样本数量。默认为 3。

  • sampling_strategy (Literal["random", "top"]) – 负样本采样策略：“top” 或 “random”。默认为 “top”。

  • query_prompt_name (Optional[str], optional) –

    在编码第一个/锚点数据集列时使用的预定义提示的名称。它必须与 model.prompts 字典中的键匹配，该字典可以在模型初始化期间设置或从模型配置中加载。

    例如，如果 query_prompt_name="query" 且模型提示字典包含 {“query”: “query: “}，那么句子“法国首都是什么？”在编码前会被转换为：“query: 法国首都是什么？”。这对于使用特定提示格式进行训练或微调的模型很有用。

    如果提供了 query_prompt，则忽略此参数。默认为 None。

  • query_prompt (Optional[str], optional) –

    在编码第一个/锚点数据集列期间，直接添加到其前面的原始提示字符串。

    例如，query_prompt=”query: “ 会将句子“法国首都是什么？”转换为：“query: 法国首都是什么？”。使用此参数完全覆盖提示逻辑并提供您自己的前缀。此参数优先于 query_prompt_name。默认为 None。

  • corpus_prompt_name (Optional[str], optional) – 编码语料库时使用的预定义提示的名称。有关更多信息，请参阅 query_prompt_name。默认为 None。

  • corpus_prompt (Optional[str], optional) – 在编码语料库期间，直接添加到其前面的原始提示字符串。有关更多信息，请参阅 query_prompt。默认为 None。

  • include_positives (bool) – 是否将正样本包含在负样本候选样本中。将其设置为 True 主要用于为 CrossEncoder 模型创建重排评估数据集，在这种情况下，从第一阶段检索模型获取完整排名（包括正样本）可能很有用。默认为 False。

  • output_format (Literal["triplet", "n-tuple", "labeled-pair", "labeled-list"]) –

    datasets.Dataset 的输出格式。选项包括：

    • “triplet”：(锚点, 正例, 负例) 三元组，即 3 列。例如，对于 CachedMultipleNegativesRankingLoss 很有用。

    • “n-tuple”：(锚点, 正例, 负例_1, …, 负例_n) 元组，即 2 + num_negatives 列。例如，对于 CachedMultipleNegativesRankingLoss 很有用。

    • “labeled-pair”：(锚点, 段落, 标签) 文本元组，其中负样本的标签为 0，正样本的标签为 1，即 3 列。例如，对于 BinaryCrossEntropyLoss 很有用。

    • “labeled-list”：(锚点, [文档1, 文档2, …, 文档N], [标签1, 标签2, …, 标签N]) 三元组，其中负样本的标签为 0，正样本的标签为 1，即 3 列。例如，对于 LambdaLoss 很有用。

    默认为“triplet”。

  • batch_size (int) – 编码数据集时的批处理大小。默认为 32。

  • faiss_batch_size (int) – FAISS top-k 搜索的批处理大小。默认为 16384。

  • use_faiss (bool) – 是否使用 FAISS 进行相似度搜索。对于大型数据集可能推荐使用。默认为 False。

  • use_multi_process (bool | List[str], optional) – 是否使用多 GPU/CPU 处理。如果为 True，则在 CUDA 可用时使用所有 GPU，如果不可用则使用 4 个 CPU 进程。您也可以传递 PyTorch 设备列表，如 [“cuda:0”, “cuda:1”, …] 或 [“cpu”, “cpu”, “cpu”, “cpu”]。

  • verbose (bool) – 是否打印统计信息和日志。默认为 True。

  • cache_folder (str, optional) – 缓存嵌入的目录路径。如果提供，函数将在首次运行后将 query_embeddings_{hash}.npy 和 corpus_embeddings_{hash}.npy 保存到此文件夹下，并在后续调用时（如果这些文件存在）从这些文件加载以避免重新计算。哈希值根据模型名称和查询/语料库计算。默认为 None。

  • as_triplets (bool, optional) – 已弃用。请改用 output_format。默认为 None。

  • margin (float, optional) – 已弃用。请改用 absolute_margin 或 relative_margin。默认为 None。

返回:

一个包含（锚点，正例，负例）三元组、（锚点，段落，标签）带标签文本元组或（锚点，正例，负例_1，…，负例_n）元组的数据集。

返回类型:

数据集

sentence_transformers.util.normalize_embeddings(embeddings: Tensor) → Tensor[source]

标准化嵌入矩阵，使每个句子嵌入都具有单位长度。

参数:

embeddings (Tensor) – 输入嵌入矩阵。

返回:

标准化后的嵌入矩阵。

返回类型:

Tensor

sentence_transformers.util.paraphrase_mining(model, sentences: list[str], show_progress_bar: bool = False, batch_size: int = 32, query_chunk_size: int = 5000, corpus_chunk_size: int = 100000, max_pairs: int = 500000, top_k: int = 100, score_function: ~typing.Callable[[~torch.Tensor, ~torch.Tensor], ~torch.Tensor] = <function cos_sim>, truncate_dim: int | None = None, prompt_name: str | None = None, prompt: str | None = None) → list[list[float | int]][source]

给定一个句子/文本列表，此函数执行释义挖掘。它将所有句子与其他所有句子进行比较，并返回具有最高余弦相似度分数对的列表。

参数:

  • model (SentenceTransformer) – 用于嵌入计算的 SentenceTransformer 模型。

  • sentences (List[str]) – 字符串列表（文本或句子）。

  • show_progress_bar (bool, optional) – 是否显示进度条。默认为 False。

  • batch_size (int, optional) – 模型同时编码的文本数量。默认为 32。

  • query_chunk_size (int, optional) – 同时为 #query_chunk_size 搜索最相似的对。减小此值可降低内存占用（增加运行时间）。默认为 5000。

  • corpus_chunk_size (int, optional) – 同时将一个句子与 #corpus_chunk_size 其他句子进行比较。减小此值可降低内存占用（增加运行时间）。默认为 100000。

  • max_pairs (int, optional) – 返回的最大文本对数量。默认为 500000。

  • top_k (int, optional) – 对于每个句子，我们最多检索 top_k 个其他句子。默认为 100。

  • score_function (Callable[[Tensor, Tensor], Tensor], optional) – 用于计算分数的函数。默认情况下，使用余弦相似度。默认为 cos_sim。

  • truncate_dim (int, optional) – 要截断句子嵌入到的维度。如果为 None，则使用模型的维度。默认为 None。

  • prompt_name (Optional[str], optional) –

    编码句子时使用的预定义提示的名称。它必须与模型 prompts 字典中的键匹配，该字典可以在模型初始化期间设置或从模型配置中加载。

    如果提供了 prompt，则忽略此参数。默认为 None。

  • prompt (Optional[str], optional) –

    在编码输入句子期间，直接添加到其前面的原始提示字符串。

    例如，prompt=”query: “ 会将句子“法国首都是什么？”转换为：“query: 法国首都是什么？”。使用此参数完全覆盖提示逻辑并提供您自己的前缀。此参数优先于 prompt_name。默认为 None。

返回:

返回一个三元组列表，格式为 [score, id1, id2]

返回类型:

List[List[Union[float, int]]]

此函数默认在查询嵌入列表和语料库嵌入列表之间执行余弦相似度搜索。它可用于对多达约 100 万条目的语料库进行信息检索/语义搜索。

参数:

  • query_embeddings (Tensor) – 一个包含查询嵌入的二维张量。可以是稀疏张量。

  • corpus_embeddings (Tensor) – 一个包含语料库嵌入的二维张量。可以是稀疏张量。

  • query_chunk_size (int, optional) – 同时处理 100 个查询。增加此值可以提高速度，但需要更多内存。默认为 100。

  • corpus_chunk_size (int, optional) – 每次扫描 10 万个语料库条目。增加此值可以提高速度，但需要更多内存。默认为 500000。

  • top_k (int, optional) – 检索前 k 个匹配条目。默认为 10。

  • score_function (Callable[[Tensor, Tensor], Tensor], optional) – 用于计算分数的函数。默认情况下，使用余弦相似度。

返回:

一个列表，每个查询对应一个条目。每个条目都是一个字典列表，包含“corpus_id”和“score”键，按余弦相似度分数降序排列。

返回类型:

List[List[Dict[str, Union[int, float]]]]

sentence_transformers.util.truncate_embeddings(embeddings: ndarray, truncate_dim: int | None) → ndarray[source]
sentence_transformers.util.truncate_embeddings(embeddings: Tensor, truncate_dim: int | None) → Tensor

截断嵌入矩阵。

参数:

  • embeddings (Union[np.ndarray, torch.Tensor]) – 要截断的嵌入。

  • truncate_dim (Optional[int]) – 要将句子嵌入截断到的维度。None 表示不进行截断。

示例

>>> from sentence_transformers import SentenceTransformer
>>> from sentence_transformers.util import truncate_embeddings
>>> model = SentenceTransformer("tomaarsen/mpnet-base-nli-matryoshka")
>>> embeddings = model.encode(["It's so nice outside!", "Today is a beautiful day.", "He drove to work earlier"])
>>> embeddings.shape
(3, 768)
>>> model.similarity(embeddings, embeddings)
tensor([[1.0000, 0.8100, 0.1426],
        [0.8100, 1.0000, 0.2121],
        [0.1426, 0.2121, 1.0000]])
>>> truncated_embeddings = truncate_embeddings(embeddings, 128)
>>> truncated_embeddings.shape
>>> model.similarity(truncated_embeddings, truncated_embeddings)
tensor([[1.0000, 0.8092, 0.1987],
        [0.8092, 1.0000, 0.2716],
        [0.1987, 0.2716, 1.0000]])
返回:

截断后的嵌入。

返回类型:

Union[np.ndarray, torch.Tensor]

模型优化

sentence_transformers.backend.export_dynamic_quantized_onnx_model(model: SentenceTransformer | CrossEncoder, quantization_config: QuantizationConfig | Literal['arm64', 'avx2','avx512','avx512_vnni'], model_name_or_path: str, push_to_hub: bool = False, create_pr: bool = False, file_suffix: str | None = None) → None[source]

从 SentenceTransformer 或 CrossEncoder 模型导出量化的 ONNX 模型。

此函数应用动态量化，即无需校准数据集。每个默认量化配置都将模型量化为 int8，从而在 CPU 上实现更快的推理，但在 GPU 上可能较慢。

有关更多信息和基准测试，请参阅以下页面

参数:

  • model (SentenceTransformer | CrossEncoder) – 要量化的 SentenceTransformer 或 CrossEncoder 模型。必须使用 backend=”onnx” 加载。

  • quantization_config (QuantizationConfig) – 量化配置。

  • model_name_or_path (str) – 量化模型将保存到的路径或 Hugging Face Hub 仓库名称。

  • push_to_hub (bool, optional) – 是否将量化模型推送到 Hugging Face Hub。默认为 False。

  • create_pr (bool, optional) – 推送到 Hugging Face Hub 时是否创建拉取请求。默认为 False。

  • file_suffix (str | None, optional) – 要添加到量化模型文件名中的后缀。默认为 None。

引发:

  • ImportError – 如果未安装所需的包 optimum 和 onnxruntime。

  • ValueError – 如果提供的模型不是使用 backend=”onnx” 加载的有效 SentenceTransformer 或 CrossEncoder 模型。

  • ValueError – 如果提供的 quantization_config 无效。

返回:

无

sentence_transformers.backend.export_optimized_onnx_model(model: SentenceTransformer | CrossEncoder, optimization_config: OptimizationConfig | Literal['O1', 'O2', 'O3','O4'], model_name_or_path: str, push_to_hub: bool = False, create_pr: bool = False, file_suffix: str | None = None) → None[source]

从 SentenceTransformer 或 CrossEncoder 模型导出优化的 ONNX 模型。

O1-O4 优化级别由 Optimum 定义，并在此处进行文档说明：https://hugging-face.cn/docs/optimum/main/en/onnxruntime/usage_guides/optimization

优化级别为：

  • O1：基本通用优化。

  • O2：基本和扩展通用优化，特定于 transformers 的融合。

  • O3：与 O2 相同，但包含 GELU 近似。

  • O4：与 O3 相同，但包含混合精度（fp16，仅限 GPU）。

有关更多信息和基准测试，请参阅以下页面

参数:

  • model (SentenceTransformer | CrossEncoder) – 要优化的 SentenceTransformer 或 CrossEncoder 模型。必须使用 backend=”onnx” 加载。

  • optimization_config (OptimizationConfig | Literal["O1", "O2", "O3", "O4"]) – 优化配置或级别。

  • model_name_or_path (str) – 优化模型将保存到的路径或 Hugging Face Hub 仓库名称。

  • push_to_hub (bool, optional) – 是否将优化模型推送到 Hugging Face Hub。默认为 False。

  • create_pr (bool, optional) – 推送到 Hugging Face Hub 时是否创建拉取请求。默认为 False。

  • file_suffix (str | None, optional) – 要添加到优化模型文件名中的后缀。默认为 None。

引发:

  • ImportError – 如果未安装所需的包 optimum 和 onnxruntime。

  • ValueError – 如果提供的模型不是使用 backend=”onnx” 加载的有效 SentenceTransformer 或 CrossEncoder 模型。

  • ValueError – 如果提供的 optimization_config 无效。

返回:

无

sentence_transformers.backend.export_static_quantized_openvino_model(model: SentenceTransformer | CrossEncoder, quantization_config: OVQuantizationConfig | dict | None, model_name_or_path: str, dataset_name: str | None = None, dataset_config_name: str | None = None, dataset_split: str | None = None, column_name: str | None = None, push_to_hub: bool = False, create_pr: bool = False, file_suffix: str = 'qint8_quantized') → None[source]

从 SentenceTransformer 或 CrossEncoder 模型导出量化的 OpenVINO 模型。

此函数使用校准数据集应用训练后静态量化 (PTQ)，该数据集在无需模型重新训练的情况下校准量化常数。每个默认量化配置都将模型转换为 int8 精度，从而在保持准确性的同时实现更快的推理。

有关更多信息和基准测试，请参阅以下页面

参数:

  • model (SentenceTransformer | CrossEncoder) – 要量化的 SentenceTransformer 或 CrossEncoder 模型。必须使用 backend=”openvino” 加载。

  • quantization_config (OVQuantizationConfig | dict | None) – 量化配置。如果为 None，则使用默认值。

  • model_name_or_path (str) – 量化模型将保存到的路径或 Hugging Face Hub 仓库名称。

  • dataset_name (str, optional) – 用于校准的加载数据集名称。如果未指定，则默认使用 glue 数据集的 sst2 子集。

  • dataset_config_name (str, optional) – 要加载数据集的特定配置。

  • dataset_split (str, optional) – 要加载数据集的拆分（例如，“train”，“test”）。默认为 None。

  • column_name (str, optional) – 数据集中用于校准的列名。默认为 None。

  • push_to_hub (bool, optional) – 是否将量化模型推送到 Hugging Face Hub。默认为 False。

  • create_pr (bool, optional) – 推送到 Hugging Face Hub 时是否创建拉取请求。默认为 False。

  • file_suffix (str, optional) – 要添加到量化模型文件名中的后缀。默认为 qint8_quantized。

引发:

  • ImportError – 如果未安装所需的包 optimum 和 openvino。

  • ValueError – 如果提供的模型不是使用 backend=”openvino” 加载的有效 SentenceTransformer 或 CrossEncoder 模型。

  • ValueError – 如果提供的 quantization_config 无效。

返回:

无

相似度指标

sentence_transformers.util.cos_sim(a: list | ndarray | Tensor, b: list | ndarray | Tensor) → Tensor[source]

计算两个张量之间的余弦相似度。

参数:

  • a (Union[list, np.ndarray, Tensor]) – 第一个张量。

  • b (Union[list, np.ndarray, Tensor]) – 第二个张量。

返回:

矩阵，其中 res[i][j] = cos_sim(a[i], b[j])

返回类型:

Tensor

sentence_transformers.util.dot_score(a: list | ndarray | Tensor, b: list | ndarray | Tensor) → Tensor[source]

计算所有 i 和 j 的点积 dot_prod(a[i], b[j])。

参数:

  • a (Union[list, np.ndarray, Tensor]) – 第一个张量。

  • b (Union[list, np.ndarray, Tensor]) – 第二个张量。

返回:

矩阵，其中 res[i][j] = dot_prod(a[i], b[j])

返回类型:

Tensor

sentence_transformers.util.euclidean_sim(a: list | ndarray | Tensor, b: list | ndarray | Tensor) → Tensor[source]

计算两个张量之间的欧几里得相似度（即负距离）。在可能的情况下，处理稀疏张量而无需转换为密集张量。

参数:

  • a (Union[list, np.ndarray, Tensor]) – 第一个张量。

  • b (Union[list, np.ndarray, Tensor]) – 第二个张量。

返回:

矩阵，其中 res[i][j] = -euclidean_distance(a[i], b[j])

返回类型:

Tensor

sentence_transformers.util.manhattan_sim(a: list | ndarray | Tensor, b: list | ndarray | Tensor) → Tensor[source]

计算两个张量之间的曼哈顿相似度（即负距离）。在可能的情况下，处理稀疏张量而无需转换为密集张量。

参数:

  • a (Union[list, np.ndarray, Tensor]) – 第一个张量。

  • b (Union[list, np.ndarray, Tensor]) – 第二个张量。

返回:

矩阵，其中 res[i][j] = -manhattan_distance(a[i], b[j])

返回类型:

Tensor

sentence_transformers.util.pairwise_cos_sim(a: Tensor, b: Tensor) → Tensor[源代码]

计算逐对余弦相似度 cos_sim(a[i], b[i])。

参数:

  • a (Union[list, np.ndarray, Tensor]) – 第一个张量。

  • b (Union[list, np.ndarray, Tensor]) – 第二个张量。

返回:

向量 res[i] = cos_sim(a[i], b[i])

返回类型:

Tensor

sentence_transformers.util.pairwise_dot_score(a: Tensor, b: Tensor) → Tensor[源代码]

计算逐对点积 dot_prod(a[i], b[i])。

参数:

  • a (Union[list, np.ndarray, Tensor]) – 第一个张量。

  • b (Union[list, np.ndarray, Tensor]) – 第二个张量。

返回:

向量 res[i] = dot_prod(a[i], b[i])

返回类型:

Tensor

sentence_transformers.util.pairwise_euclidean_sim(a: list | ndarray | Tensor, b: list | ndarray | Tensor)[源代码]

计算张量对之间的欧几里得距离（即负距离）。

参数:

  • a (Union[list, np.ndarray, Tensor]) – 第一个张量。

  • b (Union[list, np.ndarray, Tensor]) – 第二个张量。

返回:

向量 res[i] = -euclidean_distance(a[i], b[i])

返回类型:

Tensor

sentence_transformers.util.pairwise_manhattan_sim(a: list | ndarray | Tensor, b: list | ndarray | Tensor)[源代码]

计算张量对之间的曼哈顿相似度（即负距离）。

参数:

  • a (Union[list, np.ndarray, Tensor]) – 第一个张量。

  • b (Union[list, np.ndarray, Tensor]) – 第二个张量。

返回:

向量 res[i] = -manhattan_distance(a[i], b[i])

返回类型:

Tensor