Skip to content

Metrics

评估模块。

MRR #

Bases: BaseRetrievalMetric

MRR（平均倒数排名）指标，具有两种计算选项。

  • 默认方法计算第一个相关检索文档的倒数排名。
  • 更精细的方法将所有相关检索文档的倒数排名相加，然后除以相关文档的数量。
属性

use_granular_mrr（bool）：确定是否使用精细方法进行计算。 metric_name（str）：指标的名称。

Source code in llama_index/core/evaluation/retrieval/metrics.py 
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
class MRR(BaseRetrievalMetric):
    """MRR（平均倒数排名）指标，具有两种计算选项。

    - 默认方法计算第一个相关检索文档的倒数排名。
    - 更精细的方法将所有相关检索文档的倒数排名相加，然后除以相关文档的数量。

    属性:
        use_granular_mrr（bool）：确定是否使用精细方法进行计算。
        metric_name（str）：指标的名称。"""

    metric_name: str = "mrr"
    use_granular_mrr: bool = False

    def compute(
        self,
        query: Optional[str] = None,
        expected_ids: Optional[List[str]] = None,
        retrieved_ids: Optional[List[str]] = None,
        expected_texts: Optional[List[str]] = None,
        retrieved_texts: Optional[List[str]] = None,
    ) -> RetrievalMetricResult:
        """根据提供的输入和选择的方法计算MRR。

Args:
    query（可选[str]）：查询字符串（在当前实现中未使用）。
    expected_ids（可选[List[str]]）：预期的文档ID。
    retrieved_ids（可选[List[str]]）：检索到的文档ID。
    expected_texts（可选[List[str]]）：预期的文本（在当前实现中未使用）。
    retrieved_texts（可选[List[str]]）：检索到的文本（在当前实现中未使用）。

Raises:
    ValueError: 如果未提供必要的ID。

Returns:
    RetrievalMetricResult: 计算出的MRR分数的结果。
"""
        # Checking for the required arguments
        if (
            retrieved_ids is None
            or expected_ids is None
            or not retrieved_ids
            or not expected_ids
        ):
            raise ValueError("Retrieved ids and expected ids must be provided")

        if self.use_granular_mrr:
            # Granular MRR calculation: All relevant retrieved docs have their reciprocal ranks summed and averaged
            expected_set = set(expected_ids)
            reciprocal_rank_sum = 0.0
            relevant_docs_count = 0
            for index, doc_id in enumerate(retrieved_ids):
                if doc_id in expected_set:
                    relevant_docs_count += 1
                    reciprocal_rank_sum += 1.0 / (index + 1)
            mrr_score = (
                reciprocal_rank_sum / relevant_docs_count
                if relevant_docs_count > 0
                else 0.0
            )
        else:
            # Default MRR calculation: Reciprocal rank of the first relevant document retrieved
            for i, id in enumerate(retrieved_ids):
                if id in expected_ids:
                    return RetrievalMetricResult(score=1.0 / (i + 1))
            mrr_score = 0.0

        return RetrievalMetricResult(score=mrr_score)

compute #

compute(
    query: Optional[str] = None,
    expected_ids: Optional[List[str]] = None,
    retrieved_ids: Optional[List[str]] = None,
    expected_texts: Optional[List[str]] = None,
    retrieved_texts: Optional[List[str]] = None,
) -> RetrievalMetricResult

根据提供的输入和选择的方法计算MRR。

Raises:

Type Description
ValueError

如果未提供必要的ID。

Returns:

Name Type Description
RetrievalMetricResult RetrievalMetricResult

