PyTorch CNN-tutorial: Convolutionele neurale netwerken bouwen en trainen in Python

Convolutionele neurale netwerken (CNN’s) zijn een hoeksteen van moderne computervisie en maken toepassingen mogelijk zoals beeldherkenning, gezichtsdetectie en zelfrijdende auto’s. Deze netwerken zijn ontworpen om automatisch patronen en kenmerken uit beelden te halen, waardoor ze krachtiger zijn dan traditionele machinelearningtechnieken voor visuele taken.

In deze tutorial implementeren we een CNN met behulp van PyTorch, een deep-learningframework dat zowel gebruiksvriendelijk is als zeer efficiënt voor onderzoek en productie.

Vereisten: Deep learning en PyTorch

Voordat we in de details van CNN’s duiken, is het belangrijk dat je bekend bent met deep learning en de Python-bibliotheken die we gebruiken bij het opzetten van onze omgeving.

Deep learning is een subset van machine learning, waarbij het fundamentele model een netwerk is van inputs, verborgen lagen en outputs. Zo’n netwerk kan één of meerdere verborgen lagen hebben. De oorspronkelijke intuïtie achter deep learning was om modellen te creëren die geïnspireerd zijn op hoe de menselijke hersenen leren: via onderling verbonden cellen, neuronen genoemd. Daarom noemen we deep-learningmodellen nog steeds “neurale” netwerken. Deze gelaagde modelstructuren hebben veel meer data nodig om te leren dan andere modellen voor supervisie, om patronen uit ongestructureerde data af te leiden. Meestal hebben we het over minstens honderdduizenden datapunten.

Hoewel er verschillende frameworks en pakketten bestaan om deep-learningalgoritmen te implementeren, richten we ons op PyTorch, een van de populairste en best onderhouden frameworks. Naast gebruik door deep-learningengineers in de industrie, is PyTorch ook een favoriet onder onderzoekers. Veel deep-learningpapers worden met PyTorch gepubliceerd. Het is ontworpen om intuïtief en gebruiksvriendelijk te zijn en deelt veel met de Python-bibliotheek NumPy. 

Heb je een opfrisser nodig? Overweeg dan om je vandaag nog in te schrijven voor de cursus Deep Learning met PyTorch. 

Wat is een Convolutioneel Neuraal Netwerk (CNN)?

Convolutionele neurale netwerken, vaak afgekort tot CNN of ConvNet, zijn een specifiek type deep-neuraal netwerk dat zeer geschikt is voor computervisie. De uitvinding van CNN’s gaat terug tot de jaren 80. Ze werden echter pas in de jaren 2010 mainstream, na doorbraken in rekenkracht dankzij de inzet van grafische processors (GPU’s). De snelle popularisering van CNN’s hielp het veld van neurale netwerken nieuw leven in te blazen, wat leidde tot de zogenaamde “derde golf van neurale netwerken” waar we vandaag nog steeds in zitten.

CNN’s zijn specifiek geïnspireerd op de biologische visuele cortex. De cortex heeft kleine regio’s met cellen die gevoelig zijn voor specifieke gebieden in het gezichtsveld. Dit idee werd uitgebreid met een fascinerend experiment door Hubel en Wiesel in 1962. 

CNN’s proberen deze eigenschap te repliceren door complexe neurale netwerken te creëren die bestaan uit verschillende, taakspecifieke lagen. CNN’s worden “feed-forward” genoemd omdat informatie rechtstreeks door het model stroomt. Er zijn geen feedbackverbindingen waarbij de outputs van het model terug het model in gaan, in tegenstelling tot andere modellen die technieken zoals backpropagation gebruiken.

Een CNN bestaat doorgaans uit de volgende lagen:

Convolutionele laag

