Hoe je aan de hand van op entropie gebaseerde scores kunt zien wanneer je model dingen verzint — en waar —, uitgelegd in 'artefactual', ons Python-pakket.

Opmerking: Dit artikel is een vervolg op het artikel van onze vrienden bij Ardian, waarin wordt uitgelegd hoe cruciaal verantwoorde AI voor financiële instellingen. Lees het zeker eens door!

Het probleem van hallucinaties

Grote taalmodellen zijn verbazingwekkend capabel. Ze kunnen samenvatten, vertalen, redeneren en programmeren (beter dan ik). Maar in tegenstelling tot mij staan ze er ook om bekend dat ze met verontrustend zelfvertrouwen feiten verzinnen.

In de literatuur over natuurlijke taalverwerking (NLP) wordt onder een ‘hallucinatie’ verstaan: elke door een model gegenereerde inhoud die feitelijk onjuist, onzinnig of niet in overeenstemming met een opgegeven bron is, maar tegelijkertijd volkomen aannemelijk lijkt. De gevolgen variëren van onschuldig (een fout antwoord op een triviavraag) tot ernstig (een verzonnen juridische verwijzing, een onjuiste medicatiedosering). Naarmate organisaties LLM's in productiesystemen integreren, verschuift de vraag van "kan dit model bruikbare tekst genereren?" naar "kunnen we vertrouwen op wat het zojuist heeft gezegd?"

Laten we eens een concreet voorbeeld bekijken. Stel, je werkt bij een financiële instelling en je vraagt je lokale LLM:

„Wat was de netto-omzet van Emerson Electric in 2023?“

Het model antwoordt: „Emerson Electric rapporteerde voor het boekjaar 2023 een netto-omzet van ongeveer 15,2 miljard dollar.” Dat klinkt aannemelijk. Maar klopt het ook? Je hebt het jaarverslag niet bij de hand. Je hebt geen feitelijke gegevens om het mee te vergelijken. Je hebt alleen de uitkomst van het model – en twijfel.

Dit is de omgeving waarin we werken. Geen orakel. Geen referentieantwoord op het moment van inferentie. Alleen een reactie van het grootschalige taalmodel (LLM) en de metadata die het tijdens het genereren ervan produceert. Het doel: kwantificeren hoe groot de kans is dat deze output verzonnen is, op basis van één enkele generatieronde.

Hallucinaties herkennen: dat is moeilijker dan het klinkt

De brute-force-aanpak

Een voor de hand liggende manier is om het model meerdere keren dezelfde vraag te stellen en te kijken of de antwoorden overeenkomen. Als vijf van de zes runs „$15,2 miljard“ aangeven en één „$18,7 miljard“, geeft die consensus je enige zekerheid. Dit is het principe achter methoden zoals SelfCheckGPT, die de consistentie meten tussen meerdere willekeurig geselecteerde uitkomsten — een „Monte Carlo-achtige“ benadering voor het opsporen van hallucinaties.

Het werkt. Maar er zijn twee belangrijke nadelen:

  1. Kosten. Elke extra generatie zorgt ervoor dat uw budget voor inferentie vertienvoudigt. Voor SelfCheckGPT met 10 voorbeelden betaalt u ongeveer tien keer zoveel voor de rekenkracht, plus de kosten voor een semantisch gelijkenismodel daarbovenop. Op grote schaal zijn deze kosten onbetaalbaar.
  2. Granulariteit. Multi-shot-methoden werken op sequentieniveau. Ze geven aan dat „dit antwoord onbetrouwbaar lijkt“, maar niet welk deel van het antwoord precies problematisch is. Een antwoord kan voor 90% correct zijn, maar toch één verzonnen getal bevatten dat ergens in het midden verstopt zit. Je wilt graag weten waar dat precies is.

Deze beperkingen hebben ons ertoe aangezet om op zoek te gaan naar een ander signaal — een signaal dat goedkoop is, slechts één keer hoeft te worden toegepast en werkt op token-niveau (de afzonderlijke woorddelen die het LLM intern verwerkt).

Het signaal is er al

Wanneer een LLM tekst genereert, produceert het niet alleen maar tokens. Bij elke stap berekent het een waarschijnlijkheidsverdeling over zijn volledige woordenschat: „gezien de prompt en alles wat ik tot nu toe heb gegenereerd, hoe waarschijnlijk is elk mogelijk volgend token?“Het token met de hoogste waarschijnlijkheid wordt gekozen. De rest wordt weggegooid. Maar die waarschijnlijkheden (en meer specifiek, hoe verspreid ze zijn) bevatten informatie over het interne vertrouwen van het model.

Als het model er heel zeker van is, concentreert het grootste deel van de waarschijnlijkheidsmassa zich op één enkel token. Als het model twijfelt, verspreidt de waarschijnlijkheid zich over veel kandidaten. Deze spreiding is precies wat entropie meet.

