PyTorch CNN Tutorial: Bouw en Train Convolutionele Neurale Netwerken in Python

Convolutional Neural Networks (CNNs) vormen de hoeksteen van moderne computervisie, waardoor toepassingen zoals beeldherkenning, gezichtsdetectie en zelfrijdende auto’s mogelijk zijn. Deze netwerken zijn ontworpen om automatisch patronen en kenmerken uit afbeeldingen te extraheren, waardoor ze krachtiger zijn dan traditionele machine learning technieken voor visuele taken.

In deze tutorial zullen we een CNN implementeren met behulp van PyTorch, een diep-leerframework dat zowel gebruiksvriendelijk als zeer efficiënt is voor onderzoeks- en productietoepassingen.

Vereisten: Diepgaand leren en PyTorch

Voordat we ingaan op de details van CNNs, moet je bekend zijn met het gebied van diep leren en de Python bibliotheken die we zullen gebruiken tijdens het opzetten van onze omgeving.

Diep leren is een subset van machine learning, waar de fundamentele modelstructuur een netwerk van invoergegevens, verborgen lagen en uitvoer is. Zo’n netwerk kan één of meerdere verborgen lagen hebben. De oorspronkelijke intuïtie achter diep leren was om modellen te creëren die geïnspireerd waren door hoe de menselijke hersenen leren: via onderling verbonden cellen die neuronen worden genoemd. Daarom blijven we diep leren modellen “neurale” netwerken noemen. Deze gelaagde modelstructuren vereisen veel meer gegevens om te leren dan andere begeleide leermethoden om patronen uit de ongestructureerde gegevens af te leiden. We praten normaal gesproken over minstens honderdduizenden gegevenspunten.

Hoewel er verschillende frameworks en pakketten beschikbaar zijn voor het implementeren van deep learning-algoritmen, richten we ons op PyTorch, een van de meest populaire en goed onderhouden frameworks. Naast dat het wordt gebruikt door deep learning-engineers in de industrie, is PyTorch een favoriete tool onder onderzoekers. Veel deep learning-artikelen worden gepubliceerd met behulp van PyTorch. Het is ontworpen om intuïtief en gebruiksvriendelijk te zijn, met veel gemeenschappelijke basis met de Python-bibliotheek NumPy.

Als je een inleiding op deze concepten nodig hebt, overweeg dan om je vandaag in te schrijven voor de Deep Learning with PyTorch cursus.

Wat is een Convolutional Neural Network (CNN)?

Convolutional neural networks, vaak CNN of ConvNet genoemd, zijn een specifiek soort deep neural network dat goed geschikt is voor computer vision-taken. De uitvinding van CNN’s dateert uit de jaren ’80. Echter, ze werden pas mainstream in de jaren 2010, na de doorbraken in de computertechnologie die het resultaat waren van de implementatie van graphics processing units (GPU’s). Inderdaad, de snelle popularisering van CNN’s hielp het veld van neurale netwerken weer op de kaart te zetten, wat leidde tot de zogenaamde “derde golf van neurale netwerken” waar we vandaag de dag nog steeds in leven.

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

CNN’s proberen deze functie 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 terugkoppelingsverbindingen waarbij de uitvoer van het model teruggevoerd wordt naar zichzelf, in vergelijking met andere modellen die technieken zoals backpropagation gebruiken.

In het bijzonder bestaat een CNN meestal uit de volgende lagen:

Convolutielaag

Dit is het eerste bouwblok van een CNN. Zoals de naam al aangeeft, is de belangrijkste wiskundige taak die wordt uitgevoerd, convolution genaamd, wat de toepassing is van een schuivende vensterfunctie op een matrix van pixels die een afbeelding vertegenwoordigen. De schuiffunctie die op de matrix wordt toegepast, wordt kernel of filter genoemd. In de convolutielaag worden verschillende filters van gelijke grootte toegepast, en elk filter wordt gebruikt om een specifiek patroon van de afbeelding te herkennen, zoals de kromming van de cijfers, de randen, de volledige vorm van de cijfers, en meer. 

Activatiefunctie

