Batchgrootte: hoeveel voorbeelden leert een AI-model tegelijk?

Bijgewerkt: 9 september 2026 · 6 min leestijd

Stel je bent leraar en moet een stapel van duizend proefwerken nakijken. Na elk proefwerk zou je je lesmethode kunnen bijstellen op basis van de fouten die je ziet, maar dat is grillig: één opvallend slecht proefwerk kan je meteen op het verkeerde been zetten. Je zou ook kunnen wachten tot je de hele stapel hebt nagekeken voordat je iets verandert, maar dan duurt het lang voordat je bijstuurt en heb je onderweg geen idee of je aanpassingen zin hebben. De meeste leraren kiezen een tussenweg: na elke stapel van bijvoorbeeld dertig proefwerken evalueren ze en passen ze hun aanpak aan.

Precies zo werkt batchgrootte (het Engelse batch size) bij het trainen van kunstmatige intelligentie. Een AI-model leert door voorbeelden te bekijken en zijn interne instellingen — de zogeheten gewichten — telkens een beetje bij te stellen. De batchgrootte bepaalt hoeveel voorbeelden het model tegelijk bekijkt voordat het die gewichten aanpast. Bij een batchgrootte van 32 kijkt het model dus naar 32 foto's, zinnen of andere datapunten, berekent het gemiddeld hoeveel het ernaast zat, en past het zijn instellingen daarop aan. Dit klinkt technisch, maar de keuze voor deze ene instelling heeft grote gevolgen voor hoe snel, hoe stabiel en hoe goed een model uiteindelijk leert.

Wat is het precies?

Het trainen van een neuraal netwerk gebeurt met een methode die gradient descent heet, oftewel gradiëntafdaling: het model probeert stap voor stap de fouten te verkleinen die het maakt op de trainingsdata. Bij elke stap wordt berekend in welke richting de gewichten aangepast moeten worden om de fout iets kleiner te maken.

De vraag is: op basis van hoeveel voorbeelden bereken je die richting? Dat is precies wat de batchgrootte vastlegt. Er zijn twee uitersten. Aan de ene kant kun je na één enkel voorbeeld al bijstellen; dat heet stochastische gradiëntafdaling (SGD) en heeft een batchgrootte van 1. Aan de andere kant kun je wachten tot je de heële trainingsdataset — soms miljoenen voorbeelden — hebt doorgerekend voor je één keer bijstelt; dat heet full-batch training. In de praktijk kiest men vrijwel altijd voor iets ertussenin: een mini-batch van bijvoorbeeld 32, 64, 128, 256 of duizenden voorbeelden. Deze getallen zijn vaak machten van twee, omdat de rekenchips (GPU's en TPU's) die AI-modellen trainen daar het efficiëntst mee omgaan.

Een volledige doorloop van de hele trainingsdataset heet een epoch. Als een dataset 10.000 voorbeelden telt en de batchgrootte is 100, dan bestaat één epoch uit 100 updatestappen, ook wel iteraties genoemd. Een kleinere batchgrootte betekent dus meer, maar kleinere updatestappen per epoch; een grotere batchgrootte betekent minder, maar grotere stappen.

Die keuze heeft een prijs. Kleine batches geven een ruisige schatting van de juiste richting — gebaseerd op weinig voorbeelden kan de berekende richting toevallig afwijken van wat voor de hele dataset optimaal zou zijn. Die ruis is niet alleen een nadeel: onderzoek laat zien dat ze het model soms juist helpt om niet vast te lopen in ongunstige plekken in de zoekruimte, en dat modellen die met kleinere batches trainen vaak beter generaliseren naar nieuwe data. Grote batches geven een preciezere, gladdere schatting van de richting en maken optimaal gebruik van parallelle rekenkracht, waardoor elke stap sneller verwerkt wordt. Maar ze hebben doorgaans meer geheugen nodig, en boven een bepaalde grootte moet ook de leersnelheid (hoe groot de aanpassing per stap is) zorgvuldig worden meegeschaald, anders verslechtert juist de kwaliteit van het eindresultaat.

Wat wil men ermee bereiken?

De kernvraag achter onderzoek naar batchgrootte is: hoe train je grote AI-modellen zo snel en goedkoop mogelijk, zonder in te leveren op kwaliteit? Moderne modellen worden getraind op clusters met honderden of duizenden GPU's of TPU's tegelijk. Een grotere batchgrootte maakt het mogelijk om al die rekenchips tegelijk aan het werk te zetten — elke chip verwerkt een deel van de batch, en pas na de hele batch worden de resultaten samengevoegd. Zonder voldoende grote batches zou dure hardware voor een deel stil staan te wachten, wat training onnodig traag en kostbaar maakt.

Tegelijk wil men de kwaliteit van het model niet opofferen. Onderzoekers zoeken daarom naar het punt waarop een grotere batch nog steeds tot een even goed of beter model leidt, zonder dat de trainingstijd per stap verspild wordt aan te kleine, inefficiënte batches. Batchgrootte is dus een balans tussen twee doelen die elkaar deels tegenwerken: rekenefficiëntie (snelheid en kosten) en generalisatie (hoe goed het model presteert op nieuwe, ongeziene data).

