Guide de la qualité de récupération de la recherche IA

Pour améliorer la qualité de la récupération de la recherche IA, parcourez ces techniques dans l'ordre, du plus grand impact et du moins d'effort au moins grand impact et au plus grand effort. Ces techniques sont utiles pour les applications RAG en temps réel, de recherche et de correspondance.

Prérequis : Établir un cadre d'évaluation

Avant d'optimiser la qualité de l'extraction, vous devez impérativement disposer d'un système d'évaluation reproductible.

important

Si vous n'avez pas mis en place d'évaluation, arrêtez-vous ici et configurez-la d'abord. Optimiser sans mesure est de la pure spéculation.

Définir les exigences de latence

Établissez des objectifs de latence clairs basés sur votre cas d'utilisation :

• Agents RAG : Cible du Temps avant le premier jeton (TTFT) (par exemple, <2 sec)
• Barres de recherche : latence de bout en bout pour afficher les résultats (par exemple, <100 msec)

Toute optimisation que vous essayez doit satisfaire à ces exigences.

Configurer l'évaluation automatisée

Utilisez une ou plusieurs des approches suivantes :

• **dataset de référence existant** : Utilisez vos paires query-réponse étiquetées.
• Ensemble d'évaluation synthétique : Utilisez la génération de données synthétiques Databricks pour générer automatiquement des cas de test à partir de vos documents.
• Évaluation sans vérité terrain : Utilisez les juges Databricks Agent Evaluation pour évaluer la qualité sans étiquettes.

L’essentiel est d’avoir une méthode automatisée pour mesurer les changements - des données parfaites ne sont pas requises. Concentrez-vous sur les améliorations relatives lorsque vous testez différentes stratégies, et non sur les scores absolus. Même un petit dataset synthétique peut vous dire si le réordonnancement améliore la qualité de 15 % ou si la recherche hybride aide votre cas d’usage spécifique.

Choisir les métriques de qualité

Choisissez vos indicateurs de qualité en fonction de votre cas d'utilisation :

**Si le rappel est le plus important** (nécessite toutes les informations pertinentes) :

• **Agents RAG** : L'absence de contexte clé conduit à des réponses incorrectes ou à des hallucinations.
• **Mappage des essais cliniques pharmaceutiques** : ne pas manquer les patients éligibles ou les études pertinentes.
• Recherche en conformité financière : besoin de toutes les réglementations, facteurs de risque ou précédents pertinents.
• Analyse des causes profondes de fabrication : doit faire apparaître tous les incidents et schémas d'échec connexes.
• Métrique à suivre : Rappel@k (par exemple, rappel@10, rappel@50).

Si la précision est la plus importante (seuls les résultats les plus pertinents sont nécessaires) :

• Résolution d'entités/correspondance floue : mise en correspondance des enregistrements de clients, des noms de fournisseurs ou des SKU de produits entre les systèmes.
• Déduplication des services financiers : identifier les transactions ou les comptes en double avec une grande confiance.
• Mappage de pièces de la chaîne d'approvisionnement : trouver des composants exacts ou compatibles dans les catalogues.
• Base de connaissances du support technique : les ingénieurs ont besoin de la solution exacte dans les meilleurs résultats.
• Métrique à suivre : Precision@k (par exemple, precision@3, precision@10).

**Cas d'utilisation équilibrés** (nécessitent à la fois un bon rappel et une bonne précision) :

• Audit préalable des F&A : Ne pas manquer les risques (rappel) mais avoir besoin de documents pertinents en premier (précision).
• Recherche d'antériorité de brevets : Couverture complète avec les brevets les plus pertinents priorisés.
• Correspondance client 360 : unification des données client entre plusieurs systèmes.

Étape 1 : Activer la recherche hybride

Combinez la précision des mots-clés avec la compréhension sémantique.

Quand utiliser :

• Les utilisateurs recherchent avec des termes spécifiques (codes produit, termes techniques).
• Besoin d'une correspondance exacte pour certaines requêtes.
• Nous voulons un fallback lorsque la recherche sémantique manque des correspondances évidentes de mots-clés.

**Impact sur les métriques** :

• Améliore le rappel en détectant les correspondances sémantiques et par mots-clés.
• Améliore la **précision** pour les queries avec des termes spécifiques.

Implémentation : une seule ligne à modifier dans la recherche AI.

Python