Dit is de eerste bouwsteen van een CNN. Zoals de naam al aangeeft, is de belangrijkste wiskundige bewerking convolutie: het toepassen van een schuivend venster op een matrix van pixels die een afbeelding voorstellen. De schuivende functie die op de matrix wordt toegepast, heet kernel of filter. In de convolutionele laag worden meerdere filters van gelijke grootte toegepast en elk filter wordt gebruikt om een specifiek patroon uit de afbeelding te herkennen, zoals de kromming van cijfers, randen, de totale vorm van de cijfers, enzovoort. 

Activatiefunctie

Gewoonlijk wordt na elke convolutie een ReLU-activatiefunctie toegepast. Deze functie helpt het netwerk niet-lineaire relaties tussen kenmerken in de afbeelding te leren, waardoor het robuuster wordt bij het herkennen van verschillende patronen. Het helpt ook om problemen met verdwijnende gradiënten te beperken. 

Pooling-laag

Het doel van de pooling-laag is om de meest betekenisvolle kenmerken uit de geconvolueerde matrix te halen. Dit gebeurt door aggregatiebewerkingen toe te passen die de dimensie van de feature map (geconvolueerde matrix) verkleinen, waardoor het geheugengebruik tijdens het trainen afneemt.  Pooling is ook relevant om overfitting te beperken.

Volledig verbonden lagen

Deze lagen staan aan het einde van het convolutionele neuraal netwerk en hun inputs komen overeen met de afgevlakte eendimensionale matrix die door de laatste pooling-laag is gegenereerd. ReLU-activaties worden toegepast voor niet-lineariteit. 

Architectuur van een convolutioneel neuraal netwerk. Bron: DataCamp

Je kunt een meer gedetailleerde uitleg van de wiskunde achter CNN’s lezen in onze tutorial, Convolutional Neural Networks in Python.

Waarom CNN’s gebruiken voor beeldclassificatie?

Convolutionele neurale netwerken zijn een van de meest invloedrijke innovaties in het veld van computervisie. Ze presteren veel beter dan traditionele machinelearningmodellen, zoals SVM’s en beslisbomen, en leveren state-of-the-art resultaten. 

Bovendien geven de convolutionele lagen CNN’s hun translatie-invariante eigenschappen, waardoor ze patronen en kenmerken in data kunnen identificeren en extraheren, ongeacht variaties in positie, oriëntatie, schaal of translatie.


CNN’s zijn succesvol gebleken in veel verschillende praktijkcases en toepassingen, zoals:

• Beeldclassificatie, objectdetectie, segmentatie, gezichtsherkenning;
• Zelfrijdende auto’s die CNN-gebaseerde visionsystemen gebruiken;
• Classificatie van kristalstructuren met een convolutioneel neuraal netwerk;
• Beveiligingscamerasystemen.

Beyond image classification tasks, CNN’s zijn veelzijdig en kunnen worden toegepast in andere domeinen, zoals natural language processing, tijdreeksanalyse en spraakherkenning.

Een CNN implementeren met PyTorch

Nu je bekend bent met de theorie achter CNN’s, gaan we praktisch aan de slag. In deze sectie bouwen en trainen we een eenvoudige CNN met PyTorch. Ons doel is een model te bouwen dat cijfers in afbeeldingen classificeert. Voor het trainen en testen van ons model gebruiken we de bekende MNIST-dataset, een verzameling van 70.000 grijswaardenafbeeldingen van 28x28 pixels met handgeschreven cijfers.

1. Vereiste bibliotheken importeren

Hieronder vind je de bibliotheken die we in deze tutorial gebruiken. In essentie gebruiken we PyTorch om onze CNN te bouwen, en de computervisiemodule van PyTorch, torchvision, om de MNIST-dataset te downloaden en te laden. Tot slot gebruiken we ook torchmetrics om de prestaties van ons model te evalueren.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


import torch
from torch import optim
from torch import nn
from torch.utils.data import DataLoader
from tqdm import tqdm

# !pip install torchvision
import torchvision

import torch.nn.functional as F
import torchvision.datasets as datasets
import torchvision.transforms as transforms

