Reranking

Reranking

El reranking es como tener un segundo filtro más fino después de la búsqueda inicial con embeddings.

Cuando buscas con embeddings en tu base de datos vectorial, obtienes, digamos, los 20 documentos más parecidos a tu pregunta. Pero aquí viene el problema: la búsqueda por embeddings es bastante buena para encontrar contenido relacionado, pero no siempre es perfecta para ordenar los resultados por relevancia real.

Es como si fueras a una librería y preguntaras por libros sobre cocina italiana. El dependiente te trae 20 libros relacionados con cocina italiana, pero los ha ordenado un poco al azar - igual el más específico sobre pasta está en la posición 15, mientras que uno general sobre cocina mediterránea está el primero.

El reranking entra aquí como un segundo "experto" que examina esos 20 resultados y los reordena de forma más inteligente. Utiliza modelos más sofisticados que analizan no solo la similitud semántica, sino también otros factores como:

• La relevancia específica de cada fragmento con respecto a tu pregunta exacta
• La calidad del contenido
• La coherencia contextual
• Factores como la fecha de publicación si es relevante

Hay varios tipos de reranking. 

Los más comunes usan modelos como los de Cohere, que están entrenados específicamente para esta tarea. También puedes usar modelos cross-encoder, que son muy buenos evaluando la relevancia entre pares de textos.

El resultado final es que, de esos 20 documentos que encontraste inicialmente, ahora tienes los 5 o 10 más relevantes perfectamente ordenados. Esto mejora muchísimo la calidad de la respuesta final que genera tu sistema RAG, porque está trabajando con información mucho más precisa y contextualizada.

ContextualCompressionRetriever para reranking

El ContextualCompressionRetriever en LangChain es un wrapper especializado que permite aplicar técnicas de reranking sobre cualquier retriever base existente. 

Esta aproximación combina la velocidad del retrieval inicial con la precisión de algoritmos de reordenamiento más sofisticados, creando un sistema híbrido que optimiza tanto rendimiento como calidad de resultados.

La arquitectura del ContextualCompressionRetriever funciona en dos etapas claramente diferenciadas. Primero, el retriever base ejecuta una búsqueda rápida utilizando métodos tradicionales como similaridad coseno para obtener un conjunto amplio de documentos candidatos. Posteriormente, el componente de compresión aplica algoritmos de reranking más computacionalmente intensivos sobre este subconjunto reducido, reordenando los resultados según criterios de relevancia más precisos.

Configuración básica del ContextualCompressionRetriever

La implementación del ContextualCompressionRetriever requiere dos componentes principales: un retriever base y un compresor que actúe como reranker. La configuración básica sigue este patrón:

from langchain.retrievers import ContextualCompressionRetriever
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain_community.document_compressors import CohereRerank

# Configurar el retriever base
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_texts(
    ["Documento 1 sobre IA", "Documento 2 sobre ML", "Documento 3 sobre NLP"],
    embeddings
)
base_retriever = vectorstore.as_retriever(search_kwargs={"k": 10})

# Configurar el reranker
reranker = CohereRerank(
    cohere_api_key="tu_api_key",
    top_n=3
)

# Crear el ContextualCompressionRetriever
compression_retriever = ContextualCompressionRetriever(
    base_compressor=reranker,
    base_retriever=base_retriever
)

El parámetro top_n en el reranker determina cuántos documentos finales se devuelven después del proceso de reordenamiento. Es importante configurar el retriever base para que devuelva más documentos de los que finalmente necesitamos, permitiendo al reranker seleccionar los más relevantes del conjunto ampliado.

Integración con cadenas LCEL

El ContextualCompressionRetriever se integra perfectamente con las cadenas LCEL, manteniendo la interfaz estándar de retriever mientras añadiendo capacidades de reranking:

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Configurar el modelo de chat
llm = ChatOpenAI(model="gpt-4")

# Crear el prompt template
prompt = ChatPromptTemplate.from_template(
    "Basándote en el siguiente contexto, responde la pregunta:\n\n"
    "Contexto: {context}\n\n"
    "Pregunta: {question}\n\n"
    "Respuesta:"
)

# Crear la cadena RAG con reranking
rag_chain = (
    {
        "context": compression_retriever | (lambda docs: "\n\n".join([doc.page_content for doc in docs])),
        "question": lambda x: x["question"]
    }
    | prompt
    | llm
    | StrOutputParser()
)

# Ejecutar la cadena
result = rag_chain.invoke({"question": "¿Qué es el machine learning?"})

Configuración avanzada y parámetros

El ContextualCompressionRetriever ofrece varios parámetros de configuración que permiten ajustar el comportamiento del sistema según las necesidades específicas:

# Configuración con parámetros avanzados
compression_retriever = ContextualCompressionRetriever(
    base_compressor=reranker,
    base_retriever=base_retriever,
    # Configuraciones adicionales pueden variar según el compresor
)

