Pokročilý RAG: Multi-Query, HyDE, Step-Back
Na tejto strane
Ciele
- Zlepšiť vyhľadávanie pomocou pokročilých techník
- Implementovať multi-query, HyDE a step-back prompting
- Vedieť, kedy ktorú techniku použiť
Problém: Jedna otázka nestačí
Prehodnotenie (reranking) z predchádzajúcej lekcie zlepšilo poradie kandidátov, ale nepomohlo pri dokumentoch, ktoré sa vo vyhľadávaní vôbec neobjavili. Najčastejšou príčinou týchto vynechaní nie je model ani index – je to samotná otázka. Používateľ môže napísať „na mojom telefóne to nefunguje“, zatiaľ čo dokumentácia hovorí o „nekompatibilite s verziami Androidu staršími ako 12“. Žiadny embedding model tieto dve formulácie spontánne nepriblíži.
Nasledujúce techniky zdieľajú jediný princíp: namiesto akceptovania otázky v pôvodnom znení ju pred vyhľadávaním transformujeme alebo znásobíme. Všetky pôsobia na úplnosť (recall), teda na schopnosť dostať správny dokument do zoznamu kandidátov.
Multi-Query: Opýtaj sa inak
Prvý prístup je najpriamejší. Požiadaš LLM, aby preformuloval otázku z viacerých uhlov, spustíš vyhľadávanie s každou variantou a výsledky zlúčiš. Otázka „ako zruším predplatné?“ sa stane aj „postup zrušenia“, „zastavenie mesačného poplatku“ a „vymazanie môjho plateného účtu“ – tri rôzne slovníky, tri šance trafiť formuláciu, ktorú použil autor dokumentácie.
Krok zlúčenia si zaslúži poznámku: riadok s np.maximum zachová pre každý dokument najlepšie skóre dosiahnuté naprieč všetkými otázkami. Dokument, ktorý dobre sedí len na jedno preformulovanie, sa tak dostane na vrchol, čo by sa pri spriemerovaní skóre nestalo. Teplota 0,7 je tu zámerná, pretože chceme rozmanitosť, nie reprodukovateľnosť.
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: Hypotetické embeddingy dokumentov
HyDE rieši problém z opačného konca. Namiesto násobenia otázok necháme model vygenerovať pravdepodobnú odpoveď – aj keď je čiastočne nesprávna, to nevadí – a následne vyhľadáme dokumenty blízke tejto odpovedi. Otázka „ako nakonfigurujem SSO?“ vyprodukuje odsek hovoriaci o poskytovateľoch identity, SAML a metadátach, čo je presne slovník nachádzajúci sa v reálnej dokumentácii.
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
]
Ak táto technika funguje, je to preto, že embedding odpovede sa viac podobá embeddingu dokumentu než embedding otázky. Otázka je krátka, opytovacia a často formulovaná vlastnými slovami používateľa; dokument je dlhý, afirmatívny a napísaný odborným žargónom. HyDE premostí túto priepasť medzi otázkou a dokumentom tým, že presunie otázku na pôdu korpusu. Preto aj prompt špecifikuje „ako keby išlo o výňatok z technickej dokumentácie“: napodobňujeme cieľový register.
Step-Back Prompting
Tretia technika rieši opačný prípad: otázky také špecifické, že ich žiadny dokument priamo nerieši. „Môžem si odpísať elektrický bicykel kúpený vo februári?“ sa nikde nevyskytuje, ale sekcia o odpočítateľných firemných výdavkoch áno. Požiadaš teda model o všeobecnejšiu otázku skrývajúcu sa za tou špecifickou a vyhľadávaš s oboma, pričom pôvodnej otázke priradíš váhu 0,7 a tej všeobecnejšej 0,3 – široký kontext pomáha, ale nemal by dominovať.
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
]
Porovnanie techník
Každá rieši špecifickú patológiu vyhľadávania a každá so sebou nesie cenu ďalších volaní, a teda vyššiu latenciu.
| Technika | Kedy ju použiť | Dodatočné náklady |
|---|---|---|
| Multi-query | Nejasné otázky, rôznorodý slovník | n volaní embeddingu + 1 volanie LLM |
| HyDE | Priepasť medzi otázkou a dokumentom, technické domény | 1 volanie LLM + 1 volanie embeddingu |
| Step-back | Veľmi špecifické otázky, potreba kontextu | 1 volanie LLM + 2 volania embeddingu |
Kombinovanie techník
Nemusíš si vybrať len jednu. Nasledujúca funkcia prijíma zoznam stratégií, akumuluje skóre, ktoré každá vyprodukuje, do slovníka indexovaného podľa dokumentu a ponechá maximum. Dokument nájdený len pomocou HyDE sa tak umiestni vedľa dokumentu nájdeného priamym vyhľadávaním. Maj však na pamäti, že nakopenie troch stratégií strojnásobí rozpočet a predlžuje čas odozvy: túto kombináciu si nechaj pre náročné otázky alebo pre offline spracovanie, kde na latencii nezáleží.
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
]
Kľúčové poznatky
- Multi-query preformulováva otázku z viacerých uhlov, aby pokryla širší slovník
- HyDE generuje hypotetickú odpoveď, ktorá sa viac podobá cieľovým dokumentom
- Step-back kladie všeobecnejšiu otázku na zachytenie širšieho kontextu
- Tieto techniky pridávajú latenciu, ale výrazne zlepšujú úplnosť (recall)