Waarom evaluatie belangrijk is voor RAG
U begrijpt de twee onafhankelijke foutmodi in RAG-systemen: retrieval failure en generation failure, en leert waarom u afzonderlijke metrics nodig hebt om beide te diagnosticeren.
Waarom evaluatie belangrijk is voor RAG is een gratis AI Engineering Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject AI Engineering Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus AI Engineering Academy bevat in totaal 4 lessen.
Wat je niet meet, kun je niet verbeteren
Een RAG-systeem kan goed lijken te werken omdat het vloeiende, aannemelijk klinkende antwoorden geeft. Maar zonder metingen weet je niet of het systeem daadwerkelijk de juiste chunks ophaalt of betrouwbare antwoorden genereert. Teams die evaluatie overslaan, besteden vaak maanden aan het aanpassen van chunkstrategieën en promptindelingen op basis van intuïtie, om vervolgens te ontdekken dat ze de resultaten hebben verslechterd. Grondige evaluatie verandert RAG-ontwikkeling van giswerk in engineering.
Twee onafhankelijke foutmodi
RAG heeft twee afzonderlijke fasen die onafhankelijk van elkaar kunnen mislukken: ophalen en genereren. Het ophalen mislukt wanneer de relevante chunks niet in de top-K-resultaten staan — de LLM kan geen goed antwoord genereren als de juiste informatie nooit is opgehaald. Het genereren mislukt wanneer de juiste chunks wel zijn opgehaald, maar de LLM ze negeert, verkeerd leest of verzonnen informatie toevoegt. Je hebt afzonderlijke metrieken nodig voor elke fase om vast te stellen welk onderdeel het probleem veroorzaakt.
Het gevaar van alleen end-to-end-evaluatie
Als je alleen de kwaliteit van het uiteindelijke antwoord meet, blijft verborgen waar fouten vandaan komen. Stel dat je systeem in 30% van de gevallen verkeerde antwoorden geeft. Komt dat doordat het ophalen de juiste chunks mist, of doordat de LLM goede chunks negeert? Als je alleen het uiteindelijke foutpercentage kent, weet je niet welk onderdeel je moet repareren. Voorzie beide fasen afzonderlijk van instrumentatie: meet de kwaliteit van het ophalen met gouden datasets en de kwaliteit van het genereren met scores voor getrouwheid.
# Diagnosis example: which stage is failing?
# Test 1: Is retrieval finding the right chunks?
retrieval_hit_rate = evaluate_retrieval(questions, ground_truth_chunks)
print(f'Retrieval hit rate@5: {retrieval_hit_rate:.1%}')
# If this is low (< 80%), fix chunking and embedding first
# Test 2: Given perfect context, does LLM generate correct answers?
generation_faithfulness = evaluate_generation(questions, perfect_context)
print(f'Generation faithfulness: {generation_faithfulness:.1%}')
# If retrieval is fine but this is low, fix your promptsEen gouden dataset bouwen
Voor evaluatie heb je een gouden dataset nodig: een verzameling vraag-antwoordparen waarvan je het juiste antwoord kent en idealiter ook weet uit welk document en welke chunk het antwoord afkomstig is. Verzamel voor een minimaal bruikbare evaluatieset 50-100 vragen die representatief zijn voor echte query's van gebruikers. Beantwoord ze met de hand of door de brondocumenten te lezen. Neem verschillende vraagtypen op: feitelijke opzoekvragen, vergelijkingen, redeneringen over meerdere stappen en vragen buiten het domein die het systeem moet weigeren te beantwoorden.
# Golden dataset format
golden_dataset = [
{
'question': 'How many vacation days do employees receive in their first year?',
'answer': '15 days',
'relevant_chunks': ['employee_handbook_p24', 'benefits_summary_p3'],
'source_doc': 'employee_handbook_2025.pdf'
},
{
'question': 'What is the parental leave duration for primary caregivers?',
'answer': '16 weeks fully paid',
'relevant_chunks': ['parental_leave_policy_p1'],
'source_doc': 'parental_leave_policy.pdf'
}
]Gouden datasets genereren met LLM's
100 vragen handmatig maken is tijdrovend. Versnel dit met een LLM voor gegevensgeneratie: geef elk documentfragment aan GPT-4o en vraag het om 3 tot 5 verschillende vragen te genereren waarvan de antwoorden in dat fragment te vinden zijn, plus de verwachte antwoordtekst. Controleer handmatig een steekproef om kwaliteitsproblemen op te sporen. Deze aanpak schaalt snel naar duizenden vragen, maar kan randgevallen missen die alleen echte gebruikers zouden aansnijden.
def generate_qa_pairs_for_chunk(chunk_text, llm_client):
prompt = (
'Given the following document excerpt, generate 3 diverse questions '
'that can be answered using ONLY this text. '
'For each question, provide the exact answer from the text.\n\n'
f'Text:\n{chunk_text}\n\n'
'Format each as JSON: {"question": ..., "answer": ...}'
)
response = llm_client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}]
)
return response.choices[0].message.contentEvaluatie van retrieval: trefferpercentage
Trefferpercentage@K is het aandeel vragen waarvoor ten minste één relevant fragment voorkomt in de bovenste K-resultaten van de retrieval. Dit is de eenvoudigste en meest intuïtieve retrievalmetriek. Een trefferpercentage@5 van 85% betekent dat voor 85 van de 100 vragen het relevante fragment bij de vijf beste resultaten stond. Houd het trefferpercentage afzonderlijk bij voor verschillende documenttypen, querylengtes en onderwerpcategorieën om te ontdekken waar uw retriever de meeste moeite mee heeft.
def compute_hit_rate(golden_dataset, retriever, top_k=5):
hits = 0
for item in golden_dataset:
results = retriever.retrieve(item['question'], top_k=top_k)
retrieved_ids = {r['id'] for r in results}
relevant_ids = set(item['relevant_chunks'])
if retrieved_ids & relevant_ids: # intersection not empty
hits += 1
hit_rate = hits / len(golden_dataset)
print(f'Hit rate@{top_k}: {hit_rate:.1%} ({hits}/{len(golden_dataset)})')
return hit_rateEvaluatie van generatie: getrouwheid
Getrouwheid meet of het gegenereerde antwoord alleen informatie bevat die in de opgehaalde context kan worden geverifieerd. Een ongetrouw antwoord voegt feiten toe die niet door de context worden ondersteund — dat is hallucinatie. Meet de getrouwheid door een beoordelende LLM (of menselijke beoordelaar) elke zin in het antwoord te laten controleren aan de hand van de context en beweringen te markeren die niet door de opgehaalde fragmenten worden ondersteund. Een getrouwheidsscore van 95% of hoger is het doel voor productiesystemen.
def evaluate_faithfulness(answer, context, llm_client):
prompt = (
'Given this context and answer, evaluate faithfulness.\n\n'
f'Context: {context}\n\n'
f'Answer: {answer}\n\n'
'For each sentence in the answer, determine if it is '
'supported by the context (FAITHFUL) or not (HALLUCINATED). '
'Return a JSON: {"score": 0.0-1.0, "issues": ["sentence..."]}.'
)
response = llm_client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': prompt}]
)
return response.choices[0].message.contentEvaluatie van generatie: relevantie van het antwoord
Relevantie van het antwoord meet of het gegenereerde antwoord daadwerkelijk ingaat op de vraag van de gebruiker. Een zeer getrouw antwoord kan toch de kern missen door een verwante maar andere vraag te beantwoorden. Meet relevantie afzonderlijk van getrouwheid. Gebruik een beoordelende LLM om met een schaal van 1 tot 5 te beoordelen of het antwoord rechtstreeks ingaat op wat er is gevraagd. Een lage relevantie van het antwoord wijst vaak op een probleem met de structuur van de prompt of op opgehaalde context die het antwoord niet daadwerkelijk bevat.
def evaluate_answer_relevance(question, answer, llm_client):
prompt = (
f'Question: {question}\n\n'
f'Answer: {answer}\n\n'
'Rate how well this answer addresses the question on a 1-5 scale:\n'
'5 = fully answers the question\n'
'3 = partially answers but misses key aspects\n'
'1 = does not address the question at all\n\n'
'Return JSON: {"score": 1-5, "reason": "brief explanation"}'
)
response = llm_client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': prompt}]
)
return response.choices[0].message.contentMetrieken in de loop van de tijd bijhouden
Evaluatie is het waardevolst wanneer u metrieken in de loop van de tijd bijhoudt terwijl u wijzigingen aanbrengt. Sla evaluatieresultaten op in een database of spreadsheet met tijdstempels en versielabels (bijv. chunk_size=500, embed=3-small, k=5). Wanneer u een nieuwe strategie voor het opdelen in fragmenten of een nieuw inbeddingsmodel uitprobeert, voert u dezelfde evaluatie uit en vergelijkt u de resultaten. Zo voorkomt u regressie — u kunt de getrouwheid verbeteren, maar per ongeluk het trefferpercentage verlagen. Voer altijd de volledige evaluatie uit voordat u wijzigingen naar productie samenvoegt.
import json
from datetime import datetime
def save_evaluation_results(metrics, config, output_file='eval_history.jsonl'):
record = {
'timestamp': datetime.utcnow().isoformat(),
'config': config,
'metrics': metrics
}
with open(output_file, 'a') as f:
f.write(json.dumps(record) + '\n')
print(f'Saved eval result: hit_rate={metrics["hit_rate"]:.1%}, '
f'faithfulness={metrics["faithfulness"]:.1%}')De evaluatiemindset
Naast specifieke metrieken vereist evaluatie een verandering van mindset: behandel RAG als een machineleersysteem met meetbare prestaties, niet als een chatbot die u subjectief beoordeelt door ermee te chatten. Definieer vooraf succescriteria (bijv. trefferpercentage@5 > 85%, getrouwheid > 95%). Stel een testset samen die bevroren blijft en nooit wordt gebruikt voor ontwikkelbeslissingen. Reserveer een afzonderlijke ontwikkelset voor iteratie. Deze discipline onderscheidt teams die betrouwbare RAG opleveren van teams die indrukwekkende demo's opleveren die in productie falen.
Testset versus ontwikkelset
Een belangrijke discipline in machine learning die ook geldt voor RAG-evaluatie is de train-dev-test-splitsing. Uw testset moet volledig bevroren zijn — gebruik deze nooit om ontwikkelbeslissingen te nemen. Gebruik een afzonderlijke ontwikkelset om te experimenteren met strategieën voor het opdelen in fragmenten, promptwijzigingen en inbeddingsmodellen. Voer de testset alleen uit wanneer u denkt dat een wijziging klaar is voor productie. Deze scheiding voorkomt dat u uw RAG-pijplijn overfit op de testset en zorgt ervoor dat uw uiteindelijke gerapporteerde metrieken echte generalisatie weerspiegelen.
import json
from sklearn.model_selection import train_test_split
def split_golden_dataset(all_questions, test_ratio=0.3, seed=42):
dev_set, test_set = train_test_split(
all_questions,
test_size=test_ratio,
random_state=seed
)
print(f'Dev set: {len(dev_set)} questions')
print(f'Test set: {len(test_set)} questions (FROZEN)')
with open('eval/dev_set.json', 'w') as f:
json.dump(dev_set, f, indent=2)
with open('eval/test_set.json', 'w') as f:
json.dump(test_set, f, indent=2)
return dev_set, test_setKorte controle
Test uw begrip van de AI Engineering-concepten uit deze les.
Samenvatting van de les
In deze les hebt u geleerd: de twee onafhankelijke foutmodi van retrieval en generatie, waarvoor afzonderlijke metrieken nodig zijn, hoe u een gouden dataset opbouwt met vraag-antwoord-fragmentdrieluiken voor objectieve evaluatie, het trefferpercentage als belangrijkste retrievalmetriek en getrouwheid en relevantie van het antwoord als de belangrijkste generatiemetrieken, en het belang van metrieken in de loop van de tijd bijhouden om regressies te voorkomen. Hierna implementeren we specifieke retrievalmetrieken, waaronder MRR en NDCG.
Leer Python 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
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “Waarom evaluatie belangrijk is voor RAG” gratis?
Ja — de volledige tekst van “Waarom evaluatie belangrijk is voor RAG” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus AI Engineering Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus AI Engineering Academy bevat in totaal 4 lessen.
Wat leer ik in “Waarom evaluatie belangrijk is voor RAG”?
U begrijpt de twee onafhankelijke foutmodi in RAG-systemen: retrieval failure en generation failure, en leert waarom u afzonderlijke metrics nodig hebt om beide te diagnosticeren. Je oefent met AI Engineering Academy 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 Engineering Academy te beginnen?
Ervaring vooraf is niet nodig. AI Engineering Academy 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 1 van 4.
Hoe lang duurt de les “Waarom evaluatie belangrijk is voor RAG”?
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 Engineering Academy?
Ja. Elke les over AI Engineering Academy 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
- Waarom evaluatie belangrijk is voor RAG
- Retrievalmetrics: hit rate, MRR en NDCG
- Generationmetrics: faithfulness en answer relevance
- Een geautomatiseerde evaluatieharnas bouwen