# Ejemplo con múltiples filtros y compresores
from langchain_community.document_compressors import DocumentCompressorPipeline
from langchain_community.document_compressors import EmbeddingsFilter

# Pipeline de compresión con filtrado y reranking
compressor_pipeline = DocumentCompressorPipeline(
    transformers=[
        EmbeddingsFilter(embeddings=embeddings, similarity_threshold=0.7),
        CohereRerank(top_n=5)
    ]
)

advanced_retriever = ContextualCompressionRetriever(
    base_compressor=compressor_pipeline,
    base_retriever=base_retriever
)

Monitorización y debugging del proceso

Para entender mejor el comportamiento del ContextualCompressionRetriever, es útil implementar logging que muestre tanto los resultados del retriever base como los del reranking:

import logging

# Configurar logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Wrapper para monitorear el proceso
class MonitoredCompressionRetriever:
    def __init__(self, compression_retriever):
        self.compression_retriever = compression_retriever
    
    def get_relevant_documents(self, query):
        # Obtener documentos del retriever base
        base_docs = self.compression_retriever.base_retriever.get_relevant_documents(query)
        logger.info(f"Retriever base devolvió {len(base_docs)} documentos")
        
        # Aplicar compresión/reranking
        final_docs = self.compression_retriever.get_relevant_documents(query)
        logger.info(f"Después del reranking: {len(final_docs)} documentos")
        
        return final_docs

# Uso del wrapper de monitoreo
monitored_retriever = MonitoredCompressionRetriever(compression_retriever)
results = monitored_retriever.get_relevant_documents("¿Qué es el deep learning?")

Consideraciones de rendimiento

El ContextualCompressionRetriever introduce una latencia adicional debido al proceso de reranking, pero esta latencia es generalmente aceptable considerando la mejora en la calidad de los resultados. La estrategia óptima consiste en configurar el retriever base para que sea rápido y devuelva un número moderado de candidatos (típicamente entre 10-20 documentos), permitiendo al reranker trabajar con un conjunto manejable.

La configuración del parámetro k en el retriever base debe balancearse cuidadosamente. Un valor demasiado bajo puede excluir documentos relevantes antes del reranking, mientras que un valor demasiado alto incrementa innecesariamente la latencia sin beneficios proporcionales en la calidad.

Cohere Rerank vs FlashRank vs CrossEncoder

La elección del algoritmo de reranking determina tanto la calidad de los resultados como el rendimiento del sistema RAG. Cada opción presenta características distintivas en términos de precisión, latencia, costes y facilidad de implementación, siendo crucial entender sus trade-offs para seleccionar la solución más adecuada según el contexto específico.

Cohere Rerank: Precisión mediante API externa

Cohere Rerank utiliza modelos especializados entrenados específicamente para tareas de reordenamiento semántico. Este servicio basado en API ofrece resultados de alta calidad sin requerir recursos computacionales locales, siendo especialmente efectivo para aplicaciones que priorizan la precisión sobre la latencia.

from langchain_community.document_compressors import CohereRerank
from langchain.retrievers import ContextualCompressionRetriever

# Configuración de Cohere Rerank
cohere_reranker = CohereRerank(
    cohere_api_key="tu_cohere_api_key",
    top_n=5,
    model="rerank-english-v2.0"
)

# Integración con ContextualCompressionRetriever
cohere_retriever = ContextualCompressionRetriever(
    base_compressor=cohere_reranker,
    base_retriever=base_retriever
)

# Ejemplo de uso
query = "¿Cuáles son las ventajas del aprendizaje profundo?"
cohere_results = cohere_retriever.get_relevant_documents(query)

for i, doc in enumerate(cohere_results):
    print(f"Documento {i+1}: {doc.page_content[:100]}...")

Las ventajas de Cohere Rerank incluyen su alta precisión en tareas de reordenamiento semántico y la ausencia de requisitos de infraestructura local. Sin embargo, presenta limitaciones como la dependencia de conectividad externa, costes por uso y latencia adicional debido a las llamadas API.

FlashRank: Velocidad y eficiencia local

FlashRank representa una alternativa ligera y rápida que ejecuta completamente en local, eliminando dependencias externas y reduciendo significativamente la latencia. Esta solución open-source está optimizada para escenarios donde la velocidad es prioritaria.

from langchain_community.document_compressors import FlashrankRerank

# Configuración de FlashRank
flashrank_reranker = FlashrankRerank(
    top_n=5,
    model="ms-marco-MiniLM-L-12-v2"
)

# Integración con el sistema de retrieval
flashrank_retriever = ContextualCompressionRetriever(
    base_compressor=flashrank_reranker,
    base_retriever=base_retriever
)

# Medición de rendimiento
import time

start_time = time.time()
flashrank_results = flashrank_retriever.get_relevant_documents(query)
flashrank_time = time.time() - start_time

print(f"FlashRank procesó la consulta en {flashrank_time:.3f} segundos")

