模块 hugging_face_tei

TruncationDirection（截断方向）

定义当输入长度超过模型限制时截断文本的方向。

属性:

LEFT - 从左侧（文本开头）截断文本。
RIGHT - 从右侧（文本末尾）截断文本。

HuggingFaceTEIRanker

根据与查询的语义相似度对文档进行排序。

可以与 Text Embeddings Inference (TEI) API 端点一起使用

使用示例

from haystack import Document
from haystack.components.rankers import HuggingFaceTEIRanker
from haystack.utils import Secret

reranker = HuggingFaceTEIRanker(
    url="https://:8080",
    top_k=5,
    timeout=30,
    token=Secret.from_token("my_api_token")
)

docs = [Document(content="The capital of France is Paris"), Document(content="The capital of Germany is Berlin")]

result = reranker.run(query="What is the capital of France?", documents=docs)

ranked_docs = result["documents"]
print(ranked_docs)
>> {'documents': [Document(id=..., content: 'the capital of France is Paris', score: 0.9979767),
>>                Document(id=..., content: 'the capital of Germany is Berlin', score: 0.13982213)]}

HuggingFaceTEIRanker.init

def __init__(
    *,
    url: str,
    top_k: int = 10,
    raw_scores: bool = False,
    timeout: Optional[int] = 30,
    max_retries: int = 3,
    retry_status_codes: Optional[list[int]] = None,
    token: Optional[Secret] = Secret.from_env_var(["HF_API_TOKEN", "HF_TOKEN"],
                                                  strict=False)
) -> None

初始化 TEI 重排序器组件。

参数:

url: TEI 重排序服务的基 URL（例如，“https://api.example.com"）。
top_k: 返回的顶部文档的最大数量。
raw_scores: 如果为 True，则在 API 负载中包含原始相关性分数。
timeout: 请求超时（秒）。
max_retries: 失败请求的最大重试次数。
retry_status_codes: 将触发重试的 HTTP 状态码列表。如果为 None，将重试 HTTP 408、418、429 和 503（默认：None）。
token: 用作 HTTPBearer 授权的 Hugging Face 令牌。根据您的 TEI 服务器配置，并非总是必需。在您的帐户设置中查看您的 HF 令牌。

HuggingFaceTEIRanker.to_dict

def to_dict() -> dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

HuggingFaceTEIRanker.from_dict

@classmethod
def from_dict(cls, data: dict[str, Any]) -> "HuggingFaceTEIRanker"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

HuggingFaceTEIRanker.run

@component.output_types(documents=list[Document])
def run(
    query: str,
    documents: list[Document],
    top_k: Optional[int] = None,
    truncation_direction: Optional[TruncationDirection] = None
) -> dict[str, list[Document]]

使用 TEI API 重排序提供的文档，根据与查询的相关性进行排序。

参数:

query: 用于指导重排序的用户查询字符串。
documents: 匹配查询的Document列表。Document 对象需要重排序。
top_k: 可选。用于覆盖返回文档的最大数量。
truncation_direction: 如果设置，则在指定方向启用文本截断。

引发:

requests.exceptions.RequestException: - 如果 API 请求失败。
RuntimeError: - 如果 API 返回错误响应。

返回值:

包含以下键的字典

documents: 重排序后的文档列表。

HuggingFaceTEIRanker.run_async

@component.output_types(documents=list[Document])
async def run_async(
    query: str,
    documents: list[Document],
    top_k: Optional[int] = None,
    truncation_direction: Optional[TruncationDirection] = None
) -> dict[str, list[Document]]

使用 TEI API 异步重排序提供的文档，根据与查询的相关性进行排序。

参数:

query: 用于指导重排序的用户查询字符串。
documents: 匹配查询的Document列表。Document 对象需要重排序。
top_k: 可选。用于覆盖返回文档的最大数量。
truncation_direction: 如果设置，则在指定方向启用文本截断。

引发:

httpx.RequestError: - 如果 API 请求失败。
RuntimeError: - 如果 API 返回错误响应。

返回值:

包含以下键的字典

documents: 重排序后的文档列表。

模块 lost_in_the_middle

LostInTheMiddleRanker

一个 LostInTheMiddle Ranker。