Normaal gesproken wordt na elke convolutionele bewerking een ReLU-activatiefunctie toegepast. Deze functie helpt het netwerk om niet-lineaire relaties tussen de kenmerken in de afbeelding te leren, waardoor het netwerk robuuster wordt voor het identificeren van verschillende patronen. Het helpt ook om de verdwijnende gradiëntproblemen te verminderen. 

Poolinglaag

Het doel van de pooling-laag is om de meest significante kenmerken uit de geconvoceerde matrix te halen. Dit gebeurt door het toepassen van enkele aggregatie-operaties, die de dimensie van de kenmerkkaart (geconvoceerde matrix) verkleinen, waardoor het geheugen dat wordt gebruikt tijdens het trainen van het netwerk wordt verminderd. Pooling is ook relevant voor het tegengaan van overpassing.

Volledig verbonden lagen

Deze lagen bevinden zich in de laatste laag van het convolutionele neurale netwerk, en hun invoer komt overeen met de afgevlakte eendimensionale matrix die is gegenereerd door de laatste pooling-laag. Er worden ReLU-activatiefuncties op toegepast voor niet-lineariteit. 

Architectuur van 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 op het gebied van computer vision. Ze presteren veel beter dan traditionele machine learning-modellen, zoals SVM’s en beslissingsbomen, en hebben state-of-the-art resultaten opgeleverd.

Verder geven de convolutionele lagen CNN’s hun translatie-invariantie kenmerken, waardoor ze in staat zijn om patronen en kenmerken uit gegevens te identificeren en te extraheren, ongeacht variaties in positie, oriëntatie, schaal of translatie.

CNN’s hebben bewezen succesvol te zijn in veel verschillende praktijkgevallen en toepassingen, zoals:

• Beeldclassificatie, objectdetectie, segmentatie, gezichtsherkenning;
• Zelfrijdende auto’s die gebruikmaken van op CNN gebaseerde vision-systemen;
• Classificatie van kristalstructuur met behulp van een convolutioneel neuraal netwerk;
• Beveiligingscamera-systemen.

Naast beeldclassificatietaken zijn CNN’s veelzijdig en kunnen ze worden toegepast op een reeks andere domeinen, zoals natuurlijke taalverwerking, tijdreeksanalyse en spraakherkenning.

Een CNN implementeren met PyTorch

Nu je bekend bent met de theorie van CNN’s, zijn we klaar om onze handen vuil te maken. In dit gedeelte zullen we een eenvoudige CNN bouwen en trainen met PyTorch. Ons doel is om een model te bouwen om cijfers in afbeeldingen te classificeren. Om ons model te trainen en testen, zullen we de beroemde MNIST-dataset gebruiken, een verzameling van 70.000 grijswaardenafbeeldingen van 28×28 pixels met handgeschreven cijfers.

1. Benodigde bibliotheken importeren

Hieronder vind je de bibliotheken die we zullen gebruiken voor deze tutorial. In essentie zullen we PyTorch gebruiken om onze CNN te bouwen, en de computer vision-module torchvision van PyTorch om de MNIST-dataset te downloaden en te laden. Tenslotte zullen we ook torchmetrics gebruiken 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. Het laden en voorbewerken van de dataset

PyTorch wordt ook geleverd met een rijk ecosysteem van tools en extensies, waaronder torchvision, een module voor computer vision. Torchvision bevat verschillende beeld datasets die gebruikt kunnen worden voor het trainen en testen van neurale netwerken. In onze tutorial zullen we de MNIST dataset gebruiken. 

Eerst zullen we de MNIST dataset downloaden en omzetten naar een tensor, de kerngegevensstructuur in PyTorch, vergelijkbaar met NumPy-arrays maar met GPU-versnellingsmogelijkheden.