# !pip install torchmetrics
import torchmetrics

2. De dataset laden en voorbewerken

PyTorch heeft ook een rijk ecosysteem van tools en extensies, waaronder torchvision, een module voor computervisie. Torchvision bevat verschillende afbeeldingsdatasets die je kunt gebruiken voor het trainen en testen van neurale netwerken. In deze tutorial gebruiken we de MNIST-dataset. 

Eerst downloaden en converteren we de MNIST-dataset naar een tensor, de kern datastructuur in PyTorch, vergelijkbaar met NumPy-arrays maar met GPU-versnelling.

Vervolgens gebruiken we DataLoader om batching en shuffling van zowel de train- als testdatasets af te handelen. Een PyTorch DataLoader kan worden gemaakt op basis van een Dataset om data te laden, in batches op te delen en desgewenst transformaties uit te voeren. Daarna levert hij een datasample op dat klaar is voor training. In de onderstaande code laden we de data en slaan we die op in DataLoaders met een batchgrootte van 60 afbeeldingen:

batch_size = 60

train_dataset = datasets.MNIST(root="dataset/", download=True, train=True, transform=transforms.ToTensor())

train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)

test_dataset = datasets.MNIST(root="dataset/", download=True, train=False, transform=transforms.ToTensor())

test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)

Optioneel zou de trainingsset verder kunnen worden opgesplitst in train en validatie. Validatie is een techniek in deep learning om de modelprestaties tijdens het trainen te evalueren. Het helpt om mogelijke overfitting en underfitting te detecteren en is vooral handig bij het optimaliseren van hyperparameters. Voor de eenvoud gebruiken we in deze tutorial echter geen validatie. Wil je meer leren over validatie, bekijk dan de volledige uitleg in onze cursus Introduction to Deep Learning with PyTorch.

Nu we onze data hebben, kijken we hoe een willekeurige batch cijfers eruitziet:

def imshow(img):
   npimg = img.numpy()
   plt.imshow(np.transpose(npimg, (1, 2, 0)))
   plt.show()

# get some random training images
dataiter = iter(dataloader_train)
images, labels = next(dataiter)
labels
# show images
imshow(torchvision.utils.make_grid(images))

3. De CNN-architectuur definiëren

Om het classificatieprobleem op te lossen gebruiken we de nn.Module-klasse, de bouwsteen van PyTorch om op een intuïtieve manier geavanceerde neurale netwerkarchitecturen te maken. 

In de code hieronder maken we een klasse CNN, die de eigenschappen van de nn.Module-klasse erft. De klasse CNN is het blauwdruk van een CNN met twee convolutionele lagen, gevolgd door een volledig verbonden laag. 

In PyTorch gebruiken we nn.Conv2d om een convolutionele laag te definiëren. We geven het aantal input- en outputfeaturemaps door. We stellen ook enkele parameters in die nodig zijn voor de convolutionele laag, waaronder de kernel- of filtergrootte en padding. 

Vervolgens voegen we een max-poolinglaag toe met nn.MaxPool2d. ​​Daarin schuiven we een niet-overlappend venster over de output van de vorige convolutionele laag. Op elke positie selecteren we de maximale waarde uit het venster om door te geven. Deze bewerking verkleint de ruimtelijke dimensies van de featuremaps, vermindert het aantal parameters en de rekencomplexiteit in het netwerk. Tot slot voegen we een volledig verbonden lineaire laag toe. 

De functie forward() definieert hoe de verschillende lagen zijn aangesloten, met meerdere ReLU-activaties na elke convolutionele laag.

