Evaluar la calidad de la búsqueda
En esta página
Objetivos
- Comprender las métricas estándar de evaluación de búsquedas
- Construir un conjunto de datos de evaluación
- Medir y mejorar la calidad de tu motor
¿Por qué evaluar?
Las lecciones anteriores han presentado una serie de decisiones: modelo de embeddings, número de dimensiones, tamaño de los fragmentos y ponderación híbrida. Cada elección puede mejorar o degradar tu sistema. Las impresiones subjetivas obtenidas al probar manualmente tres consultas no son suficientes para tomar una decisión, especialmente porque un cambio suele mejorar una categoría de consultas mientras empeora otra. Sin métricas, estás volando a ciegas.
Métricas clave
Recall@k responde a esta pregunta: de entre los documentos relevantes, ¿cuántos aparecen en los k primeros resultados? Esta es la métrica de referencia para RAG, porque un documento que falta en el contexto nunca podrá ser citado por el modelo de generación, por muy bueno que sea este.
def recall_at_k(pertinents: set[str], resultats: list[str], k: int) -> float:
"""Proporción de documentos relevantes encontrados en los top-k."""
top_k = set(resultats[:k])
trouves = pertinents & top_k
return len(trouves) / len(pertinents) if pertinents else 0.0
Precision@k observa lo inverso: de los k resultados devueltos, ¿cuántos son realmente relevantes? Esto es crucial cuando el contexto enviado al LLM es limitado, ya que cada documento fuera de tema ocupa espacio y diluye la atención del modelo.
def precision_at_k(pertinents: set[str], resultats: list[str], k: int) -> float:
"""Proporción de resultados relevantes en los top-k."""
top_k = resultats[:k]
trouves = sum(1 for r in top_k if r in pertinents)
return trouves / k if k > 0 else 0.0
MRR (Mean Reciprocal Rank) mide la posición del primer resultado relevante. Un documento en primer lugar puntuación 1, en segundo lugar 0,5 y en quinto lugar 0,2. Prioriza esta métrica para barras de búsqueda destinadas a humanos, que rara vez miran más allá de las tres primeras líneas.
def mrr(pertinents: set[str], resultats: list[str]) -> float:
"""Rango recíproco del primer resultado relevante."""
for i, r in enumerate(resultats):
if r in pertinents:
return 1.0 / (i + 1)
return 0.0
NDCG@k (Normalized Discounted Cumulative Gain) va más allá al abandonar la relevancia binaria: acepta grados de relevancia, lo que te permite distinguir entre un documento que responde exactamente a la pregunta y otro que solo la roza. El logaritmo del denominador aplica un descuento progresivo según la posición, y la normalización frente al ranking ideal escala todo entre 0 y 1.
import numpy as np
def ndcg_at_k(relevances: list[float], k: int) -> float:
"""NDCG con puntuaciones de relevancia graduadas."""
dcg = sum(
rel / np.log2(i + 2) for i, rel in enumerate(relevances[:k])
)
ideal = sorted(relevances, reverse=True)[:k]
idcg = sum(
rel / np.log2(i + 2) for i, rel in enumerate(ideal)
)
return dcg / idcg if idcg > 0 else 0.0
Crear un conjunto de datos de evaluación
Ninguna de estas fórmulas es útil sin una verdad de terreno. Un conjunto de datos de evaluación asocia cada consulta con la lista de documentos que deberían aparecer y, opcionalmente, con aquellos que definitivamente no deberían; estos últimos son útiles para monitorizar falsos positivos conocidos.
import json
# Estructura del conjunto de datos
dataset_eval = [
{
"requête": "comment installer Python sur Windows",
"pertinents": ["doc_install_python", "doc_setup_env"],
"non_pertinents": ["doc_cuisine"]
},
{
"requête": "configurer nginx comme reverse proxy",
"pertinents": ["doc_nginx_proxy", "doc_nginx_config"],
"non_pertinents": ["doc_python_web"]
},
]
# Guardar
with open("eval_dataset.json", "w") as f:
json.dump(dataset_eval, f, ensure_ascii=False, indent=2)
Treinta pares bien elegidos que cubran los diferentes tipos de preguntas que tu motor recibe realmente valen más que trescientos generados en masa. Prioriza extraerlos de tus registros de búsqueda: estas son las formulaciones reales de tus usuarios, no las que tú imaginas.
Generar consultas de prueba con un LLM
En un corpus grande, la redacción manual se vuelve inviable. Así que invertimos el problema: en lugar de buscar documentos que respondan a una pregunta, preguntamos al modelo qué preguntas puede abordar un documento dado. El documento es, por construcción, relevante para estas preguntas, y obtienes pares en minutos.
from openai import OpenAI
client = OpenAI()
def generer_requetes_test(document: str, n: int = 3) -> list[str]:
"""Generar n preguntas a las que este documento debería responder."""
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{
"role": "user",
"content": (
f"Voici un document :\n\n{document}\n\n"
f"Génère {n} questions auxquelles ce document répond. "
f"Retourne uniquement les questions, une par ligne."
)
}]
)
return response.choices[0].message.content.strip().split("\n")
Este método tiene un punto ciego que debes conocer: las preguntas generadas suelen reutilizar el vocabulario exacto del documento, lo que las hace más fáciles que las consultas reales de los usuarios e infla artificialmente tus puntuaciones. Úsalas para comparar dos configuraciones entre sí, nunca para declarar un nivel de calidad absoluto.
Pipeline de evaluación completo
El evaluador ejecuta cada consulta del conjunto de datos en el motor, calcula todas las métricas para varios valores de k y luego promedia todo el conjunto.
class EvaluateurRecherche:
def __init__(self, moteur_recherche):
self.moteur = moteur_recherche
def evaluer(
self, dataset: list[dict], k_values: list[int] = [1, 3, 5, 10]
) -> dict:
"""Evaluar el motor en un conjunto de datos completo."""
resultats = {f"recall@{k}": [] for k in k_values}
resultats.update({f"precision@{k}": [] for k in k_values})
resultats["mrr"] = []
for item in dataset:
# Ejecutar búsqueda
res = self.moteur.rechercher(item["requête"], k=max(k_values))
ids_resultats = [r["id"] for r in res]
pertinents = set(item["pertinents"])
# Calcular métricas
resultats["mrr"].append(mrr(pertinents, ids_resultats))
for k in k_values:
resultats[f"recall@{k}"].append(
recall_at_k(pertinents, ids_resultats, k)
)
resultats[f"precision@{k}"].append(
precision_at_k(pertinents, ids_resultats, k)
)
# Promedio
return {
metrique: round(np.mean(scores), 4)
for metrique, scores in resultats.items()
}
# Uso
evaluateur = EvaluateurRecherche(moteur)
metriques = evaluateur.evaluer(dataset_eval)
print("Résultats d'évaluation :")
for metrique, score in metriques.items():
print(f" {metrique}: {score}")
Seguimiento de múltiples valores de k es instructivo por sí mismo: un recall@10 alto junto con un recall@1 bajo indica que se están encontrando los documentos correctos pero mal clasificados; es un problema de reordenación, no de indexación.
Comparar dos configuraciones
La siguiente función enfrenta dos motores al mismo conjunto de datos y muestra la brecha de métricas por cada indicador. Repite este paso antes de cada despliegue en producción, incluso para un cambio que parezca trivial.
def comparer_configs(moteur_a, moteur_b, dataset, noms=("A", "B")):
"""Comparar dos motores de búsqueda."""
eval_a = EvaluateurRecherche(moteur_a).evaluer(dataset)
eval_b = EvaluateurRecherche(moteur_b).evaluer(dataset)
print(f"{Métrique:<20} {noms[0]:<10} {noms[1]:<10} {Delta:<10}")
print("-" * 50)
for metrique in eval_a:
delta = eval_b[metrique] - eval_a[metrique]
signe = "+" if delta > 0 else ""
print(f"{metrique:<20} {eval_a[metrique]:<10.4f} "
f"{eval_b[metrique]:<10.4f} {signe}{delta:<10.4f}")
Lee las deltas con cautela en un conjunto de datos pequeño: una diferencia de 0,02 en treinta consultas es probablemente ruido, mientras que una caída de 0,10 en recall@5 es una señal clara para no desplegar.
Resumen
- Recall@k, Precision@k, MRR y NDCG son las métricas estándar
- Crea un conjunto de datos de evaluación con pares (consulta, documentos relevantes)
- Automatiza la generación de consultas con un LLM
- Compara sistemáticamente las configuraciones antes de desplegar