RAG-Documind-AI / src /rag /reranking.py
AIenthusSP's picture
fix: fix linting issues
a6df84a
Raw History Blame Contribute Delete
8.53 kB
"""
Cross-Encoder Reranking Module
Improves retrieval quality by reranking initial results
using a more powerful cross-encoder model.
"""
import logging
from typing import List, Optional
from dataclasses import dataclass
from langchain_core.documents import Document
logger = logging.getLogger(__name__)
@dataclass
class RerankResult:
"""Result of reranking operation."""
documents: List[Document]
scores: List[float]
original_scores: List[float]
class CrossEncoderReranker:
"""
Reranks documents using a cross-encoder model.
Cross-encoders are more accurate than bi-encoders for similarity
scoring because they process query and document together.
"""
def __init__(
self,
model_name: str = "cross-encoder/ms-marco-MiniLM-L-6-v2",
top_k: int = 5,
batch_size: int = 32,
):
"""
Initialize the reranker.
Args:
model_name: HuggingFace model name for cross-encoder
top_k: Number of documents to return after reranking
batch_size: Batch size for processing
"""
self.model_name = model_name
self.top_k = top_k
self.batch_size = batch_size
self._model = None
@property
def model(self):
"""Lazy load the cross-encoder model."""
if self._model is None:
try:
from sentence_transformers import CrossEncoder
self._model = CrossEncoder(self.model_name)
logger.info(f"Loaded cross-encoder model: {self.model_name}")
except ImportError:
logger.error("sentence-transformers not installed for reranking")
raise ImportError(
"Please install sentence-transformers: "
"pip install sentence-transformers"
)
return self._model
def rerank(
self,
query: str,
documents: List[Document],
original_scores: Optional[List[float]] = None,
) -> RerankResult:
"""
Rerank documents using cross-encoder.
Args:
query: The search query
documents: List of documents to rerank
original_scores: Original retrieval scores (optional)
Returns:
RerankResult with reranked documents and scores
"""
if not documents:
return RerankResult(
documents=[],
scores=[],
original_scores=[],
)
if original_scores is None:
original_scores = [0.0] * len(documents)
# Create query-document pairs
pairs = [(query, doc.page_content) for doc in documents]
# Get cross-encoder scores
try:
scores = self.model.predict(pairs, batch_size=self.batch_size)
scores = scores.tolist() if hasattr(scores, 'tolist') else list(scores)
except Exception as e:
logger.error(f"Reranking failed: {e}")
# Fall back to original order
return RerankResult(
documents=documents[:self.top_k],
scores=original_scores[:self.top_k],
original_scores=original_scores[:self.top_k],
)
# Sort by score (descending)
doc_score_pairs = list(zip(documents, scores, original_scores))
doc_score_pairs.sort(key=lambda x: x[1], reverse=True)
# Take top_k
top_docs = doc_score_pairs[:self.top_k]
return RerankResult(
documents=[d[0] for d in top_docs],
scores=[d[1] for d in top_docs],
original_scores=[d[2] for d in top_docs],
)
class LLMReranker:
"""
Reranks documents using an LLM for more nuanced scoring.
Uses prompt-based relevance scoring with Gemini.
"""
def __init__(
self,
top_k: int = 5,
model: str = "gemini-2.0-flash",
):
self.top_k = top_k
self.model = model
self._llm = None
@property
def llm(self):
"""Lazy load the LLM."""
if self._llm is None:
from src.llmops.llm_manager import LLMManager
manager = LLMManager(model=self.model)
self._llm = manager.get_llm()
return self._llm
def rerank(
self,
query: str,
documents: List[Document],
original_scores: Optional[List[float]] = None,
) -> RerankResult:
"""
Rerank using LLM-based relevance scoring.
Args:
query: The search query
documents: List of documents to rerank
original_scores: Original retrieval scores
Returns:
RerankResult with reranked documents
"""
if not documents:
return RerankResult(documents=[], scores=[], original_scores=[])
if original_scores is None:
original_scores = [0.0] * len(documents)
scores = []
for doc in documents:
prompt = f"""Rate the relevance of this document to the query.
Query: {query}
Document: {doc.page_content[:500]}
Rate from 0-10 where 10 is highly relevant. Reply with just the number."""
try:
response = self.llm.invoke(prompt)
score = float(response.content.strip())
scores.append(min(max(score, 0), 10)) # Clamp to 0-10
except Exception as e:
logger.warning(f"LLM scoring failed: {e}")
scores.append(5.0) # Default mid-score
# Sort by score
doc_score_pairs = list(zip(documents, scores, original_scores))
doc_score_pairs.sort(key=lambda x: x[1], reverse=True)
top_docs = doc_score_pairs[:self.top_k]
return RerankResult(
documents=[d[0] for d in top_docs],
scores=[d[1] for d in top_docs],
original_scores=[d[2] for d in top_docs],
)
class HybridReranker:
"""
Combines cross-encoder and LLM reranking.
Uses cross-encoder for speed, with optional LLM refinement
for top candidates.
"""
def __init__(
self,
cross_encoder_model: str = "cross-encoder/ms-marco-MiniLM-L-6-v2",
cross_encoder_top_k: int = 10,
final_top_k: int = 5,
use_llm_refinement: bool = False,
):
self.cross_encoder = CrossEncoderReranker(
model_name=cross_encoder_model,
top_k=cross_encoder_top_k,
)
self.final_top_k = final_top_k
self.use_llm_refinement = use_llm_refinement
if use_llm_refinement:
self.llm_reranker = LLMReranker(top_k=final_top_k)
def rerank(
self,
query: str,
documents: List[Document],
original_scores: Optional[List[float]] = None,
) -> RerankResult:
"""Hybrid reranking with cross-encoder and optional LLM."""
# First pass: cross-encoder
ce_result = self.cross_encoder.rerank(query, documents, original_scores)
if not self.use_llm_refinement:
# Just return cross-encoder results
return RerankResult(
documents=ce_result.documents[:self.final_top_k],
scores=ce_result.scores[:self.final_top_k],
original_scores=ce_result.original_scores[:self.final_top_k],
)
# Second pass: LLM refinement on top candidates
llm_result = self.llm_reranker.rerank(
query,
ce_result.documents,
ce_result.scores,
)
return llm_result
def create_reranker(
reranker_type: str = "cross-encoder",
**kwargs,
) -> CrossEncoderReranker | LLMReranker | HybridReranker:
"""
Factory function to create a reranker.
Args:
reranker_type: One of "cross-encoder", "llm", "hybrid"
**kwargs: Additional arguments passed to reranker
Returns:
Configured reranker instance
"""
rerankers = {
"cross-encoder": CrossEncoderReranker,
"llm": LLMReranker,
"hybrid": HybridReranker,
}
if reranker_type not in rerankers:
raise ValueError(f"Unknown reranker type: {reranker_type}")
return rerankers[reranker_type](**kwargs)