class CNN(nn.Module):
   def __init__(self, in_channels, num_classes):

       """
       Building blocks of convolutional neural network.

       Parameters:
           * in_channels: Number of channels in the input image (for grayscale images, 1)
           * num_classes: Number of classes to predict. In our problem, 10 (i.e digits from  0 to 9).
       """
       super(CNN, self).__init__()

       # 1st convolutional layer
       self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=8, kernel_size=3, padding=1)
       # Max pooling layer
       self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
       # 2nd convolutional layer
       self.conv2 = nn.Conv2d(in_channels=8, out_channels=16, kernel_size=3, padding=1)
       # Fully connected layer
       self.fc1 = nn.Linear(16 * 7 * 7, num_classes)

   def forward(self, x):
       """
       Define the forward pass of the neural network.

       Parameters:
           x: Input tensor.

       Returns:
           torch.Tensor
               The output tensor after passing through the network.
       """
       x = F.relu(self.conv1(x))  # Apply first convolution and ReLU activation
       x = self.pool(x)           # Apply max pooling
       x = F.relu(self.conv2(x))  # Apply second convolution and ReLU activation
       x = self.pool(x)           # Apply max pooling
       x = x.reshape(x.shape[0], -1)  # Flatten the tensor
       x = self.fc1(x)            # Apply fully connected layer
       return x
       x = x.reshape(x.shape[0], -1)  # Flatten the tensor
       x = self.fc1(x)            # Apply fully connected layer
       return x

Zodra we de klasse CNN hebben gedefinieerd, kunnen we ons model aanmaken en verplaatsen naar het apparaat waarop het getraind en uitgevoerd zal worden. 

Neurale netwerken, inclusief CNN’s, presteren beter op GPU’s, maar dat is misschien niet het geval op jouw computer. Daarom draaien we het model op een GPU als die beschikbaar is; anders gebruiken we een gewone CPU.

device = "cuda" if torch.cuda.is_available() else "cpu"

model = CNN(in_channels=1, num_classes=10).to(device)
print(model)
>>> CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

4. Het CNN-model trainen

Nu we ons model hebben, is het tijd om het te trainen. Daarvoor moeten we eerst bepalen hoe we de prestaties van het model meten. Omdat we te maken hebben met een multiclass-classificatieprobleem, gebruiken we de cross-entropy-verliesfunctie, in PyTorch beschikbaar als nn.CrossEntropyLoss. We gebruiken ook de Adam-optimizer, een van de populairste optimalisatie-algoritmen. 

# Define the loss function
criterion = nn.CrossEntropyLoss()

# Define the optimizer
optimizer = optim.Adam(model.parameters(), lr=0.001)

We itereren over tien epochs en trainingsbatches om het model te trainen en voeren voor elke batch de gebruikelijke stappen uit, zoals hieronder weergegeven.

num_epochs=10
for epoch in range(num_epochs):
 # Iterate over training batches
   print(f"Epoch [{epoch + 1}/{num_epochs}]")

   for batch_index, (data, targets) in enumerate(tqdm(dataloader_train)):
       data = data.to(device)
       targets = targets.to(device)
       scores = model(data)
       loss = criterion(scores, targets)
       optimizer.zero_grad()
       loss.backward()
       optimizer.step()

Epoch [1/10]
100%|██████████| 1000/1000 [00:13<00:00, 72.94it/s]
Epoch [2/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.27it/s]
Epoch [3/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.16it/s]
Epoch [4/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.00it/s]
Epoch [5/10]
100%|██████████| 1000/1000 [00:13<00:00, 75.69it/s]
Epoch [6/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.24it/s]
Epoch [7/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.23it/s]
Epoch [8/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.16it/s]
Epoch [9/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.96it/s]
Epoch [10/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.93it/s]

5. Het model evalueren

Zodra het model getraind is, kunnen we de prestaties evalueren op de testdataset. We gebruiken accuracy, een populaire metriek voor classificatieproblemen. Accuracy meet het aandeel correct geclassificeerde gevallen van het totale aantal objecten in de dataset. Het wordt berekend door het aantal correcte voorspellingen te delen door het totale aantal voorspellingen dat door het model is gedaan. 