Vervolgens zullen we ook DataLoader gebruiken om zowel de trainings- als testdatasets te verwerken voor batchverwerking en willekeurige volgorde. Een PyTorch DataLoader kan worden gemaakt vanuit een Dataset om gegevens te laden, deze in batches te verdelen en eventuele transformaties op de gegevens uit te voeren indien gewenst. Vervolgens levert het een gegevensvoorbeeld klaar voor training. In de onderstaande code laden we de gegevens en slaan deze 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 kan de trainingsdataset verder worden opgesplitst in twee partities van trainings- en validatiegegevens. Validatie is een techniek die in deep learning wordt gebruikt om de prestaties van het model tijdens training te evalueren. Het helpt bij het detecteren van mogelijke over- of onderaanpassing van onze modellen en is bijzonder nuttig voor het optimaliseren van hyperparameters. Echter, voor de eenvoud zullen we in deze tutorial geen validatie gebruiken. Als je meer wilt weten over validatie, kun je een uitgebreide uitleg bekijken in onze Inleiding tot Deep Learning met PyTorch Cursus.

Nu we onze gegevens hebben, laten we eens kijken hoe een willekeurige batch cijfers eruitziet:

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

# krijg wat willekeurige trainingsafbeeldingen
dataiter = iter(dataloader_train)
images, labels = next(dataiter)
labels
# toon afbeeldingen
imshow(torchvision.utils.make_grid(images))

3. Definiëren van de CNN-architectuur

Om het classificatieprobleem op te lossen, zullen we gebruikmaken van de klasse nn.Module, PyTorch’s bouwsteen voor intuïtief creëren van geavanceerde neurale netwerkarchitecturen.

In de onderstaande code maken we een klasse genaamd CNN, die de eigenschappen van de klasse nn.Module erft. De klasse CNN zal het blauwdruk zijn 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 het aantal invoer- en uitvoerkenmerkkaarten door. We stellen ook enkele parameters in voor de convolutionele laag om te werken, waaronder de grootte van de kernel of filter en padding.

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

De functie forward() bepaalt hoe de verschillende lagen met elkaar verbonden zijn, waarbij verschillende ReLU-activatiefuncties worden toegevoegd 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__()

       # 1e convolutielaag
       self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=8, kernel_size=3, padding=1)
       # Max pooling laag
       self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
       # 2e convolutielaag
       self.conv2 = nn.Conv2d(in_channels=8, out_channels=16, kernel_size=3, padding=1)
       # Volledig verbonden laag
       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))  # Pas de eerste convolutie en ReLU-activatie toe
       x = self.pool(x)           # Pas max pooling toe
       x = F.relu(self.conv2(x))  # Pas de tweede convolutie en ReLU-activatie toe
       x = self.pool(x)           # Pas max pooling toe
       x = x.reshape(x.shape[0], -1)  # Flatten de tensor
       x = self.fc1(x)            # Pas de volledig verbonden laag toe
       return x
       x = x.reshape(x.shape[0], -1)  # Flatten de tensor
       x = self.fc1(x)            # Pas de volledig verbonden laag toe
       return x

Eenmaal we de CNN klasse hebben gedefinieerd, kunnen we ons model creëren en het verplaatsen naar het apparaat waar het getraind en uitgevoerd zal worden.

Neurale netwerken, inclusief CNN’s, presteren beter wanneer ze op GPU’s draaien, maar dat kan op jouw computer het geval zijn. Daarom zullen we het model alleen op een GPU draaien wanneer deze 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 trainen van het CNN-model

Nu we ons model hebben, is het tijd om het te trainen. Om dit te doen, moeten we eerst bepalen hoe we de prestaties van het model zullen meten. Aangezien we te maken hebben met een multi-classificatieprobleem, zullen we de kruis-entropie verliesfunctie gebruiken, beschikbaar in PyTorch als nn.CrossEntropyLoss. We zullen ook de Adam optimizer gebruiken, een van de meest populaire optimalisatiealgoritmen.

# Definieer de verliesfunctie
criterion = nn.CrossEntropyLoss()

# Definieer de optimizer
optimizer = optim.Adam(model.parameters(), lr=0.001)

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

num_epochs=10
for epoch in range(num_epochs):
 # Itereer over trainingsbatches
   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. Evalueren van het model

