Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

RAG avancé : requêtes multiples, HyDE, étape en arrière

Paskaita 14 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Objectifs
  2. Le problème : une seule requête ne suffit pas
  3. Requêtes multiples : poser la question autrement
  4. HyDE : embeddings de documents hypothétiques
  5. Prompting « étape en arrière » (Step-Back)
  6. Comparaison des techniques
  7. Combinaison des techniques
  8. Svarbiausi punktai

Objectifs

  • Améliorer la récupération grâce à des techniques avancées
  • Mettre en œuvre les stratégies de requêtes multiples, HyDE et d’étape en arrière (step-back)
  • Savoir quand utiliser chaque technique

Le problème : une seule requête ne suffit pas

Le reclassement vu dans la leçon précédente a amélioré l’ordre des candidats, mais il ne peut rien faire pour les documents que la récupération n’a jamais trouvés au départ. La cause la plus fréquente de ces échecs n’est ni le modèle ni l’index, mais la requête elle-même. Un utilisateur peut taper « ça ne marche pas sur mon téléphone », alors que la documentation parle d’« incompatibilité avec les versions Android antérieures à la 12 ». Aucun modèle d’embedding ne rapprochera spontanément ces deux formulations.

Les techniques suivantes reposent sur un seul principe : au lieu d’accepter la requête telle quelle, nous la transformons ou la multiplions avant la recherche. Elles agissent toutes sur le rappel (recall), c’est-à-dire la capacité à faire entrer le bon document dans la liste des candidats.

Requêtes multiples : poser la question autrement

La première approche est la plus directe. Nous demandons au LLM de reformuler la question sous plusieurs angles, d’exécuter une recherche avec chaque variante, puis de fusionner les résultats. La question « comment annuler mon abonnement ? » devient aussi « procédure d’annulation », « arrêter le prélèvement mensuel » et « supprimer mon compte payant » : trois vocabulaires différents, trois chances de tomber sur la formulation choisie par l’auteur de la documentation.

Une précision s’impose sur l’étape de fusion : la ligne np.maximum conserve, pour chaque document, le meilleur score obtenu parmi toutes les requêtes. Un document qui correspond bien à une seule reformulation remonte ainsi en tête, ce qui n’arriverait pas si nous faisions une moyenne des scores. La température de 0,7 est ici volontaire, car nous cherchons la variété, pas la reproductibilité.

from openai import OpenAI
import numpy as np

client = OpenAI()

def generer_multi_queries(question: str, n: int = 3) -> list[str]:
    """Generate n rephrasings of the question."""
    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"Generate {n} different rephrasings of this question "
                f"for document search. Each rephrasing "
                f"should cover a different angle.\n\n"
                f"Original question: {question}\n\n"
                f"Return only the rephrasings, one per line."
            )
        }],
        temperature=0.7
    )
    queries = response.choices[0].message.content.strip().split("\n")
    return [q.strip().lstrip("0123456789.-) ") for q in queries if q.strip()]

def recherche_multi_query(
    question: str,
    corpus_embeddings: np.ndarray,
    documents: list[dict],
    k: int = 5,
    n_queries: int = 3
) -> list[dict]:
    """Search with multiple rephrasings."""
    queries = [question] + generer_multi_queries(question, n_queries)
    print(f"Queries: {queries}")

    tous_scores = np.zeros(len(documents))
    for query in queries:
        query_emb = client.embeddings.create(
            input=query, model="text-embedding-3-large"
        ).data[0].embedding
        scores = corpus_embeddings @ np.array(query_emb)
        tous_scores = np.maximum(tous_scores, scores)

    top_k = np.argsort(tous_scores)[-k:][::-1]
    return [
        {**documents[i], "score": float(tous_scores[i])}
        for i in top_k
    ]

HyDE : embeddings de documents hypothétiques

HyDE attaque le problème par l’autre bout. Au lieu de multiplier les questions, nous faisons générer au modèle une réponse plausible – même si elle est partiellement fausse, peu importe – puis nous cherchons des documents proches de cette réponse. La question « comment configurer le SSO ? » produit un paragraphe évoquant les fournisseurs d’identité, SAML et les métadonnées, soit exactement le vocabulaire présent dans la documentation réelle.

def recherche_hyde(
    question: str,
    corpus_embeddings: np.ndarray,
    documents: list[dict],
    k: int = 5
) -> list[dict]:
    """Search with a hypothetical document (HyDE)."""
    # 1. Generate a hypothetical document
    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"Write a short paragraph (3-5 sentences) that would answer "
                f"this question. Write as if it were an excerpt "
                f"from technical documentation.\n\n"
                f"Question: {question}"
            )
        }],
        temperature=0.3
    )
    doc_hypothetique = response.choices[0].message.content

    # 2. Encode the hypothetical document
    hyde_emb = client.embeddings.create(
        input=doc_hypothetique,
        model="text-embedding-3-large"
    ).data[0].embedding

    # 3. Search for similar documents
    scores = corpus_embeddings @ np.array(hyde_emb)
    top_k = np.argsort(scores)[-k:][::-1]

    return [
        {**documents[i], "score": float(scores[i])}
        for i in top_k
    ]