Voorbeelden uit de praktijk

In 2017 publiceerde een team van Facebook AI Research, onder leiding van Priya Goyal, het invloedrijke artikel “Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour”. Door een batchgrootte van 8192 te combineren met 256 GPU's tegelijk en een zorgvuldig opgebouwde leersnelheid, trainden zij een ResNet-50-beeldherkenningsmodel op de ImageNet-dataset in ongeveer een uur — een training die daarvoor dagen kostte, zonder verlies aan nauwkeurigheid.

In 2019 ontwikkelde Yang You, destijds verbonden aan UC Berkeley en Google, samen met collega's de LAMB-optimalisatietechniek (Layer-wise Adaptive Moments for Batch training). Daarmee werd het mogelijk om taalmodel BERT te trainen met batchgroottes tot enkele tienduizenden voorbeelden tegelijk, wat de trainingstijd van ongeveer drie dagen terugbracht tot iets meer dan een uur op grote clusters.

OpenAI's taalmodel GPT-3, gepresenteerd in 2020, gebruikte tijdens de training een batchgrootte die opliep tot 3,2 miljoen tokens (tokens zijn de tekstdeeltjes waarin taalmodellen tekst opknippen). Zo'n enorme batchgrootte was nodig omdat het model, met 175 miljard parameters, alleen stabiel en efficiënt te trainen was door de rekenlast over zeer veel chips tegelijk te verdelen.

Bij Google's taalmodel PaLM (2022, 540 miljard parameters) werd de batchgrootte niet vast gehouden maar tijdens de training geleidelijk opgeschaald, om in het begin van de training met kleinere, ruisigere batches stabieler te starten en later met grotere batches efficiënter door te trainen.

Ook buiten taalmodellen speelt batchgrootte een rol: in de jaarlijkse MLPerf-benchmarks, waarin bedrijven als NVIDIA, Google en Intel hun trainingssnelheid met elkaar vergelijken, is het optimaliseren van de batchgrootte per hardwareconfiguratie een van de belangrijkste knoppen waaraan wordt gedraaid om trainingsrecords te verbreken.

Hoe ver is de techniek?

Batchgrootte is geen nieuwe uitvinding meer; het is een fundamenteel, decennialang begrepen onderdeel van hoe neurale netwerken worden getraind. Toch is de zoektocht naar de optimale batchgrootte voor een gegeven model en dataset nog altijd deels empirisch: er bestaat geen simpele formule die voor elk model exact de beste waarde voorspelt. Onderzoekers gebruiken vuistregels, kleinschalige experimenten en theoretische kaders om dichtbij een goede waarde te komen.

Een belangrijke theoretische stap kwam in 2018 met het OpenAI-artikel “An Empirical Model of Large-Batch Training” van Sam McCandlish en collega's. Zij introduceerden het begrip gradient noise scale, een maat die aangeeft tot welke batchgrootte — de zogeheten critical batch size — het vergroten van de batch nog efficiëntiewinst oplevert, en waarboven extra rekenkracht grotendeels verspild wordt.

Het belangrijkste obstakel bij zeer grote batches is nog altijd de zogeheten generalisatiekloof: modellen die met erg grote batches getraind worden, presteren soms net iets slechter op nieuwe data, ook al leren ze de trainingsdata net zo goed. Technieken zoals LARS en LAMB, en een geleidelijke opbouw van de leersnelheid (“warmup”), zijn ontwikkeld om die kloof te verkleinen. Volledig opgelost is het probleem niet; het blijft een actief onderzoeksveld hoe batchgrootte, leersnelheid en modelgrootte zich precies tot elkaar verhouden. Wat wel duidelijk is: naarmate modellen en datasets groeien, groeit ook de gebruikte batchgrootte mee, gedreven door de beschikbaarheid van steeds grotere rekenclusters.

Wie werken eraan?

Onderzoek naar batchgrootte en grootschalige training wordt vooral gedreven door de grote AI-laboratoria die zelf de zwaarste modellen trainen en dus het meeste belang hebben bij efficiëntie: Google (met de onderzoeksgroepen Google Brain en DeepMind, inmiddels samengevoegd tot Google DeepMind), OpenAI, Meta AI (voorheen Facebook AI Research) en Microsoft Research. Chipmaker NVIDIA speelt een grote rol aan de hardwarekant, omdat de mogelijke batchgrootte direct samenhangt met het geheugen en de rekenkracht van GPU's.

Aan academische zijde hebben onderzoekers als Yang You (nu verbonden aan de National University of Singapore) en teams van UC Berkeley en Stanford University belangrijke bijdragen geleverd aan optimalisatietechnieken voor grote batches. Geografisch is dit onderzoek sterk geconcentreerd in de Verenigde Staten, met daarnaast groeiende bijdragen vanuit Chinese techbedrijven zoals Baidu en Alibaba, die eveneens grootschalige modellen trainen en gepubliceerd hebben over batchgrootte-optimalisatie.