Salt la conținutul principal
Română— Alege o limbă
Meniu

RAG avansat: Multi-Query, HyDE, Step-Back

Lecția 14 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Obiective
  2. Problema: O singură interogare nu este suficientă
  3. Multi-Query: Puneți întrebarea diferit
  4. HyDE: Embedding-uri de documente ipotetice
  5. Prompting Step-Back
  6. Compararea tehnicilor
  7. Combinarea tehnicilor
  8. Puncte cheie

Obiective

  • Îmbunătățirea recuperării documentelor folosind tehnici avansate
  • Implementarea prompturilor de tip multi-query, HyDE și step-back
  • Înțelegerea momentului oportun pentru utilizarea fiecărei tehnici

Problema: O singură interogare nu este suficientă

Reclasificarea (reranking) din lecția anterioară a îmbunătățit modul în care candidații sunt ordonați, dar nu a putut ajuta în cazul documentelor pe care recuperarea nu le-a identificat deloc de la început. Cea mai frecventă cauză a acestor omisiuni nu este modelul sau indexul, ci interogarea însăși. Un utilizator poate tasta „nu funcționează pe telefonul meu“, în timp ce documentația discută despre „incompatibilitatea cu versiunile de Android anterioare lui 12“. Niciun model de embedding nu va apropia spontan aceste două formulări.

Tehnicile următoare se bazează pe un singur principiu: în loc să acceptăm interogarea așa cum este, o transformăm sau o multiplicăm înainte de căutare. Toate acționează asupra recall-ului — adică asupra capacității de a include documentul corect în lista de candidați.

Multi-Query: Puneți întrebarea diferit

Prima abordare este cea mai directă. Solicităm LLM-ului să reformuleze întrebarea din mai multe unghiuri, executăm o căutare cu fiecare variantă și fuzionăm rezultatele. Întrebarea „cum îmi anulez abonamentul?“ devine astfel „procedura de anulare“, „oprirea taxei lunare“ și „ștergerea contului plătit“ — trei vocabulare diferite, trei șanse de a nimeri formularea folosită de autorul documentației.

Etapa de fuziune merită o mențiune: linia cu np.maximum păstrează, pentru fiecare document, cel mai bun scor obținut across toate interogările. Un document care se potrivește bine doar cu o singură reformulare urcă totuși în top, lucru care nu s-ar întâmpla dacă am face media scorurilor. Temperatura de 0.7 este intenționată aici, deoarece dorim varietate, nu reproductibilitate.

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: Embedding-uri de documente ipotetice

HyDE abordează problema din celălalt capăt. În loc să multiplicăm întrebările, cerem modelului să genereze un răspuns plauzibil — chiar dacă este parțial greșit, nu contează — și apoi căutăm documente apropiate de acel răspuns. Întrebarea „cum configurez SSO?“ produce un paragraf care vorbește despre furnizori de identitate, SAML și metadate, exact vocabularul găsit în documentația reală.

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
    ]

Dacă această tehnică funcționează, este pentru că embedding-ul unui răspuns seamănă mai mult cu embedding-ul unui document decât o face embedding-ul unei întrebări. O întrebare este scurtă, interogativă și adesea formulată în cuvintele proprii ale utilizatorului; un document este lung, afirmativ și scris în jargonul domeniului. HyDE reduce acest decalaj dintre interogare și document, aducând interogarea pe terenul corpusului. De aceea și promptul specifică „ca și cum ar fi un extras din documentația tehnică“: imităm registrul țintă.

Prompting Step-Back

A treia tehnică gestionează cazul opus: întrebări atât de specifice încât niciun document nu le abordează direct. „Pot deduce o bicicletă electrică cumpărată în februarie?“ nu apare nicăieri, dar secțiunea despre cheltuielile de afaceri deductibile da. Așadar, cerem modelului să identifice întrebarea generală care se ascunde în spatele celei specifice, apoi căutăm cu ambele, ponderându-le cu 0.7 pentru întrebarea originală și 0.3 pentru cea mai largă — contextul larg ajută, dar nu trebuie să domine.

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
    ]

Compararea tehnicilor

Fiecare abordează o patologie specifică a recuperării, iar fiecare are ca preț apeluri suplimentare și, prin urmare, o latență mai mare.

TehnicăCând să o utilizațiCost suplimentar
Multi-queryInterogări ambigue, vocabular variatn apeluri de embedding + 1 apel LLM
HyDEDecalaj interogare-document, domenii tehnice1 apel LLM + 1 apel de embedding
Step-backÎntrebări foarte specifice, nevoie de context1 apel LLM + 2 apeluri de embedding

Combinarea tehnicilor

Nu trebuie să alegeți doar una. Funcția următoare acceptă o listă de strategii, acumulează scorurile produse de fiecare într-un dicționar indexat după document și păstrează maximul. Un document găsit doar de HyDE se clasează astfel alături de un document găsit prin căutare directă. Rețineți totuși că stivuirea a trei strategii triplează bugetul și prelungește timpul de răspuns: rezervați această combinație pentru interogări dificile sau pentru procesarea offline, unde latența nu contează.

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
    ]

Puncte cheie

  • Multi-query reformulează întrebarea din mai multe unghiuri pentru a acoperi un vocabular mai larg
  • HyDE generează un răspuns ipotetic ce seamănă mai mult cu documentele țintă
  • Step-back pune o întrebare mai generală pentru a captura un context larg
  • Aceste tehnici adaugă latență, dar îmbunătățesc semnificativ recall-ul