Query herschrijven en HyDE
De recall van retrieval verbeteren
Query herschrijven en HyDE is een gratis AI-promptengineering-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject AI-promptengineering. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus AI-promptengineering bevat in totaal 4 lessen.
De zoekopdracht is de zwakke schakel
De kwaliteit van het ophalen wordt begrensd door de zoekopdracht. Ruwe zoekopdrachten van gebruikers zijn vaak kort, dubbelzinnig, staan vol voornaamwoorden of zijn anders geformuleerd dan de documenten. Zoekopdrachttransformatie geeft de zoekopdracht vóór het ophalen een andere vorm om recall en precisie te verhogen.
Dit is een van de goedkoopste verbeteringen met de grootste impact op een naïeve RAG-aanpak: verbeter de zoekopdracht en elke volgende fase profiteert daarvan.
def transform_query(raw, history):
# Resolve references, expand, decompose, or hypothesize
# BEFORE embedding and retrieving.
return rewrite(raw, history)Zoekopdracht herschrijven
De eenvoudigste transformatie: een LLM herschrijft de zoekopdracht van de gebruiker tot een duidelijkere, zelfstandige vorm die geschikt is om op te halen. Het corrigeert typefouten, schrijft afkortingen uit en verwijdert ruis uit het gesprek.
Dit is vooral belangrijk in gesprekken met meerdere beurten, waarin het laatste bericht zonder context onbegrijpelijk is, zoals: ‘Hoe zit het met de tweede?’
def rewrite_query(raw):
prompt = (
'Rewrite the user question into a clear, standalone search '
'query optimized for document retrieval. Keep key entities.\n'
'Question: ' + raw
)
return llm(prompt, temperature=0).strip()Gesprekscondensering
In chat-RAG combineer je het gesprek en de nieuwe beurt tot één zelfstandige vraag. Zonder deze stap maken voornaamwoorden en weglatingen de embedding betekenisloos en stort het ophalen in.
Geef eerdere beurten door, zodat de herschrijver ‘het’, ‘dat’ en ‘de vorige’ kan omzetten in expliciete entiteiten waarmee de ophaler overeenkomsten kan vinden.
def condense(history, follow_up):
prompt = (
'Given the conversation, rewrite the follow-up as a standalone '
'question with all references resolved.\nConversation:\n' +
render(history) + '\nFollow-up: ' + follow_up
)
return llm(prompt, temperature=0).strip()Zoekopdracht uitbreiden
Uitbreiding genereert synoniemen, verwante termen of alternatieve formuleringen om de lexicale en semantische dekking te vergroten. Dit gaat een verschil in woordenschat tegen: het document zegt ‘ongeldig maken’, terwijl de gebruiker ‘intrekken’ zegt.
Breid de zoekopdracht uit voor het ophalen en haal daarna op met de unie van de resultaten; toon de uitgebreide vorm niet aan de gebruiker. Pas op voor te veel uitbreiding, want die kan resultaten buiten het onderwerp opleveren.
def expand(query, n=3):
prompt = (
'List ' + str(n) + ' alternative phrasings of this query using '
'synonyms and domain terms, one per line.\n' + query
)
variants = parse_lines(llm(prompt, temperature=0.5))
return [query] + variantsOphalen met meerdere zoekopdrachten
Genereer verschillende uiteenlopende herformuleringen, haal voor elke herformulering resultaten op en voeg de resultatenlijsten samen (reciprocal rank fusion). Verschillende formuleringen brengen verschillende relevante fragmenten aan het licht; het samenvoegen combineert hun sterke punten en stabiliseert de recall.
Dit ruilt extra ophaalaanroepen in voor robuustheid tegen één slechte formulering.
def multi_query(raw, n=4):
queries = expand(raw, n)
rankings = [dense_retrieve(q, 30) for q in queries]
fused = rrf(*rankings)
return dedup(fused)Zoekopdracht opsplitsen
Complexe multi-hopvragen moeten worden opgesplitst in deelvragen, die je elk afzonderlijk ophaalt en daarna samenvoegt. De vraag welke CEO van het bedrijf dat X heeft overgenomen ouder is dan ... kun je niet met één keer ophalen beantwoorden.
Splits de vraag op, haal per deelvraag informatie op en laat de generator het verzamelde bewijs combineren.
def decompose_and_retrieve(question):
subs = parse_lines(llm(
'Break this into independent sub-questions, one per line.\n' +
question, temperature=0))
evidence = {s: rerank(s, dense_retrieve(s, 30))[:3] for s in subs}
return evidence # generator synthesizes the final answerHyDE: het kernidee
HyDE (Hypothetical Document Embeddings, Gao et al., 2022) draait het probleem om. In plaats van de korte zoekopdracht te embedden, vraagt het een LLM om een hypothetisch antwoorddocument te genereren. Vervolgens wordt dat document geëmbed en daarmee worden resultaten opgehaald.
Het hypothetische document gebruikt hetzelfde taalregister als echte documenten. Daardoor ligt de embedding ervan dichter bij echte antwoorden en wordt het verschil tussen zoekopdracht en document verkleind.
def hyde(query):
hypo = llm(
'Write a short passage that would answer this question, as if '
'from a reference document.\nQuestion: ' + query,
temperature=0.3)
return dense_retrieve_by_vector(embed(hypo), k=30) # embed the answerWaarom HyDE de recall verbetert
Een vraag en het antwoord daarop zijn anders geformuleerd; een vraag en een nepantwoord dat aannemelijk klinkt, zijn juist vergelijkbaar geformuleerd met het echte antwoord. HyDE gebruikt de generatieve voorkennis van de LLM om die kloof te overbruggen, zelfs als het hypothetische document feitelijke fouten bevat.
De juistheid van het hypothetische document is niet zo belangrijk: het hoeft alleen de juiste woordenschat en structuur te hebben om in de embeddingruimte dicht bij echte documenten terecht te komen.
# Robustness: average several hypothetical docs to reduce variance
def hyde_avg(query, n=3):
vecs = [embed(llm(HYDE_PROMPT + query, temperature=0.5))
for _ in range(n)]
centroid = sum(vecs) / n
return dense_retrieve_by_vector(centroid, 30)Afwegingen en foutmodi van HyDE
HyDE voegt vóór het ophalen een LLM-generatie toe, waardoor de latentie en kosten toenemen. De LLM kan ook een hallucinatoir hypothetisch document genereren dat van het onderwerp afdwaalt. Dat schaadt de recall bij nichezoekopdrachten of zoekopdrachten buiten de trainingsverdeling waarover het model niets weet.
Beperk dit risico door ophalen met de HyDE-vector te combineren met ophalen op basis van de oorspronkelijke zoekopdracht via samenvoeging. Zo kan een slechte hypothetische tekst de recall niet volledig onderuit halen.
def hyde_hybrid(query):
a = dense_retrieve_by_vector(embed(hyde_doc(query)), 30)
b = dense_retrieve(query, 30) # raw-query fallback
return dedup(rrf(a, b)) # robust to bad hypotheticalsTechnieken kiezen en combineren
Deze transformaties vullen elkaar aan. Gebruik condensering voor chat, uitbreiding/zoekopdrachten met meerdere varianten voor verschillen in woordenschat, opsplitsing voor multi-hopvragen en HyDE wanneer het taalregister van de vraag niet overeenkomt met dat van het document. Veel productiesystemen koppelen eerst condenseren en daarna HyDE, voegen dat samen met de oorspronkelijke zoekopdracht en herordenen vervolgens.
Elke extra transformatie kost een LLM-aanroep. Bepaal daarom op basis van het type zoekopdracht welke transformaties je uitvoert, in plaats van ze altijd allemaal te gebruiken.
def route_transform(query, history, qtype):
q = condense(history, query) if history else query
if qtype == 'multi_hop': return decompose_and_retrieve(q)
if qtype == 'mismatch': return hyde_hybrid(q)
if qtype == 'vocab_gap': return multi_query(q)
return dense_retrieve(q, 30)Transformaties evalueren
Meet elke transformatie aan de hand van de verbetering in retrieval recall@k en de nauwkeurigheid van het uiteindelijke antwoord ten opzichte van de onbewerkte query, op een set zonder datalekken. Houd de extra latentie en LLM-kosten bij, zodat je alleen transformaties behoudt die zichzelf terugverdienen.
Pas op: een transformatie die de recall verbetert maar afleidende resultaten toevoegt, kan de nauwkeurigheid van het antwoord verlagen tenzij je die combineert met herordening en compressie.
def eval_transform(name, fn, eval_set):
return {
'recall@10': recall_at_k(eval_set, retriever=fn, k=10),
'answer_acc': answer_accuracy(eval_set, retriever=fn),
'extra_latency_ms': transform_latency(fn),
}Korte controle
Redeneer over waarom HyDE werkt ondanks onvolmaakte hypothetische antwoorden.
Samenvatting
Belangrijkste lessen:
- Het ophalen van informatie wordt begrensd door de query; de query transformeren is een goedkope RAG-upgrade met grote impact.
- Herschrijven en samenvatten maken chatquery's zelfstandig; uitbreiding en meerdere query's vullen hiaten in de woordenschat.
- Decompositie behandelt meerstapsvragen door per deelvraag informatie op te halen.
- HyDE embedt een hypothetisch antwoord om een verschil in register tussen vraag en document te overbruggen; het hypothetische antwoord hoeft niet correct te zijn.
- Combineer transformaties op basis van het type query, voeg ze voor robuustheid samen met de onbewerkte query en evalueer recall, antwoordnauwkeurigheid, latentie en kosten.
Leer AI-promptengineering met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 53
- Lessen
- 199
Veelgestelde vragen
Is de les “Query herschrijven en HyDE” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad AI-promptengineering, waaronder “Query herschrijven en HyDE”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus AI-promptengineering bevat in totaal 4 lessen.
Wat leer ik in “Query herschrijven en HyDE”?
De recall van retrieval verbeteren Je oefent met AI-promptengineering door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met AI-promptengineering te beginnen?
Ervaring vooraf is niet nodig. AI-promptengineering op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.
Hoe lang duurt de les “Query herschrijven en HyDE”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over AI-promptengineering?
Ja. Elke les over AI-promptengineering bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Verder dan naïeve RAG
- Opgehaalde chunks opnieuw rangschikken
- Contextcompressie
- Query herschrijven en HyDE