63 LlamaIndex中的节点后处理器模块：提升检索结果的利器（各个具体模块的使用）

本文链接：https://blog.csdn.net/xycxycooo/article/details/141359840

LlamaIndex中的节点后处理器模块：提升检索结果的利器

在LlamaIndex中，节点后处理器（Node Postprocessor）是一组强大的工具，用于在检索节点后对其进行各种处理，以提升检索结果的质量和相关性。本文将介绍几种常用的节点后处理器模块，并展示如何使用它们来优化检索结果。

SimilarityPostprocessor

SimilarityPostprocessor 用于移除相似度低于阈值的节点。通过设置 similarity_cutoff 参数，可以过滤掉不相关的节点，从而提高检索结果的准确性。

from llama_index.core.postprocessor import SimilarityPostprocessor

postprocessor = SimilarityPostprocessor(similarity_cutoff=0.7)
filtered_nodes = postprocessor.postprocess_nodes(nodes)

KeywordNodePostprocessor

KeywordNodePostprocessor 用于确保某些关键词被包含或排除。通过设置 required_keywords 和 exclude_keywords 参数，可以精确控制检索结果的内容。

from llama_index.core.postprocessor import KeywordNodePostprocessor

postprocessor = KeywordNodePostprocessor(
    required_keywords=["word1", "word2"], exclude_keywords=["word3", "word4"]
)
filtered_nodes = postprocessor.postprocess_nodes(nodes)

MetadataReplacementPostProcessor

MetadataReplacementPostProcessor 用于将节点内容替换为节点元数据中的某个字段。如果该字段不存在于元数据中，则节点文本保持不变。最常用于与 SentenceWindowNodeParser 结合使用。

from llama_index.core.postprocessor import MetadataReplacementPostProcessor

postprocessor = MetadataReplacementPostProcessor(
    target_metadata_key="window",
)
processed_nodes = postprocessor.postprocess_nodes(nodes)

LongContextReorder

LongContextReorder 模块会重新排序检索到的节点，这在需要较大 top-k 值的情况下非常有用。它可以帮助模型更好地访问长上下文中的重要细节。

from llama_index.core.postprocessor import LongContextReorder

postprocessor = LongContextReorder()
reordered_nodes = postprocessor.postprocess_nodes(nodes)

SentenceEmbeddingOptimizer

SentenceEmbeddingOptimizer 通过使用嵌入技术移除与查询不相关的句子，从而优化令牌使用。可以通过 percentile_cutoff 或 threshold_cutoff 参数来控制句子的保留。

from llama_index.core.postprocessor import SentenceEmbeddingOptimizer

postprocessor = SentenceEmbeddingOptimizer(
    embed_model=service_context.embed_model,
    percentile_cutoff=0.5,
    # threshold_cutoff=0.7
)
optimized_nodes = postprocessor.postprocess_nodes(nodes)

CohereRerank

CohereRerank 使用 Cohere ReRank 功能对节点进行重排序，并返回前 N 个节点。

from llama_index.postprocessor.cohere_rerank import CohereRerank

postprocessor = CohereRerank(
    top_n=2, model="rerank-english-v2.0", api_key="YOUR COHERE API KEY"
)
reranked_nodes = postprocessor.postprocess_nodes(nodes)

SentenceTransformerRerank

SentenceTransformerRerank 使用 sentence-transformer 包中的交叉编码器对节点进行重排序，并返回前 N 个节点。

from llama_index.core.postprocessor import SentenceTransformerRerank

postprocessor = SentenceTransformerRerank(
    model="cross-encoder/ms-marco-MiniLM-L-2-v2", top_n=3
)
reranked_nodes = postprocessor.postprocess_nodes(nodes)

LLMRerank

LLMRerank 使用 LLM 对节点进行重排序，通过询问 LLM 返回相关文档及其相关性得分，返回前 N 个排序的节点。

from llama_index.core.postprocessor import LLMRerank

postprocessor = LLMRerank(top_n=2, service_context=service_context)
reranked_nodes = postprocessor.postprocess_nodes(nodes)

JinaRerank

JinaRerank 使用 Jina ReRank 功能对节点进行重排序，并返回前 N 个节点。

from llama_index.postprocessor.jinaai_rerank import JinaRerank

postprocessor = JinaRerank(
    top_n=2, model="jina-reranker-v1-base-en", api_key="YOUR JINA API KEY"
)
reranked_nodes = postprocessor.postprocess_nodes(nodes)