# Enable hybrid search
results = index.similarity_search(
    query_text="error code E404",
    query_type="HYBRID"  # Combines vector and keyword search
)

Pour plus d'information, voir Query un index de recherche IA.

Étape 2 : Implémenter le filtrage des métadonnées

C'est votre plus grand levier pour la qualité de l'extraction.

Le filtrage réduit considérablement l'espace de recherche et améliore à la fois la précision et le rappel.

**Impact sur les métriques** :

• Améliore considérablement la précision en éliminant les résultats non pertinents.
• Améliore le rappel au sein du sous-ensemble filtré.
• Peut réduire l'espace de recherche de plus de 90 %.

Exemples

• Documentation technique : Filtrez par version du produit, composant ou module.
• Manuels de voiture : Filtrer par marque, modèle, année.
• Support client : Filtrer par gamme de produits, région, catégorie de problème.

Mise en œuvre

Python

# AI Search with metadata filtering
results = index.similarity_search(
    query_text="brake system maintenance",
    filters='make = "Toyota" AND model = "Camry" AND year = 2023',
    num_results=10
)

Sélection dynamique de filtres

Approche programmatique :

Python

# Parse query for filter criteria
def extract_filters(user_query):
    filter_parts = []
    if "Toyota" in user_query:
        filter_parts.append('make = "Toyota"')
    if "2023" in user_query:
        filter_parts.append('year = 2023')
    return " AND ".join(filter_parts) if filter_parts else None

Filtrage basé sur les agents avec Databricks :

Python

from databricks_ai_bridge.agents.tools.vector_search import VectorSearchTool

# Create the AI Search tool
vector_search_tool = VectorSearchTool(
    index_name="catalog.schema.car_manuals_index",
    # Optional: specify columns to return
    columns=["content", "make", "model", "year", "chunk_id"],
    # Optional: set number of results
    num_results=10,
    # Optional: add additional parameters as needed
    additional_parameters={
        "query_type": "HYBRID"  # Enable hybrid search
    }
)

# The tool automatically handles filter generation based on the agent's understanding
# Agent analyzes "brake issues in my 2023 Toyota Camry" and generates appropriate filters

# For LangChain agents:
from langchain.agents import create_react_agent

agent = create_react_agent(
    tools=[vector_search_tool],
    llm=your_llm,
    prompt=your_prompt
)

L'agent automatiquement :

1. Extrait les entités pertinentes de la requête.
2. Génère des chaînes de filtre de type SQL appropriées.
3. Exécute la recherche avec une compréhension sémantique et un filtrage précis.

**Impact** : Peut réduire l'espace de recherche de plus de 90 % tout en améliorant la pertinence.

Étape 3 : Ajouter la réorganisation

Modification d'une ligne pour une amélioration de la qualité d'environ 15 %.

Databricks fournit un reranker intégré parfait pour les agents RAG.

**Impact sur les métriques** :

• Améliore la précision en atteignant un rappel élevé avec moins de candidats.
• Fonctionne mieux lorsqu'il est combiné avec des techniques telles que la recherche hybride et le filtrage.

Mise en œuvre

Python

# Python SDK
results = index.similarity_search(
    query_text="How to create an AI Search index",
    num_results=10,
    columns=["id", "text", "parent_doc_summary"],
    reranker={
        "model": "databricks_reranker",
        "parameters": {
            "columns_to_rerank": ["text", "parent_doc_summary"]
        }
    }
)

Pour plus d’informations, consultez Réorganiser les résultats de la query.

Quand utiliser

Idéal pour :