Zodra het model is getraind, kunnen we de prestaties ervan op de testdataset evalueren. We zullen nauwkeurigheid gebruiken, een populaire metriek voor classificatieproblemen. Nauwkeurigheid meet de verhouding van correct geclassificeerde gevallen ten opzichte van het totale aantal objecten in de dataset. Het wordt berekend door het aantal correcte voorspellingen te delen door het totale aantal voorspellingen van het model.

Eerst stellen we de nauwkeurigheidsmetric van torchmetrics in. 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 het trainen in vergelijking met de testfase. We voegen ook een Python-context toe met torch.no_grad, wat aangeeft dat we geen gradientberekeningen zullen uitvoeren.

Daarna itereren we over testvoorbeelden zonder gradientberekeningen. Voor elke testbatch krijgen we modeloutputs, nemen we de meest waarschijnlijke klasse en geven we deze door aan de nauwkeurigheidsfunctie samen met de labels. Ten slotte berekenen we de metrics en printen we de resultaten. We hebben een nauwkeurigheidsscore van 0,98 behaald, wat betekent dat ons model 98% van de cijfers correct heeft geclassificeerd. Niet slecht!

# Instellen van de multiclass nauwkeurigheidsmetric
acc = Accuracy(task="multiclass",num_classes=10)

# Itereren over de dataset-batches
model.eval()
with torch.no_grad():
   for images, labels in dataloader_test:
       # Verkrijg voorspelde waarschijnlijkheden voor de testdata-batch
       outputs = model(images)
       _, preds = torch.max(outputs, 1)
       acc(preds, labels)
       precision(preds, labels)
       recall(preds, labels)

# Bereken de totale testnauwkeurigheid
test_accuracy = acc.compute()
print(f"Test accuracy: {test_accuracy}")

>>> Test accuracy: 0.9857000112533569

Je zou ook andere populaire classificatiemetrics kunnen gebruiken, waaronder recall en precisie. We vertellen je alles over deze metrics met praktische voorbeelden in onze Tussentijds Deep Learning met PyTorch Cursus.

Verbeteren van de modelprestaties

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

In deze sectie zullen we belangrijke technieken verkennen zoals data-augmentatie, hyperparameterafstemming en transfer learning om de prestaties van ons model te optimaliseren.

Data-augmentatietechnieken

Data-augmentatie is een techniek die wordt gebruikt om de nauwkeurigheid van ons model te verbeteren door willekeurig nieuwe trainingsgegevens te creëren. Tijdens het laden kan men bijvoorbeeld transformaties toepassen op de trainingsafbeeldingen, zoals vergroten, horizontaal of verticaal spiegelen, willekeurige rotatie, enzovoort. Op die manier kunnen augmented afbeeldingen worden gecreëerd en aan hen dezelfde label worden toegewezen als de originele afbeelding, waardoor de omvang van de trainingsset toeneemt.

Het toevoegen van willekeurige transformaties aan de originele afbeeldingen stelt ons in staat om meer gegevens te genereren, terwijl de omvang en diversiteit van de trainingsset toenemen. Het maakt het model robuuster tegen variaties en verstoringen die vaak voorkomen in afbeeldingen in de echte wereld, en vermindert overpassing doordat het model leert om de willekeurige transformaties te negeren.

Het is echter belangrijk om voorzichtig te zijn met data-augmentatie, omdat het soms het trainingsproces kan schaden. Bijvoorbeeld, in ons probleem, als we de verticale spiegeling toepassen op het cijfer “6”, zal het eruitzien als het cijfer “9”. Wanneer het aan het model wordt doorgegeven met het label “6”, kan het model in de war raken en training belemmeren. Deze voorbeelden tonen aan dat bepaalde augmentaties soms van invloed kunnen zijn op het label.

Hyperparameterafstemming

Een andere strategie om de prestaties van ons model te verbeteren, is door de waarden van de hyperparameters die betrokken zijn bij de verschillende lagen van het model te wijzigen. Deze hyperparameterafstemming vereist een diepgaand begrip van de wiskunde achter neurale netwerken en de betekenis van de verschillende hyperparameters.