根据“中间丢失”的顺序对文档进行排序，使最相关的文档位于开头或结尾，而最不相关的文档位于中间。

LostInTheMiddleRanker 假设管道中的某个先前组件已按相关性对文档进行了排序，并且不需要查询作为输入，只需要文档。它通常用作 LLM 提示构建之前的最后一个组件，以准备 LLM 的输入上下文。

“中间丢失”排序将文档内容布局到 LLM 上下文中，使最相关的内容位于输入上下文的开头或结尾，而最不相关的内容位于上下文的中间。有关更多详细信息，请参阅论文“Lost in the Middle: How Language Models Use Long Contexts”。

使用示例

from haystack.components.rankers import LostInTheMiddleRanker
from haystack import Document

ranker = LostInTheMiddleRanker()
docs = [Document(content="Paris"), Document(content="Berlin"), Document(content="Madrid")]
result = ranker.run(documents=docs)
for doc in result["documents"]:
    print(doc.content)

LostInTheMiddleRanker.init

def __init__(word_count_threshold: Optional[int] = None,
             top_k: Optional[int] = None)

初始化 LostInTheMiddleRanker。

如果指定了“word_count_threshold”，则此排序器将包含所有文档，直到添加另一个文档会超出“word_count_threshold”。导致阈值超出限制的最后一个文档将包含在生成的文档列表中，但所有后续文档都将被丢弃。

参数:

word_count_threshold: 排序器选择的所有文档的总词数上限。
top_k: 要返回的最大文档数。

LostInTheMiddleRanker.run

@component.output_types(documents=list[Document])
def run(documents: list[Document],
        top_k: Optional[int] = None,
        word_count_threshold: Optional[int] = None
        ) -> dict[str, list[Document]]

根据“中间丢失”的顺序重新排序文档。

参数:

documents: 需要重新排序的文档列表。
top_k: 要返回的最大文档数。
word_count_threshold: 排序器选择的所有文档的总词数上限。

引发:

ValueError: 如果任何文档不是文本格式。

返回值:

包含以下键的字典

documents: 重排序后的文档列表。

模块 meta_field

MetaFieldRanker

根据其特定元字段的值对文档进行排序。

可以按降序或升序执行排序。

使用示例

from haystack import Document
from haystack.components.rankers import MetaFieldRanker

ranker = MetaFieldRanker(meta_field="rating")
docs = [
    Document(content="Paris", meta={"rating": 1.3}),
    Document(content="Berlin", meta={"rating": 0.7}),
    Document(content="Barcelona", meta={"rating": 2.1}),
]

output = ranker.run(documents=docs)
docs = output["documents"]
assert docs[0].content == "Barcelona"

MetaFieldRanker.init

def __init__(meta_field: str,
             weight: float = 1.0,
             top_k: Optional[int] = None,
             ranking_mode: Literal["reciprocal_rank_fusion",
                                   "linear_score"] = "reciprocal_rank_fusion",
             sort_order: Literal["ascending", "descending"] = "descending",
             missing_meta: Literal["drop", "top", "bottom"] = "bottom",
             meta_value_type: Optional[Literal["float", "int",
                                               "date"]] = None)

创建 MetaFieldRanker 的实例。

参数:

meta_field: 用于排序的元字段的名称。
weight: 范围为 [0,1]。0 禁用按元字段排序。0.5 前一个组件的排序和基于元字段的排序具有相同的权重。1 仅按元字段排序。
top_k: 每个查询返回的最大文档数。如果未提供，则排序器返回其在新排序顺序中接收到的所有文档。
ranking_mode: 用于组合检索器和排序器的分数的模式。可能的值为“reciprocal_rank_fusion”（默认）和“linear_score”。“linear_score”模式仅与返回分数在 [0,1] 范围内的检索器或排序器一起使用。
sort_order: 是按升序还是降序对元字段进行排序。可能的值为descending（默认）和ascending（升序）。.
missing_meta: 对于缺少排序元数据的文档如何处理。可能的值为
'drop' 会将文档完全丢弃。
'top' 会将文档放在元数据排序列表的顶部（无论“ascending”还是“descending”）。
'bottom' 会将文档放在元数据排序列表的底部（无论“ascending”还是“descending”）。
meta_value_type: 在排序之前将元值解析为指定的数据类型。仅当提供的文档中meta_field下的所有元值都是字符串时，此功能才有效。例如，如果我们指定meta_value_type="date"，那么对于元值"date": "2015-02-01"，我们将字符串解析为 datetime 对象，然后按日期对文档进行排序。可用选项为'float' 将把元值解析为浮点数。
'int' 将把元值解析为整数。
'date' 将把元值解析为 datetime 对象。
'None'（默认）将不进行解析。
MetaFieldRanker.run

