模块 answer_exact_match

AnswerExactMatchEvaluator

一个答案精确匹配的评估器类。

该评估器用于检查预测答案是否与任何一个地面真实答案完全匹配。结果是一个介于 0.0 到 1.0 之间的数字，表示匹配到地面真实答案的预测答案的比例。输入可以有多个地面真实答案和多个预测答案。

使用示例

from haystack.components.evaluators import AnswerExactMatchEvaluator

evaluator = AnswerExactMatchEvaluator()
result = evaluator.run(
    ground_truth_answers=["Berlin", "Paris"],
    predicted_answers=["Berlin", "Lyon"],
)

print(result["individual_scores"])
# [1, 0]
print(result["score"])
# 0.5

AnswerExactMatchEvaluator.run

@component.output_types(individual_scores=list[int], score=float)
def run(ground_truth_answers: list[str],
        predicted_answers: list[str]) -> dict[str, Any]

在给定的输入上运行 AnswerExactMatchEvaluator。

该ground_truth_answers 和retrieved_answers 必须具有相同的长度。

参数:

ground_truth_answers: 预期答案的列表。
predicted_answers: 预测答案的列表。

返回值:

一个包含以下输出的字典

individual_scores - 一个由 0 和 1 组成的列表，其中 1 表示预测答案匹配了地面真实答案之一。
score - 一个介于 0.0 到 1.0 之间的数字，表示任何预测答案匹配地面真实答案之一的问题的比例。

模块 context_relevance

ContextRelevanceEvaluator

用于检查提供的上下文是否与问题相关的评估器。

LLM 会将上下文分解成多个陈述，并检查每个陈述是否与回答问题相关。每个上下文的分数是二进制的 1 或 0，1 表示上下文与问题相关，0 表示上下文与问题不相关。该评估器还提供上下文中的相关陈述以及所有提供的输入问题-上下文对的平均分数。

使用示例

from haystack.components.evaluators import ContextRelevanceEvaluator

questions = ["Who created the Python language?", "Why does Java needs a JVM?", "Is C++ better than Python?"]
contexts = [
    [(
        "Python, created by Guido van Rossum in the late 1980s, is a high-level general-purpose programming "
        "language. Its design philosophy emphasizes code readability, and its language constructs aim to help "
        "programmers write clear, logical code for both small and large-scale software projects."
    )],
    [(
        "Java is a high-level, class-based, object-oriented programming language that is designed to have as few "
        "implementation dependencies as possible. The JVM has two primary functions: to allow Java programs to run"
        "on any device or operating system (known as the 'write once, run anywhere' principle), and to manage and"
        "optimize program memory."
    )],
    [(
        "C++ is a general-purpose programming language created by Bjarne Stroustrup as an extension of the C "
        "programming language."
    )],
]

evaluator = ContextRelevanceEvaluator()
result = evaluator.run(questions=questions, contexts=contexts)
print(result["score"])
# 0.67
print(result["individual_scores"])
# [1,1,0]
print(result["results"])
# [{
#   'relevant_statements': ['Python, created by Guido van Rossum in the late 1980s.'],
#    'score': 1.0
#  },
#  {
#   'relevant_statements': ['The JVM has two primary functions: to allow Java programs to run on any device or
#                           operating system (known as the "write once, run anywhere" principle), and to manage and
#                           optimize program memory'],
#   'score': 1.0
#  },
#  {
#   'relevant_statements': [],
#   'score': 0.0
#  }]

ContextRelevanceEvaluator.init

def __init__(examples: Optional[list[dict[str, Any]]] = None,
             progress_bar: bool = True,
             raise_on_failure: bool = True,
             chat_generator: Optional[ChatGenerator] = None)

创建 ContextRelevanceEvaluator 的一个实例。

如果未通过chat_generator 参数指定 LLM，组件将使用 OpenAI 的 JSON 模式。

参数:

examples: 可选的少样本示例，符合 ContextRelevanceEvaluator 预期的输入和输出格式。如果未提供，将使用默认示例。每个示例都必须是一个字典，包含“inputs”和“outputs”键。“inputs”必须是一个包含“questions”和“contexts”键的字典。“outputs”必须是一个包含“relevant_statements”的字典。预期格式

