Voorbeeld: Katten En Honden Herkennen

We hebben verkend hoe afbeeldingen als pixels worden opgeslagen, hoe convolutionele netwerken visuele features detecteren en hoe classifiers beslissingen nemen. Laten we het nu allemaal samenbrengen in een compleet voorbeeld: een systeem bouwen dat kan bepalen of een afbeelding een kat of een hond bevat.

Dit probleem is een benchmark in computer vision geworden omdat het eenvoudig genoeg is om uit te leggen, maar uitdagend genoeg om te laten zien waarom moderne methoden zoals CNN’s ertoe doen. Net zoals de MNIST-cijfers dat deden voor deep learning, demonstreert kat-vs-hond-classificatie hoe kernconcepten samenkomen in een werkende pipeline.

Stap 1: Het Probleem En De Data Begrijpen

Zoals altijd beginnen we met een dataset. Dit keer hebben we een dataset nodig met tienduizenden afbeeldingen gelabeld als “kat” of “hond”.

• Beeldgrootte: varieert (voor training geresized naar $224×224$)
• Kleur: volledige RGB-kanalen (3 getallen per pixel)
• Labels: 2 klassen (kat of hond)

Waarom is dit moeilijk?

• Variatie: Katten en honden verschijnen in veel poses, belichtingen en hoeken.
• Achtergrondruis: Dieren kunnen op gras, banken of schoot zitten.
• Overlap: Sommige rassen lijken verrassend veel op elkaar—een pluizige kat kan op een kleine hond lijken.

Elke afbeelding wordt omgezet in een matrix van $224×224×3$—bijna 150.000 waarden—het ruwe materiaal dat ons model moet interpreteren.

Stap 2: De Architectuur Ontwerpen

Een volledig verbonden netwerk zou verdrinken in parameters. In plaats daarvan gebruiken we een Convolutional Neural Network (CNN). Hopelijk herken je enkele componenten en zie je dezelfde structuur die we eerder gebruikten.

Laten we de architectuur van het netwerk schetsen:

• Input: $224×224×3$ pixels.
• Conv-laag 1: 32 filters ($3×3$) → detecteert randen, eenvoudige texturen.
• Pooling-laag: 2×2 max pooling → verkleint naar $112×112$.
• Conv-laag 2: 64 filters ($3×3$) → detecteert krommen, vachtexturen, vormen.
• Pooling-laag → verkleint naar $56×56$.
• Conv-laag 3: 128 filters ($3×3$) → detecteert objectdelen (oren, neuzen).
• Volledig verbonden laag: 256 neuronen → combineert alle features.
• Output-laag: 2 neuronen met softmax → kansen voor kat vs hond.

Deze gelaagde structuur bouwt progressief op van randen → texturen → delen → objecten.

Stap 3: De Data Voorbereiden

Voor het trainen bereiden we de afbeeldingen zodat het netwerk effectief leert:

• Normalisatie: Her-schaal pixelwaarden van $[0, 255]$ naar $[0, 1]$.
• Resizing: Standaardiseer naar $224×224$.
• Augmentatie: Willekeurige flips, rotaties en kleurverschuivingen maken het model robuust.

Deze stappen bootsen de invariantie-uitdagingen na die we eerder bespraken—het netwerk leren dat een gedraaide kat nog steeds een kat is.

Stap 4: Het Netwerk Trainen

Loss function: We gebruiken binary cross-entropy, een manier om te meten hoe goed het model de juiste klasse voorspelt wanneer er slechts twee opties zijn. Het lijkt sterk op de cross-entropy loss die we eerder zagen:

Laten we het opsplitsen:

• $y$ is het ware label (0 = kat, 1 = hond).
• $p$ is de waarschijnlijkheid die het model toekent aan “hond”.

Deze formule werkt door een kleine straf te geven wanneer het model zelfverzekerd en juist is, en een grote straf wanneer het zelfverzekerd en fout is.

🏞️ Voorspellingsvoorbeeld: Als het ware label hond is ($y = 1$) en het model voorspelt $p = 0.95$ (95% hond), dan is de loss heel klein: $-\log(0.95) \approx 0.05$. Als het model in plaats daarvan $p = 0.05$ voorspelt (slechts 5% hond), is de loss enorm: $-\log(0.05) \approx 3.0$.