计算出的MRR分数的结果。
Source code in llama_index/core/evaluation/retrieval/metrics.py 
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
    def compute(
        self,
        query: Optional[str] = None,
        expected_ids: Optional[List[str]] = None,
        retrieved_ids: Optional[List[str]] = None,
        expected_texts: Optional[List[str]] = None,
        retrieved_texts: Optional[List[str]] = None,
    ) -> RetrievalMetricResult:
        """根据提供的输入和选择的方法计算MRR。

Args:
    query（可选[str]）：查询字符串（在当前实现中未使用）。
    expected_ids（可选[List[str]]）：预期的文档ID。
    retrieved_ids（可选[List[str]]）：检索到的文档ID。
    expected_texts（可选[List[str]]）：预期的文本（在当前实现中未使用）。
    retrieved_texts（可选[List[str]]）：检索到的文本（在当前实现中未使用）。

Raises:
    ValueError: 如果未提供必要的ID。

Returns:
    RetrievalMetricResult: 计算出的MRR分数的结果。
"""
        # Checking for the required arguments
        if (
            retrieved_ids is None
            or expected_ids is None
            or not retrieved_ids
            or not expected_ids
        ):
            raise ValueError("Retrieved ids and expected ids must be provided")

        if self.use_granular_mrr:
            # Granular MRR calculation: All relevant retrieved docs have their reciprocal ranks summed and averaged
            expected_set = set(expected_ids)
            reciprocal_rank_sum = 0.0
            relevant_docs_count = 0
            for index, doc_id in enumerate(retrieved_ids):
                if doc_id in expected_set:
                    relevant_docs_count += 1
                    reciprocal_rank_sum += 1.0 / (index + 1)
            mrr_score = (
                reciprocal_rank_sum / relevant_docs_count
                if relevant_docs_count > 0
                else 0.0
            )
        else:
            # Default MRR calculation: Reciprocal rank of the first relevant document retrieved
            for i, id in enumerate(retrieved_ids):
                if id in expected_ids:
                    return RetrievalMetricResult(score=1.0 / (i + 1))
            mrr_score = 0.0

        return RetrievalMetricResult(score=mrr_score)

HitRate #

Bases: BaseRetrievalMetric

命中率指标：使用两种计算选项计算命中率。

  • 默认方法检查检索到的任何文档和期望文档之间的单个匹配。
  • 更精细的方法检查检索到的文档和期望文档之间的所有潜在匹配。

属性： use_granular_hit_rate（布尔值）：确定是否使用更精细的方法进行计算。 metric_name（字符串）：指标的名称。

Source code in llama_index/core/evaluation/retrieval/metrics.py 
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
class HitRate(BaseRetrievalMetric):
    """命中率指标：使用两种计算选项计算命中率。

    - 默认方法检查检索到的任何文档和期望文档之间的单个匹配。
    - 更精细的方法检查检索到的文档和期望文档之间的所有潜在匹配。

    属性：
        use_granular_hit_rate（布尔值）：确定是否使用更精细的方法进行计算。
        metric_name（字符串）：指标的名称。"""

    metric_name: str = "hit_rate"
    use_granular_hit_rate: bool = False

    def compute(
        self,
        query: Optional[str] = None,
        expected_ids: Optional[List[str]] = None,
        retrieved_ids: Optional[List[str]] = None,
        expected_texts: Optional[List[str]] = None,
        retrieved_texts: Optional[List[str]] = None,
    ) -> RetrievalMetricResult:
        """根据提供的输入计算度量标准。

Args:
    query (可选[str]): 查询字符串（在当前实现中未使用）。
    expected_ids (可选[List[str]]): 预期的文档ID。
    retrieved_ids (可选[List[str]]): 检索到的文档ID。
    expected_texts (可选[List[str]]): 预期的文本（在当前实现中未使用）。
    retrieved_texts (可选[List[str]]): 检索到的文本（在当前实现中未使用）。

引发:
    ValueError: 如果未提供必要的ID。

Returns:
    RetrievalMetricResult: 计算得出的命中率分数的结果。
"""
        # Checking for the required arguments
        if (
            retrieved_ids is None
            or expected_ids is None
            or not retrieved_ids
            or not expected_ids
        ):
            raise ValueError("Retrieved ids and expected ids must be provided")

        if self.use_granular_hit_rate:
            # Granular HitRate calculation: Calculate all hits and divide by the number of expected docs
            expected_set = set(expected_ids)
            hits = sum(1 for doc_id in retrieved_ids if doc_id in expected_set)
            score = hits / len(expected_ids) if expected_ids else 0.0
        else:
            # Default HitRate calculation: Check if there is a single hit
            is_hit = any(id in expected_ids for id in retrieved_ids)
            score = 1.0 if is_hit else 0.0

        return RetrievalMetricResult(score=score)

