RAG avansat: Multi-Query, HyDE, Step-Back
Pe această pagină
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ți | Cost suplimentar |
|---|---|---|
| Multi-query | Interogări ambigue, vocabular variat | n apeluri de embedding + 1 apel LLM |
| HyDE | Decalaj interogare-document, domenii tehnice | 1 apel LLM + 1 apel de embedding |
| Step-back | Întrebări foarte specifice, nevoie de context | 1 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