根据选定的元字段对文档列表进行排序

@component.output_types(documents=list[Document])
def run(documents: list[Document],
        top_k: Optional[int] = None,
        weight: Optional[float] = None,
        ranking_mode: Optional[Literal["reciprocal_rank_fusion",
                                       "linear_score"]] = None,
        sort_order: Optional[Literal["ascending", "descending"]] = None,
        missing_meta: Optional[Literal["drop", "top", "bottom"]] = None,
        meta_value_type: Optional[Literal["float", "int", "date"]] = None)

按元字段的降序或升序对文档进行排序。

根据排序模式和权重合并来自前一个组件的排名和基于元字段的排名。
返回 top-k 文档。
documents: 需要排序的文档。

参数:

top_k: 每个查询返回的最大文档数。如果未提供，则使用初始化时提供的 top_k。
weight: 范围为 [0,1]。0 禁用按元字段排序。0.5 前一个组件的排序和基于元字段的排序具有相同的权重。1 仅按元字段排序。如果未提供，则使用初始化时提供的 weight。
ranking_mode: （可选）用于组合检索器和排序器的分数的模式。可能的值为“reciprocal_rank_fusion”（默认）和“linear_score”。'score' 模式仅与返回分数在 [0,1] 范围内的检索器或排序器一起使用。如果未提供，则使用初始化时提供的 ranking_mode。
ascending。如果未提供，则使用初始化时提供的 sort_order。
sort_order: 是按升序还是降序对元字段进行排序。可能的值为descending（默认）和'bottom' 会将文档放在元数据排序列表的底部（无论“ascending”还是“descending”）。如果未提供，则使用初始化时提供的 missing_meta。
missing_meta: 对于缺少排序元数据的文档如何处理。可能的值为
'drop' 会将文档完全丢弃。
'top' 会将文档放在元数据排序列表的顶部（无论“ascending”还是“descending”）。
"date": "2015-02-01"，我们将字符串解析为 datetime 对象，然后按日期对文档进行排序。可用选项为：-'float' 将把元值解析为浮点数。-'int' 将把元值解析为整数。-'date' 将把元值解析为 datetime 对象。-'None'（默认）将不进行解析。
meta_value_type: 在排序之前将元值解析为指定的数据类型。仅当提供的文档中meta_field下的所有元值都是字符串时，此功能才有效。例如，如果我们指定meta_value_type="date"，那么对于元值"date": "2015-02-01"，我们将字符串解析为 datetime 对象，然后按日期对文档进行排序。可用选项为top_k 不大于 0。如果

引发:

ValueError: 如果weight 不在 [0,1] 范围内。如果ranking_mode 不是 'reciprocal_rank_fusion' 或 'linear_score'。如果sort_order 不是 'ascending' 或 'descending'。如果meta_value_type 不是 'float'、'int'、'date' 或documents: 按指定元字段排序的文档列表。None.

返回值:

包含以下键的字典

模块 meta_field_grouping_ranker

通过根据元数据键对文档进行分组来重新排序它们。

MetaFieldGroupingRanker

MetaFieldGroupingRanker 可以按主元数据键进行分组，

group_by，并使用可选的次要键进行子分组，subgroup_by。在每个组或子组内，还可以按元数据键对文档进行排序sort_docs_by输出是一个扁平的文档列表，按.

group_by 和subgroup_by 的值排序。任何没有组的文档都放在列表的末尾。文档的正确组织有助于提高 LLM 后续处理的效率和性能。

MetaFieldGroupingRanker.__init__

使用示例

from haystack.components.rankers import MetaFieldGroupingRanker
from haystack.dataclasses import Document