[{
    "inputs": {
        "questions": "What is the capital of Italy?", "contexts": ["Rome is the capital of Italy."],
    },
    "outputs": {
        "relevant_statements": ["Rome is the capital of Italy."],
    },
}]

progress_bar: 在评估期间是否显示进度条。
raise_on_failure: 如果 API 调用失败，是否引发异常。
chat_generator: 一个 ChatGenerator 实例，代表 LLM。为了使组件正常工作，LLM 应配置为返回 JSON 对象。例如，当使用 OpenAIChatGenerator 时，您应该传递{"response_format": {"type": "json_object"}} 在generation_kwargs.

ContextRelevanceEvaluator.run

@component.output_types(score=float, results=list[dict[str, Any]])
def run(**inputs) -> dict[str, Any]

运行 LLM 评估器。

参数:

questions: 问题列表。
contexts: 上下文列表的列表。每个上下文列表对应一个问题。

返回值:

一个包含以下输出的字典

score: 所有提供的输入问题上的平均上下文相关性分数。
results: 一个字典列表，包含relevant_statements 和score 对于每个输入上下文。

ContextRelevanceEvaluator.to_dict

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

将此组件序列化为字典。

返回值:

包含序列化数据的字典。

ContextRelevanceEvaluator.from_dict

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

从字典反序列化此组件。

参数:

data：此组件的字典表示。

返回值:

反序列化的组件实例。

ContextRelevanceEvaluator.validate_init_parameters

@staticmethod
def validate_init_parameters(inputs: list[tuple[str, type[list]]],
                             outputs: list[str], examples: list[dict[str,
                                                                     Any]])

验证初始化参数。

参数:

inputs: 要验证的输入。
outputs: 要验证的输出。
examples: 要验证的示例。

引发:

ValueError: 如果输入不是包含字符串和列表类型的元组列表。如果输出不是字符串列表。如果示例不是字典列表。如果任何示例没有“inputs”和“outputs”键，其值是包含字符串键的字典。

ContextRelevanceEvaluator.prepare_template

def prepare_template() -> str

准备提示模板。

将指令、输入、输出和示例组合成一个提示模板，格式如下：指令<instructions>

以 JSON 格式生成响应，包含以下键<list of output keys> 考虑下面的指令和示例来确定这些值。

示例<examples>

输入<inputs> 输出

返回值:

提示模板。

ContextRelevanceEvaluator.validate_input_parameters

@staticmethod
def validate_input_parameters(expected: dict[str, Any],
                              received: dict[str, Any]) -> None

验证输入参数。

参数:

expected: 预期的输入参数。
received: 收到的输入参数。

引发:

ValueError: 如果在收到的输入中不存在所有预期的输入。如果收到的输入不是列表或长度不同。

ContextRelevanceEvaluator.is_valid_json_and_has_expected_keys

def is_valid_json_and_has_expected_keys(expected: list[str],
                                        received: str) -> bool

输出必须是具有预期键的有效 JSON。

参数:

expected: 预期的输出名称
received: 收到的输出名称

引发:

ValueError: 如果输出不是具有预期键的有效 JSON。
与raise_on_failure 设置为 True 时，将引发 ValueError。
与raise_on_failure 设置为 False 时，将发出警告并返回 False。

返回值:

如果收到的输出是具有预期键的有效 JSON，则返回 True，否则返回 False。

模块 document_map

DocumentMAPEvaluator

文档的平均精度 (MAP) 评估器。

用于计算检索文档平均精度 (MAP) 的评估器，该指标衡量检索文档的排名有多高。每个问题可以有多个地面真实文档和多个检索文档。

DocumentMAPEvaluator 不会对输入进行归一化，DocumentCleaner 组件应在将文档传递给此评估器之前用于清理和规范化文档。

使用示例

from haystack import Document
from haystack.components.evaluators import DocumentMAPEvaluator