Dus hoe dichter $p$ bij het juiste label ligt, hoe lager de loss.

Trainingslus:

1. Forward pass: afbeelding → CNN → waarschijnlijkheden.
2. Loss berekenen: hoe fout was de voorspelling?
3. Backpropagate: convolutionele filters en volledig verbonden gewichten bijwerken.
4. Herhaal over duizenden batches.

Over epochs evolueren filters:

• Vroege filters worden randdetectoren.
• Latere filters specialiseren in vachtexturen of snuitvormen.
• Diepe lagen stellen dit samen tot het concept “hond” of “kat”.

Via dit iteratieve proces bouwt het netwerk geleidelijk op van eenvoudige patronen naar rijke concepten, wat nauwkeurige herkenning van complexe objecten mogelijk maakt.

Stap 5: Wat Het Netwerk Leert

Tijdens het trainen bouwen CNN’s een hiërarchie van features:

• Laag 1: horizontale/verticale randen, eenvoudige kleurvlekken.
• Laag 2: vachachtige texturen, gebogen oorcontouren.
• Laag 3: combinaties van texturen en randen → neuzen, snorharen, ogen.
• Volledig verbonden: “kat-heid” vs “hond-heid”-scores.

Voor een foto van een cypers kat:

• Randen en texturen lichten strepen uit.
• Middellagen detecteren vacht en spitse oren.
• Laatste lagen combineren dit tot een hoge kans op kat.

Zo zetten CNN’s ruwe pixels om in gelaagde representaties die uitmonden in zelfverzekerde, hoog-niveau classificaties.

Stap 6: Evaluatie

Eenmaal getraind evalueren we op ongeziene testafbeeldingen:

• Nauwkeurigheid: 94% — classificeert de meeste katten en honden correct.
• Verwarringen: Sommige kleine pluizige honden worden voor katten aangezien, en sommige exotische katten lijken op honden.

Veelvoorkomende fouten onthullen grenzen van patroon-gebaseerde herkenning: het model “weet” biologisch niet wat een dier tot hond maakt—het vergelijkt enkel visuele patronen.

Stap 7: Van Classificatie Naar Generatie

Hier wordt het spannend: dezelfde principes kunnen worden omgekeerd.

• Bij classificatie extraheren CNN’s features en mappen die naar labels.
• In generatieve modellen samplen we uit een latente ruimte en mappen features terug naar pixels.

Zo kunnen systemen zoals GAN’s en diffusion-modellen volledig nieuwe katten en honden creëren—die nooit hebben bestaan. Een gegenereerde kattenafbeelding “lijkt” echt omdat ze dezelfde visuele regels respecteert (vachtextuur, oorplaatsing, symmetrie) die tijdens classificatie zijn geleerd.

Alles bij Elkaar Brengen

Dit kat-vs-hond-voorbeeld brengt de hele computer vision-reis rond:

1. Pixels → getallen: Elke foto start als ruwe RGB-waarden.
2. Feature-extractie: CNN’s detecteren randen, texturen, vormen.
3. Hiërarchieën: Lokale features combineren tot globale representaties.
4. Classificatie: Softmax geeft waarschijnlijkheden voor categorieën.
5. Generatie: De pipeline omdraaien produceert nieuwe, synthetische beelden.

Wat begon met pixelrasters wordt een volledig AI-systeem dat zowel kan herkennen als creëren.

Belangrijkste Inzichten

Net zoals de MNIST-cijfers de kracht van deep learning illustreerden, illustreert kat-vs-hond-classificatie de essentie van moderne computer vision. Het laat zien hoe convolutie, pooling, hiërarchische features en supervised learning ruwe pixels transformeren in betekenisvolle voorspellingen. En het kondigt de generatieve wending aan: zodra een netwerk kan representeren wat een kat of hond “echt” doet lijken, kan het er ook volledig nieuwe maken.

Deze reis van herkenning naar generatie vat het kernverhaal van computer vision vandaag samen.