docs = [
    Document(content="Javascript is a popular programming language", meta={"group": "42", "split_id": 7, "subgroup": "subB"}),
    Document(content="Python is a popular programming language",meta={"group": "42", "split_id": 4, "subgroup": "subB"}),
    Document(content="A chromosome is a package of DNA", meta={"group": "314", "split_id": 2, "subgroup": "subC"}),
    Document(content="An octopus has three hearts", meta={"group": "11", "split_id": 2, "subgroup": "subD"}),
    Document(content="Java is a popular programming language", meta={"group": "42", "split_id": 3, "subgroup": "subB"})
]

ranker = MetaFieldGroupingRanker(group_by="group",subgroup_by="subgroup", sort_docs_by="split_id")
result = ranker.run(documents=docs)
print(result["documents"])

# [
#     Document(id=d665bbc83e52c08c3d8275bccf4f22bf2bfee21c6e77d78794627637355b8ebc,
#             content: 'Java is a popular programming language', meta: {'group': '42', 'split_id': 3, 'subgroup': 'subB'}),
#     Document(id=a20b326f07382b3cbf2ce156092f7c93e8788df5d48f2986957dce2adb5fe3c2,
#             content: 'Python is a popular programming language', meta: {'group': '42', 'split_id': 4, 'subgroup': 'subB'}),
#     Document(id=ce12919795d22f6ca214d0f161cf870993889dcb146f3bb1b3e1ffdc95be960f,
#             content: 'Javascript is a popular programming language', meta: {'group': '42', 'split_id': 7, 'subgroup': 'subB'}),
#     Document(id=d9fc857046c904e5cf790b3969b971b1bbdb1b3037d50a20728fdbf82991aa94,
#             content: 'A chromosome is a package of DNA', meta: {'group': '314', 'split_id': 2, 'subgroup': 'subC'}),
#     Document(id=6d3b7bdc13d09aa01216471eb5fb0bfdc53c5f2f3e98ad125ff6b85d3106c9a3,
#             content: 'An octopus has three hearts', meta: {'group': '11', 'split_id': 2, 'subgroup': 'subD'})
# ]

创建 MetaFieldGroupingRanker 的实例。

def __init__(group_by: str,
             subgroup_by: Optional[str] = None,
             sort_docs_by: Optional[str] = None)

group_by: 用于聚合文档的元数据键。

参数:

subgroup_by: 用于聚合由
group_by 键创建的组内文档的元数据键。sort_docs_by: 确定用于排序文档的元数据键。如果未提供，则组或子组内的文档不会被排序，并且保持其在子组中插入时的顺序。
MetaFieldGroupingRanker.run

根据

@component.output_types(documents=list[Document])
def run(documents: list[Document]) -> dict[str, Any]

group_by 参数，并可选地根据subgroup_by对提供的文档列表进行分组。.

输出是一个根据分组方式重新排序的文档列表。

参数:

documents: 需要分组的文档列表。

返回值:

包含以下键的字典

documents: 根据subgroup_by 的值排序。任何没有组的文档都放在列表的末尾。subgroup_by 元数据值排序的文档列表。

模块 sentence_transformers_diversity

DiversityRankingStrategy（多样性排序策略）

用于多样性排序的策略。

DiversityRankingStrategy.str

def __str__() -> str

将 Strategy 枚举转换为字符串。

DiversityRankingStrategy.from_str

@staticmethod
def from_str(string: str) -> "DiversityRankingStrategy"

将字符串转换为 Strategy 枚举。

DiversityRankingSimilarity（多样性排序相似度）

用于比较嵌入的相似度度量。

DiversityRankingSimilarity.str

def __str__() -> str

将 Similarity 枚举转换为字符串。

DiversityRankingSimilarity.from_str

@staticmethod
def from_str(string: str) -> "DiversityRankingSimilarity"

将字符串转换为 Similarity 枚举。

SentenceTransformersDiversityRanker

基于 Sentence Transformers 的多样性排序器。

应用基于以下两种策略之一的文档排序算法

Greedy Diversity Order（贪婪多样性排序）

实现一种文档排序算法，该算法以最大化文档相对于查询的整体多样性的方式对文档进行排序。

它使用预先训练的 Sentence Transformers 模型来嵌入查询和文档。
Maximum Margin Relevance（最大边际相关性）

实现一种文档排序算法，该算法根据文档的最大边际相关性 (MMR) 分数进行排序。