Eerst stellen we de accuracy-metriek in met torchmetrics. Vervolgens gebruiken we de .eval-methode van het model om het model in evaluatiemodus te zetten, omdat sommige lagen in PyTorch-modellen zich anders gedragen tijdens trainen dan tijdens testen. We voegen ook een Python-context toe met torch.no_grad, waarmee we aangeven dat we geen gradiënten berekenen.

Daarna itereren we over testvoorbeelden zonder gradiëntberekening. Voor elke testbatch halen we de modeloutputs op, nemen we de meest waarschijnlijke klasse en geven die door aan de accuracymetriek samen met de labels. Tot slot berekenen we de metriek en printen we de resultaten. We behaalden een accuracy van 0,98, wat betekent dat ons model 98% van de cijfers correct classificeerde. Niet slecht!

# Set up of multiclass accuracy metric
acc = Accuracy(task="multiclass",num_classes=10)

# Iterate over the dataset batches
model.eval()
with torch.no_grad():
   for images, labels in dataloader_test:
       # Get predicted probabilities for test data batch
       outputs = model(images)
       _, preds = torch.max(outputs, 1)
       acc(preds, labels)
       precision(preds, labels)
       recall(preds, labels)

#Compute total test accuracy
test_accuracy = acc.compute()
print(f"Test accuracy: {test_accuracy}")

>>> Test accuracy: 0.9857000112533569

Je kunt ook andere populaire classificatiemetrieken gebruiken, zoals recall en precisie. We leggen deze metrieken met praktische voorbeelden uit in onze cursus Intermediate Deep Learning with PyTorch.

De modelprestaties verbeteren

Hoewel ons CNN-model sterke prestaties levert, zijn er verschillende strategieën om de nauwkeurigheid, robuustheid en generalisatie naar nieuwe data verder te verbeteren. 

In deze sectie verkennen we kerntechnieken zoals data-augmentatie, hyperparametertuning en transfer learning om de prestaties van ons model te optimaliseren.

Technieken voor data-augmentatie

Data-augmentatie is een techniek om de nauwkeurigheid van ons model te verbeteren door willekeurig nieuwe trainingsdata te creëren. Je kunt tijdens het laden bijvoorbeeld transformaties toepassen op de trainingsafbeeldingen, zoals resizen, horizontaal of verticaal spiegelen, willekeurige rotatie, enzovoort. Op die manier kun je augmented afbeeldingen maken en ze hetzelfde label geven als de originele afbeelding, waardoor de trainingsset groter wordt.

Door willekeurige transformaties aan de originele afbeeldingen toe te voegen, genereren we meer data en vergroten we de omvang en diversiteit van de trainingsset. Dit maakt het model robuuster voor variaties en vervormingen die vaak in echte beelden voorkomen, en vermindert overfitting doordat het model leert de willekeurige transformaties te negeren. 

Het is echter belangrijk om voorzichtig te zijn met data-augmentatie, omdat het de training soms kan schaden. In ons probleem bijvoorbeeld: als we een verticale flip toepassen op het cijfer “6”, lijkt het op het cijfer “9”. Als we dat als “6” aan het model doorgeven, raakt het model in de war en belemmert dat de training. Dit soort voorbeelden laat zien dat specifieke augmentaties soms het label kunnen beïnvloeden.

Hyperparametertuning

Een andere strategie om de prestaties van ons model te verbeteren, is het aanpassen van de waarden van de hyperparameters in de verschillende lagen van het model. Deze hyperparametertuning vereist een goed begrip van de wiskunde achter neurale netwerken en de betekenis van de verschillende hyperparameters. 

Je kunt bijvoorbeeld je CNN-lagen tunen door de grootte van de filters te wijzigen of de padding te verhogen. Je kunt ook een andere waarde instellen voor de initiële gewichten van de neuronen. 

Omdat we de optimale hyperparameters niet vooraf kennen, is er een zekere mate van trial-and-error nodig. Dit gebeurt doorgaans via een techniek die grid search heet, waarmee je een model systematisch kunt evalueren over een raster van parameterwaarden. 