evaluator = DocumentMAPEvaluator()
result = evaluator.run(
    ground_truth_documents=[
        [Document(content="France")],
        [Document(content="9th century"), Document(content="9th")],
    ],
    retrieved_documents=[
        [Document(content="France")],
        [Document(content="9th century"), Document(content="10th century"), Document(content="9th")],
    ],
)

print(result["individual_scores"])
# [1.0, 0.8333333333333333]
print(result["score"])
# 0.9166666666666666

DocumentMAPEvaluator.run

@component.output_types(score=float, individual_scores=list[float])
def run(ground_truth_documents: list[list[Document]],
        retrieved_documents: list[list[Document]]) -> dict[str, Any]

在给定的输入上运行 DocumentMAPEvaluator。

所有列表必须具有相同的长度。

参数:

ground_truth_documents: 每个问题的预期文档列表。
retrieved_documents: 每个问题的检索文档列表。

返回值:

一个包含以下输出的字典

score - 计算分数的平均值。
individual_scores - 一个介于 0.0 到 1.0 之间的数字列表，表示检索文档的排名有多高。

模块 document_mrr

DocumentMRREvaluator

计算检索文档的平均倒数排名 (MRR) 的评估器。

MRR 衡量第一个检索文档的排名有多高。每个问题可以有多个地面真实文档和多个检索文档。

DocumentMRREvaluator 不会对输入进行归一化，DocumentCleaner 组件应在将文档传递给此评估器之前用于清理和规范化文档。

使用示例

from haystack import Document
from haystack.components.evaluators import DocumentMRREvaluator

evaluator = DocumentMRREvaluator()
result = evaluator.run(
    ground_truth_documents=[
        [Document(content="France")],
        [Document(content="9th century"), Document(content="9th")],
    ],
    retrieved_documents=[
        [Document(content="France")],
        [Document(content="9th century"), Document(content="10th century"), Document(content="9th")],
    ],
)
print(result["individual_scores"])
# [1.0, 1.0]
print(result["score"])
# 1.0

DocumentMRREvaluator.run

@component.output_types(score=float, individual_scores=list[float])
def run(ground_truth_documents: list[list[Document]],
        retrieved_documents: list[list[Document]]) -> dict[str, Any]

在给定的输入上运行 DocumentMRREvaluator。

ground_truth_documents 和retrieved_documents 必须具有相同的长度。

参数:

ground_truth_documents: 每个问题的预期文档列表。
retrieved_documents: 每个问题的检索文档列表。

返回值:

一个包含以下输出的字典

score - 计算分数的平均值。
individual_scores - 一个介于 0.0 到 1.0 之间的数字列表，表示第一个检索文档的排名有多高。

模块 document_ndcg

DocumentNDCGEvaluator

计算检索文档的归一化折扣累计增益 (NDCG) 的评估器。

每个问题可以有多个地面真实文档和多个检索文档。如果地面真实文档具有相关性分数，则 NDCG 计算使用这些分数。否则，它假定所有地面真实文档都具有二进制相关性。

使用示例

from haystack import Document
from haystack.components.evaluators import DocumentNDCGEvaluator

evaluator = DocumentNDCGEvaluator()
result = evaluator.run(
    ground_truth_documents=[[Document(content="France", score=1.0), Document(content="Paris", score=0.5)]],
    retrieved_documents=[[Document(content="France"), Document(content="Germany"), Document(content="Paris")]],
)
print(result["individual_scores"])
# [0.8869]
print(result["score"])
# 0.8869

DocumentNDCGEvaluator.run

@component.output_types(score=float, individual_scores=list[float])
def run(ground_truth_documents: list[list[Document]],
        retrieved_documents: list[list[Document]]) -> dict[str, Any]

在给定的输入上运行 DocumentNDCGEvaluator。

ground_truth_documents 和retrieved_documents 必须具有相同的长度。其中的列表项ground_truth_documents 和retrieved_documents 可以有不同的长度。

参数:

ground_truth_documents: 预期文档列表，每个问题一个列表。如果没有分数，则使用二进制相关性。
retrieved_documents: 检索文档列表，每个问题一个列表。

