Chain-of-Density: Steeds Informatievere Samenvattingen

Samenvatten behoort tot de meest frequent uitgevoerde taken voor grote taalmodellen in productieomgevingen. Toch leveren standaard instructies zoals "vat deze tekst samen in 100 woorden" verrassend vaak teleurstellende resultaten op. Modellen vallen in zo'n scenario terug op een herkenbaar patroon: ze selecteren de meest voor de hand liggende centrale verhaallijn en vullen de resterende ruimte met breedsprakige overgangszinnen, functiewoorden en vage containerbegrippen. Het eindresultaat leest weliswaar vloeiend en grammaticaal vlekkeloos, maar de informatiedichtheid per zin blijft bijzonder laag. Een professional verliest daardoor kostbare tijd met het doornemen van tekst die weinig harde feiten bevat.

De Chain-of-Density (CoD) techniek doorbreekt deze beperking door de informatiedichtheid van een samenvatting stapsgewijs en doelgericht te verhogen binnen een strikt vastgehouden lengtebegrenzing. In plaats van een eenmalige, statische generatie dwingt het algoritme het model om in een opeenvolgende cyclus ontbrekende entiteiten uit de brontekst te identificeren en deze via actieve syntactische herformulering in te weven. In dit artikel ontleden we de wiskundige en taalkundige werking van Chain-of-Density, vergelijken we concrete implementatiesjablonen en presenteren we meetmethodes om entiteitsdichtheid objectief te kwantificeren. Om te bepalen wanneer deze intensieve techniek rendabel is ten opzichte van andere prompting-strategieën, raadpleeg je het overzicht over welke prompttechniek wanneer ingezet wordt.

Het fundamentele probleem van standaard samenvattingen

Wanneer een taalmodel gevraagd wordt om een complex brondocument samen te vatten zonder verdere structurele sturing, optimaliseert het probabilistische generatieproces primair op algemene syntactische samenhang en globale contextrepresentatie. Dit leidt tot een uitgesproken voorkeur voor grammaticale vulling: bijzinnen die beginnen met "het is belangrijk om op te merken dat", passieve constructies en repetitieve parafraseringen. Het model kiest de statistisch veiligste weg om het gevraagde aantal woorden vol te maken zonder feitelijke risico's te nemen.

In professionele domeinen zoals financiële audits, juridische documentanalyses, technische storingsrapportages of klinische dossiers is deze traditionele vorm van samenvatten ronduit ineffectief. Een beleggingsanalist of ingenieur heeft geen behoefte aan algemeenheden zoals "het bestuur heeft operationele wijzigingen doorgevoerd om de marktpositie te versterken". Er is directe behoefte aan de exacte parameters: welke productielocaties zijn gesloten, welke patenten zijn verworven, welke omzetdaling in procenten is geregistreerd en welke sleutelfiguren zijn vervangen. Wie de onderliggende basisprincipes van lengtebeheersing en brontrouw wil doorgronden, kan terecht bij de gids over samenvattingsprompts die kloppen.

Het simpelweg instrueren van een model om "zoveel mogelijk feiten en entiteiten" op te nemen in een single-shot prompt faalt steevast. Onder zulke ongecontroleerde druk ontstaan twee uitersten: het model verliest zijn grammaticale integriteit en produceert een onsamenhangende lijst van losse trefwoorden, of het negeert de opgegeven lengterestrictie volledig en genereert alsnog een langdradig document. Chain-of-Density biedt een gecontroleerd, wiskundig en taalkundig raamwerk om deze wisselwerking tussen informatielading, lengtebegrenzing en grammaticale coherentie stap voor stap te perfectioneren.

Wat is Chain-of-Density (CoD)?

Chain-of-Density is een gespecialiseerde promptengineering-methode waarbij een taalmodel een reeks van opeenvolgende samenvattingen produceert, traditioneel opgebouwd uit vijf iteratieve stappen. Het proces begint bewust met een initiële samenvatting die opzettelijk "luchtig" en breedsprakig van opzet is. Deze eerste versie dekt de grote lijnen van het brondocument af, maar bevat relatief weinig specifieke zelfstandige naamwoorden, cijfers of unieke namen.