Wees echter voorzichtig met deze techniek, want ze is meestal rekenintensief, vooral bij complexe neurale netwerken en grote trainingsdatasets.

Je kunt ook de complexiteit van je model vergroten door meer convolutionele en lineaire lagen toe te voegen. Wees daarbij wel bedachtzaam, want het aantal neuronen kan drastisch toenemen, wat leidt tot langere trainingstijden en mogelijk overfitting.

Je kunt meer leren over hyperparametertuning in onze cursus Introduction to Deep Learning with PyTorch.

Gebruik van voorgetrainde modellen

Deep-learningmodellen vanaf nul trainen is een lang en tijdrovend proces en vereist doorgaans veel trainingsdata. In plaats daarvan kunnen we vaak voorgetrainde modellen gebruiken: modellen die al op een bepaalde taak zijn getraind. 

Soms kunnen we een voorgetraind model direct hergebruiken als het de taak die we nodig hebben al kan oplossen. In andere gevallen moeten we het voorgetrainde model aanpassen aan de nieuwe taak. Dit staat bekend als transfer learning.

Het gebruiken van voorgetrainde modellen in PyTorch is vrij eenvoudig. Torchvision biedt een verzameling voorgetrainde modellen voor verschillende beeldgerelateerde taken. Deze modellen zijn getraind op grootschalige afbeeldingsdatasets en zijn eenvoudig beschikbaar. Bekijk onze cursus Deep Learning for Images with PyTorch om er alles over te leren.

Het CNN-model deployen

Nu je een zeer nauwkeurig classificatiemodel in PyTorch hebt getraind, kun je het model en zijn voorgetrainde gewichten opslaan voor toekomstig gebruik en het met je team delen, zodat zij het naadloos kunnen laden.

Om een model op te slaan, kunnen we torch.save gebruiken. Een gangbare bestandsextensie voor torch-modellen is pt of pth. Om de gewichten van het model op te slaan, geven we model.state_dict door aan torch.save met de bestandsnaam, bijvoorbeeld MulticlassCNN.pth.

Om een opgeslagen model te laden, initialiseren we een nieuw model met dezelfde architectuur. Vervolgens gebruiken we de methode load state dict samen met torch.load om de parameters in het nieuwe model te laden.

# Save the model
torch.save(model.state_dict(), 'MulticlassCNN.pth')

# Create a new model
loaded_model = CNN(in_channels=1, num_classes=10)

# Load the saved model
loaded_model.load_state_dict(torch.load('MulticlassCNN.pth'))
print(loaded_model)


CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

Conclusie

We hebben een volledig overzicht gegeven van CNN’s, met details over elke laag van de CNN-architectuur. Daarnaast gaven we een handleiding voor het implementeren van een CNN in PyTorch, met de belangrijkste stappen: van data laden en modelontwerp tot training en evaluatie. Tot slot bespraken we verschillende strategieën om de prestaties van ons model te verbeteren. We pasten al deze vaardigheden toe op een praktijkscenario rond een multiclass-classificatietaak. 

Er valt veel te leren over deep learning, wellicht een van de meest spannende en veeleisende velden binnen AI. Gelukkig is DataCamp er om te helpen. Bekijk onze materialen en cursussen en word een expert in neurale netwerken:

• An Introduction to Convolutional Neural Networks: A Comprehensive Guide to CNNs in Deep Learning 
• Convolutional Neural Networks in Python with Keras
• Python Convolutional Neural Networks (CNN) with TensorFlow Tutorial
• Introduction to Activation Functions in Neural Networks 
• Master Deep Learning for Text with PyTorch Course
• Deep Learning in Python
• How to Learn Deep Learning in 2025: A Complete Guide
• Intermediate Deep Learning with PyTorch Course
• A Guide to PyTorch Certifications & Certificates