MMR 分数根据每个文档与查询的相关性以及与已选文档的多样性进行计算。该算法根据其 MMR 分数迭代选择文档，在与查询的相关性和与已选文档的多样性之间进行权衡。“lambda_threshold”控制相关性和多样性之间的权衡。

使用示例

from haystack import Document
from haystack.components.rankers import SentenceTransformersDiversityRanker

ranker = SentenceTransformersDiversityRanker(model="sentence-transformers/all-MiniLM-L6-v2", similarity="cosine", strategy="greedy_diversity_order")
ranker.warm_up()

docs = [Document(content="Paris"), Document(content="Berlin")]
query = "What is the capital of germany?"
output = ranker.run(query=query, documents=docs)
docs = output["documents"]

SentenceTransformersDiversityRanker.init

def __init__(
        model: str = "sentence-transformers/all-MiniLM-L6-v2",
        top_k: int = 10,
        device: Optional[ComponentDevice] = None,
        token: Optional[Secret] = Secret.from_env_var(
            ["HF_API_TOKEN", "HF_TOKEN"], strict=False),
        similarity: Union[str, DiversityRankingSimilarity] = "cosine",
        query_prefix: str = "",
        query_suffix: str = "",
        document_prefix: str = "",
        document_suffix: str = "",
        meta_fields_to_embed: Optional[list[str]] = None,
        embedding_separator: str = "\n",
        strategy: Union[str,
                        DiversityRankingStrategy] = "greedy_diversity_order",
        lambda_threshold: float = 0.5,
        model_kwargs: Optional[dict[str, Any]] = None,
        tokenizer_kwargs: Optional[dict[str, Any]] = None,
        config_kwargs: Optional[dict[str, Any]] = None,
        backend: Literal["torch", "onnx", "openvino"] = "torch")

初始化 SentenceTransformersDiversityRanker。

参数:

model：在 Hugging Face 模型中心中模型的本地路径或名称，例如'sentence-transformers/all-MiniLM-L6-v2'.
top_k: 每个查询返回的最大文档数。
device: 加载模型的设备。如果None，默认设备会自动选择。
token：用于从 Hugging Face 下载私有模型的 API 令牌。
similarity: 用于比较嵌入的相似度度量。可以设置为“dot_product”（默认）或“cosine”。
query_prefix: 在排序之前添加到查询文本开头的字符串。可用于在文本前添加指令，这对于某些嵌入模型（如 E5 和 BGE）是必需的。
query_suffix: 在排序之前添加到查询文本末尾的字符串。
document_prefix: 在排序之前添加到每个文档开头的字符串。可用于在文本前添加指令，这对于某些嵌入模型（如 E5 和 BGE）是必需的。
document_suffix: 在排序之前添加到每个文档末尾的字符串。
meta_fields_to_embed：应与 Document 内容一起嵌入的元字段列表。
embedding_separator：用于将元字段连接到 Document 内容的分隔符。
strategy: 用于多样性排序的策略。可以是“greedy_diversity_order”或“maximum_margin_relevance”。
lambda_threshold: 相关性和多样性之间的权衡参数。仅当 strategy 为“maximum_margin_relevance”时使用。
model_kwargs: 加载模型时传递给AutoModelForSequenceClassification.from_pretrained 的额外关键字参数。有关可用 kwargs，请参阅特定模型的文档。
tokenizer_kwargs: 加载分词器时传递给AutoTokenizer.from_pretrained 的额外关键字参数。有关可用 kwargs，请参阅特定模型的文档。
config_kwargs: 加载模型配置时传递给AutoConfig.from_pretrained 的额外关键字参数。
backend: 用于 Sentence Transformers 模型的后端。选择 "torch"、"onnx" 或 "openvino"。有关加速和量化选项的更多信息，请参阅 Sentence Transformers 文档。

SentenceTransformersDiversityRanker.warm_up

def warm_up()

Initializes the component.

SentenceTransformersDiversityRanker.to_dict

def to_dict() -> dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

SentenceTransformersDiversityRanker.from_dict

@classmethod
def from_dict(cls, data: dict[str,
                              Any]) -> "SentenceTransformersDiversityRanker"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

SentenceTransformersDiversityRanker.run