返回值:

一个包含以下输出的字典

score - 计算分数的平均值。
individual_scores - 一个介于 0.0 到 1.0 之间的数字列表，表示每个问题的 NDCG。

DocumentNDCGEvaluator.validate_inputs

@staticmethod
def validate_inputs(gt_docs: list[list[Document]],
                    ret_docs: list[list[Document]])

验证输入参数。

参数:

gt_docs: 要验证的 ground_truth_documents。
ret_docs: 要验证的 retrieved_documents。

引发:

ValueError: 如果 ground_truth_documents 或 retrieved_documents 为空列表。如果 ground_truth_documents 和 retrieved_documents 的长度不同。如果 ground_truth_documents 中的任何文档列表包含带有分数和没有分数的文档混合。

DocumentNDCGEvaluator.calculate_dcg

@staticmethod
def calculate_dcg(gt_docs: list[Document], ret_docs: list[Document]) -> float

计算检索文档的折扣累计增益 (DCG)。

参数:

gt_docs: 地面真实文档。
ret_docs: 检索文档。

返回值:

基于地面真实文档的检索文档的折扣累计增益 (DCG)。

DocumentNDCGEvaluator.calculate_idcg

@staticmethod
def calculate_idcg(gt_docs: list[Document]) -> float

计算地面真实文档的理想折扣累计增益 (IDCG)。

参数:

gt_docs: 地面真实文档。

返回值:

地面真实文档的理想折扣累计增益 (IDCG)。

模块 document_recall

RecallMode

用于计算召回率分数的模式枚举。

RecallMode.from_str

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

将字符串转换为 RecallMode 枚举。

DocumentRecallEvaluator

用于计算文档列表召回率分数的评估器。

返回每个问题的分数列表以及平均分。输入可以有多个地面真实文档和多个预测文档。

使用示例

from haystack import Document
from haystack.components.evaluators import DocumentRecallEvaluator

evaluator = DocumentRecallEvaluator()
result = evaluator.run(
    ground_truth_documents=[
        [Document(content="France")],
        [Document(content="9th century"), Document(content="9th")],
    ],
    retrieved_documents=[
        [Document(content="France")],
        [Document(content="9th century"), Document(content="10th century"), Document(content="9th")],
    ],
)
print(result["individual_scores"])
# [1.0, 1.0]
print(result["score"])
# 1.0

DocumentRecallEvaluator.init

def __init__(mode: Union[str, RecallMode] = RecallMode.SINGLE_HIT)

创建 DocumentRecallEvaluator 组件。

参数:

mode: 用于计算召回率分数的模式。

DocumentRecallEvaluator.run

@component.output_types(score=float, individual_scores=list[float])
def run(ground_truth_documents: list[list[Document]],
        retrieved_documents: list[list[Document]]) -> dict[str, Any]

在给定的输入上运行 DocumentRecallEvaluator。

ground_truth_documents 和retrieved_documents 必须具有相同的长度。

参数:

ground_truth_documents: 每个问题的预期文档列表。
retrieved_documents: 每个问题的检索文档列表。一个包含以下输出的字典
score - 计算分数的平均值。
individual_scores - 一个介于 0.0 到 1.0 之间的数字列表，表示检索到匹配文档的比例。如果模式是single_hit，则单个分数是 0 或 1。

DocumentRecallEvaluator.to_dict

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

将组件序列化为字典。

返回值:

包含序列化数据的字典。

模块 faithfulness

FaithfulnessEvaluator

用于检查生成的答案是否可以从提供的上下文中推断出来的评估器。

LLM 会将答案分解成多个陈述，并检查每个陈述是否可以从上下文中推断出来。最终对整个答案的分数是一个介于 0.0 到 1.0 之间的数字。它表示可以从提供的上下文中推断出的陈述的比例。

使用示例

from haystack.components.evaluators import FaithfulnessEvaluator

