# Lost-in-the-middle effect meten in contextvensters [Naar de inhoud](#lm-inhoud)Netwerk/NL[EN](/en/)[Hubhub.llmnet.nlModellen vergelijken op taak, taal, kosten en licentie.](https://hub.llmnet.nl/)[Communitycommunity.llmnet.nlPrompttechnieken, patronen en systeemprompts.](https://community.llmnet.nl/)[APIapi.llmnet.nlLLM's robuust in software: rate limits, routing, structured output.](https://api.llmnet.nl/)[Consultancyconsultancy.llmnet.nlAI invoeren in een organisatie, van pilot tot productie.](https://consultancy.llmnet.nl/)[Nieuwsnieuws.llmnet.nlOntwikkelingen in AI, geduid voor Nederland.](https://nieuws.llmnet.nl/)[Benchmarkbenchmark.llmnet.nlZelf meten wat AI-kwaliteit is, voor jouw taken.](https://benchmark.llmnet.nl/)[Vacaturesvacatures.llmnet.nlAI-rollen, salarissen en carrièrepaden in Nederland.](https://vacatures.llmnet.nl/)[Lerenleren.llmnet.nlAI-concepten in gewoon Nederlands, van beginner tot bouwer.](https://leren.llmnet.nl/)[Gidsgids.llmnet.nlAI privé draaien op eigen Mac, pc, NAS of thuisserver.](https://gids.llmnet.nl/)[Directorydirectory.llmnet.nlHet AI-ecosysteem in kaart: tools, modellen, bedrijven.](https://directory.llmnet.nl/)[Radarradar.llmnet.nlSignalen uit X, onderzoek en communities voor indie developers.](https://radar.llmnet.nl/)[llmnet.nl — hoofdsite](https://llmnet.nl/)[](https://x.com/intent/post?url=https%3A%2F%2Fbenchmark.llmnet.nl%2Fhet-lost-in-the-middle-effect-meten-in-lange-contextvensters&text=Lost-in-the-middle%20effect%20meten%20in%20contextvensters)[](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fbenchmark.llmnet.nl%2Fhet-lost-in-the-middle-effect-meten-in-lange-contextvensters)[](https://www.reddit.com/submit?url=https%3A%2F%2Fbenchmark.llmnet.nl%2Fhet-lost-in-the-middle-effect-meten-in-lange-contextvensters&title=Lost-in-the-middle%20effect%20meten%20in%20contextvensters)[](#)[](https://x.com/intent/post?url=https%3A%2F%2Fbenchmark.llmnet.nl%2Fhet-lost-in-the-middle-effect-meten-in-lange-contextvensters&text=Lost-in-the-middle%20effect%20meten%20in%20contextvensters)[](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fbenchmark.llmnet.nl%2Fhet-lost-in-the-middle-effect-meten-in-lange-contextvensters)[](https://www.reddit.com/submit?url=https%3A%2F%2Fbenchmark.llmnet.nl%2Fhet-lost-in-the-middle-effect-meten-in-lange-contextvensters&title=Lost-in-the-middle%20effect%20meten%20in%20contextvensters)[](#) # Lost-in-the-middle effect meten in lange contextvensters Door Ivo Donker — samengesteld met AI-ondersteuning (Claude & Gemini) Wanneer een taalmodel een groot contextvenster ondersteunt, betekent dit niet automatisch dat alle informatie over de volledige as gelijkwaardig wordt verwerkt. In de praktijk treedt er vaak een fenomeen op waarbij feiten die diep in het midden van de prompt verborgen zitten over het hoofd worden gezien, terwijl informatie aan het begin en aan het einde feilloos wordt opgehaald. Dit staat bekend als het lost-in-the-middle effect. Dit artikel onderscheidt zich van algemene retrieval-tests door specifiek in te zoomen op de wiskundige spreiding van aandachtsverlies over variërende dieptes en venstergroottes. De beslissing die met deze meting wordt genomen is fundamenteel voor elke softwarearchitectuur: vertrouw je op het inherente geheugen van een groot contextvenster voor analyse van omvangrijke documenten, of is een aanvullende retrieval-laag met gerichte herschikking van documentfragmenten noodzakelijk? Wie zonder validatie blindelings vertrouwt op een omvangrijk contextvenster, riskeert dat cruciale clausules in juridische dossiers of variabelen in codebases geruisloos worden genegeerd. ## De mechanica van aandachtsdegradatie Aandachtsmechanismen in transformer-architecturen berekenen paarsgewijze interacties tussen alle tokens in een sequentie via de Softmax-operatie. In theorie kan elk token aandacht schenken aan elk ander token. In de praktijk verdeelt de aandachtsdistributie zich echter niet homogeen. Naarmate het aantal tokens toeneemt, treedt er dispersie op: de aandachtsvectoren moeten over tienduizenden invoerposities worden genormaliseerd, waardoor de gewichten naar afzonderlijke tokens in het midden verwateren. Een tweede oorzaak ligt in de positionele codering. Veel moderne architecturen gebruiken Rotary Position Embeddings (RoPE) om relatieve afstanden tussen tokens vast te leggen. Lees het artikel over [Rotary Position Embedding en lange teksten](https://leren.llmnet.nl/rotary-position-embedding-rope) om te begrijpen hoe frequentieschaling en basiswaarden de relatieve afstandsberekening over tienduizenden tokens beïnvloeden. Wanneer een contextvenster kunstmatig is opgerekt via interpolatietechnieken, verliest het model vaak resolutie bij relatief grote afstanden ten opzichte van de instructieprompt, die zich meestal aan het begin of het einde van het venster bevindt. Het resultaat is een karakteristieke U-vormige prestatiecurve: aan het begin (direct na de systeemprompt) en aan het einde (vlak voor de vraag) presteert het model sterk, maar in het centrale gedeelte zakt de trefzekerheid significant in. Om te bepalen of een specifiek model geschikt is voor de eigen use-case, moet deze prestatiecurve exact in kaart worden gebracht. ## Afbakening: synthetische naalden versus semantische synthese Bij het evalueren van contextvensters bestaan twee verschillende testbenaderingen. De klassieke synthetische test plaatst een willekeurig feitje in een zee van irrelevante tekst en vraagt het model om dat feitje letterlijk te reproduceren. Raadpleeg de gids over [de needle-in-a-haystack testmethode](https://benchmark.llmnet.nl/needle-in-a-haystack-testmethode) voor het basisprincipe van dergelijke synthetische ophaaltesten. Het meten van het lost-in-the-middle effect gaat echter een stap verder dan enkel binaire trefzekerheid. Hierbij worden twee specifieke dimensies tegelijkertijd gevarieerd: - Contextdiepte (relatieve positie): de exacte procentuele locatie van de informatie binnen de totale invoer. - Contextlengte (absolute omvang): de totale lengte van de context in tokens. Bovendien moet onderscheid worden gemaakt tussen single-needle retrieval (het opdiepen van één uniek feit) en multi-needle reasoning (het combineren van twee gerelateerde feiten die beide op verschillende dieptes in het midden verborgen liggen). Waar modellen op single-needle tests vaak nog redelijke resultaten halen, verloopt de accuratesse bij multi-needle opgaven in het midden beduidend moeizamer. ## Het systematische meetprotocol: de dieptematrix Een robuust meetprotocol vereist een gecontroleerde rasterevaluatie. Er wordt een matrix gedefinieerd waarbij de totale contextlengte wordt uitgezet tegen de relatieve diepte. Om betrouwbare statistiek te verzamelen, wordt elke cel in het raster herhaald met verschillende zaadwaarden en variërende documentfragmenten. Illustratief rekenvoorbeeld: De onderstaande matrix dient ter illustratie van de meetopzet en vormt geen universeel benchmarkresultaat voor specifieke modellen. Prestaties variëren per taak, kwantisatie en promptopbouw. Diepte / Lengte | Korte context | Middelmatige context | Lange context | Zeer lange context | 0% (Begin) | Sterk | Sterk | Sterk | Goed | 25% (Kwart) | Sterk | Goed | Matig | Laag | 50% (Midden) | Goed | Matig | Laag | Kritiek | 75% (Driekwart) | Sterk | Goed | Matig | Laag | 100% (Einde) | Sterk | Sterk | Sterk | Goed | De bovenstaande tabel toont het kwalitatieve patroon van degradatie: bij kortere contexten blijft de prestatie over de hele as behouden, maar bij maximale lengtes keldert de accuratesse in het midden. Om dergelijke testbestanden op te bouwen, kan de interactieve [needle-in-a-haystack generator tool](https://benchmark.llmnet.nl/tool-needle-haystack-generator) worden gebruikt voor het samenstellen van gestandaardiseerde invoerbestanden met configureerbare dieptes. ## Ruisdistributie en Nederlandstalige specificiteit De samenstelling van de achtergrondtekst beïnvloedt de uitkomst van de meting enorm. Wanneer de achtergrondtekst bestaat uit monotone herhalingen van één zin, is de contrastverhouding tussen de naald en de ruis onrealistisch hoog. Aandachtsmechanismen kunnen een afwijkend feitje in synthetische ruis veel eenvoudiger isoleren dan in realistische documenten. Voor een betrouwbare evaluatie moet de ruis bestaan uit semantisch coherent materiaal binnen hetzelfde domein als de vraag. Test men een juridische zoektoepassing, dan wordt de context gevuld met authentieke gerechtelijke uitspraken of wetsartikelen. Test men softwareanalyse, dan worden daadwerkelijke broncodebestanden gebruikt. Hierbij speelt ook een specifieke Nederlandstalige valkuil een rol. Het Nederlands maakt uitgebreid gebruik van lange samenstellingen en complexe tangconstructies waarbij werkwoorden ver uit elkaar worden geplaatst. Tokenizers splitsen lange Nederlandse samenstellingen vaak op in meerdere sub-tokens. Hierdoor neemt het absolute tokenvolume per informatieve eenheid toe in vergelijking met Engels. Als een sleutelwoord in het midden van de tekst wordt opgeknipt in zeldzame sub-tokens, verlaagt dit de aandachtsactivatie verder, wat het lost-in-the-middle effect in Nederlandstalige teksten merkbaar kan versterken. ## Scoringsmechanismen en beoordelingsfouten Het bepalen of een antwoord correct is, lijkt triviaal bij feitelijke vragen, maar kent subtiele methodologische valkuilen. Er zijn drie primaire scoringsmethoden: - Exacte String Match (Regex): Controleert of de exacte sleutelwaarde aanwezig is in de uitvoer. Dit is snel en deterministisch, maar kan vals-negatieven opleveren als het model het antwoord parafraseert. - F1-score over sub-tokens: Berekent de overlap tussen de gegenereerde tokens en het referentie-antwoord. Biedt meer nuance, maar kan bij ontkennende ziningangen misleidend zijn. - LLM-as-a-Judge: Een extern evaluatiemodel beoordeelt of het gegenereerde antwoord semantisch correct is op basis van de bronnaald. Dit vangt parafrases af, maar introduceert een eigen foutmarge en extra tokenkosten. Een veelvoorkomende fout is dat een model begint te hallucineren op basis van de omringende achtergrondtekst in plaats van de specifieke naald te gebruiken. Als de scoringsmethode enkel zoekt naar termen die ook elders in het document voorkomen, wordt een hallucinatie onterecht als correct gemarkeerd. De naald moet daarom altijd een unieke identifier of sleutelwaarde bevatten die nergens anders in de testcontext voorkomt. ## Statistiek, herhalingen en steekproefgrootte Een enkele meting per cel in de matrix is statistisch waardeloos. LLM's vertonen lichte niet-deterministische variatie als gevolg van floating-point afrondingen bij parallelle berekeningen. Bovendien hangt de aandachtsfocus sterk af van de exacte tokenposities van omringende leestekens. Elke cel in de testmatrix vereist meerdere onafhankelijke herhalingen met gerandomiseerde naaldwaarden en verschillende segmentvolgordes van de achtergrondtekst. Raadpleeg de richtlijnen over [statistiek voor LLM-evaluaties](https://benchmark.llmnet.nl/statistiek-voor-evaluaties) om te berekenen hoe betrouwbaarheidsintervallen zich gedragen bij toenemende steekproefomvang. Wanneer een cel een matige trefzekerheid laat zien op basis van enkele runs, is het werkelijke betrouwbaarheidsinterval breed. Pas bij voldoende herhalingen per cel verkrijgt men voldoende resolutie om met zekerheid vast te stellen of een daling op de middelste diepte significant verschilt van de score aan de randen. ## Praktische meetopzet in Python Hieronder staat een modulair Python-script dat een systematische dieptetest uitvoert. Het script genereert een context, injecteert een unieke naald op een gespecificeerd percentage van de totale lengte, roept het te testen model aan via een gestandaardiseerde API-interface en evalueert het resultaat. import math import random import time from typing import List, Dict, Tuple # Constanten voor de evaluatiematrix DEPTH_PERCENTAGES = [0.0, 0.25, 0.50, 0.75, 1.0] CONTEXT_LENGTHS = [4000, 8000, 16000, 32000] RUNS_PER_CELL = 10 def generate_background_corpus(target_tokens: int) -> str: """Genereert achtergrondtekst op basis van alinea's.""" base_paragraph = ( "De inspectie van industriële installaties vereist periodieke controle " "van hydraulische systemen, sensordata en mechanische toleranties. " "Afwijkingen in drukprofielen moeten direct worden gelogd in het " "centrale onderhoudsregister conform de geldende veiligheidsnormen.\n\n" ) words_needed = int(target_tokens / 1.3) paragraph_words = len(base_paragraph.split()) repeats = math.ceil(words_needed / paragraph_words) return (base_paragraph * repeats)[:words_needed * 6] def inject_needle( haystack: str, needle: str, depth_fraction: float ) -> str: """Plaatst de naald op de relatieve diepte van het document.""" paragraphs = haystack.split("\n\n") total_p = len(paragraphs) insert_idx = int(total_p * depth_fraction) insert_idx = min(max(insert_idx, 0), total_p) paragraphs.insert(insert_idx, needle) return "\n\n".join(paragraphs) def evaluate_response(response: str, secret_key: str) -> bool: """Controleert op deterministische aanwezigheid van de sleutel.""" return secret_key.lower() in response.lower() def run_depth_benchmark( model_name: str, api_client ) -> Dict[Tuple[int, float], float]: results = {} for length in CONTEXT_LENGTHS: for depth in DEPTH_PERCENTAGES: successes = 0 for run_id in range(RUNS_PER_CELL): secret_id = f"NL-VAL-{random.randint(100000, 999999)}" needle = ( f"BELANGRIJK DOSSIERKENMERK: Het unieke autorisatienummer " f"voor deze specifieke sessie is {secret_id}." ) prompt_question = ( "Wat is het unieke autorisatienummer voor deze sessie? " "Geef uitsluitend de code terug." ) raw_haystack = generate_background_corpus(length) full_context = inject_needle(raw_haystack, needle, depth) messages = [ {"role": "system", "content": "Je bent een feitelijke data-assistent."}, {"role": "user", "content": f"{full_context}\n\nVraag: {prompt_question}"} ] response = api_client.chat.completions.create( model=model_name, messages=messages, temperature=0.0, max_tokens=50 ) output_text = response.choices[0].message.content if evaluate_response(output_text, secret_id): successes += 1 accuracy = successes / RUNS_PER_CELL results[(length, depth)] = accuracy print(f"Lengte: {length} | Diepte: {depth*100}% | Score: {accuracy*100:.1f}%") return results ## Tokenbudgettering en evaluatiekosten Het benchmarken van lange contexten is financieel en computationeel kostbaar. Een matrix van meerdere lengtes en dieptes bevat al snel tientallen cellen. Bij meerdere herhalingen per cel resulteert dit in honderden afzonderlijke API-aanroepen. Illustratief rekenvoorbeeld: Stel dat een testreeks bestaat uit 50 runs over een gecombineerd volume van 248.000 tokens per cyclus, resulterend in een totaalverbruik van 12.400.000 tokens. Bij een aangenomen hypothetisch tarief van bijvoorbeeld 2,50 euro per miljoen invoertokens, kost een enkele benchmarkrun ruwweg 30 euro. Uitbreiding naar uitgebreide statistische validatie kan oplopen tot 150 euro per geteste modelversie. Dit betreft een theoretisch rekenvoorbeeld om de kostenstructuur te duiden; werkelijke tarieven verschillen per provider en modelklasse. Zie de analyse over [de kosten van evalueren bij LLM-toepassingen](https://benchmark.llmnet.nl/kosten-van-evalueren) voor strategieën om via trapsgewijze sampling en lokale proxy-modellen het testbudget te beheersen zonder aan zeggingskracht in te boeten. ## Architecturale mitigaties valideren Zodra de meetresultaten aantonen dat een model last heeft van het lost-in-the-middle effect, hoeft het model niet direct te worden afgedankt. De meting dient als nulmeting om architecturale verzachtingen te valideren. De meest effectieve ingreep is het herordenen van documenten vóórdat ze aan de prompt worden toegevoegd. In plaats van documenten lineair op volgorde van relevantie te plaatsen, worden ze gesorteerd volgens een alternerend patroon. Hierdoor belanden de meest relevante brokken aan het begin en aan het absolute einde van de context, precies waar de aandachtsmechanismen het sterkst presteren. Zie het artikel over [lost-in-the-middle voorkomen met slimme contextvolgorde](https://community.llmnet.nl/lost-in-the-middle-voorkomen-met-slimme-contextvolgorde) voor concrete implementaties van dergelijke sorteeralgoritmen in Python. Na implementatie van zo'n algoritme wordt exact hetzelfde meetprotocol opnieuw uitgevoerd. Pas wanneer de dieptematrix een evenwichtig patroon vertoont over alle posities, is de applicatie gereed voor veilige productie-inzet. ## Van testmatrix naar besluit Het meten van het lost-in-the-middle effect transformeert vage aannames over contextvensters in harde technische kaders. Een model dat claimt enorme hoeveelheden tokens te ondersteunen, kan in werkelijkheid slechts tot een fractie daarvan betrouwbaar presteren wanneer informatie gelijkmatig verdeeld is over de invoer. Door periodiek de prestatiecurve over verschillende lengtes en dieptes te kwantificeren, voorkomt men kostbare productiefouten en kiest men gefundeerd tussen pure prompt-invoer of een hybride architectuur met dynamische documentherschikking.