Si cette technique fonctionne, c’est parce que l’embedding d’une réponse ressemble davantage à l’embedding d’un document que ne le fait l’embedding d’une question. Une question est courte, interrogative et souvent formulée avec les mots de l’utilisateur ; un document est long, affirmatif et rédigé dans le jargon du domaine. HyDE comble cet écart entre requête et document en déplaçant la requête sur le terrain du corpus. C’est aussi pour cela que l’instruction précise « comme s’il s’agissait d’un extrait de documentation technique » : nous imitons le registre cible.

Prompting « étape en arrière » (Step-Back)

La troisième technique gère le cas opposé : des questions si spécifiques qu’aucun document ne les traite frontalement. « Puis-je déduire un vélo électrique acheté en février ? » n’apparaît nulle part, mais la section sur les charges professionnelles déductibles, si. Nous demandons donc au modèle la question générale qui se cache derrière la question spécifique, puis nous recherchons avec les deux, en les pondérant à 0,7 pour la question originale et 0,3 pour la plus large : le contexte large aide, mais ne doit pas dominer.

def recherche_step_back(
    question: str,
    corpus_embeddings: np.ndarray,
    documents: list[dict],
    k: int = 5
) -> list[dict]:
    """Two-pass search: general then specific."""
    # 1. Generate a step-back question
    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"What is the more general question or underlying concept "
                f"behind this specific question?\n\n"
                f"Specific question: {question}\n\n"
                f"Return only the general question."
            )
        }],
        temperature=0.3
    )
    question_generale = response.choices[0].message.content.strip()

    # 2. Search with both questions
    resultats_combines = {}

    for q, poids in [(question, 0.7), (question_generale, 0.3)]:
        q_emb = client.embeddings.create(
            input=q, model="text-embedding-3-large"
        ).data[0].embedding
        scores = corpus_embeddings @ np.array(q_emb)

        for i, s in enumerate(scores):
            if i not in resultats_combines:
                resultats_combines[i] = 0.0
            resultats_combines[i] += float(s) * poids

    top_k = sorted(
        resultats_combines.items(),
        key=lambda x: x[1], reverse=True
    )[:k]

    return [
        {**documents[idx], "score": score}
        for idx, score in top_k
    ]

Comparaison des techniques

Chacune répond à une pathologie spécifique de la récupération, et chacune a un coût en appels supplémentaires, donc en latence accrue.

TechniqueQuand l’utiliserCoût supplémentaire
Requêtes multiplesRequêtes ambiguës, vocabulaire varién appels d’embedding + 1 appel LLM
HyDEÉcart requête-document, domaines techniques1 appel LLM + 1 appel d’embedding
Étape en arrièreQuestions très spécifiques, besoin de contexte1 appel LLM + 2 appels d’embedding

Combinaison des techniques

Tu n’es pas obligé de n’en choisir qu’une. La fonction suivante accepte une liste de stratégies, accumule les scores produits par chacune dans un dictionnaire indexé par document, et conserve le maximum. Un document trouvé uniquement par HyDE se retrouve ainsi classé aux côtés d’un document trouvé par recherche directe. Garde toutefois à l’esprit que l’empilement de trois stratégies triple le budget et allonge le temps de réponse : réserve cette combinaison aux requêtes difficiles, ou au traitement hors ligne où la latence importe peu.

def recherche_avancee(
    question: str,
    corpus_embeddings: np.ndarray,
    documents: list[dict],
    k: int = 5,
    strategies: list[str] = ["direct", "multi_query", "hyde"]
) -> list[dict]:
    """Combine multiple search strategies."""
    tous_resultats = {}

    if "direct" in strategies:
        q_emb = client.embeddings.create(
            input=question, model="text-embedding-3-large"
        ).data[0].embedding
        scores = corpus_embeddings @ np.array(q_emb)
        for i, s in enumerate(scores):
            tous_resultats.setdefault(i, []).append(float(s))

    if "hyde" in strategies:
        res_hyde = recherche_hyde(
            question, corpus_embeddings, documents, k=k*2
        )
        for r in res_hyde:
            tous_resultats.setdefault(r["id"], []).append(r["score"])

    # Final score = max of scores
    scores_finaux = {
        idx: max(scores) for idx, scores in tous_resultats.items()
    }

    top_k = sorted(
        scores_finaux.items(), key=lambda x: x[1], reverse=True
    )[:k]

    return [
        {**documents[idx], "score": score}
        for idx, score in top_k
    ]

Svarbiausi punktai

  • Les requêtes multiples reformulent la question sous plusieurs angles pour couvrir plus de vocabulaire
  • HyDE génère une réponse hypothétique qui ressemble davantage aux documents cibles
  • L’étape en arrière pose une question plus générale pour capturer un contexte large
  • Ces techniques ajoutent de la latence mais améliorent significativement le rappel