Vanaf iteratie twee voert het model bij elke doorgang twee nauw met elkaar verweven handelingen uit:

• Entiteitsidentificatie: Het model scant de brontekst en selecteert één tot drie specifieke, informatieve entiteiten (Missing Entities) die cruciaal zijn voor het begrip van het onderwerp, maar nog niet in de voorafgaande samenvatting voorkomen. Wie entiteitsherkenning als losstaande taak wil inrichten, kan de patronen voor data-extractie uit ongestructureerde tekst raadplegen.
• Compressieve integratie: Het model herschrijft de voorgaande samenvatting volledig. De nieuwe entiteiten worden ingevoegd, terwijl het totale aantal woorden strikt binnen de oorspronkelijke limiet moet blijven.

Omdat het totale aantal woorden tijdens alle stappen constant blijft, dwingt de prompt het model tot agressieve stilistische reductie. Vaste uitdrukkingen, lege signaalwoorden en passieve constructies moeten wijken voor compacte apposities, samengestelde zelfstandige naamwoorden en directe actiewerkwoorden. Het proces stopt wanneer de maximale entiteitsverzadiging is bereikt. Dit resulteert in een reeks teksten met een strak oplopende informatiedichtheid.

Deze werkwijze verschilt fundamenteel van technieken die puur gericht zijn op het reduceren van tokenvolumes voor machine-invoer. Terwijl men bij prompt-compressie voor lange contexten vaak pragmatisch filtert op relevantie om downstream API-kosten te verlagen, optimaliseert Chain-of-Density primair voor menselijke informatieverwerking: het maximaliseren van de feitelijke overdracht per seconde leestijd.

Het stapsgewijze CoD-algoritme ontleed

Om de mechanica van deze transformatie te doorgronden, analyseren we de vijf typische stappen van het Chain-of-Density proces. Hierbij hanteren we de strikte definitie van een Missing Entity: een specifiek feit, kwantitatieve waarde, persoonsnaam, geografische aanduiding, organisatie of causale gebeurtenis die direct afkomstig is uit het brondocument maar ontbrak in de direct voorafgaande samenvatting.

Het bepalende mechanisme achter het succes van dit algoritme is de expliciete scheiding tussen identificatie en integratie. Doordat de prompt voorschrijft dat het model eerst de lijst met Missing_Entities als tussenstap moet genereren voordat de nieuwe samenvatting wordt geschreven, fungeert deze lijst als een extern werkgeheugen. Het model activeert hiermee de relevante aandachtsvectoren in het neurale netwerk, wat hallucinaties tijdens de daaropvolgende compressieslag drastisch reduceert.

Een illustratief voorbeeld: 5 iteraties van een fictief ICT-incident

Om de transformatie in de praktijk te demonstreren, bekijken we een illustratief, verzonnen voorbeeld over een IT-calamiteit. De fictieve casus beschrijft een netwerkstoring bij de verzonnen instelling Ziekenhuis De Noorderbrug, veroorzaakt door een foutieve firmware-update van de hypothetische leverancier MedTech Systems, waardoor 28 geplande behandelingen moesten worden verplaatst en lokale noodstroomvoorzieningen werden ingezet.

Iteratie 1 (Luchtig, weinig specifiek — 54 woorden)

"Er heeft recent een aanzienlijke technische storing plaatsgevonden in een regionaal ziekenhuis, waardoor de reguliere werkzaamheden ernstig werden verstoord. Diverse medische ingrepen moesten uit voorzorg worden geannuleerd om de veiligheid van patiënten te waarborgen. De organisatie heeft direct maatregelen getroffen om de systemen te herstellen en onderzoekt momenteel de exacte toedracht van het incident."

Geïdentificeerde entiteiten: regionaal ziekenhuis (1 entiteit op 54 woorden = dichtheid 0.02).

Iteratie 2 (Toevoegen van Ziekenhuis De Noorderbrug, firmware-update, serveruitval — 55 woorden)

"Een mislukte firmware-update veroorzaakte een acute serveruitval in Ziekenhuis De Noorderbrug, waardoor de reguliere zorgverlening tijdelijk werd lamgelegd. Verschillende geplande medische ingrepen moesten per direct worden geannuleerd om risico's voor patiënten te vermijden. Het IT-team schakelde direct over op noodprotocollen om de vitale databases veilig te herstellen en de bronoorzaak grondig te analyseren."