Entropie: een korte uitstap

Entropie is een grootheid uit de informatietheorie die de onzekerheid van een kansverdeling meet. Het principe is eenvoudig. Stel je drie dozen voor. In één daarvan zit een koekje. Je moet raden in welke.

  • Scenario A: Je weet dat het koekje in vakje 2 zit. Je onzekerheid is nul. Entropie = 0.
  • Scenario B: Je hebt geen idee. Elke doos heeft een kans van 1/3. Je onzekerheid is maximaal. Entropie = log₂(3) ≈ 1,58 bits.

Vervang nu de vakjes door tokens en het koekje door het ‘juiste’ volgende woord. Bij elke generatiestap staat een LLM voor precies deze keuze — alleen kiest het in plaats van uit drie vakjes uit een woordenschat van meer dan 100.000 tokens. Als het model zeker is, overheerst één token en is de entropie laag. Als het aarzelt, neemt de entropie toe.

De kansverdeling in twee verschillende gevallen.

De belangrijkste conclusie is dat een hoge entropie op een bepaalde tokenpositie samenhangt met een grotere kans op een fout op die positie. Het model geeft via zijn waarschijnlijkheidsverdeling aan dat het niet zeker weet wat er daarna komt. We hoeven alleen maar te luisteren.

Van entropie tot hallucinatiescores

EPR: Entropieproductiesnelheid

Onze eerste maatstaf, EPR (Entropy Production Rate), is rechttoe rechtaan. Voor elk token in de gegenereerde reeks berekenen we de entropie van de top-K voorspelde tokenkansen van het model. Vervolgens berekenen we het gemiddelde over de hele reeks. Dit levert één getal op dat de gemiddelde aarzeling van het model over het gehele antwoord weergeeft.

Dit is een onbegeleide maatstaf: er zijn geen labels nodig. In onze experimenten (gepubliceerd op ECIR 2026) behaalt EPR op zichzelf ROC-AUC-scores tussen 74 en 81 op TriviaQA bij vier verschillende LLM’s. Niet slecht voor een maatstaf die in feite niets meer kost dan één generatieronde.

Maar dat kan beter.

WEPR: Gewogen entropieproductiesnelheid

Bij ruwe entropie worden alle tokenrangschikkingen gelijk behandeld. De entropiebijdrage van het token op de eerste plaats (het meest waarschijnlijke) en die van het token op de tiende plaats worden even zwaar gewogen. In de praktijk bevat de manier waarop de onzekerheid over de rangschikkingen is verdeeld, onderscheidende informatie.

WEPR (Weighted EPR) leert een reeks gewichten om deze bijdragen opnieuw in evenwicht te brengen. Het maakt gebruik van twee signalen:

  • De gewogen gemiddelde entropie over de gehele reeks — die de totale aarzeling weergeeft.
  • De maximale entropiebijdrage per rang — waarmee pieken in onzekerheid worden vastgelegd. Een enkel moment van grote aarzeling kan kenmerkend zijn voor een hallucinatie, zelfs als de rest van de reeks met zekerheid is gegenereerd.

Deze kenmerken worden ingevoerd in een logistische regressie, die is getraind op een gelabelde dataset. De output van de sigmoïde is een gekalibreerde waarschijnlijkheid:

“Deze reactie bevat met een waarschijnlijkheid van 86% een hallucinatie.”

Naast classificatie genereert WEPR ook scores op token-niveau. Elk token in de gegenereerde reeks krijgt zijn eigen hallucinatiekans, waardoor je precies kunt vaststellen welke delen van een antwoord nader moeten worden bekeken. Dit wordt in realtime berekend, token voor token, terwijl het model de tekst genereert — je hoeft dus niet te wachten op de volledige uitvoer.

Hoe zit het met etiketten?

Bij een begeleide methode zijn annotaties nodig. Het met de hand labelen van duizenden vraag-antwoordparen is tijdrovend. Daarom maken we gebruik van een ‘LLM-as-a-judge’-aanpak: een apart model vergelijkt elk gegenereerd antwoord met de bekende ‘ground truth’ en labelt het als correct of onjuist.

Is dit betrouwbaar? We hebben het getoetst aan de hand van menselijke beoordelaars. Een groep van 15 onderzoekers heeft meer dan 1.300 antwoordparen handmatig gelabeld. De overeenstemming tussen de geautomatiseerde beoordelaar en de menselijke beoordelaars bedroeg 95,7%, met een Cohen’s Kappa van 0,90. De geautomatiseerde labels vormen een betrouwbare benadering van menselijk oordeel en zijn robuust genoeg om een hallucinatiedetector op te trainen.

Maak kennis met artefactual: nu is het jouw beurt om te spelen.

We hebben dit alles gebundeld in een open-source Python-bibliotheek: artefactual.