FlashRank destaca por su velocidad de procesamiento, ausencia de costes por uso y funcionamiento completamente offline. No obstante, puede ofrecer menor precisión que soluciones basadas en modelos más grandes y requiere recursos computacionales locales.

CrossEncoder: Flexibilidad con modelos Hugging Face

CrossEncoderReranker proporciona acceso a una amplia variedad de modelos de reranking disponibles en Hugging Face, permitiendo seleccionar el modelo más adecuado para dominios específicos. Esta aproximación ofrece un equilibrio entre personalización y rendimiento.

from langchain_community.document_compressors import CrossEncoderReranker

# Configuración con modelo BGE
bge_reranker = CrossEncoderReranker(
    model_name="BAAI/bge-reranker-base",
    top_n=5
)

# Configuración alternativa con modelo específico para dominio médico
medical_reranker = CrossEncoderReranker(
    model_name="microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract-fulltext",
    top_n=3
)

# Comparación de modelos
cross_encoder_retriever = ContextualCompressionRetriever(
    base_compressor=bge_reranker,
    base_retriever=base_retriever
)

cross_encoder_results = cross_encoder_retriever.get_relevant_documents(query)

La ventaja principal del CrossEncoder radica en la flexibilidad para elegir modelos especializados según el dominio de aplicación. Modelos como BAAI/bge-reranker-base ofrecen excelente rendimiento general, mientras que modelos específicos pueden superar a las alternativas en dominios particulares.

Comparación práctica de rendimiento

Para evaluar objetivamente las diferencias entre estos enfoques, es útil implementar un sistema de comparación que mida tanto latencia como calidad de resultados:

import time
from typing import List, Dict, Any

def compare_rerankers(query: str, base_retriever, rerankers: Dict[str, Any]) -> Dict[str, Dict]:
    """Compara diferentes rerankers en términos de tiempo y resultados"""
    results = {}
    
    for name, reranker in rerankers.items():
        retriever = ContextualCompressionRetriever(
            base_compressor=reranker,
            base_retriever=base_retriever
        )
        
        start_time = time.time()
        docs = retriever.get_relevant_documents(query)
        execution_time = time.time() - start_time
        
        results[name] = {
            'time': execution_time,
            'num_docs': len(docs),
            'first_doc_preview': docs[0].page_content[:100] if docs else "No documents"
        }
    
    return results

# Configurar rerankers para comparación
rerankers = {
    'cohere': CohereRerank(cohere_api_key="tu_api_key", top_n=3),
    'flashrank': FlashrankRerank(top_n=3),
    'crossencoder': CrossEncoderReranker(model_name="BAAI/bge-reranker-base", top_n=3)
}

# Ejecutar comparación
comparison_results = compare_rerankers(
    "¿Qué técnicas de machine learning son más efectivas?",
    base_retriever,
    rerankers
)

for name, metrics in comparison_results.items():
    print(f"{name.upper()}:")
    print(f"  Tiempo: {metrics['time']:.3f}s")
    print(f"  Documentos: {metrics['num_docs']}")
    print(f"  Preview: {metrics['first_doc_preview']}...")
    print()

Criterios de selección según el caso de uso

La elección del reranker debe basarse en los requisitos específicos del proyecto. Para aplicaciones que requieren máxima precisión y disponen de presupuesto para APIs externas, Cohere Rerank representa la opción más robusta. En escenarios donde la latencia es crítica y se prefiere evitar dependencias externas, FlashRank ofrece el mejor equilibrio velocidad-autonomía.

CrossEncoderReranker resulta ideal cuando se necesita personalización para dominios específicos o cuando se requiere un control granular sobre el modelo utilizado. La disponibilidad de modelos especializados en Hugging Face permite optimizar el rendimiento para casos de uso particulares como documentación técnica, contenido médico o textos legales.

# Ejemplo de selección condicional de reranker
def select_reranker(use_case: str, latency_priority: bool = False):
    """Selecciona el reranker más adecuado según el caso de uso"""
    
    if latency_priority:
        return FlashrankRerank(top_n=5)
    
    elif use_case == "medical":
        return CrossEncoderReranker(
            model_name="microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract-fulltext",
            top_n=5
        )
    
    elif use_case == "high_precision":
        return CohereRerank(
            cohere_api_key="tu_api_key",
            top_n=5,
            model="rerank-english-v2.0"
        )
    
    else:  # Caso general
        return CrossEncoderReranker(
            model_name="BAAI/bge-reranker-base",
            top_n=5
        )

# Uso del selector
selected_reranker = select_reranker("medical", latency_priority=False)

La configuración híbrida también es posible, utilizando diferentes rerankers según el contexto de la consulta o implementando sistemas de fallback que cambien de Cohere a FlashRank en caso de problemas de conectividad. Esta flexibilidad permite construir sistemas RAG robustos que se adapten dinámicamente a las condiciones operativas.