4.4 Neurale Netwerken en CNN's

Open de deur naar deep learning

image-20260331170612103

In de vorige hoofdstukken hebben we gezien dat traditionele computer vision-methoden vaak falen in de echte wereld. Hun succes hangt meestal af van de scène die overeenkomt met een specifiek patroon of set aannames, zoals stabiele belichting, schone achtergronden, vaste gezichtspunten of voorspelbare objectvormen. Zodra deze omstandigheden veranderen, kan hun prestatie snel verslechteren. Deep learning hanteert echter een heel andere aanpak. In plaats van voornamelijk te vertrouwen op met de hand gemaakte regels, leert het nuttige visuele patronen rechtstreeks uit grote hoeveelheden data. Dit stelt het in staat veel meer variatie in uiterlijk, achtergrond, schaal, belichting en pose aan te kunnen. Als gevolg daarvan heeft deep learning computer vision veel robuuster en praktischer gemaakt voor toepassingen in de echte wereld.

Van Regels naar Geleerde Representaties

In klassieke vision schrijven we regels expliciet:

  • maak het beeld wazig
  • vind de randen
  • extraheer de contour

In een neuraal netwerk laten we het model nuttige patronen leren uit voorbeelden.

Dit is de belangrijkste conceptuele verschuiving: het systeem leert representaties in plaats van uitsluitend te vertrouwen op handmatig ontworpen kenmerken.

Wat Is een Neuraal Netwerk

image-20260401094617887

Een neuraal netwerk is een functie bestaande uit lagen die invoergegevens stap voor stap transformeren.

Elke laag leert parameters. Tijdens de training worden deze parameters aangepast zodat de uitvoer van het netwerk nuttiger wordt voor de taak.

Hoe ziet een NN eruit in code?

python
import torch
import torch.nn as nn
import torch.nn.functional as F

# 1. Define the Network Structure
class SimpleMLP(nn.Module):
    def __init__(self, input_size=784, hidden_size=128, num_classes=10):
        super(SimpleMLP, self).__init__()
        
        # --- Fully Connected Layers (Dense Layers) ---
        
        # First layer: Maps input features to the first hidden layer
        self.fc1 = nn.Linear(input_size, hidden_size)
        
        # Second layer: Maps first hidden layer to the second hidden layer
        self.fc2 = nn.Linear(hidden_size, 64)
        
        # Output layer: Maps second hidden layer to the number of classes
        self.fc3 = nn.Linear(64, num_classes)
        
        # Optional: Dropout layer to prevent overfitting (drops 20% of neurons)
        self.dropout = nn.Dropout(p=0.2)

    # 2. Define the Data Flow (Forward Pass)
    def forward(self, x):
        # Flatten the input tensor
        # Converts (batch_size, channels, height, width) to (batch_size, -1)
        # Example: 28x28 image becomes a 784-dimensional vector
        x = x.view(x.size(0), -1)  
        
        # First hidden layer: Linear transformation -> ReLU Activation -> Dropout
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        
        # Second hidden layer: Linear transformation -> ReLU Activation
        x = F.relu(self.fc2(x))
        
        # Output layer: Linear transformation (no activation here, usually handled by loss function)
        x = self.fc3(x)
        
        return x

# 3. Instantiate the Model
model = SimpleMLP()
print(model)

Probeer het uit

bash
cd 4.4-Neural-Networks-and-CNNs/code
python powerful_neural_network.py

🚀 Train je eigen neurale netwerk en zie hoe het presteert!

nn

Waarom CNN Goed Zijn voor Beelden

CNN (convolutional neural network) werken goed voor beelden omdat beelden niet zomaar willekeurige getallen zijn. In een beeld behoren nabijgelegen pixels meestal tot dezelfde rand, vorm of textuur, dus lokale patronen zijn erg belangrijk. CNN profiteren hiervan door kleine filters te gebruiken die over het beeld scannen en zoeken naar nuttige kenmerken zoals randen, hoeken en eenvoudige vormen. Naarmate het netwerk dieper gaat, combineert het deze kleine kenmerken tot grotere, zoals delen van een object en uiteindelijk het hele object zelf. Daarom zijn CNN's bijzonder goed in het efficiënt en accuraat begrijpen van beelden.

Input Shape : (1, 9, 9) - Output Shape : (1, 7, 7) - K : (3, 3) - P : (0, 0) - S : (1, 1) - D : (1, 1) - G : 1.gif