questions = ["Who created the Python language?"]
contexts = [
    [(
        "Python, created by Guido van Rossum in the late 1980s, is a high-level general-purpose programming "
        "language. Its design philosophy emphasizes code readability, and its language constructs aim to help "
        "programmers write clear, logical code for both small and large-scale software projects."
    )],
]
predicted_answers = [
    "Python is a high-level general-purpose programming language that was created by George Lucas."
]
evaluator = FaithfulnessEvaluator()
result = evaluator.run(questions=questions, contexts=contexts, predicted_answers=predicted_answers)

print(result["individual_scores"])
# [0.5]
print(result["score"])
# 0.5
print(result["results"])
# [{'statements': ['Python is a high-level general-purpose programming language.',
'Python was created by George Lucas.'], 'statement_scores': [1, 0], 'score': 0.5}]

FaithfulnessEvaluator.init

def __init__(examples: Optional[list[dict[str, Any]]] = None,
             progress_bar: bool = True,
             raise_on_failure: bool = True,
             chat_generator: Optional[ChatGenerator] = None)

创建 FaithfulnessEvaluator 的一个实例。

如果未通过chat_generator 参数指定 LLM，组件将使用 OpenAI 的 JSON 模式。

参数:

examples: 可选的少样本示例，符合 FaithfulnessEvaluator 预期的输入和输出格式。如果未提供，将使用默认示例。每个示例都必须是一个字典，包含“inputs”和“outputs”键。“inputs”必须是一个包含“questions”、“contexts”和“predicted_answers”键的字典。“outputs”必须是一个包含“statements”和“statement_scores”的字典。预期格式

[{
    "inputs": {
        "questions": "What is the capital of Italy?", "contexts": ["Rome is the capital of Italy."],
        "predicted_answers": "Rome is the capital of Italy with more than 4 million inhabitants.",
    },
    "outputs": {
        "statements": ["Rome is the capital of Italy.", "Rome has more than 4 million inhabitants."],
        "statement_scores": [1, 0],
    },
}]

progress_bar: 在评估期间是否显示进度条。
raise_on_failure: 如果 API 调用失败，是否引发异常。
chat_generator: 一个 ChatGenerator 实例，代表 LLM。为了使组件正常工作，LLM 应配置为返回 JSON 对象。例如，当使用 OpenAIChatGenerator 时，您应该传递{"response_format": {"type": "json_object"}} 在generation_kwargs.

FaithfulnessEvaluator.run

@component.output_types(individual_scores=list[int],
                        score=float,
                        results=list[dict[str, Any]])
def run(**inputs) -> dict[str, Any]

运行 LLM 评估器。

参数:

questions: 问题列表。
contexts: 与问题对应的上下文的嵌套列表。
predicted_answers: 预测答案的列表。

返回值:

一个包含以下输出的字典

score: 所有提供的输入答案上的平均忠实度分数。
individual_scores: 每个输入答案的忠实度分数列表。
results: 一个字典列表，包含statements 和statement_scores 对于每个输入答案。

FaithfulnessEvaluator.to_dict

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

将此组件序列化为字典。

返回值:

包含序列化数据的字典。

FaithfulnessEvaluator.from_dict

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

从字典反序列化此组件。

参数:

data：此组件的字典表示。

返回值:

反序列化的组件实例。

FaithfulnessEvaluator.validate_init_parameters

@staticmethod
def validate_init_parameters(inputs: list[tuple[str, type[list]]],
                             outputs: list[str], examples: list[dict[str,
                                                                     Any]])

验证初始化参数。

参数:

inputs: 要验证的输入。
outputs: 要验证的输出。
examples: 要验证的示例。

引发:

ValueError: 如果输入不是包含字符串和列表类型的元组列表。如果输出不是字符串列表。如果示例不是字典列表。如果任何示例没有“inputs”和“outputs”键，其值是包含字符串键的字典。

FaithfulnessEvaluator.prepare_template

def prepare_template() -> str

准备提示模板。

将指令、输入、输出和示例组合成一个提示模板，格式如下：指令<instructions>

以 JSON 格式生成响应，包含以下键<list of output keys> 考虑下面的指令和示例来确定这些值。

示例<examples>

输入<inputs> 输出