De bibliotheek wordt geleverd met vooraf berekende kalibratiegewichten voor verschillende modelfamilies (Mistral-Small, Falcon-3, Phi-4, Ministral-8B), zodat je direct kunt beginnen met het beoordelen van outputs zonder een trainingspijplijn te hoeven uitvoeren. De bibliotheek verwerkt standaard outputs van vLLM, de OpenAI Chat Completions API en de OpenAI Responses API.

Hier volgt de meest eenvoudige manier om het te gebruiken:

De scores op token-niveau zijn vooral handig voor visualisatie. Elk token in het antwoord krijgt zijn eigen hallucinatiekans, die je kunt weergeven als een kleurverloop: groen voor zekerheid en rood voor onzekerheid. In één oogopslag zie je precies welke delen van een antwoord nader moeten worden bekeken.

In een RAG-pijplijn

Dit komt in de praktijk tot uiting bij ‘Retrieval-Augmented Generation’. Stel je een proces voor waarbij documenten uit een kennisbank worden opgehaald en als context aan een groot taalmodel (LLM) worden aangeboden. Als het ophalen mislukt (verkeerde documenten, ontbrekende pagina’s, onvolledige context, enz.), zal het model proberen de hiaten op te vullen vanuit zijn parametrische geheugen, en dat is waar hallucinaties de kop opsteken.

Met artefactual kun je een poort toevoegen:

Ons wetenschappelijk artikel in een notendop — Wat we hebben ontdekt

We hebben EPR en WEPR getest op vier grote taalmodellen (Mistral-Small-24B, Falcon-3–10B, Phi-4, Ministral-8B) bij drie taken: het opsporen van hallucinaties in TriviaQA, generalisatie naar WebQuestions en het opsporen van ontbrekende context in een financiële RAG-omgeving.

Enkele hoogtepunten:

  • WEPR presteert consequent beter dan bestaande methoden. Het presteert beter dan zowel SelfCheckGPT (een multi-shot-methode die tien keer zoveel rekenkracht vereist) als HalluDetect (een single-shot-concurrent) bij vrijwel alle combinaties van modellen en datasets.
  • Je hebt niet veel log-waarschijnlijkheden nodig. De prestaties stabiliseren bij ongeveer K = 8–10 beschikbare log-waarschijnlijkheden per token. Zelfs met beperkte API-toegang is het signaal duidelijk aanwezig.
  • Het is algemeen toepasbaar. WEPR, dat is getraind op TriviaQA, presteert goed op WebQuestions en zelfs op een gespecialiseerd financieel corpus, waarbij het gevallen opspoort waarin een RAG-systeem antwoorden genereerde zonder voldoende context.
  • Het gaat snel. Het genereren van een tekst kost ongeveer 80 microseconden per reeks. Vergelijk dat eens met de meer dan 10 seconden die SelfCheckGPT nodig heeft.

In onze experimenten met een financiële RAG-taak (het analyseren van reports de ArGiMi-Ardian-dataset) behaalde WEPR een ROC-AUC van maar liefst 93,6 bij het opsporen van antwoorden die zonder de juiste context waren gegenereerd. Dit is een duidelijk signaal om een tweede zoekronde te starten.

Opmerking over toegang via log-waarschijnlijkheid:

Alles wat hierboven is beschreven, hangt af van één ding: toegang tot de log-waarschijnlijkheden op token-niveau uit het model. Hierdoor kunnen we de entropie berekenen en, in het verlengde daarvan, de hallucinatiescores.

Op dit moment is deze toegang niet gegarandeerd. Anthropic stelt log-probabilities niet beschikbaar via zijn API. OpenAI biedt deze wel aan voor modellen die niet redeneren — je kunt top_logprobs opvragen bij GPT-5.4 of GPT-5.4-mini, maar alleen als je de redeneringsinspanning instelt op ‘none’. Google daarentegen biedt toegang tot alle logprobs via zijn generate_content-API.

Modellen zonder gewichtsbeperkingen die via vLLM of vergelijkbare inferentie-engines worden aangeboden, bieden volledige toegang.

Dit is belangrijk. Log-waarschijnlijkheden vormen een eenvoudig, maar zeer informatief signaal. Het kost niets extra om ze te genereren (het model berekent ze toch al tijdens het genereren) en ze maken een hele reeks methoden voor het kwantificeren van onzekerheid mogelijk — waaronder die van ons. Door de toegang hiertoe te beperken, worden gebruikers gedwongen om ofwel blindelings te vertrouwen op modelresultaten, ofwel hun toevlucht te nemen tot dure detectiemethoden waarbij meerdere metingen nodig zijn.

Als je in de praktijk met LLM’s werkt en de betrouwbaarheid van de output belangrijk vindt, zou de beschikbaarheid van log-probabilities een van je selectiecriteria voor modellen moeten zijn. En als je een modelaanbieder bent: het beschikbaar stellen van log-probabilities is een van de goedkoopste manieren om je modellen betrouwbaarder te maken.