@component.output_types(documents=list[Document])
def run(query: str,
        documents: list[Document],
        top_k: Optional[int] = None,
        lambda_threshold: Optional[float] = None) -> dict[str, list[Document]]

根据文档的多样性对文档进行排序。

参数:

query: 搜索查询。
documents: 需要排序的 Document 对象列表。
top_k: 可选。一个整数，用于覆盖初始化期间设置的 top_k。
lambda_threshold: 覆盖相关性和多样性之间的权衡参数。仅当 strategy 为“maximum_margin_relevance”时使用。

引发:

ValueError: 如果 top_k 值小于或等于 0。
RuntimeError: 如果组件尚未预热。

返回值:

一个字典，其中包含以下键

documents: 根据多样性排序选择的 Document 对象列表。

模块 sentence_transformers_similarity

SentenceTransformersSimilarityRanker

根据与查询的语义相似度对文档进行排序。

它使用 Hugging Face 的预训练 cross-encoder 模型来嵌入查询和文档。

使用示例

from haystack import Document
from haystack.components.rankers import SentenceTransformersSimilarityRanker

ranker = SentenceTransformersSimilarityRanker()
docs = [Document(content="Paris"), Document(content="Berlin")]
query = "City in Germany"
ranker.warm_up()
result = ranker.run(query=query, documents=docs)
docs = result["documents"]
print(docs[0].content)

SentenceTransformersSimilarityRanker.init

def __init__(*,
             model: Union[str, Path] = "cross-encoder/ms-marco-MiniLM-L-6-v2",
             device: Optional[ComponentDevice] = None,
             token: Optional[Secret] = Secret.from_env_var(
                 ["HF_API_TOKEN", "HF_TOKEN"], strict=False),
             top_k: int = 10,
             query_prefix: str = "",
             document_prefix: str = "",
             meta_fields_to_embed: Optional[list[str]] = None,
             embedding_separator: str = "\n",
             scale_score: bool = True,
             score_threshold: Optional[float] = None,
             trust_remote_code: bool = False,
             model_kwargs: Optional[dict[str, Any]] = None,
             tokenizer_kwargs: Optional[dict[str, Any]] = None,
             config_kwargs: Optional[dict[str, Any]] = None,
             backend: Literal["torch", "onnx", "openvino"] = "torch",
             batch_size: int = 16)

创建 SentenceTransformersSimilarityRanker 的实例。

参数:

model: 排序模型。传入本地路径或 Hugging Face cross-encoder 模型的名称。
device: 加载模型的设备。如果None，默认设备会自动选择。
token: 用于从 Hugging Face 下载私有模型的 API 令牌。
top_k: 返回的文档的最大数量。
query_prefix: 在排序之前添加到查询文本开头的字符串。使用它可以将指令添加到文本前面，这对于 bge 等重排序模型是必需的。bge.
document_prefix: 在排序之前添加到每个文档开头的字符串。您可以使用它将指令添加到文档前面，这对于像bge.
meta_fields_to_embed: 需要与文档一起嵌入的元数据字段列表。
embedding_separator: 用于将元数据字段连接到文档的分隔符。
scale_score: 如果True，使用 Sigmoid 激活函数缩放原始 logit 预测。如果False，则禁用对原始 logit 预测的缩放。
score_threshold: 使用它只返回分数高于此阈值的文档。
trust_remote_code: 如果为False，则只允许 Hugging Face 经过验证的模型架构。如果为True，则允许自定义模型和脚本。
model_kwargs: 加载模型时传递给AutoModelForSequenceClassification.from_pretrained 的额外关键字参数。有关可用 kwargs，请参阅特定模型的文档。
tokenizer_kwargs: 加载分词器时传递给AutoTokenizer.from_pretrained 的额外关键字参数。有关可用 kwargs，请参阅特定模型的文档。
config_kwargs: 加载模型配置时传递给AutoConfig.from_pretrained 的额外关键字参数。
backend: 用于 Sentence Transformers 模型的后端。选择 "torch"、"onnx" 或 "openvino"。有关加速和量化选项的更多信息，请参阅 Sentence Transformers 文档。
batch_size: 用于推理的批处理大小。批处理大小越大，所需内存越多。如果遇到内存问题，请减小批处理大小。

引发:

ValueError: 如果top_k 不大于 0。

SentenceTransformersSimilarityRanker.warm_up