Een CNN heeft meestal een gelaagde structuur om een beeld om te zetten in begrip op hoger visueel niveau. Het begint met een invoerbeeld, dat vervolgens door meerdere convolutielagen wordt geleid die lokale patronen zoals randen, texturen en vormen leren. Deze worden vaak gevolgd door activatiefuncties zoals ReLU en pooling-lagen die de ruimtelijke grootte verkleinen terwijl belangrijke informatie behouden blijft. Na meerdere van zulke blokken worden de feature maps afgeplat of gepoold tot een compacte representatie en vervolgens doorgegeven aan een of meer volledig verbonden lagen om de uiteindelijke voorspelling te produceren, zoals een klasse-label. Kortom, een veel voorkomende CNN ziet er als volgt uit:

invoer → convolutie + activatie → pooling → herhaalde feature-extractieblokken → volledig verbonden laag → uitvoer

image-20260401175822373

Voordelen van convolutie:

  • lokale patroonextractie

Convolutie helpt het model kleine nuttige patronen in een beeld te vinden, zoals randen, hoeken, texturen of eenvoudige vormen. Deze kleine patronen zijn de basisbouwstenen voor het begrijpen van grotere objecten.

image-20260401150136006

  • parameter sharing

Hetzelfde filter wordt op verschillende delen van het beeld gebruikt. Dit betekent dat het model geen nieuwe set gewichten hoeft te leren voor elke positie, wat het efficiënter maakt en het aantal parameters vermindert.

  • translatierobuustheid

Als een object naar een andere plaats in het beeld beweegt, kan het convolutiefilter het nog steeds detecteren. Met andere woorden, het model kan hetzelfde patroon herkennen, zelfs wanneer de positie verandert.

Feature Maps

Wanneer een convolutielaag een beeld verwerkt, produceert het feature maps. Deze maps reageren op patronen zoals:

  • randen
  • hoeken
  • texturen
  • grotere semantische structuren in diepere lagen

image-20260401100245367

Pooling en Downsampling

Pooling vermindert de ruimtelijke grootte terwijl belangrijke informatie behouden blijft.

image-20260401103259828 image-20260401104155947

Dit helpt:

  • berekeningen verminderen
  • robuustheid verbeteren
  • compactere representaties opbouwen

Probeer het uit

bash
cd 4.4-Neural-Networks-and-CNNs/code
python cnn_process_visualization.py

🚀 Voer het script uit om het verwerkingsproces van het convolutionele netwerk op het beeld te ervaren.

conv

Training vs Inferentie

  • Training: het model leert door gewichten bij te werken
  • Inference: het getrainde model maakt voorspellingen zonder gewichten bij te werken

Dit onderscheid is cruciaal omdat de latere implementatiehoofdstukken zich voornamelijk richten op inferentie.

Hoe ziet een CNN eruit in code?

python
mport torch
import torch.nn as nn

class TinyCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(16, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(32 * 56 * 56, 64),
            nn.ReLU(),
            nn.Linear(64, 10)
        )

    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x

model = TinyCNN()
dummy = torch.randn(1, 3, 224, 224)
output = model(dummy)
print(output.shape)

Veelvoorkomende Misverstanden

  • "Een CNN ziet letterlijk als een menselijk oog."
    • CNN's verwerken numerieke patronen. De analogie is nuttig, maar niet letterlijk.
  • "Meer lagen betekent altijd betere prestaties."
    • Diepere modellen kunnen krachtiger zijn, maar ook moeilijker om te trainen en te implementeren.
  • "Als ik de code begrijp, begrijp ik automatisch de training."
    • Training hangt ook af van data, verlies, optimalisatie en evaluatie.

Oefeningen / Reflectie

  1. Leg in je eigen woorden uit waarom convolutie geschikter is voor beelden dan een gewone volledig verbonden laag.
  2. Voer het tiny CNN-voorbeeld uit en print de uitvoershape.
  3. Verander het aantal uitvoerkanalen in de eerste convolutie en kijk hoe de modelstructuur verandert.
  4. Reflecteer op hoe CNN's verschillen van klassieke filters zoals vervaging of randdetectie.

Samenvatting

Neurale netwerken leren representaties uit data en CNN's zijn vooral effectief voor beelden omdat ze lokale structuur benutten. Het begrijpen van convolutie, feature maps, pooling en het verschil tussen training en inferentie bereidt de lerende voor op moderne vision-taken.

Voorgestelde Volgende Stap

Ga verder naar 4.5 Computer Vision-Taken met Deep Learning.

Referenties