Bijvoorbeeld, je zou je CNN-lagen kunnen afstemmen door de grootte van de filters te veranderen of door de padding te vergroten. Je zou ook een andere waarde kunnen instellen voor de initiële gewichten van de neuronen.

Aangezien we de optimale waarden van de hyperparameters van tevoren niet zullen kennen, zal enige mate van trial and error nodig zijn. Dit wordt meestal gedaan via een techniek die bekend staat als grid search, waarmee je systematisch een model kunt evalueren over een grid van parameterwaarden.

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

Evenzo zou je de complexiteit van je model kunnen verhogen door meer convolutionele en lineaire lagen toe te voegen. Wees echter voorzichtig bij het toevoegen van nieuwe lagen, want het aantal neuronen kan drastisch toenemen, resulterend in langere trainingsperiodes en mogelijke overfitting.

Je kunt meer leren over hyperparameterafstemming in onze Inleiding tot Deep Learning met PyTorch Cursus.

Het gebruik van vooraf getrainde modellen

Het trainen van deep learning modellen vanaf nul is een lang en moeizaam proces, en het vereist meestal een grote hoeveelheid trainingsdata. In plaats daarvan kunnen we vaak gebruikmaken van voorgetrainde modellen, dat wil zeggen modellen die al op een bepaalde taak zijn getraind.

Soms kunnen we een voorgetraind model direct hergebruiken als het al de taak kan oplossen die wij belangrijk vinden. Op andere momenten moeten we het voorgetrainde model mogelijk aanpassen om het geschikt te maken voor de nieuwe taak. Dit staat bekend als transfer learning.

Het gebruik van voorgetrainde modellen in PyTorch is vrij eenvoudig. Torchvision biedt een verzameling voorgetrainde modellen voor verschillende beeldgerelateerde taken. Deze modellen zijn voorgetraind op grootschalige afbeeldingsdatasets en zijn gemakkelijk beschikbaar. Bekijk onze Deep Learning for Images with PyTorch Course om alles te leren wat je erover moet weten.

Het implementeren van het CNN-model

Nadat je je zeer nauwkeurige classificatiemodel in PyTorch hebt getraind, kun je het model en zijn voorgetrainde gewichten opslaan voor toekomstig gebruik en het delen met je team, zodat zij het probleemloos kunnen laden.

Om een model op te slaan, kunnen we torch.save gebruiken. Een veelvoorkomende 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 en geven we de naam van het uitvoerbestand op, 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 naar het nieuwe model te laden.

# Sla het model op
torch.save(model.state_dict(), 'MulticlassCNN.pth')

# Maak een nieuw model aan
loaded_model = CNN(in_channels=1, num_classes=10)

# Laad het opgeslagen 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 van CNNs behandeld, waarbij we details hebben gegeven over elke laag van de CNN-architectuur. Verder hebben we een handleiding gegeven over hoe je een CNN kunt implementeren in PyTorch, waarbij we de belangrijkste stappen behandelen, van het laden van gegevens en het ontwerpen van het model tot het trainen en evalueren van het model. Ten slotte hebben we ook verschillende strategieën geanalyseerd om de prestaties van ons model te verbeteren. We hebben al deze vaardigheden toegepast op een realistisch scenario met betrekking tot een multiklassificatietaak. 

Er valt veel te leren over diep leren, misschien wel een van de meest opwindende en veeleisende gebieden in AI. Gelukkig staat DataCamp klaar om te helpen. Bekijk onze speciale materialen en cursussen en word een expert in neurale netwerken:

• Een Inleiding tot Convolutional Neural Networks: Een Uitgebreide Gids voor CNNs in Deep Learning 
• Convolutional Neural Networks in Python met Keras
• Python Convolutional Neural Networks (CNN) met TensorFlow zelfstudie
• Introductie tot Activatiefuncties in Neurale Netwerken
• Meester Deep Learning voor Tekst met PyTorch Cursus
• Diep Leren in Python
• Hoe Deep Learning te Leren in 2025: Een Compleet Gids
• Intermediate Deep Learning met PyTorch Cursus
• Een Gids voor PyTorch Certificaten & Certificaten