• Agents RAG (la latence est dominée par la génération LLM).
• Applications axées sur la qualité.
• QPS faible à modéré (environ 5 QPS prêts à l'emploi).

Réorganisateur intégré non adapté pour :

• Applications à QPS élevé (>5 QPS sans mise à l'échelle supplémentaire).
• Barres de recherche en temps réel nécessitant une latence <100 ms.
• Applications pour lesquelles un temps de reclassement inférieur à la seconde est inacceptable.

Performances : reclassifie 50 résultats en moins d'une seconde dans les charges de travail typiques. Jusqu’à environ 250 ms pour des segments plus courts.

Pour les cas d'utilisation à faible latence/non-RAG

Le reclassement peut toujours apporter des améliorations significatives de la qualité pour les barres de recherche et les applications à QPS élevé — vous avez juste besoin d'un réorganisateur plus rapide. Envisagez de déployer un modèle de reclassement léger (par exemple, cross-encoder/ms-marco-TinyBERT-L-2-v2) en tant que modèle personnalisé sur Databricks Model Serving pour un reclassement en moins de 100 ms.

Étape 4 : améliorer la préparation des données

Cette section décrit quelques techniques que vous pouvez utiliser pour améliorer la préparation des données : le découpage, l'analyse, l'ajout de contexte sémantique et le nettoyage des données.

Stratégie de segmentation

L'optimisation de la taille des blocs reste un domaine de recherche actif. Des travaux récents de DeepMind (LIMIT) montrent que les embeddings peuvent échouer à capturer des informations de base dans des contextes longs, ce qui en fait une décision nuancée.

Points de départ pour l'expérimentation :

Python

# Common configurations to test
small_chunks = 256   # Better for precise fact retrieval
medium_chunks = 512  # Balanced approach
large_chunks = 1024  # More context per chunk

Compromis clés à prendre en compte :

• Fragments plus petits : meilleure localisation d'informations spécifiques, mais peut perdre le contexte.
• Fragments plus volumineux : plus de contexte est conservé, mais il est plus difficile de cerner les informations pertinentes.
• Limites de contexte : doit tenir dans la fenêtre de contexte du LLM lors de la récupération de plusieurs fragments.

Optimisations plus efficaces : au lieu de sur-optimiser la taille des blocs, concentrez-vous sur :

1. Extraction d'informations pour les métadonnées : extrayez les entités, les sujets et les catégories pour permettre un filtrage précis.
2. **Analyse de haute qualité** : utilisez ai_parse_document pour un texte propre et structuré.
3. **Métadonnées sémantiques** : ajoutez des résumés de documents et des en-têtes de section aux fragments.

Considérez également les approches avancées suivantes. Ces techniques demandent plus d'efforts, mais peuvent avoir un impact plus important :

**Découpage sémantique** : Regroupez les phrases par similarité plutôt que par taille fixe.

• Utilisez des intégrations pour trouver des limites sémantiques naturelles.
• Maintient les idées connexes regroupées.
• Meilleure préservation du contexte.
• Voir Le guide ultime des stratégies de découpage pour les applications RAG.

Segmentation parent-enfant (récupération du petit au grand) :

Python

# Record child and parent chunks in your source table
for parent_chunk in create_chunks(doc, size=2048):  # Large for context
    for child_chunk in create_chunks(parent_chunk, size=512):  # Small for precision
        source_table.append({"text": child_chunk, "parent_text": parent_chunk})

# Search children, return parents
results = index.similarity_search(
    query_text="Is attention all you need?",
    num_results=10,
    columns=["text", "parent_text"]
)

Consultez les documents du récupérateur de documents parents LangChain.

Analyse des documents

Pour les PDF et les documents complexes, Databricks recommande d'utiliser ai_parse_document pour une analyse de haute qualité. Une analyse médiocre (tables manquantes, formatage rompu) a un impact direct sur la qualité de l'extraction.

Enrichir avec des métadonnées sémantiques

Ajoutez un contexte sémantique pour améliorer la récupération.

Pourquoi cela fonctionne :

• Fournit un signal sémantique supplémentaire pour les modèles d'intégration.
• Fournit aux réorganisateurs plus de contexte pour la notation.
• Facilite les queries qui font référence aux concepts de niveau document.

Option 1 : Inclure les métadonnées dans les segments

Python

# Prepend document summary to each chunk
chunk_with_context = f"""
Document: {doc_title}
Summary: {doc_summary}
Section: {section_name}
{chunk_content}
"""

Option 2 : stocker en tant que colonnes de métadonnées séparées

Python

# Store semantic metadata for reranker to use
metadata = {
    "doc_summary": "Technical manual for brake system maintenance",
    "section": "Emergency brake adjustment procedures",
    "keywords": ["brake", "safety", "adjustment"]
}

important

Cette approche nécessite un traitement en aval pour exploiter les métadonnées :

• Pour les métadonnées sémantiques : utilisez le reclassement avec le paramètre columns_to_rerank pour prendre en compte ces colonnes.
• Pour les métadonnées uniquement par mots-clés : utilisez la recherche hybride (mode texte intégral) pour correspondre à ces champs.

Nettoyage des données

• Supprimer le passe-partout (en-têtes, pieds de page, numéros de page).
• Préservez la structure du document (titres, listes, tableaux).
• Maintenir les limites sémantiques lors du découpage.

Étape 5 : Optimisation des query

Query expansion

Générer plusieurs variations de query pour améliorer le rappel. Voir le guide LangChain.

**Impact** : Améliore le **rappel** en trouvant des documents avec une terminologie différente.

Python

# Use LLM to expand query with synonyms and related terms
def expand_query(user_query):
    prompt = f"""Generate 3 variations of this search query including synonyms:
    Query: {user_query}
    Return only the variations, one per line."""

    variations = llm.generate(prompt).split('\n')

    # Search with original + variations
    all_results = []
    for query in [user_query] + variations:
        results = index.similarity_search(query_text=query, num_results=10)
        all_results.extend(results)

    # Deduplicate and return
    return deduplicate_results(all_results)

Exemple : « entretien automobile » recherche également « réparation automobile », « entretien de véhicule », « maintenance automobile »

Pour en savoir plus sur les techniques, consultez :

• Techniques avancées d’expansion des query
• Implémentation du récupérateur multi-query

Reformulation de query

Pour les queries complexes, décomposez ou reformulez. Consultez les stratégies OpenAI RAG.

• Questions multi-sauts → recherches séquentielles
• queries ambiguës → recherches multiples spécifiques
• Voir les techniques de décomposition

Étape 6 : Techniques d'incitation avancées

Optimisation des Prompts

Utilisez des techniques d'optimisation automatique des prompts comme MIPROv2 ou GEPA (disponibles dans DSPy) pour améliorer vos prompts utilisés pour la préparation des données, la réécriture de query ou partout dans votre système de récupération. Knowledge Assistant et Supervisor Agent intègrent GEPA pour obtenir d'importantes améliorations des performances à faible coût. Voir Building state-of-the-art enterprise agents 90x cheaper with automated prompt optimization.

Pour plus d’informations, voir Reflective Prompt Evolution with GEPA.

Étape 7 : Stratégies de récupération adaptatives

Modèle d'agent React

Construisez des agents qui peuvent orchestrer intelligemment la récupération :

• L'agent évalue si une récupération est nécessaire.
• Vous pouvez reformuler les requêtes en fonction des résultats initiaux.
• Combine la récupération avec d'autres outils (calculateurs, APIs, etc.).
• Relancer les récupérations échouées avec des queries modifiées.
• Implémenter à l'aide d'Agents personnalisés.

Exemples d'extraction agentique

Python

# Agent decides when to search and what filters to apply
# Based on conversation context and user intent
agent = create_agent(
    tools=[vector_search_tool, calculator, web_search],
    instructions="Retrieve relevant docs only when needed, apply appropriate filters"
)

Étape 8 : Affiner les modèles d'incorporation

Premièrement : diagnostiquez si vous avez un problème d'intégration

Test rapide : comparez GTE et les intégrations OpenAI sur Databricks.

Python

# Test with both embedding models
# Databricks native: gte-large-en-v1.5
gte_results = gte_index.similarity_search(query)

# OpenAI: text-embedding-3-large (3072 dims)
openai_results = openai_index.similarity_search(query)

# If OpenAI text-embedding-3-large significantly outperforms GTE:
# - Fine-tuning a smaller model could match or exceed OpenAI quality
# - You have an embedding model problem, not a data problem

Interprétation :

• Si text-embedding-3-large est bien plus performant que gte-large-en, envisagez l'affinement. Vous pouvez obtenir une qualité similaire avec un modèle plus petit.
• Si text-embedding-3-large a des performances approximativement équivalentes à celles de gte-large-en, votre problème ne vient pas du modèle d'intégration. Concentrez-vous sur d'autres optimisations.

Quand affiner

important

L'affinement doit être considéré comme un dernier recours et ne doit être envisagé que lorsque les critères suivants sont remplis :

1. Vous avez essayé les Étapes 1 à 7.
2. OpenAI surpasse considérablement GTE dans vos tests.
3. Vous avez un vocabulaire spécifique au domaine ou un cas d'usage.

remarque

Vous n'avez pas besoin de données d'entraînement étiquetées : vous pouvez utiliser la génération de données synthétiques, comme indiqué dans le blog de Databricks sur l'affinement des embeddings.