compute #

compute(
    query: Optional[str] = None,
    expected_ids: Optional[List[str]] = None,
    retrieved_ids: Optional[List[str]] = None,
    expected_texts: Optional[List[str]] = None,
    retrieved_texts: Optional[List[str]] = None,
) -> RetrievalMetricResult

根据提供的输入计算度量标准。

Parameters:

Name Type Description Default
query 可选[str]

查询字符串（在当前实现中未使用）。

 None
expected_ids 可选[List[str]]

预期的文档ID。

 None
retrieved_ids 可选[List[str]]

检索到的文档ID。

 None
expected_texts 可选[List[str]]

预期的文本（在当前实现中未使用）。

 None
retrieved_texts 可选[List[str]]

检索到的文本（在当前实现中未使用）。

 None
引发

ValueError: 如果未提供必要的ID。

Returns:

Name Type Description
RetrievalMetricResult RetrievalMetricResult

计算得出的命中率分数的结果。
Source code in llama_index/core/evaluation/retrieval/metrics.py 
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
    def compute(
        self,
        query: Optional[str] = None,
        expected_ids: Optional[List[str]] = None,
        retrieved_ids: Optional[List[str]] = None,
        expected_texts: Optional[List[str]] = None,
        retrieved_texts: Optional[List[str]] = None,
    ) -> RetrievalMetricResult:
        """根据提供的输入计算度量标准。

Args:
    query (可选[str]): 查询字符串（在当前实现中未使用）。
    expected_ids (可选[List[str]]): 预期的文档ID。
    retrieved_ids (可选[List[str]]): 检索到的文档ID。
    expected_texts (可选[List[str]]): 预期的文本（在当前实现中未使用）。
    retrieved_texts (可选[List[str]]): 检索到的文本（在当前实现中未使用）。

引发:
    ValueError: 如果未提供必要的ID。

Returns:
    RetrievalMetricResult: 计算得出的命中率分数的结果。
"""
        # Checking for the required arguments
        if (
            retrieved_ids is None
            or expected_ids is None
            or not retrieved_ids
            or not expected_ids
        ):
            raise ValueError("Retrieved ids and expected ids must be provided")

        if self.use_granular_hit_rate:
            # Granular HitRate calculation: Calculate all hits and divide by the number of expected docs
            expected_set = set(expected_ids)
            hits = sum(1 for doc_id in retrieved_ids if doc_id in expected_set)
            score = hits / len(expected_ids) if expected_ids else 0.0
        else:
            # Default HitRate calculation: Check if there is a single hit
            is_hit = any(id in expected_ids for id in retrieved_ids)
            score = 1.0 if is_hit else 0.0

        return RetrievalMetricResult(score=score)

RetrievalMetricResult #

Bases: BaseModel

度量结果。

属性

score (float): 度量的分数 metadata (Dict[str, Any]): 度量结果的元数据

Source code in llama_index/core/evaluation/retrieval/metrics_base.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class RetrievalMetricResult(BaseModel):
    """度量结果。

    属性:
        score (float): 度量的分数
        metadata (Dict[str, Any]): 度量结果的元数据"""

    score: float = Field(..., description="Score for the metric")
    metadata: Dict[str, Any] = Field(
        default_factory=dict, description="Metadata for the metric result"
    )

    def __str__(self) -> str:
        """字符串表示。"""
        return f"Score: {self.score}\nMetadata: {self.metadata}"

    def __float__(self) -> float:
        """浮点数表示。"""
        return self.score

resolve_metrics #

resolve_metrics(
    metrics: List[str],
) -> List[Type[BaseRetrievalMetric]]

从指标名称列表中解析指标。

Source code in llama_index/core/evaluation/retrieval/metrics.py 
214
215
216
217
218
219
220
def resolve_metrics(metrics: List[str]) -> List[Type[BaseRetrievalMetric]]:
    """从指标名称列表中解析指标。"""
    for metric in metrics:
        if metric not in METRIC_REGISTRY:
            raise ValueError(f"Invalid metric name: {metric}")

    return [METRIC_REGISTRY[metric] for metric in metrics]