Voorbeeld: Herkennen van Handgeschreven Cijfers

We hebben in dit hoofdstuk veel behandeld—van enkele perceptrons tot diepe netwerken, van backpropagation tot veelvoorkomende uitdagingen. Nu is het tijd om te zien hoe alles samenkomt in een volledig, praktisch voorbeeld.

Laten we een neuraal netwerk bouwen om handgeschreven cijfers te herkennen met de beroemde MNIST-dataset. Dit voorbeeld doorloopt elke stap: data voorbereiden, architectuur ontwerpen, het netwerk trainen en resultaten evalueren. Je zult zien hoe concepten uit eerdere hoofdstukken—functies, matrices, statistiek, gradient descent—samenkomen om een werkend AI-systeem te creëren.

Dit is hetzelfde type probleem dat de Deep Learning-revolutie lanceerde en blijft een perfecte introductie tot praktische ontwikkeling van neurale netwerken.

Stap 1: Het Probleem en de Data Begrijpen

✍🏼 De MNIST-Dataset: MNIST (Modified National Institute of Standards and Technology) bevat 70.000 afbeeldingen van handgeschreven cijfers, verzameld van Amerikaanse censusmedewerkers en middelbare scholieren.

We hebben deze dataset eerder besproken, omdat het een zeer bekend voorbeeld is. Laten we het uitsplitsen:

• 60.000 trainingsafbeeldingen om patronen te leren.
• 10.000 testafbeeldingen voor de uiteindelijke evaluatie.
• Beeldgrootte: $28×28$ pixels (totaal 784 pixels).
• Pixelwaarden: 0 (wit) tot 255 (zwart) grijswaardenintensiteiten.
• Labels: Cijfers 0 t/m 9 (in totaal 10 klassen).

Hoewel mensen handgeschreven cijfers moeiteloos herkennen, is dit voor computers uitdagend omdat:

• Variatie in handschriften; iedereen schrijft anders.
• Ruis en imperfecties; gescande beelden zijn niet perfect.
• Rotatie en schaal; cijfers kunnen gekanteld zijn of van grootte verschillen.
• Ambiguïteit; sommige 1’en lijken op 7’s, sommige 6’en op 0’s.

Weet je nog matrices uit Hoofdstuk 2? Elke afbeelding wordt een $28×28$-matrix van pixelintensiteiten. Voor ons neuraal netwerk flattenen we dit tot een vector van 784 getallen—we transformeren visuele informatie naar wiskundige input die het netwerk kan verwerken.

Stap 2: De Architectuur van het Neurale Netwerk Ontwerpen

We gebruiken een multi-layer-perceptron (MLP)—een feedforward-netwerk met volledig verbonden lagen:

• Inputlaag: 784 neuronen (één per pixel).
• Verborgen laag: 128 neuronen met ReLU-activatie.
• Outputlaag: 10 neuronen met softmax-activatie (één per cijfer).

Laten we de redenen voor onze ontwerpkeuzes doornemen:

Inputlaag (784 neuronen): Elke neuron ontvangt één pixelintensiteitswaarde. Deze directe pixel-naar-neuron-koppeling is eenvoudig maar effectief voor de kleine MNIST-afbeeldingen.

Verborgen laag (128 neuronen met ReLU): Deze laag leert belangrijke features te detecteren zoals randen, bochten en patronen die verschillende cijfers onderscheiden. We gebruiken ReLU om niet-lineariteit toe te voegen en verdwijnende gradiënten te vermijden.

Outputlaag (10 neuronen met softmax): Elke neuron vertegenwoordigt één cijferklasse (0-9). Softmax zorgt dat de outputs optellen tot 1 en vormt zo een waarschijnlijkheidsverdeling over mogelijke cijfers.

Laten we nu een laatste parametercount doen voor ons model:

• Input naar verborgen → $784 \times 128 = 100.352 \ \text{weights} + 128 \ \text{biases}$.
• Verborgen naar output → $128 \times 10 = 1.280 \ \text{weights} + 10 \ \text{biases}$.
• Totaal → $101.770$ te leren parameters!

Deze architectuur biedt een balans tussen eenvoud en expressieve kracht, waardoor hij goed geschikt is om handgeschreven cijfers te leren herkennen.