返回值:

提示模板。

FaithfulnessEvaluator.validate_input_parameters

@staticmethod
def validate_input_parameters(expected: dict[str, Any],
                              received: dict[str, Any]) -> None

验证输入参数。

参数:

expected: 预期的输入参数。
received: 收到的输入参数。

引发:

ValueError: 如果在收到的输入中不存在所有预期的输入。如果收到的输入不是列表或长度不同。

FaithfulnessEvaluator.is_valid_json_and_has_expected_keys

def is_valid_json_and_has_expected_keys(expected: list[str],
                                        received: str) -> bool

输出必须是具有预期键的有效 JSON。

参数:

expected: 预期的输出名称
received: 收到的输出名称

引发:

ValueError: 如果输出不是具有预期键的有效 JSON。
与raise_on_failure 设置为 True 时，将引发 ValueError。
与raise_on_failure 设置为 False 时，将发出警告并返回 False。

返回值:

如果收到的输出是具有预期键的有效 JSON，则返回 True，否则返回 False。

模块 llm_evaluator

LLMEvaluator

使用 LLM 根据包含指令和示例的提示来评估输入。

默认 API 要求将 OpenAI API 密钥作为环境变量“OPENAI_API_KEY”提供。输入是用户定义的列表，具体取决于所需的度量。输出是一个字典，其中包含一个键results，其中包含评估结果列表。每个结果都是一个字典，其中包含用户定义的键，值分别为 0 表示 FALSE 或 1 表示 TRUE。

使用示例

from haystack.components.evaluators import LLMEvaluator
evaluator = LLMEvaluator(
    instructions="Is this answer problematic for children?",
    inputs=[("predicted_answers", list[str])],
    outputs=["score"],
    examples=[
        {"inputs": {"predicted_answers": "Damn, this is straight outta hell!!!"}, "outputs": {"score": 1}},
        {"inputs": {"predicted_answers": "Football is the most popular sport."}, "outputs": {"score": 0}},
    ],
)
predicted_answers = [
    "Football is the most popular sport with around 4 billion followers worldwide",
    "Python language was created by Guido van Rossum.",
]
results = evaluator.run(predicted_answers=predicted_answers)
print(results)
# {'results': [{'score': 0}, {'score': 0}]}

LLMEvaluator.init

def __init__(instructions: str,
             inputs: list[tuple[str, type[list]]],
             outputs: list[str],
             examples: list[dict[str, Any]],
             progress_bar: bool = True,
             *,
             raise_on_failure: bool = True,
             chat_generator: Optional[ChatGenerator] = None)

创建 LLMEvaluator 的一个实例。

如果未通过chat_generator 参数指定 LLM，组件将使用 OpenAI 的 JSON 模式。

参数:

instructions: 用于评估的提示指令。应该是一个关于输入的问题，可以回答是或否。
inputs: 组件期望作为传入连接并进行评估的输入。每个输入都是一个输入名称和输入类型的元组。输入类型必须是列表。
outputs: 评估结果的输出名称。它们对应于输出字典中的键。
examples: 符合在inputs 和outputs 参数中定义的预期输入和输出格式的少样本示例。每个示例都是一个包含“inputs”和“outputs”键的字典。它们分别包含输入和输出字典。
raise_on_failure: 如果为 True，则在 API 调用不成功时组件将引发异常。
progress_bar: 在评估期间是否显示进度条。
chat_generator: 一个 ChatGenerator 实例，代表 LLM。为了使组件正常工作，LLM 应配置为返回 JSON 对象。例如，当使用 OpenAIChatGenerator 时，您应该传递{"response_format": {"type": "json_object"}} 在generation_kwargs.

LLMEvaluator.validate_init_parameters

@staticmethod
def validate_init_parameters(inputs: list[tuple[str, type[list]]],
                             outputs: list[str], examples: list[dict[str,
                                                                     Any]])

验证初始化参数。

参数:

inputs: 要验证的输入。
outputs: 要验证的输出。
examples: 要验证的示例。

引发:

