Overzicht · het volledige boek
Van losse neuronen tot een echt taalmodel
Een boek in twee delen. Deel I bouwt deep learning op vanaf nul: de basisbegrippen, een netwerk dat leert optellen (met de volledige wiskunde en draaiende code), een groter netwerk voor vier bewerkingen, en de vragen die er echt toe doen — generaliseren en slimmer trainen. Deel II maakt daarna een echt taalmodel open, bestand en bytes en al, en vindt daarin precies dezelfde bouwstenen terug. Deel I met alle code in Java én Python en live demo's in je browser; Deel II in pure Java. Lees op volgorde, of spring naar wat je interesseert.
Een netwerk dat zichzelf leert rekenen
De rode draad door het hele boek: we laten een netwerk een rekenregel zelf ontdekken door het de juiste antwoorden te tonen — precies zoals een netwerk in het echt taal, beelden of geluid leert. We bouwen op van klein naar groot: eerst de begrippen (De basis), dan een netwerk dat leert optellen, dan een complexer netwerk voor vier bewerkingen — en in Deel II een echt taalmodel van 494 miljoen parameters.
Rekenen met de getallen 0 tot en met 4 is daarvoor een ideaal speelveld: klein genoeg om volledig te begrijpen, en je kan elk antwoord meteen zelf controleren. Toch begint elk netwerk volledig blanco en moet het alles uit de voorbeelden halen.
Een eerlijke kanttekening
Optellen is wiskundig gezien een makkelijke taak: het is “lineair”, en in principe zou een piepklein netwerkje al volstaan. We bouwen tóch een volwaardig netwerk mét verborgen laag, om een goede reden: het laat alle onderdelen van echt leren zien — codering van invoer, een verborgen laag, softmax, een verliesfunctie en backpropagatie — en het geeft je een patroon dat je daarna op moeilijkere problemen kan loslaten. De optelling is hier het lesvoorbeeld, niet het einddoel.
Het pad, stap voor stap
Begin bij de basisbegrippen en werk van daaruit op. Je kan alles op volgorde lezen, of meteen naar een hoofdstuk springen dat je interesseert.
De basis
De begrippen onder deep learning: neuron, laag, activatiefunctie, verlies, gradient descent en backpropagatie — met een interactief voorbeeld. Begin hier als die termen nog nieuw zijn.
Het ontwerp
Hoe geef je getallen aan een netwerk? We coderen ze als one-hot, kiezen een uitvoer met 9 mogelijkheden, en bepalen de vorm van het netwerk: 10 → 16 → 9.
Het leren
De wiskunde, stap voor stap: de voorwaartse doorgang, softmax, de kruisentropie als verlies, en backpropagatie die alle gewichten bijstelt.
De code
Het volledige, draaiende programma — eerst in pure Java, daarna hetzelfde in Python. Stuk voor stuk uitgelegd, met de echte uitvoer.
Live demo
Train hetzelfde netwerk in je browser. Kijk hoe het verlies daalt en de juistheid stijgt, en gooi er daarna je eigen sommen tegenaan.
Verder: van optellen naar vier bewerkingen
Klaar met optellen? Dan kan je zien wat er gebeurt als de taak moeilijker wordt. In deze vervolgreeks leert één netwerk niet één maar vier bewerkingen — optellen, aftrekken, vermenigvuldigen en (gehele) delen — en kijken we, met echte metingen, hoe en waarom het netwerk daarvoor moet groeien. De vorige hoofdstukken blijven gewoon staan; dit bouwt erop voort.
De bewerkingen
Eén netwerk voor vier bewerkingen: de invoer groeit met een bewerkingscode (10 → 14), de uitvoer naar 21 mogelijke antwoorden, en delen pakken we apart aan.
Waarom het groeit
De kern: gemeten hoe extra bewerkingen het leren vertragen, en hoe een groter en dieper netwerk dat oplost. Plus de grens van classificatie.
De code
RekenNet in Java én Python: twee verborgen lagen, He-initialisatie en backpropagatie door beide lagen. Met de echte uitvoer — 100% op alle 95 sommen.
Live demo
Train het vier-bewerkingen-netwerk in je browser. Kies een bewerking, volg de juistheid per bewerking, en test je eigen sommen.
Generaliseren en slimmer trainen
Onze netwerken haalden 100% — maar op sommen die ze al kenden. De echte vraag van machine learning is of een netwerk ook werkt op wat het nooit zag. En daarna: kan het leren zelf sneller en slimmer?
Over- en underfitting
Onthouden is niet hetzelfde als leren. Train-, validatie- en testdata, de verraderlijke curve die omhoog buigt, en bias tegenover variantie.
Remedies & demo
Vroeg stoppen, regularisatie, dropout, meer data. Met een speeltuin waarin je overfitting zelf laat gebeuren — en weer laat verdwijnen.
Mini-batches
Waarom veel kleine stappen sneller leren dan weinig grote — de standaardmanier waarop grote netwerken echt getraind worden.
Dezelfde bouwstenen, 494 miljoen keer
Alles tot hier was leerzaam speelgoed: netwerken van hooguit een paar duizend gewichten die we volledig konden overzien. In Deel II maken we een echt taalmodel open — Qwen2.5, een half miljard parameters, zoals het op een gewone computer draait — en ontdekken we dat er binnenin niets nieuws zit: gewichten in roosters, een uitvoerlaag die kansen over hokjes legt, en een lange rij geleerde getallen. Alleen de schaal is anders. Deze hoofdstukken horen bij het Q_LLM-project, dat zo'n model in pure Java nabouwt.
Het plan
Kan dit überhaupt, een taalmodel in pure Java? De haalbaarheidsstudie: wat de JDK meebrengt, de anatomie van zo'n programma, echte metingen op een echte MacBook, en het traject in zeven mijlpalen.
Het GGUF-bestand
Wat zit er in dat bestand van 379 MB dat "een taalmodel" heet? Laag voor laag opengemaakt, met de echte bytes: header, woordenschat, en 494 miljoen samengeperste gewichten.
De tokenizer
Hoe leest een taalmodel tekst? Byte-pair encoding vanaf nul: de samenvoegregels, het teken Ġ, waarom Nederlands 43% duurder is dan Engels — en waarom een model de letters van een woord niet ziet.
De forward pass
De motor zelf: hoe één token door 24 blokken stroomt en een kansverdeling wordt. Aandacht, RoPE, de KV-cache — en het bewijs: 8 van 8 reeksen exact gelijk aan llama.cpp — sinds de Vector API-kernen aan 36 tokens per seconde.
De chat
Sampling (temperatuur, top-k, top-p), het echte gesprekssjabloon uit het bestand, en een geheugen dat over de beurten blijft staan. Bewijs: 4 van 4 gesprekken woord voor woord gelijk aan llama.cpp — "Your name is Willy."
De proef: Qwen3.8
Naschrift: twee dagen na de release wordt de toolchain losgelaten op Qwen3.8-27B. De lader en de tokenizer reizen mee (296 van 296 tokenreeksen gelijk aan de HuggingFace-referentie); de motor weigert — om de goede reden.
De agent
Het model gaat aan het werk: het bouwt een HTML-pagina met gereedschap, automatische controles na elke stap, en een poortwachter die pas "klaar" zegt als alles groen is. Gemeten les: bij een half miljard parameters gaat bouwen maar verbouwen niet; bij drie miljard kantelt dat — en de betrouwbaarheid zit in beide gevallen in de lus.
De tweede motor
De weigering van hoofdstuk 16 wordt opgeheven: de hybride Gated DeltaNet-graf van Qwen3.5/3.8 draait nu in pure Java — een geheugenmatrix van vaste grootte die per token leert van zijn fout. Bewijs: 8 van 8 greedy reeksen identiek aan llama.cpp.
Om mee te doen
Voor de code heb je Java (versie 11 of nieuwer) of Python 3 nodig — beide versies staan volledig uitgewerkt, je hoeft niets anders te installeren. Voor de live demo heb je enkel deze pagina's en een moderne browser nodig — daar draait alles in JavaScript, geen installatie. Voor Deel II volstaat een recente JDK (22 of nieuwer) en de map code/ die bij dit boek zit, hieronder ook als zip te downloaden: daarmee draai je de GGUF-lezer, de tokenizer én het model zelf — hoofdstuk 15 eindigt met een echte chat op je eigen machine. Voor dat pratende model heb je daarnaast een Qwen2.5-GGUF-bestand nodig; gebruik je ollama, dan staat het er al.
Over dit boek
Een doorlopend leerproces
Deep learning leer je niet op één avond. Het is een doorlopend proces: begrippen vallen vaak pas na de tweede of derde keer op hun plek, en elk nieuw voorbeeld scherpt het inzicht verder aan. Dit boek is in dat licht bedoeld als een groeiend geheel. Deel I is volledig uitgewerkt met Claude Opus 4.8; Deel II — het echte taalmodel — kwam er later bij met Claude Opus 5, samen met een redactieronde over het geheel. Alle metingen en programma-uitvoer in dit boek zijn echt en nagerekend.
En daarin zit meteen de kern: dit toont hoe AI een leerproces kan versterken. Niet om het eigen denkvermogen te vervangen, maar om het te vergroten — als een geduldige hulp die moeilijke stof helder maakt, voorbeelden uitwerkt en code laat draaien, terwijl het begrijpen, de keuzes en de nieuwsgierigheid bij de mens blijven. De mens stuurt, de AI versnelt.