def warm_up() -> None

Initializes the component.

SentenceTransformersSimilarityRanker.to_dict

def to_dict() -> dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

SentenceTransformersSimilarityRanker.from_dict

@classmethod
def from_dict(cls, data: dict[str,
                              Any]) -> "SentenceTransformersSimilarityRanker"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

SentenceTransformersSimilarityRanker.run

@component.output_types(documents=list[Document])
def run(*,
        query: str,
        documents: list[Document],
        top_k: Optional[int] = None,
        scale_score: Optional[bool] = None,
        score_threshold: Optional[float] = None) -> dict[str, list[Document]]

返回根据与给定查询的相似度排序的文档列表。

参数:

query: 用于比较文档的输入查询。
documents: 需要排序的文档列表。
top_k: 要返回的最大文档数。
scale_score: 如果True，使用 Sigmoid 激活函数缩放原始 logit 预测。如果False，禁用对原始 logit 预测的缩放。如果设置，将覆盖初始化时设置的值。
score_threshold: 使用它只返回分数高于此阈值的文档。如果设置，将覆盖初始化时设置的值。

引发:

ValueError: 如果top_k 不大于 0。
RuntimeError: 如果模型未加载，因为warm_up() 未在此之前调用。

返回值:

包含以下键的字典

documents: 最接近查询的文档列表，从最相似到最不相似排序。

模块 transformers_similarity

TransformersSimilarityRanker

根据与查询的语义相似度对文档进行排序。

它使用 Hugging Face 的预训练 cross-encoder 模型来嵌入查询和文档。

注意事项:

此组件被视为过时，将不再收到更新。在未来的版本中，它可能会被弃用，并在弃用期后移除。请考虑使用 SentenceTransformersSimilarityRanker，它提供了相同的功能以及其他附加功能。

使用示例

from haystack import Document
from haystack.components.rankers import TransformersSimilarityRanker

ranker = TransformersSimilarityRanker()
docs = [Document(content="Paris"), Document(content="Berlin")]
query = "City in Germany"
ranker.warm_up()
result = ranker.run(query=query, documents=docs)
docs = result["documents"]
print(docs[0].content)

TransformersSimilarityRanker.init

def __init__(model: Union[str, Path] = "cross-encoder/ms-marco-MiniLM-L-6-v2",
             device: Optional[ComponentDevice] = None,
             token: Optional[Secret] = Secret.from_env_var(
                 ["HF_API_TOKEN", "HF_TOKEN"], strict=False),
             top_k: int = 10,
             query_prefix: str = "",
             document_prefix: str = "",
             meta_fields_to_embed: Optional[list[str]] = None,
             embedding_separator: str = "\n",
             scale_score: bool = True,
             calibration_factor: Optional[float] = 1.0,
             score_threshold: Optional[float] = None,
             model_kwargs: Optional[dict[str, Any]] = None,
             tokenizer_kwargs: Optional[dict[str, Any]] = None,
             batch_size: int = 16)

创建 TransformersSimilarityRanker 的实例。

参数:

model: 排序模型。传入本地路径或 Hugging Face cross-encoder 模型的名称。
device: 加载模型的设备。如果None，覆盖默认设备。
token: 用于从 Hugging Face 下载私有模型的 API 令牌。
top_k: 返回的文档的最大数量。
query_prefix: 在排序之前添加到查询文本开头的字符串。使用它可以将指令添加到文本前面，这对于 bge 等重排序模型是必需的。bge.
document_prefix: 在排序之前添加到每个文档开头的字符串。您可以使用它将指令添加到文档前面，这对于像bge.
meta_fields_to_embed: 需要与文档一起嵌入的元数据字段列表。
embedding_separator: 用于将元数据字段连接到文档的分隔符。
scale_score: 如果True，使用 Sigmoid 激活函数缩放原始 logit 预测。如果False，则禁用对原始 logit 预测的缩放。
calibration_factor: 使用此因子校准概率，使用sigmoid(logits * calibration_factor)。仅当scale_score 为True.
score_threshold: 使用它只返回分数高于此阈值的文档。
model_kwargs: 加载模型时传递给AutoModelForSequenceClassification.from_pretrained 的额外关键字参数。有关可用 kwargs，请参阅特定模型的文档。
tokenizer_kwargs: 加载分词器时传递给AutoTokenizer.from_pretrained 的额外关键字参数。有关可用 kwargs，请参阅特定模型的文档。
batch_size: 用于推理的批处理大小。批处理大小越大，所需内存越多。如果遇到内存问题，请减小批处理大小。

