Spaces:
Build error
Build error
Download src/rag/reranking.py from AIenthusSP/RAG-Documind-AI: direct link, hf CLI and curl.
- Browser
- Download file 8.53 kB
-
https://huggingface.co/spaces/AIenthusSP/RAG-Documind-AI/resolve/main/src/rag/reranking.py
- Command line
-
hf download hf://spaces/AIenthusSP/RAG-Documind-AI/src/rag/reranking.py
-
curl -L -o reranking.py https://huggingface.co/spaces/AIenthusSP/RAG-Documind-AI/resolve/main/src/rag/reranking.py
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__) | |
| 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 | |
| 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 | |
| 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) | |