Lähe põhisisu juurde
Eesti— Vali keel
Menüü

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

Õppetund 14 / 22 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  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. Invite « étape en arrière » (Step-Back Prompting)
  6. Comparaison des techniques
  7. Combiner les techniques
  8. Peamised punktid

Objectifs

  • Améliorer la récupération grâce à des techniques avancées
  • Mettre en œuvre les requêtes multiples, HyDE et l’invite « é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é le rang des candidats, mais il n’a rien pu faire pour les documents que la récupération n’a jamais fait remonter. La cause la plus fréquente de ces oublis 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 », tandis 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 même principe : au lieu d’accepter la requête telle quelle, on la transforme ou on la multiplie 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. On demande au LLM de reformuler la question sous plusieurs angles, on lance une recherche avec chaque variante, puis on fusionne 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 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 l’on faisait la moyenne des scores. La température de 0,7 est volontaire ici, car on cherche de la variété, pas de 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, on fait générer au modèle une réponse plausible – même partiellement fausse, peu importe – puis on cherche les 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 ramenant la requête sur le terrain du corpus. C’est aussi pour cela que l’invite précise « comme s’il s’agissait d’un extrait de documentation technique » : on imite le registre cible.

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

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. On demande donc au modèle la question générale qui se cache derrière la question spécifique, puis on recherche avec les deux, en pondérant à 0,7 la question originale et à 0,3 la question élargie : le contexte large aide, mais il 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 : des appels supplémentaires, donc une latence plus élevée.

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

Combiner les 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 aux côtés d’un document trouvé par recherche directe. Garde toutefois en tête qu’empiler 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
    ]

Peamised punktid

  • 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’invite « é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