ValueError: 如果输入不是包含字符串和列表类型的元组列表。如果输出不是字符串列表。如果示例不是字典列表。如果任何示例没有“inputs”和“outputs”键，其值是包含字符串键的字典。

LLMEvaluator.run

@component.output_types(results=list[dict[str, Any]])
def run(**inputs) -> dict[str, Any]

运行 LLM 评估器。

参数:

inputs: 要评估的输入值。键是输入名称，值是输入值列表。

引发:

ValueError: 仅在raise_on_failure 设置为 True 且收到的输入不是列表或长度不同，或者输出不是有效 JSON 或不包含预期键时。

返回值:

一个包含results 条目的字典，其中包含结果列表。每个结果是一个字典，包含 LLMEvaluator 的outputs 参数中定义的键以及作为值的评估结果。如果特定输入值发生异常，该条目的结果将为None。如果 API 是“openai”且响应包含“meta”键，则 OpenAI 的元数据将包含在输出字典中，键为“meta”。

LLMEvaluator.prepare_template

def prepare_template() -> str

准备提示模板。

将指令、输入、输出和示例组合成一个提示模板，格式如下：指令<instructions>

以 JSON 格式生成响应，包含以下键<list of output keys> 考虑下面的指令和示例来确定这些值。

示例<examples>

输入<inputs> 输出

返回值:

提示模板。

LLMEvaluator.to_dict

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

将此组件序列化为字典。

返回值:

序列化后的组件（字典格式）。

LLMEvaluator.from_dict

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

从字典反序列化此组件。

参数:

data：此组件的字典表示。

返回值:

反序列化的组件实例。

LLMEvaluator.validate_input_parameters

@staticmethod
def validate_input_parameters(expected: dict[str, Any],
                              received: dict[str, Any]) -> None

验证输入参数。

参数:

expected: 预期的输入参数。
received: 收到的输入参数。

引发:

ValueError: 如果在收到的输入中不存在所有预期的输入。如果收到的输入不是列表或长度不同。

LLMEvaluator.is_valid_json_and_has_expected_keys

def is_valid_json_and_has_expected_keys(expected: list[str],
                                        received: str) -> bool

输出必须是具有预期键的有效 JSON。

参数:

expected: 预期的输出名称
received: 收到的输出名称

引发:

ValueError: 如果输出不是具有预期键的有效 JSON。
与raise_on_failure 设置为 True 时，将引发 ValueError。
与raise_on_failure 设置为 False 时，将发出警告并返回 False。

返回值:

如果收到的输出是具有预期键的有效 JSON，则返回 True，否则返回 False。

模块 sas_evaluator

SASEvaluator

SASEvaluator 计算预测列表与地面真实列表之间的语义答案相似度 (SAS)。

它通常用于检索增强生成 (RAG) pipeline 中，以评估生成答案的质量。SAS 使用 Hugging Face 模型中心预训练的模型进行计算。该模型可以是 Bi-Encoder 或 Cross-Encoder。模型的选择基于model 参数。

使用示例

from haystack.components.evaluators.sas_evaluator import SASEvaluator

evaluator = SASEvaluator(model="cross-encoder/ms-marco-MiniLM-L-6-v2")
evaluator.warm_up()
ground_truths = [
    "A construction budget of US $2.3 billion",
    "The Eiffel Tower, completed in 1889, symbolizes Paris's cultural magnificence.",
    "The Meiji Restoration in 1868 transformed Japan into a modernized world power.",
]
predictions = [
    "A construction budget of US $2.3 billion",
    "The Eiffel Tower, completed in 1889, symbolizes Paris's cultural magnificence.",
    "The Meiji Restoration in 1868 transformed Japan into a modernized world power.",
]
result = evaluator.run(
    ground_truths_answers=ground_truths, predicted_answers=predictions
)

print(result["score"])
# 0.9999673763910929

print(result["individual_scores"])
# [0.9999765157699585, 0.999968409538269, 0.9999572038650513]

SASEvaluator.init