Nieuwe entiteiten: firmware-update, serveruitval, Ziekenhuis De Noorderbrug (4 entiteiten op 55 woorden = dichtheid 0.07).

Iteratie 3 (Toevoegen van MedTech Systems, 28 geplande behandelingen — 53 woorden)

"Een defecte firmware-update van leverancier MedTech Systems legde de centrale database van Ziekenhuis De Noorderbrug plat. Hierdoor moesten artsen 28 geplande behandelingen uitstellen en overschakelen op noodprocedures. Technische teams activeerden direct herstelprotocollen om de patiëntveiligheid te waarborgen en de integriteit van medische dossiers handmatig te controleren."

Nieuwe entiteiten: MedTech Systems, centrale database, 28 geplande behandelingen (7 entiteiten op 53 woorden = dichtheid 0.13).

Iteratie 4 (Toevoegen van noodstroomvoorzieningen, data-integriteitscontrole — 52 woorden)

"Door MedTech Systems' defecte firmware-update crashte de Noorderbrug-database, wat leidde tot uitstel van 28 behandelingen en inschakeling van noodstroomvoorzieningen. Specialisten controleerden handmatig de data-integriteit van patiëntendossiers terwijl noodprotocollen draaiden. Binnen vier uur herstelden technici de servers zonder blijvend dataverlies voor de klinische afdelingen."

Nieuwe entiteiten: noodstroomvoorzieningen, data-integriteit patiëntendossiers, vier uur (10 entiteiten op 52 woorden = dichtheid 0.19).

Iteratie 5 (Maximale verzadiging — 51 woorden)

"MedTech Systems' defecte firmware-update crashte Noorderbrugs centrale database: 28 behandelingen uitgesteld, noodstroomvoorzieningen ingeschakeld en dossiers handmatig gevalideerd op data-integriteit. Klinische teams handhaafden noodprotocollen terwijl IT-specialisten binnen vier uur volledige serverfunctionaliteit herstelden zonder patiëntgeheugenschade of structureel dataverlies."

Nieuwe entiteiten: handmatige validatie, volledige serverfunctionaliteit, structureel dataverlies (13 entiteiten op 51 woorden = dichtheid 0.25).

In dit voorbeeld is duidelijk zichtbaar hoe iteratie 3 en 4 een uitstekend evenwicht bewaren tussen rijke context en vlotte leesbaarheid, terwijl iteratie 5 zeer compact is en een hogere cognitieve inspanning van de lezer vraagt.

Meetmethoden voor informatiedichtheid in tekst

Om Chain-of-Density objectief te evalueren in geautomatiseerde pipelines, volstaat een subjectief oordeel niet. Er zijn formele metrieken nodig om vast te stellen of een model daadwerkelijk entiteiten toevoegt zonder de lengtebeperking te schenden. In de praktijk worden drie complementaire meetmethodes gehanteerd:

1. Directe Entiteitsdichtheid (Entity Density Metric): Dit is de verhouding tussen het aantal unieke geëxtraheerde entiteiten en het totale aantal woorden in de samenvatting:

   Dichtheid = (Aantal Unieke Entiteiten) / (Totaal Aantal Woorden)

   Hierbij wordt gebruikgemaakt van een Named Entity Recognition (NER) pipeline (zoals spaCy of een gespecialiseerd extractiemodel) om persoonsnamen, organisaties, locaties, datums en numerieke waarden te tellen. Een gezonde CoD-reeks toont een strakke stijging van circa 0.08 in iteratie 1 naar ruim 0.22 in iteratie 5.
2. Token-to-Fact Ratio (TFR): Deze metriek berekent hoeveel afzonderlijke feitelijke beweringen (proposities) een tekstfragment bevat per 100 gegenereerde tokens. Dit gebeurt vaak via een LLM-as-a-Judge opstelling die de tekst ontleedt in atomaire feiten en controleert of deze feiten direct herleidbaar zijn tot de brontekst.
3. Leesbaarheidsindex (Flesch-Kincaid & Gunning Fog): Naarmate de entiteitsdichtheid toeneemt, daalt de traditionele leesbaarheidsscore onvermijdelijk doordat zinnen complexer worden en het percentage meerlettergrepige woorden stijgt. Het monitoren van deze score voorkomt dat een model doorschiet naar onbegrijpelijke telegramstijl.