Stap 3: De Data Voorbereiden

Een belangrijke stap bij het bouwen van elk AI-algoritme is datapreprocessing. Voor het trainen moeten we onze data goed voorbereiden:

Normalisatie: Zet pixelwaarden van $[0, 255]$ om naar $[0, 1]$ door te delen door 255. Dit helpt bij trainingsstabiliteit en snellere convergentie.

One-Hot-Encoding: Zet cijferlabels om naar vectoren:

• Label 0 → $[1, 0, 0, 0, 0, 0, 0, 0, 0, 0]$.
• Label 3 → $[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]$.
• Label 7 → $[0, 0, 0, 0, 0, 0, 0, 1, 0, 0]$.

Datasplit: Van onze 70.000 afbeeldingen gebruiken we:

• 50.000 voor training (patronen leren).
• 10.000 voor validatie (voortgang monitoren en overfitting voorkomen).
• 10.000 testafbeeldingen blijven onaangeroerd tot de uiteindelijke evaluatie.

Met de juiste preprocessing zetten we de data klaar in een vorm die het netwerk efficiënt laat leren en goed laat generaliseren.

Stap 4: Het Trainingsproces

Loss Function: We gebruiken opnieuw cross-entropy loss, perfect voor multi-class-classificatie:

Als het netwerk $0.9$ waarschijnlijkheid voorspelt voor het juiste cijfer, dan $\text{loss} = -log(0.9) = 0.05$ (lage straf). Als het $0.1$ voorspelt, dan $\text{los}s = -log(0.1) = 2.3$ (hoge straf).

Hyperparameters: We stellen de volgende hyperparameters in; onthoud, deze worden vooraf gekozen en kunnen niet tijdens training worden veranderd.

• Learning rate: 0.001 (agressief genoeg voor voortgang, conservatief genoeg voor stabiliteit).
• Batchgrootte: 64 (balans tussen geheugengebruik en kwaliteit van de gradiënt).
• Epochs: 20 (genoeg iteraties om te convergeren zonder te overfitten).

Trainingslus: Voor elke epoch en voor elke batch van 64 afbeeldingen:

1. Forward pass: afbeeldingen → netwerk → voorspellingen.
2. Loss-berekening: vergelijk voorspellingen met ware labels.
3. Backpropagation: bereken gradiënten voor alle 101.770 parameters.
4. Gewichtsupdate: pas optimizer toe met de gradiënten.
5. Metrics bijhouden: loss, nauwkeurigheid op training en validatie.

Trainingsresultaten: De volgende resultaten worden tijdens training gevonden:

• Epoch 1: 85% nauwkeurigheid (netwerk leert basisvormen van cijfers).
• Epoch 5: 94% nauwkeurigheid (features verfijnen).
• Epoch 10: 97% nauwkeurigheid (moeilijke gevallen aanpakken).
• Epoch 15: 98% nauwkeurigheid (edge cases fijnslijpen).
• Epoch 20: 98,2% nauwkeurigheid (convergentie).

Via dit gestructureerde trainingsproces evolueert ons netwerk van willekeurige gokker naar een zeer nauwkeurige cijferherkenner.

Stap 5: Wat Het Netwerk Leert

De 128 verborgen neuronen leren automatisch betekenisvolle patronen detecteren:

Vroege Training: Willekeurige, ruisachtige featuredetectors.

Na Training: Gespecialiseerde detectors voor:

• Horizontale en verticale lijnen.
• Bochten en lussen (belangrijk voor 0, 6, 8, 9).
• Hoeken en kruisingen.
• Eindpunten van streken en richtingen.

Beslissingsproces: Voor een handgeschreven "8":

• Inputlaag: Ontvangt 784 pixelintensiteiten.
• Verborgen laag: Detecteert features zoals "twee lussen", "verticale symmetrie", "gesloten curven".
• Outputlaag: Combineert features om de "8"-neuron sterk te activeren.

Het netwerk leert deze hiërarchie automatisch—we hebben nooit expliciet geleerd wat lussen of curven zijn!

Stap 6: Evaluatie en Resultaten

