Kleine modellen evalueren: waar ze verrassen en falen

De adoptie van compacte taalmodellen (Small Language Models of SLM's, grofweg tussen 1 miljard en 9 miljard parameters) groeit exponentieel door lagere rekeneisen en de wens om data lokaal te houden. Publieke leaderboards schilderen echter regelmatig een vertekend beeld: benchmarks zoals MMLU of GSM8k suggereren dat een modern 7B-model kan concurreren met mastodonten van honderden miljarden parameters. Wie zo'n model zonder taakgerichte evaluatie in een productiepijplijn plaatst, loopt tegen harde grenzen aan.

De centrale vraag bij het evalueren van kleine modellen is niet of ze 'slim' genoeg zijn, maar welke specifieke cognitieve deeltaken ze betrouwbaar kunnen uitvoeren zonder kwaliteitsverlies. Dit artikel bakent zich expliciet af van algemene LLM-evaluaties door in te zoomen op de asymmetrische eigenschappen van compacte architecturen: hun verrassende precisie op afgebakende deterministische extractietaken versus hun abrupte degradatie bij contextaccumulatie en deductieve redeneerketens. We behandelen een reproduceerbare meetopzet, de specifieke Nederlandse taalvalkuilen en de randvoorwaarden om te bepalen wanneer een klein model een zwaarder alternatief mag vervangen.

1. De anatomie van compacte modellen: representatiecapaciteit

Om te begrijpen waar kleine modellen falen, moeten we kijken naar de representatiecapaciteit van het neurale netwerk. Een model met 3 miljard parameters beschikt simpelweg over minder gewichten om feitelijke wereldkennis, grammatica, meertaligheid en deductieve redeneerpaden gelijktijdig te coderen. Waar een gigantisch fundamentmodel redundantie benut om vage nuances op te vangen, functioneert een compact model als een gecomprimeerde informatiespons. Kennis die niet frequent in de trainingsdata voorkwam, vertoont compressieartefacten.

Bij distillatietrajecten leert een compact model de kansverdeling van een groter model na te bootsen. Dit leidt tot een opmerkelijk fenomeen: het model produceert syntactisch vlekkeloze antwoorden die qua toon overtuigend klinken, maar inhoudelijk fundamentele denkfouten bevatten. Bij evaluaties moeten we daarom scherp onderscheid maken tussen formele oppervlaktestructuur (woordkeus, zinsbouw, JSON-opmaak) en semantische correctheid (logica, feitelijkheid, restrictie-opvolging).

Voor achtergrondinformatie over hardware-eisen en geheugenprofielen bij lokale uitrol vind je details in de gids over kleine modellen op apparaten en lokale hardware, wat helpt om de trade-off tussen parameteromvang en latentie te contextualiseren.

2. Waar kleine modellen verrassen: afgebakende precisie

In gerichte, eenduidige taken presteren compacte modellen vaak op exact hetzelfde niveau als modellen die twintig keer zo groot zijn. Het geheim zit in de taakcomplexiteit: zolang de taak geen synthese van diffuse kennis vereist maar transformatie van expliciet meegeleverde invoer, blinkt de compacte architectuur uit.

Uit systematische metingen komen drie domeinen naar voren waar kleine modellen consequent positief verrassen:

• Gestructureerde gegevensextractie: Het transformeren van ongestructureerde tekst naar een vooraf gedefinieerd schema (zoals JSON of XML) wanneer alle doelentiteiten expliciet in de brontekst aanwezig zijn.
• Gesloten classificatie en routering: Het toekennen van categorieën, sentimentlabels of routing-tags op basis van een compacte verzameling regels.
• Stijltransformatie en tekstopschoning: Het herformuleren van e-mails, samenvatten van korte passages of corrigeren van grammaticale fouten binnen een context van maximaal 1.000 tokens.

Wanneer de taak helder is afgebakend en de context binnen het aandachtsvenster past, halen geoptimaliseerde 3B- en 8B-modellen deterministische scores die nauwelijks onderdoen voor frontier-modellen, tegen een fractie van de infrastructuurkosten.

3. Waar compacte modellen structureel falen

Het structurele falen van kleine modellen manifesteert zich niet willekeurig, maar volgt specifieke patronen die direct herleidbaar zijn naar hun beperkte aandachtsmechanismen en parameterruimte. Bij het inrichten van een evaluatiekader moet je doelgericht toetsen op de volgende vier faalmodi:

A. Negatieve restricties en restrictie-accumulatie

Kleine modellen hebben moeite met prompts die meerdere voorwaarden stapelen, vooral wanneer die voorwaarden ontkenningen bevatten. Een instructie zoals "Vat deze alinea samen in maximaal drie zinnen, gebruik geen vaktermen en noem de auteur niet" faalt bij kleine modellen opvallend vaak op de negatieve clausules. Ze registreren het semantische concept ("vaktermen", "auteur") door aandachtsactivatie, maar slagen er niet in de remmende werking van het woord "geen" over meerdere generatiestappen consistent vast te houden.

Om te controleren of strikte negatieve restricties worden nageleefd, bekijken we de methodologie uit het artikel over instructievolgzaamheid kwantificeren via IFEval voor verifieerbare criteria.

B. Multi-hop redeneren en tussenstappen

Wanneer een antwoord vraagt om feit A te koppelen aan feit B om conclusie C af te leiden, stort de betrouwbaarheid van modellen onder de 9B parameters vaak in. Tenzij je het model expliciet dwingt om via een stapsgewijze denkketen (Chain of Thought) te werken, genereren kleine modellen direct de meest waarschijnlijke tokenvolgorde op basis van associaties. Zonder expliciete 'denkruimte' in het uitvoervenster produceren ze causale onjuistheden die logisch klinken maar inhoudelijk foutief zijn.

C. Aandachtsverdunning in het contextvenster (Lost-in-the-Middle)

Hoewel moderne kleine modellen adverteren met contextvensters van 32k of 128k tokens, degradeert de retrieval-precisie bij compacte netwerken al fors voorbij 4.000 tot 8.000 tokens. De representatiediepte van de transformer-lagen is onvoldoende om subtiele signalen scherp te onderscheiden tussen duizenden irrelevante contexttokens. Naalden in het midden van de context worden simpelweg genegeerd of overschreven door sterke patronen aan het begin en einde van de prompt.

4. De specifieke Nederlandse taalvalkuil

Een cruciaal aspect bij de evaluatie van kleine modellen in een Nederlandstalige context is de tokenisatiedichtheid en de verdeling van trainingsdata. Veruit de meeste open-weight modellen zijn getraind op corpora die voor meer dan 85 tot 90 procent uit het Engels bestaan. Voor een groot model van 70B parameters is de resterende fractie Nederlandse data voldoende om complexe grammaticale structuren te abstraheren. Voor een model van 3B of 7B parameters leidt deze scheefgroei tot specifieke degradaties:

• Tokenizer-inefficiëntie: Nederlandse woorden worden opgeknipt in veel meer subtokens dan Engelse woorden (bijvoorbeeld samengestelde zelfstandige naamwoorden zoals "aansprakelijkheidsverzekering"). Dit vreet niet alleen contextruimte op, maar vergroot ook de kans op foutieve binaire splitsingen tijdens de autoregressieve generatie.
• Verwarring tussen aanspreekvormen: Kleine modellen schakelen binnen één alinea geregeld over van de formele vorm ('u', 'uw') naar de informele vorm ('je', 'jouw'), zelfs wanneer de systeemprompt een strikte directieve bevat.
• Letterlijke anglicismen: Bij complexere redeneertaken vallen kleine modellen terug op Engelse idioomstructuren die letterlijk naar het Nederlands worden vertaald (zoals "het maakt geen zin" in plaats van "het heeft geen zin").
• Duits-Nederlandse interferentie: Door de lexicale nabijheid vertonen kleine modellen bij verlies van zelfvertrouwen plotseling Duitse tussenvoegsels of verbuigingen in Nederlandse teksten.

Elke evaluatieset voor de Nederlandse markt moet daarom specifieke testcases bevatten die toetsen op stijlinconsistentie, samengestelde woorden en pragmatische registerwisselingen.

5. Een reproduceerbare meetopzet inrichten

Het betrouwbaar evalueren van een klein model vereist een striktere controle over hyperparameters dan bij grote modellen. Omdat kleine modellen gevoeliger zijn voor minieme kansverschuivingen in de softmax-laag, kan een kleine wijziging in temperatuur de reproduceerbaarheid volledig ondermijnen.

Hanteer de volgende vier pijlers voor een geldige meetopstelling:

1. Determinisme vastzetten: Zet de temperature op 0.0 (of minimale waarde) en hanteer een vaste seed. Voer voor robuustheidstesten minimaal 3 herhalingen uit per promptvariatie om kansafhankelijke schommelingen te kwantificeren.
2. Strikte prompt-isolatie: Test het model met en zonder systeemprompt en meet de impact van format-instructies. Kleine modellen zijn extreem gevoelig voor delimiters (zoals Markdown-koppen versus XML-tags).
3. Geautomatiseerde schemavalidatie: Evalueer output niet uitsluitend met een LLM-beoordelaar, maar gebruik deterministische parsers (zoals Pydantic of JSON-validators) om syntaxfouten objectief af te straffen.
4. Gekalibreerde steekproef: Gebruik een testset met voldoende statistische omvang. Hoeveel testgevallen statistisch noodzakelijk zijn om toeval van structurele winst te onderscheiden, staat beschreven in het fundament over statistiek voor LLM-evaluaties.

Om te testen hoe gevoelig een compact model reageert op minimale formuleringwijzigingen, pas je methoden toe uit het artikel over A/B-testen van prompts om varianten systematisch tegen elkaar af te zetten.

6. Voorbeeld: evaluatiescript voor gestructureerde extractie

Hieronder staat een praktisch Python-evaluatiepatroon waarmee de syntactische en semantische betrouwbaarheid van een klein model deterministisch gemeten kan worden. Het script controleert of de JSON-uitvoer valide is én of alle vereiste entiteiten foutloos zijn geëxtraheerd.

import json
from typing import Dict, Any, List

def evaluate_extraction_batch(
    test_cases: List[Dict[str, Any]], 
    model_outputs: List[str]
) -> Dict[str, float]:
    """
    Evalueert de extractiekwaliteit van een klein model op JSON-validiteit
    en veld-correctheid.
    """
    total = len(test_cases)
    valid_json_count = 0
    exact_match_count = 0
    schema_adherence_count = 0

    for test_case, raw_output in zip(test_cases, model_outputs):
        expected = test_case["ground_truth"]
        
        # 1. Toets op pure JSON validiteit
        try:
            parsed = json.loads(raw_output.strip())
            valid_json_count += 1
        except (json.JSONDecodeError, ValueError):
            continue

        # 2. Toets op aanwezigheid van verplichte sleutels
        required_keys = set(expected.keys())
        if required_keys.issubset(set(parsed.keys())):
            schema_adherence_count += 1
        else:
            continue

        # 3. Toets op inhoudelijke veldgelijkheid
        if all(parsed.get(k) == expected[k] for k in required_keys):
            exact_match_count += 1

    return {
        "sample_size": float(total),
        "json_validity_rate": (valid_json_count / total) if total else 0.0,
        "schema_adherence_rate": (schema_adherence_count / total) if total else 0.0,
        "exact_match_rate": (exact_match_count / total) if total else 0.0
    }

7. Het effect van kwantisering en precisieverlies

Kleine modellen worden in de praktijk zelden in hun originele FP16-precisie gedraaid; ze worden vaak geconverteerd naar 4-bit of 8-bit formaten (zoals GGUF of AWQ) om te passen op consumentengpu's of lokale edge-apparatuur. Dit introduceert een belangrijke meetvariabele: kwantisatieruis.

Bij grote modellen (70B+) heeft 4-bit kwantisering (zoals Q4_K_M) nauwelijks meetbare invloed op het deductief redeneervermogen. Bij kleine modellen (1B tot 4B) is die marge veel smaller. 4-bit kwantisering kan bij een 3B-model net de breeklijn betekenen waardoor het model plotseling faalt in JSON-opmaak of getallenreeksen verwisselt.

Voor een diepere analyse van bitreductie en kwaliteitsverlies verwijzen we naar het dossier over het kwaliteitseffect van kwantisering meten om degradatie per bitniveau vast te leggen.

8. Evaluatie in multi-stap systemen en agentische workflows

Een populaire architectuur is het inzetten van kleine modellen als gespecialiseerde 'werkers' binnen een groter multi-agent systeem: één compact model classificeert de vraag, een tweede haalt entiteiten op, en een zwaar model genereert het uiteindelijke antwoord. Dit reduceert de operationele kosten aanzienlijk.

Wanneer een klein model ingezet wordt voor tussenstappen in een workflow, biedt het artikel over agent-evaluatie en trajectanalyse handvatten om te meten of gereedschapsaanroepen slagen.

Bij het evalueren van kleine modellen binnen een agentisch traject moet je specifiek meten op cascade-fouten. Een kleine fout in de routeringslaag (bijvoorbeeld een incorrect geclassificeerde klantvraag) plant zich voort door de rest van de keten. De evaluatiematrix voor een compact routeringsmodel moet daarom een uitzonderlijk hoge specificiteit (lage false-positive rate) aantonen voordat het model productiewaardig is.

Wie meerdere modelaanbieders en lokale endpoints wil combineren binnen één infrastructuur, leest in het overzicht over API-aggregators en model-gateways hoe routeringstechniek en fallbacks ingericht worden.

9. Kosten, latentie en doorvoer in de besliskaart

De uiteindelijke beslissing om een klein model in te zetten rust op de driehoek van kwaliteit, latentie en kosten per 1.000 afgeronde taken. Een model dat 5 procentpunt lager scoort op nauwkeurigheid maar tien keer zo snel is en lokaal kan draaien zonder API-kosten per token, kan bedrijfskundig de superieure keuze zijn — mits de fouten herkenbaar en afvangbaar zijn.

Bij het opstellen van het evaluatierapport documenteren we altijd de volgende meetwaarden per kandidaatmodel:

• Taaksuccesratio (Task Success Rate): Het percentage gevallen dat foutloos door de geautomatiseerde validatie komt.
• Time-to-First-Token (TTFT) en tokens/seconde: Gemeten op de beoogde productiehardware onder realistische belasting.
• Fallback-ratio: Het percentage transacties dat alsnog moet escaleren naar een groter model.
• Geheugenbeslag (VRAM/RAM): De stabiele footprint tijdens piekbelasting met maximale contextlengte.

10. Conclusie en beslisboom

Kleine modellen zijn geen inferieure versies van frontier-modellen; het zijn gespecialiseerde precisie-instrumenten die floreren bij scherpe begrenzing en falen bij conceptuele overbelasting. Door ze systematisch te toetsen op restrictie-opvolging, JSON-integriteit, contextretentie en Nederlandse taalzuiverheid, ontstaat een helder beeld van hun inzetbaarheid.

Hanteer als vuistregel: reserveer frontier-modellen voor synthese, diffuse creativiteit en complexe logica met open einde; zet compacte modellen in voor afgebakende transformaties, deterministische extracties en snelle classificaties. Wie meet op taakniveau in plaats van blind te varen op algemene benchmarks, benut de kracht van kleine modellen zonder concessies te doen aan betrouwbaarheid.