Een robuuste Chain-of-Density prompt in de praktijk

Voor een stabiele werking in productie via API-koppelingen is een strikte instructiestructuur onmisbaar. Zonder expliciete schema-definities vertonen taalmodellen de neiging om na de tweede iteratie de woordlimiet te overschrijden of entiteiten te verzinnen. Om te voorkomen dat het model buiten het JSON-formaat treedt, is de handleiding over vorm afdwingen vanuit de prompt zelf essentieel voor een betrouwbare parseerbare structuur.

You will generate increasingly concise, entity-dense summaries of the provided article.

Guidelines:
- Carefully read the source text and identify core information and specific entities.
- You will perform exactly 5 sequential iterations of summarization.
- Each summary must be EXACTLY between 50 and 65 words long.
- Summary 1 must be informative but verbose, containing few specific entities (broad overview).
- For Summaries 2 through 5:
  1. Identify 1 to 3 Missing Entities from the article that are NOT present in the previous summary.
  2. Rewrite the previous summary to seamlessly integrate these new entities.
  3. Keep the total word count strictly within the 50-65 word limit.
  4. Make space by fusing sentences, removing conversational filler, and using dense phrasing.
  5. Never invent facts; every entity must be grounded in the source text.

Output strictly valid JSON matching this schema:
[
  {
    "iteration": 1,
    "missing_entities": [],
    "word_count": 58,
    "summary": "..."
  },
  {
    "iteration": 2,
    "missing_entities": ["Entity A", "Entity B"],
    "word_count": 61,
    "summary": "..."
  },
  {
    "iteration": 3,
    "missing_entities": ["Entity C", "Entity D"],
    "word_count": 59,
    "summary": "..."
  },
  {
    "iteration": 4,
    "missing_entities": ["Entity E"],
    "word_count": 62,
    "summary": "..."
  },
  {
    "iteration": 5,
    "missing_entities": ["Entity F", "Entity G"],
    "word_count": 60,
    "summary": "..."
  }
]

Article text:
{{ARTICLE_TEXT}}

Bij het uitrollen van dergelijke prompts over diverse modelarchitecturen is het verstandig om systematisch te evalueren welk model de beste compressie levert zonder hallucinaties te introduceren. Voor het opzetten van betrouwbare evaluatiestudies biedt de methodiek voor A/B-testen van prompts de nodige handvatten om varianten kwantitatief tegen elkaar af te zetten.

Entiteitsdichtheid versus menselijke leesbaarheid: de afweging

Een hogere informatiedichtheid is niet onder alle omstandigheden wenselijk. Uit uitgebreide menselijke evaluaties blijkt consistent dat lezers een sterke voorkeur hebben voor samenvattingen uit iteratie 3 of iteratie 4. Iteratie 1 en 2 worden beoordeeld als te vaag en inefficiënt, terwijl iteratie 5 door velen als vermoeiend en stilistisch stroef wordt ervaren.

Wanneer de entiteitsdichtheid boven de grens van circa 0.22 entiteiten per woord stijgt, treden specifieke cognitieve en taalkundige fricties op:

• Verdwijnen van causale verbanden: Om ruimte te besparen verwijdert het model verbindingswoorden zoals "omdat", "waardoor" en "gevolgtrekking". Hierdoor verandert de tekst van een samenhangend betoog in een aaneenschakeling van losse feitelijke constateringen, waardoor de lezer zelf causale verbanden moet construeren.
• Syntactische overbelasting: Door het veelvuldig stapelen van bijvoeglijke bepalingen en samengestelde zelfstandige naamwoorden ontstaan zinnen met een extreem hoge informatiedruk. De lezer moet zinnen meerdere keren herlezen om te ontleden welke bepaling bij welk kernwoord hoort.
• Verhoogde cognitieve belasting: Hoewel de fysieke tekst kort is, neemt de verwerkingstijd per woord aanzienlijk toe. Voor snelle scanning door mensen is een gematigde dichtheid (stap 3) daardoor productiever dan maximale compressie (stap 5).