FixedRecencyPostprocessor

FixedRecencyPostprocessor 返回按日期排序的前 K 个节点。假设每个节点的元数据中有一个日期字段。

from llama_index.core.postprocessor import FixedRecencyPostprocessor

postprocessor = FixedRecencyPostprocessor(
    tok_k=1, date_key="date"  # 元数据中日期字段的键
)
sorted_nodes = postprocessor.postprocess_nodes(nodes)

EmbeddingRecencyPostprocessor

EmbeddingRecencyPostprocessor 在按日期排序后，通过测量嵌入相似度移除过于相似的旧节点，返回前 K 个节点。

from llama_index.core.postprocessor import EmbeddingRecencyPostprocessor

postprocessor = EmbeddingRecencyPostprocessor(
    service_context=service_context, date_key="date", similarity_cutoff=0.7
)
sorted_nodes = postprocessor.postprocess_nodes(nodes)

TimeWeightedPostprocessor

TimeWeightedPostprocessor 返回前 K 个节点，并对每个节点应用时间加权重排序。每次检索节点时，记录检索时间，这会偏向于尚未在查询中返回的信息。

from llama_index.core.postprocessor import TimeWeightedPostprocessor

postprocessor = TimeWeightedPostprocessor(time_decay=0.99, top_k=1)
weighted_nodes = postprocessor.postprocess_nodes(nodes)

(Beta) PIINodePostprocessor

PIINodePostprocessor 移除可能存在安全风险的信息，使用 NER（命名实体识别）或本地 LLM 模型来实现。

LLM 版本

from llama_index.core.postprocessor import PIINodePostprocessor

postprocessor = PIINodePostprocessor(
    service_context=service_context  # 应设置为你信任的 LLM
)
processed_nodes = postprocessor.postprocess_nodes(nodes)

NER 版本

from llama_index.core.postprocessor import NERPIINodePostprocessor

postprocessor = NERPIINodePostprocessor()
processed_nodes = postprocessor.postprocess_nodes(nodes)

(Beta) PrevNextNodePostprocessor

PrevNextNodePostprocessor 使用预定义设置读取节点关系，并获取之前、之后或两者的所有节点。这在节点关系指向重要数据时非常有用。

from llama_index.core.postprocessor import PrevNextNodePostprocessor

postprocessor = PrevNextNodePostprocessor(
    docstore=index.docstore,
    num_nodes=1,  # 向前或向后获取的节点数量
    mode="next",  # 可以是 'next', 'previous', 或 'both'
)
processed_nodes = postprocessor.postprocess_nodes(nodes)

(Beta) AutoPrevNextNodePostprocessor

AutoPrevNextNodePostprocessor 与 PrevNextNodePostprocessor 相同，但让 LLM 决定模式（next, previous, 或 both）。

from llama_index.core.postprocessor import AutoPrevNextNodePostprocessor

postprocessor = AutoPrevNextNodePostprocessor(
    docstore=index.docstore,
    service_context=service_context,
    num_nodes=1,  # 向前或向后获取的节点数量
)
processed_nodes = postprocessor.postprocess_nodes(nodes)

(Beta) RankGPT

RankGPT 使用 RankGPT 代理根据相关性对文档进行重排序，返回前 N 个排序的节点。

from llama_index.postprocessor.rankgpt_rerank import RankGPTRerank

postprocessor = RankGPTRerank(top_n=3, llm=OpenAI(model="gpt-3.5-turbo-16k"))
reranked_nodes = postprocessor.postprocess_nodes(nodes)

Colbert Reranker

ColbertRerank 使用 Colbert V2 模型作为重排序器，根据查询令牌和段落令牌之间的细粒度相似性对文档进行重排序，返回前 N 个排序的节点。

from llama_index.postprocessor.colbert_rerank import ColbertRerank

colbert_reranker = ColbertRerank(
    top_n=5,
    model="colbert-ir/colbertv2.0",
    tokenizer="colbert-ir/colbertv2.0",
    keep_retrieval_score=True,
)
query_engine = index.as_query_engine(
    similarity_top_k=10,
    node_postprocessors=[colbert_reranker],
)
response = query_engine.query(
    query_str,
)

rankLLM

RankLLMRerank 使用 rankLLM 中的模型对文档进行重排序，返回前 N 个排序的节点。

from llama_index.postprocessor import RankLLMRerank

postprocessor = RankLLMRerank(top_n=5, model="zephyr")
reranked_nodes = postprocessor.postprocess_nodes(nodes)