引发:

ValueError: 如果weight 不在 [0,1] 范围内。如果scale_score 为 True 且calibration_factor 未提供时使用。

TransformersSimilarityRanker.warm_up

def warm_up()

Initializes the component.

TransformersSimilarityRanker.to_dict

def to_dict() -> dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

TransformersSimilarityRanker.from_dict

@classmethod
def from_dict(cls, data: dict[str, Any]) -> "TransformersSimilarityRanker"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

TransformersSimilarityRanker.run

@component.output_types(documents=list[Document])
def run(query: str,
        documents: list[Document],
        top_k: Optional[int] = None,
        scale_score: Optional[bool] = None,
        calibration_factor: Optional[float] = None,
        score_threshold: Optional[float] = None)

返回根据与给定查询的相似度排序的文档列表。

参数:

query: 用于比较文档的输入查询。
documents: 需要排序的文档列表。
top_k: 要返回的最大文档数。
scale_score: 如果True，使用 Sigmoid 激活函数缩放原始 logit 预测。如果False，则禁用对原始 logit 预测的缩放。
calibration_factor: 使用此因子校准概率，使用sigmoid(logits * calibration_factor)。仅当scale_score 为True.
score_threshold: 使用它只返回分数高于此阈值的文档。

引发:

ValueError: 如果weight 不在 [0,1] 范围内。如果scale_score 为 True 且calibration_factor 未提供时使用。
RuntimeError: 如果模型未加载，因为warm_up() 未在此之前调用。

返回值:

包含以下键的字典

documents: 最接近查询的文档列表，从最相似到最不相似排序。

模块 hugging_face_tei

TruncationDirection（截断方向）

HuggingFaceTEIRanker

HuggingFaceTEIRanker.__init__

HuggingFaceTEIRanker.to_dict

HuggingFaceTEIRanker.from_dict

HuggingFaceTEIRanker.run

HuggingFaceTEIRanker.run_async

模块 lost_in_the_middle

LostInTheMiddleRanker

LostInTheMiddleRanker.__init__

LostInTheMiddleRanker.run

模块 meta_field

MetaFieldRanker

MetaFieldRanker.__init__

根据选定的元字段对文档列表进行排序

通过根据元数据键对文档进行分组来重新排序它们。

MetaFieldGroupingRanker

使用示例

创建 MetaFieldGroupingRanker 的实例。

根据

模块 sentence_transformers_diversity

DiversityRankingStrategy（多样性排序策略）

DiversityRankingStrategy.__str__

DiversityRankingStrategy.from_str

DiversityRankingSimilarity（多样性排序相似度）

DiversityRankingSimilarity.__str__

DiversityRankingSimilarity.from_str

SentenceTransformersDiversityRanker

使用示例

SentenceTransformersDiversityRanker.__init__

SentenceTransformersDiversityRanker.warm_up

SentenceTransformersDiversityRanker.to_dict

SentenceTransformersDiversityRanker.from_dict

SentenceTransformersDiversityRanker.run

模块 sentence_transformers_similarity

SentenceTransformersSimilarityRanker

使用示例

SentenceTransformersSimilarityRanker.__init__

SentenceTransformersSimilarityRanker.warm_up

SentenceTransformersSimilarityRanker.to_dict

SentenceTransformersSimilarityRanker.from_dict

SentenceTransformersSimilarityRanker.run

模块 transformers_similarity

TransformersSimilarityRanker

使用示例

TransformersSimilarityRanker.__init__

TransformersSimilarityRanker.warm_up

TransformersSimilarityRanker.to_dict

TransformersSimilarityRanker.from_dict

TransformersSimilarityRanker.run

HuggingFaceTEIRanker.init

LostInTheMiddleRanker.init

MetaFieldRanker.init

DiversityRankingStrategy.str

DiversityRankingSimilarity.str

SentenceTransformersDiversityRanker.init

SentenceTransformersSimilarityRanker.init

TransformersSimilarityRanker.init