Small Language Model

Wat is een Small Language Model?

Een small language model (SLM) is een compact taalmodel, typisch onder ongeveer tien miljard parameters, ontworpen om snel en goedkoop te draaien, vaak op één GPU, een laptop, of een telefoon. Het ruilt de piekcapaciteit van frontier-modellen in voor lage latentie, lage kosten, dataprivacy, en de optie om on-device te implementeren.

De belangrijkste punten

• Grootte is relatief en blijft bewegen. In 2026 betekent "klein" meestal ongeveer 1B tot 10B parameters, en de beste modellen in dat bereik presteren beter dan de 175B-klasse-modellen van een paar jaar geleden op veel taken.
• SLM's winnen op economie: kosten per token kunnen één of twee ordes van grootte onder een frontier-model liggen, en latentie daalt genoeg om real-time- en on-device-gebruik mogelijk te maken.
• Het praktische patroon is routing, het gros van simpel, hoogvolume-werk (classificatie, extractie, samenvatting) naar een SLM sturen en moeilijke gevallen escaleren naar een groter model.
• Een fine-getunede SLM verslaat vaak een geprompte frontier-model op één smalle taak, terwijl hij zwaar verliest op open-einde redenering.
• On-device-implementatie houdt gevoelige data lokaal, wat ertoe doet voor gereguleerde sectoren en privacygevoelige producten.

Hoe het werkt

Architecturaal is een small language model hetzelfde transformer-ontwerp als een large language model, gewoon met minder lagen, smallere verborgen dimensies, en vaak een korter contextvenster. Wat de afgelopen jaren veranderde is hoeveel capaciteit in dat budget past. Betere datacuratie, langere trainingsruns, en model distillation, waar een groot leraarmodel trainingssignaal genereert voor een kleine student, betekenen dat moderne SLM's ver boven hun parameteraantal uitstijgen. Google DeepMinds Gemma 2-lijn toont het distillatie-effect direct: zijn 2B- en 9B-varianten werden getraind via distillatie, en de familie presteert competitief met modellen twee tot drie keer groter [1]. Families zoals Phi, Gemma, Qwen, en de kleinere varianten van Llama zijn de referentiepunten die de meeste teams eerst evalueren.

Implementatie is waar SLM's afwijken van hun grotere broers en zussen. Omdat de gewichten in een paar gigabytes passen, vooral na kwantisering ze comprimeert tot 8-bit- of 4-bit-precisie, kan een SLM op consumentenhardware draaien via runtimes zoals llama.cpp, Ollama, of on-device-frameworks van Apple en Google. Dat ontgrendelt drie dingen tegelijk: inferentie zonder per-token-API-rekening, antwoorden in tientallen milliseconden, en data die het apparaat nooit verlaat. Aan het extreme uiteinde is het stroombudget minuscuul: Google meldde in 2025 dat zijn Gemma 3 270M van 270 miljoen parameters, gekwantiseerd naar INT4, slechts 0,75% van de batterij van een Pixel 9 Pro gebruikte over 25 gesprekken in interne tests [2].

De capaciteitsruil toont in breedte, niet polish. Een SLM behandelt een goed afgebakende taak met duidelijke instructies betrouwbaar, maar verslechtert op meerstaps-redenering, obscure kennis, en lange-horizon-agentwerk waar fouten zich opstapelen over veel stappen. Daarom kiezen productiesystemen zelden tussen klein en groot; ze routeren ertussen.

Voorbeeld

Een klantsupportplatform verwerkt twee miljoen inkomende berichten per dag en moet elk taggen met intentie, sentiment, en urgentie voordat het routeert. Elk bericht door een frontier-model laten lopen zou duizenden dollars per dag kosten en een seconde latentie toevoegen aan elk ticket. Het team fine-tunet een open-weight-model van 8B op 20.000 gelabelde tickets, kwantiseert het naar 4-bit, en bedient het op twee GPU's die ze al bezitten. Nauwkeurigheid op hun evalset landt binnen één punt van het frontier-model, kosten dalen met meer dan 95 procent, en de 4 procent berichten die de SLM als laag-vertrouwen markeert, escaleren naar het grote model. Het frontier-model werd het uitzonderingspad in plaats van de standaard.

Veelvoorkomende misvattingen

De fout is SLM's behandelen als strikt slechtere modellen waar je genoegen mee neemt wanneer budget krap is. Modelkeuze is een fitprobleem: voor een smalle, hoogvolume-taak met een goede evalset matcht of verslaat een getunede kleine model vaak een geprompte frontier-model terwijl hij sneller en privé is. De teams die zich branden zijn degene die een modelgrootte op gevoel kiezen in beide richtingen, triviale classificatie naar een duur frontier-model sturen of een 3B-model vragen een meerstaps-agentworkflow te plannen. Meet met LLM evals op je eigen taak en laat de cijfers de grootte kiezen.

FAQ

Wat telt als SLM versus LLM? Er is geen officiële grens. Gangbaar gebruik in 2026 legt SLM's onder ongeveer 10B parameters, met "tiny"-modellen onder 1B voor embedded gebruik. De lijn blijft verschuiven naarmate kleine modellen capaciteiten absorberen die ooit veel grotere vereisten: Microsofts phi-3-mini, een model van 3,8 miljard parameters getraind op 3,3 biljoen tokens, scoort 69% op MMLU en 8,38 op MT-bench, en rivaliseert met Mixtral 8x7B en GPT-3.5 terwijl het klein genoeg blijft om op een telefoon te draaien [3]. De nuttige vraag is of het model de kwaliteitslat van je taak haalt binnen je latentie- en kostendoelen.

Kan een small language model een AI-agent aandrijven? Voor begrensde agenttaken, ja: tool calling met een kleine toolset, gestructureerde extractie, en routering werken allemaal goed. Lange-horizon-autonoom-werk is moeilijker omdat kleine modellen fouten opstapelen over stappen heen en complexe instructies minder betrouwbaar volgen. De meeste agent-stacks gebruiken een SLM voor de goedkope binnenste-lus-aanroepen en een groter model voor planning.

Hallucineren SLM's meer? Over het algemeen ja, bij kennis-zware vragen, want minder parameters slaan minder feiten op. De mitigatie is dezelfde als voor elk model, grounding via retrieval-augmented generation en strak taakbereik, en een geaarde SLM verslaat vaak een niet-geaard groot model op feitelijke nauwkeurigheid binnen zijn domein.

Bronnen

1. Google DeepMind (arXiv). "Gemma 2-modellen (2B-27B) leveren prestaties competitief met modellen 2-3 keer groter; de 2B- en 9B-varianten werden getraind via kennisdistillatie." https://arxiv.org/abs/2408.00118. Geraadpleegd augustus 2026.
2. Google Developers Blog. "Gemma 3 270M gekwantiseerd naar INT4 gebruikte 0,75% van de batterij van een Pixel 9 Pro over 25 gesprekken in interne tests." https://developers.googleblog.com/en/introducing-gemma-3-270m/. Geraadpleegd augustus 2026.
3. Microsoft Research (arXiv). "phi-3-mini (3,8B, getraind op 3,3T tokens) scoort 69% op MMLU en 8,38 op MT-bench, en rivaliseert met Mixtral 8x7B en GPT-3.5." https://arxiv.org/abs/2404.14219. Geraadpleegd augustus 2026.