def __init__(
    model: str = "sentence-transformers/paraphrase-multilingual-mpnet-base-v2",
    batch_size: int = 32,
    device: Optional[ComponentDevice] = None,
    token: Secret = Secret.from_env_var(["HF_API_TOKEN", "HF_TOKEN"],
                                        strict=False))

创建 SASEvaluator 的新实例。

参数:

model: SentenceTransformers 语义文本相似度模型，应为指向可下载模型的路径或字符串。
batch_size: 一次编码的预测-标签对的数量。
device: 加载模型的设备。如果None，默认设备会自动选择。
token: 用于 HTTP bearer 授权的 Hugging Face token。您可以在您的账户设置中找到您的 HF token。

SASEvaluator.to_dict

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

将此组件序列化为字典。

返回值:

序列化后的组件（字典格式）。

SASEvaluator.from_dict

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

从字典反序列化此组件。

参数:

data：此组件的字典表示。

返回值:

反序列化的组件实例。

SASEvaluator.warm_up

def warm_up()

Initializes the component.

SASEvaluator.run

@component.output_types(score=float, individual_scores=list[float])
def run(ground_truth_answers: list[str],
        predicted_answers: list[str]) -> dict[str, Any]

SASEvaluator 组件运行方法。

运行 SASEvaluator 以计算预测答案列表与地面真实答案列表之间的语义答案相似度 (SAS)。两者都必须是相同长度的字符串列表。

参数:

ground_truth_answers: 每个问题的预期答案列表。
predicted_answers: 每个问题的生成答案列表。

返回值:

一个包含以下输出的字典

score: 所有预测/地面真实对的平均 SAS 分数。
individual_scores: 每个预测/地面真实对的相似度分数列表。

模块 answer_exact_match

AnswerExactMatchEvaluator

AnswerExactMatchEvaluator.run

模块 context_relevance

ContextRelevanceEvaluator

ContextRelevanceEvaluator.__init__

ContextRelevanceEvaluator.run

ContextRelevanceEvaluator.to_dict

ContextRelevanceEvaluator.from_dict

ContextRelevanceEvaluator.validate_init_parameters

ContextRelevanceEvaluator.prepare_template

ContextRelevanceEvaluator.validate_input_parameters

ContextRelevanceEvaluator.is_valid_json_and_has_expected_keys

模块 document_map

DocumentMAPEvaluator

DocumentMAPEvaluator.run

模块 document_mrr

DocumentMRREvaluator

DocumentMRREvaluator.run

模块 document_ndcg

DocumentNDCGEvaluator

DocumentNDCGEvaluator.run

DocumentNDCGEvaluator.validate_inputs

DocumentNDCGEvaluator.calculate_dcg

DocumentNDCGEvaluator.calculate_idcg

模块 document_recall

RecallMode

RecallMode.from_str

DocumentRecallEvaluator

DocumentRecallEvaluator.__init__

DocumentRecallEvaluator.run

DocumentRecallEvaluator.to_dict

模块 faithfulness

FaithfulnessEvaluator

FaithfulnessEvaluator.__init__

FaithfulnessEvaluator.run

FaithfulnessEvaluator.to_dict

FaithfulnessEvaluator.from_dict

FaithfulnessEvaluator.validate_init_parameters

FaithfulnessEvaluator.prepare_template

FaithfulnessEvaluator.validate_input_parameters

FaithfulnessEvaluator.is_valid_json_and_has_expected_keys

模块 llm_evaluator

LLMEvaluator

LLMEvaluator.__init__

LLMEvaluator.validate_init_parameters

LLMEvaluator.run

LLMEvaluator.prepare_template

LLMEvaluator.to_dict

LLMEvaluator.from_dict

LLMEvaluator.validate_input_parameters

LLMEvaluator.is_valid_json_and_has_expected_keys

模块 sas_evaluator

SASEvaluator

SASEvaluator.__init__

SASEvaluator.to_dict

SASEvaluator.from_dict

SASEvaluator.warm_up

SASEvaluator.run

ContextRelevanceEvaluator.init

DocumentRecallEvaluator.init

FaithfulnessEvaluator.init

LLMEvaluator.init

SASEvaluator.init