Voor geautomatiseerde verwerkingsketens geldt echter het omgekeerde: zoekmachines, semantische vectordatabases en geautomatiseerde kennissystemen functioneren juist optimaal bij iteratie 5, omdat deze versie de maximale hoeveelheid doorzoekbare trefwoorden en relaties bevat binnen een minimaal aantal tokens.

Valkuilen, modeldrift en hallucinaties bij CoD

Het forceren van een taalmodel om te comprimeren brengt aanzienlijke risico's met zich mee. Doordat het model onder zware druk staat om zowel nieuwe entiteiten op te nemen als de lengte te bewaken, treden specifieke foutpatronen frequenter op dan bij standaard generatieve taken.

Het meest verraderlijke fenomeen is Entity Fusion Hallucination (entiteitsversmelting). Wanneer een model twee afzonderlijke zinnen probeert samen te voegen tot één compacte zin, bestaat het gevaar dat eigenschappen van het ene object per ongeluk worden toegeschreven aan het andere. Als de brontekst vermeldt dat "Systeem X een geheugenlek vertoonde" en "Server Y oververhit raakte door koelingsproblemen", kan een overgecomprimeerde stap 4-samenvatting onterecht melden dat "Systeem X oververhit raakte door een geheugenlek". Deze fouten zijn voor menselijke lezers lastig te spotten omdat de namen en termen daadwerkelijk in de brontekst voorkomen.

Een tweede risico is lengtedrift. Met name compactere en lokaal draaiende modellen verliezen rond iteratie 3 vaak de controle over de woordbegrenzing. Ze voegen de nieuwe entiteiten keurig toe, maar slagen er niet in om voldoende bestaande tekst weg te snijden. Het resultaat is een cumulatieve groei van de tekstlengte, waardoor het basisprincipe van Chain-of-Density teniet wordt gedaan. Dit vereist geautomatiseerde validatielagen op de API-output.

Kosten, latency en optimalisatie in productie

Het grootste praktische nadeel van Chain-of-Density in productieomgevingen betreft de operationele kosten en de verwerkingstijd. Omdat het model in één enkele aanroep vijf volledige samenvattingen sequentieel moet genereren, verbruikt de taak aanzienlijk meer output-tokens dan een standaard samenvatting. Bovendien kan het genereren van vijf iteraties enkele seconden duren, wat ongewenst is voor interactieve gebruikersinterfaces. Een gedetailleerde analyse van de financiële impact van dit verhoogde tokenvolume vind je in het artikel over wat een prompt kost qua tokens, caching en de rekening.

Om deze knelpunten op te lossen, kunnen organisaties gerichte architectuurkeuzes maken. Door standaard te stoppen bij iteratie 3 bespaart men meer dan de helft op de tokenkosten, terwijl de gegenereerde tekst precies aansluit bij de menselijke voorkeur. Voor grootschalige systemen kan een tweetraps-architectuur worden ingericht: een klein, snel model extraheert eerst alle kernentiteiten, waarna een groter model in één gerichte stap een samenvatting met een vooraf ingestelde doeldichtheid genereert.

Conclusie en implementatierichtlijnen

Chain-of-Density transformeert tekstsamenvatting van een passieve schrijfopdracht naar een gecontroleerd, meetbaar compressieproces. Door taalmodellen expliciet te dwingen tot het identificeren en invlechten van ontbrekende entiteiten binnen een vaste woordlimiet, wordt het maximale rendement gehaald uit elke gegenereerde zin.

Bij het inrichten van productiepipelines rondom CoD gelden drie centrale richtlijnen: stem het aantal iteraties af op de eindgebruiker (stap 3 voor menselijke consumptie, stap 5 voor vectordatabases), implementeer strikte validatie tegen entiteitsversmelting, en kies voor vroegtijdige stopzetting om tokenkosten en latency onder controle te houden. Daarmee vormt Chain-of-Density een onmisbaar precisie-instrument in het arsenaal van de moderne prompt engineer.