Prestaties op de Testset: Na training op 50.000 afbeeldingen en validatie op 10.000, evalueren we op de laatste 10.000 testafbeeldingen die het netwerk nog nooit heeft gezien. We halen een nauwkeurigheid van 98,1%!

Dit betekent dat ons netwerk 9.810 van de 10.000 handgeschreven cijfers correct identificeert!

Enkele veelvoorkomende fouten die we kunnen vinden als we dieper graven:

• 4 → 9: Sommige handgeschreven 4’en met gesloten bovenkant lijken op 9’en.
• 7 → 1: Minimalistisch geschreven 7’en zonder duidelijke horizontale streep.
• 6 → 0: Slecht gevormde 6’en die rond lijken.
• 8 → 3: Gebroken of slecht gevormde middenverbinding in 8’en.

Deze fouten zijn intuïtief—het zijn dezelfde vergissingen die mensen zouden kunnen maken!

Deze evaluatie laat zien dat, hoewel het model uitstekende nauwkeurigheid behaalt, de resterende fouten zowel de uitdagingen van handschriftvariatie als de grenzen van zelfs goed getrainde neurale netwerken blootleggen.

Stap 7: Alles Samenbrengen

Laten we controleren wat we hebben bereikt. Beginnend met ruwe pixeldata heeft ons netwerk geleerd om:

1. Automatisch betekenisvolle features uit visuele input te extraheren.
2. Hiërarchische representaties op te bouwen van eenvoudige randen tot complexe cijfervormen.
3. Zelfverzekerde, nauwkeurige classificaties te maken op nieuwe, ongeziene voorbeelden.
4. Te generaliseren voorbij de trainingsdata met 98%+ nauwkeurigheid.

Sleutelconcepten

Uit Hoofdstuk 2 (Wiskundige Basis):

• Functies: Netwerk implementeert een complexe functiemapping van 784 inputs naar 10 outputs.
• Matrices: Efficiënte berekening met matrixoperaties voor batchverwerking.
• Afgeleiden: Backpropagation gebruikt de kettingregel om gradiënten te berekenen.
• Statistiek: Trainingsdata levert de statistische basis voor leren.

Uit Hoofdstuk 3 (Machine Learning):

• Supervised learning: Leren van gelabelde input-outputparen.
• Datasplits: Juiste evaluatiemethodologie.
• Overfitting voorkomen: Validatieprestaties monitoren.
• Functie-approximatie: Netwerk leert een complexe mappingfunctie.

Uit Hoofdstuk 4 (Deep Learning):

• Multi-layer-architectuur: Verborgen lagen maken feature learning mogelijk.
• Activatiefuncties: ReLU en softmax hebben verschillende doelen.
• Backpropagation: Efficiënte gradiëntberekening door alle lagen.
• Optimalisatie: Onze hyperparameters gaan om met het complexe loss-landschap.

Door deze wiskundige fundamenten, machine learning-principes en Deep Learning-technieken te integreren, hebben we een compleet systeem gebouwd dat ruwe data transformeert naar accurate, realistische voorspellingen.

Belangrijkste Inzichten

Dit MNIST-voorbeeld laat zien hoe wiskundige fundamenten, machine learning-principes en Deep Learning-technieken samen echte problemen oplossen. Beginnend met 784 pixelintensiteiten leerde ons netwerk betekenisvolle features te extraheren, hiërarchische representaties op te bouwen en nauwkeurige classificaties te maken via het iteratieve proces van forward propagatie, loss-berekening, backpropagation en gewichtsupdates. De behaalde nauwkeurigheid van 98%+ toont aan dat zelfs een eenvoudig neuraal netwerk complexe patronen kan leren met voldoende data en juiste training.

Het belangrijkste is dat het netwerk deze patronen automatisch ontdekte—het leerde dat lussen 0’en van 1’en onderscheiden, dat kruisingen 8’en kenmerken en dat curven 3’en definiëren—zonder expliciete programmering. Deze mogelijkheid tot automatisch feature learning verklaart waarom Deep Learning vakgebieden van computer vision tot natural language processing heeft gerevolutioneerd, en transformeert de principes van MNIST-cijferherkenning tot het fundament van moderne AI-systemen.