113 深入解析`QueryFusionRetriever`类中的倒数排名融合方法 llamaindex.core.retrievers

深入解析QueryFusionRetriever类中的倒数排名融合方法

在信息检索系统中，如何有效地融合多个检索器的输出结果是一个关键问题。QueryFusionRetriever类提供了_reciprocal_rerank_fusion方法，用于应用倒数排名融合（Reciprocal Rank Fusion, RRF）技术。本文将详细解析该方法，帮助您更好地理解其工作原理及实际应用。

前置知识

在深入代码之前，我们需要了解以下几个关键概念：

1. 倒数排名融合（RRF）：一种用于融合多个检索器结果的算法，通过计算每个文档在不同检索器中的倒数排名来确定最终排名。
2. 节点（Node）：表示检索结果中的一个文档或信息片段。
3. 节点评分（NodeWithScore）：包含节点及其评分的封装对象。

代码解析

_reciprocal_rerank_fusion方法

def _reciprocal_rerank_fusion(
        self, results: Dict[Tuple[str, int], List[NodeWithScore]]
    ) -> List[NodeWithScore]:
    """
    Apply reciprocal rank fusion.

    The original paper uses k=60 for best results:
    https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf
    """
    k = 60.0  # `k` is a parameter used to control the impact of outlier rankings.
    fused_scores = {}
    hash_to_node = {}

    # compute reciprocal rank scores
    for nodes_with_scores in results.values():
        for rank, node_with_score in enumerate(
            sorted(nodes_with_scores, key=lambda x: x.score or 0.0, reverse=True)
        ):
            hash = node_with_score.node.hash
            hash_to_node[hash] = node_with_score
            if hash not in fused_scores:
                fused_scores[hash] = 0.0
            fused_scores[hash] += 1.0 / (rank + k)

    # sort results
    reranked_results = dict(
        sorted(fused_scores.items(), key=lambda x: x[1], reverse=True)
    )

    # adjust node scores
    reranked_nodes: List[NodeWithScore] = []
    for hash, score in reranked_results.items():
        reranked_nodes.append(hash_to_node[hash])
        reranked_nodes[-1].score = score

    return reranked_nodes

方法解析

• 功能：该方法应用倒数排名融合技术，对多个检索器的输出结果进行重新排序。
• 参数：results，一个字典，键为(str, int)元组，值为NodeWithScore列表，表示每个检索器的输出结果。
• 返回值：一个包含重新排序后的NodeWithScore实例的列表。

处理流程

1. 初始化参数：

   k = 60.0
   fused_scores = {}
   hash_to_node = {}
   

   k是控制离群排名影响的参数，fused_scores用于存储融合后的评分，hash_to_node用于存储节点哈希到节点的映射。

2. 计算倒数排名评分：

   for nodes_with_scores in results.values():
       for rank, node_with_score in enumerate(
           sorted(nodes_with_scores, key=lambda x: x.score or 0.0, reverse=True)
       ):
           hash = node_with_score.node.hash
           hash_to_node[hash] = node_with_score
           if hash not in fused_scores:
               fused_scores[hash] = 0.0
           fused_scores[hash] += 1.0 / (rank + k)
   

   遍历每个检索器的输出结果，按评分降序排序，计算每个节点的倒数排名评分，并累加到fused_scores中。

3. 排序结果：

   reranked_results = dict(
       sorted(fused_scores.items(), key=lambda x: x[1], reverse=True)
   )
   

   将融合后的评分按降序排序，得到重新排序的结果。

4. 调整节点评分：

   reranked_nodes: List[NodeWithScore] = []
   for hash, score in reranked_results.items():
       reranked_nodes.append(hash_to_node[hash])
       reranked_nodes[-1].score = score
   

   根据重新排序的结果，调整节点的评分，并生成最终的重新排序后的节点列表。

实际应用示例

假设我们有多个检索器的输出结果，需要应用倒数排名融合技术进行重新排序：

from some_module import QueryFusionRetriever, NodeWithScore

# 初始化QueryFusionRetriever实例
fusion_retriever = QueryFusionRetriever(...)

# 假设我们有多个检索器的输出结果
results = {
    ("retriever1", 0): [NodeWithScore(node=..., score=0.8), NodeWithScore(node=..., score=0.7)],
    ("retriever2", 0): [NodeWithScore(node=..., score=0.9), NodeWithScore(node=..., score=0.6)],
}

# 应用倒数排名融合技术
reranked_results = fusion_retriever._reciprocal_rerank_fusion(results)

# 输出生成的查询
for node_with_score in reranked_results:
    print(f"Node: {node_with_score.node}, Score: {node_with_score.score}")

总结

通过本文的详细解析，我们深入理解了QueryFusionRetriever类中倒数排名融合方法的实现原理和应用方法。该方法通过计算每个文档在不同检索器中的倒数排名，有效地融合多个检索器的输出结果，从而提升检索系统的准确性和全面性。希望本文能为您的编程实践提供有益的参考和帮助。