Convolutionele Neurale Netwerken (CNN) met TensorFlow-tutorial

Stel je voor dat je in een dierentuin probeert te herkennen of een dier een cheeta of een luipaard is. Als mens kan je brein moeiteloos lichaams- en gelaatskenmerken analyseren om tot een geldige conclusie te komen. Op dezelfde manier kunnen Convolutionele Neurale Netwerken (CNN’s) worden getraind om dezelfde herkeningstaak uit te voeren, hoe complex de patronen ook zijn. Dat maakt ze krachtig binnen computer vision. 

Deze conceptuele CNN-tutorial begint met een overzicht van wat CNN’s zijn en waarom ze belangrijk zijn in machine learning. Daarna loodst hij je door een stapsgewijze implementatie van een CNN in TensorFlow Framework 2.

Wat is een CNN?

Een Convolutioneel Neuraal Netwerk (CNN of ConvNet) is een deep learning-algoritme dat speciaal is ontworpen voor taken waarbij objectherkenning cruciaal is, zoals beeldclassificatie, detectie en segmentatie.  Veel toepassingen in de echte wereld, zoals zelfrijdende auto’s, bewakingscamera’s en meer, gebruiken CNN’s. 

Het belang van CNN’s

Er zijn meerdere redenen waarom CNN’s belangrijk zijn, zoals hieronder benadrukt:

• In tegenstelling tot traditionele machinelearningmodellen zoals SVM en beslisbomen, die handmatige feature-extractie vereisen, kunnen CNN’s automatische feature-extractie op schaal uitvoeren, wat ze efficiënt maakt. 
• De convolutionele lagen maken CNN’s translatie-invariant, wat betekent dat ze patronen in data kunnen herkennen en features kunnen extraheren ongeacht hun positie, of de afbeelding nu gedraaid, geschaald of verschoven is.
• Meerdere voorgetrainde CNN-modellen zoals VGG-16, ResNet50, Inceptionv3 en EfficientNet hebben state-of-the-art resultaten behaald en kunnen met relatief weinig data worden fijnafgesteld op nieuwe taken. 
• CNN’s kunnen ook worden gebruikt voor niet-beeldclassificatietaken en zijn niet beperkt tot natural language processing, tijdreeksanalyse en spraakherkenning.

Architectuur van een CNN

De architectuur van CNN’s probeert de structuur van neuronen in het menselijke visuele systeem na te bootsen, bestaande uit meerdere lagen, waarbij elke laag verantwoordelijk is voor het detecteren van een specifieke feature in de data.  Zoals geïllustreerd in de onderstaande afbeelding, bestaat een typisch CNN uit een combinatie van vier hoofdlagen: 

• Convolutionele lagen
• Rectified Linear Unit (kortweg ReLU)
• Pooling-lagen
• Volledig verbonden lagen 

Laten we begrijpen hoe elk van deze lagen werkt aan de hand van het volgende voorbeeld van de classificatie van een handgeschreven cijfer.

Convolution-lagen

Dit is het eerste bouwblok 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 weergeeft. De schuivende functie op de matrix heet kernel of filter; beide termen worden door elkaar gebruikt. 

In de convolution-laag worden meerdere filters van gelijke grootte toegepast, en elk filter wordt gebruikt om een specifiek patroon in de afbeelding te herkennen, zoals de kromming van de cijfers, de randen, de volledige vorm van de cijfers, enzovoort. 

Laten we deze 32x32-grijswaardenafbeelding van een handgeschreven cijfer bekijken. De waarden in de matrix zijn ter illustratie gegeven.

Beschouw ook de kernel die voor de convolutie wordt gebruikt. Dit is een matrix met een afmeting van 3x3. De gewichten van elk element van de kernel zijn weergegeven in het raster. Nulgewichten zijn weergegeven in de zwarte vakjes en eenen in de witte vakjes. 

Moeten we deze gewichten handmatig bepalen? 

In de praktijk worden de gewichten van de kernels bepaald tijdens het trainingsproces van het neurale netwerk. 

Met deze twee matrices kunnen we de convolutie uitvoeren door het uitvoeren van het inwendig product, en dat werkt als volgt: 

1. Plaats de kernelmatrix op de linkerbovenhoek en schuif naar rechts.
2. Voer elementgewijze vermenigvuldiging uit.  
3. Sommeer de producten.
4. De resulterende waarde komt overeen met de eerste waarde (linkerbovenhoek) in de geconvolueerde matrix.
5. Schuif de kernel omlaag afhankelijk van de stapgrootte van het schuivend venster.
6. Herhaal stap 1 t/m 5 totdat de hele afbeeldingsmatrix is afgedekt.

De afmeting van de geconvolueerde matrix hangt af van de grootte van het schuivend venster (stride). Hoe groter de stap, hoe kleiner de afmeting.

Een andere benaming voor de kernel in de literatuur is feature detector, omdat de gewichten kunnen worden fijnafgesteld om specifieke features in de invoerafbeelding te detecteren. 

Bijvoorbeeld: 

• Een kernel die naburige pixels gemiddelde, kan worden gebruikt om de invoerafbeelding te vervagen.
• Een kernel die naburige waarden aftrekt, wordt gebruikt voor randdetectie.

Hoe meer convolution-lagen het netwerk heeft, hoe beter een laag in staat is meer abstracte features te detecteren. 

Activatiefunctie

Na elke convolutie wordt een ReLU-activatiefunctie toegepast. Deze functie helpt het netwerk niet-lineaire relaties tussen features in de afbeelding te leren en maakt het netwerk daardoor robuuster bij het identificeren van verschillende patronen. Het helpt ook het probleem van verdwijnende gradiënten te beperken. 

Pooling-laag

Het doel van de pooling-laag is om de meest significante features uit de geconvolueerde matrix te halen. Dit gebeurt door aggregatie-operaties toe te passen, waardoor de dimensie van de feature map (geconvolueerde matrix) kleiner wordt en er tijdens het trainen minder geheugen nodig is.  Pooling helpt ook om overfitting te beperken.

De meest voorkomende aggregatiefuncties die kunnen worden toegepast, zijn: 

• Max pooling: de maximale waarde van de feature map
• Sum pooling: de som van alle waarden van de feature map
• Average pooling: het gemiddelde van alle waarden. 

Hieronder staat een illustratie van elk van de vorige voorbeelden: 

Ook hier geldt: de afmeting van de feature map wordt kleiner naarmate de pooling-functie wordt toegepast. 

De laatste pooling-laag maakt zijn feature map plat (flatten) zodat deze kan worden verwerkt door de volledig verbonden laag. 

Volledig verbonden lagen

Deze lagen bevinden zich aan het einde van het convolutionele neurale netwerk,  en  hun input komt overeen met de afgevlakte eendimensionale matrix die door de laatste pooling-laag is gegenereerd. ReLU-activaties worden toegepast voor niet-lineariteit. 

Tot slot wordt een softmax-voorspellingslaag gebruikt om kanswaarden te genereren voor elk van de mogelijke outputlabels; het uiteindelijke label is dat met de hoogste kansscore. 

Dropout 

Dropout is een regularisatietechniek die wordt toegepast om het generaliserend vermogen te verbeteren van neurale netwerken met een groot aantal parameters. Het bestaat uit het willekeurig uitschakelen van sommige neuronen tijdens het trainen, waardoor de overgebleven neuronen gedwongen worden nieuwe features uit de invoerdata te leren.  

Aangezien de technische implementatie wordt uitgevoerd met TensorFlow 2, biedt de volgende sectie een volledig overzicht van verschillende componenten van dit framework om efficiënt deep learning-modellen te bouwen. 

Wat is het TensorFlow-framework?

Google ontwikkelde TensorFlow in november 2015. Ze definiëren het als een open-source machinelearningframework voor iedereen, om meerdere redenen. 

• Open-source: uitgebracht onder de Apache 2.0 open-sourcelicentie. Dit stelt onderzoekers, organisaties en ontwikkelaars in staat bij te dragen aan de bibliotheek en erop voort te bouwen zonder beperkingen. 
• Machinelearningframework: het bevat een set bibliotheken en tools die het bouwen van machinelearningmodellen ondersteunen.
• Voor iedereen: met TensorFlow wordt het implementeren van machinelearningmodellen eenvoudiger via gangbare programmeertalen zoals Python. Bovendien maken ingebouwde bibliotheken zoals Keras het nog makkelijker om robuuste deep learning-modellen te creëren. 

Al deze functionaliteit maakt TensorFlow een goede kandidaat voor het bouwen van neurale netwerken. 

Bovendien is TensorFlow 2 installeren eenvoudig en kan dit als volgt met de Python-pakketbeheerder pip zoals uitgelegd in de officiële documentatie. 

Na de installatie kunnen we zien dat de gebruikte versie 2.9.1 is

import tensorflow as tf
print("TensorFlow version:", tf.__version__)

Nu gaan we de belangrijkste bouwstenen voor het maken van deze netwerken verder verkennen. 

Wat zijn tensors?

Bij het bouwen van machinelearning- en deep learning-modellen werken we vooral met hoog-dimensionale data. Tensors zijn multidimensionale arrays met een uniform type die worden gebruikt om verschillende kenmerken van de data te representeren. 

Hieronder staat de grafische weergave van de verschillende dimensietypen van tensors. 

• Een 0-dimensionale tensor bevat een enkele waarde.
• Een 1-dimensionale tensor, ook wel ‘rank-1’ tensor, is een lijst met waarden. 
• Een 2-dimensionale tensor is een ‘rank-2’ tensor.
• Ten slotte kunnen we een N-dimensionale tensor hebben, waarbij N het aantal dimensies binnen de tensor voorstelt. In de vorige gevallen is N respectievelijk 0, 1 en 2.

Hieronder staat een illustratie van een nul- tot en met 3-dimensionale tensor. Elke tensor is gemaakt met de functie constant() van TensorFlow. 

# Zero dimensional tensor
zero_dim_tensor = tf.constant(20)
print(zero_dim_tensor)

# One dimensional tensor
one_dim_tensor = tf.constant([12, 20, 53, 26, 11, 56])
print(one_dim_tensor)

# Two dimensional tensor
two_dim_array = [[3, 6, 7, 5],
             	[9, 2, 3, 4],
             	[7, 1, 10,6],
             	[0, 8, 11,2]]

two_dim_tensor = tf.constant(two_dim_array)
print(two_dim_tensor)

Een succesvolle uitvoering van de vorige code zou de onderstaande outputs moeten genereren; we zien het sleutelwoord ‘tf.Tensor’ om aan te geven dat het resultaat een tensor is. Het heeft drie parameters:

•  De werkelijke waarde van de tensor.
• De shape() van de tensor, die respectievelijk 0, 6 bij 1 en 4 bij 4 is voor de eerste, tweede en derde tensor.
• Het datatype, weergegeven door het attribuut dtype; alle tensors zijn int32.

Onze TensorFlow-tutorial voor beginners biedt een volledig overzicht van TensorFlow en leert je hoe je modellen bouwt en traint.

Tensors vs. matrices: verschillen

Veel mensen verwarren tensors met matrices. Hoewel deze twee objecten op elkaar lijken, hebben ze compleet verschillende eigenschappen. Deze sectie geeft een beter begrip van het verschil tussen matrices en tensors.

• Je kunt een matrix zien als een tensor met slechts twee dimensies. 
• Tensors daarentegen zijn een algemener formaat dat elk aantal dimensies kan hebben.

In tegenstelling tot matrices zijn tensors geschikter voor deep learning-problemen om de volgende redenen: 

• Ze kunnen overweg met elk aantal dimensies, wat ze geschikter maakt voor multidimensionale data.
• Tensors’ vermogen om compatibel te zijn met een breed scala aan datatypen, vormen en dimensies maakt ze veelzijdiger dan matrices.
• TensorFlow biedt GPU- en TPU-ondersteuning om berekeningen te versnellen. Met tensors kunnen machinelearning-engineers automatisch van deze voordelen profiteren.
• Tensors ondersteunen native broadcasting, wat inhoudt dat rekenkundige bewerkingen kunnen worden uitgevoerd tussen tensors met verschillende vormen; dat is niet altijd mogelijk met matrices.  

TensorFlow: constants, variabelen en placeholders

Constants zijn niet de enige soorten tensors. Er zijn ook variabelen en placeholders; dit zijn allemaal bouwstenen van een computationele graaf. 

Een computationele graaf is in feite een representatie van een reeks bewerkingen en de datastroom ertussen. 

Laten we nu het verschil tussen deze soorten tensors begrijpen.

Constants

Constants zijn tensors waarvan de waarden niet veranderen tijdens de uitvoering van de computationele graaf. Ze worden gemaakt met de functie tf.constant() en worden vooral gebruikt om vaste parameters op te slaan die tijdens het trainen van het model niet hoeven te veranderen.

Variabelen

Variabelen zijn tensors waarvan de waarde kan veranderen tijdens de uitvoering van de computationele graaf en ze worden gemaakt met de functie tf.Variable(). In het geval van neurale netwerken kunnen bijvoorbeeld gewichten en biases worden gedefinieerd als variabelen, omdat ze tijdens het trainingsproces moeten worden bijgewerkt. 

Placeholders

Deze werden gebruikt in de eerste versie van TensorFlow als lege containers zonder specifieke waarden. Ze werden alleen gebruikt om ruimte te reserveren voor data die later zou worden gebruikt. Dit gaf gebruikers de vrijheid om verschillende datasets en batchgroottes te gebruiken tijdens training en validatie.

In TensorFlow versie 2 zijn placeholders vervangen door de tf.function()-functie, een meer Pythonische en dynamische aanpak om data in de computationele graaf te voeren. 

CNN stap-voor-stap implementatie

Laat we alles wat we eerder hebben geleerd in de praktijk brengen. Deze sectie laat de end-to-end implementatie zien van een convolutioneel neuraal netwerk in TensorFlow, toegepast op de CIFAR-10-dataset, een ingebouwde dataset met de volgende eigenschappen: 

• Bevat 60.000 kleurenafbeeldingen van 32 bij 32
• De dataset heeft 10 verschillende klassen
• Elke klasse heeft 6000 afbeeldingen
• Er zijn in totaal 50.000 trainingsafbeeldingen 
• En in totaal 10.000 testafbeeldingen

De broncode van het artikel is beschikbaar in DataCamp’s Workspace

Architectuur van het netwerk

Voordat we in de technische implementatie duiken, is het goed om eerst de algehele architectuur van het netwerk te begrijpen dat we implementeren. 

• De input van het model is een 32x32x3-tensor, respectievelijk voor breedte, hoogte en kanalen. 
• We hebben twee convolutionele lagen. De eerste laag past 32 filters van elk 3x3 toe en een ReLU-activatie. De tweede past 64 filters van 3x3 toe
• De eerste pooling-laag past 2x2 max pooling toe
• De tweede pooling-laag past ook 2x2 max pooling toe
• De volledig verbonden laag heeft 128 units en een ReLU-activatie
• Tot slot bestaat de output uit 10 units die overeenkomen met de 10 klassen, en de activatiefunctie is softmax om de kansverdelingen te genereren.

Dataset laden

De ingebouwde dataset wordt als volgt geladen uit keras.datasets(): 

(train_images, train_labels), (test_images, test_labels) = cf10.load_data()

Exploratory Data Analysis

In deze sectie beperken we ons tot het tonen van enkele voorbeeldafbeeldingen, omdat we de verdeling van elke klasse in zowel de trainings- als testdata al kennen. 

De hulpfunctie show_images() toont standaard 12 afbeeldingen en neemt drie hoofdparameters aan: 

• De trainingsafbeeldingen
• De class-namen
• En de trainingslabels.

import matplotlib.pyplot as plt

def show_images(train_images,
            	class_names,
            	train_labels,
            	nb_samples = 12, nb_row = 4):
    
	plt.figure(figsize=(12, 12))
	for i in range(nb_samples):
    	plt.subplot(nb_row, nb_row, i + 1)
    	plt.xticks([])
    	plt.yticks([])
    	plt.grid(False)
    	plt.imshow(train_images[i], cmap=plt.cm.binary)
    	plt.xlabel(class_names[train_labels[i][0]])
	plt.show()

Nu kunnen we de functie aanroepen met de vereiste parameters. 

class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
           	'dog', 'frog', 'horse', 'ship', 'truck']

show_images(train_images, class_names, train_labels)

Een succesvolle uitvoering van de vorige code levert de onderstaande afbeeldingen op. 

Datapreprocessing

Voor we het model trainen, moeten we de pixelwaarden van de data normaliseren naar hetzelfde bereik (bijv. 0 tot 1). Dit is een veelgebruikte preprocessingstap bij afbeeldingen om schaalinvariantie te waarborgen en sneller te convergeren tijdens het trainen. 

max_pixel_value = 255

train_images = train_images / max_pixel_value
test_images = test_images / max_pixel_value

Ook zien we dat de labels in een categorisch formaat zijn weergegeven, zoals cat, horse, bird, enzovoort. We moeten ze omzetten naar een numeriek formaat zodat het neuraal netwerk ze eenvoudig kan verwerken.

from tensorflow.keras.utils import to_categorical
train_labels = to_categorical(train_labels, len(class_names))
test_labels = to_categorical(test_labels, len(class_names))

Implementatie van de modelarchitectuur

De volgende stap is het implementeren van de architectuur van het netwerk op basis van de eerdere beschrijving. 

Eerst definiëren we het model met de Sequential()-klasse en elke laag wordt aan het model toegevoegd met de add()-functie. 

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# Variables
INPUT_SHAPE = (32, 32, 3)
FILTER1_SIZE = 32
FILTER2_SIZE = 64
FILTER_SHAPE = (3, 3)
POOL_SHAPE = (2, 2)
FULLY_CONNECT_NUM = 128
NUM_CLASSES = len(class_names)

# Model architecture implementation
model = Sequential()
model.add(Conv2D(FILTER1_SIZE, FILTER_SHAPE, activation='relu', input_shape=INPUT_SHAPE))
model.add(MaxPooling2D(POOL_SHAPE))
model.add(Conv2D(FILTER2_SIZE, FILTER_SHAPE, activation='relu'))
model.add(MaxPooling2D(POOL_SHAPE))
model.add(Flatten())
model.add(Dense(FULLY_CONNECT_NUM, activation='relu'))
model.add(Dense(NUM_CLASSES, activation='softmax'))

Na het aanroepen van de functie summary() op het model krijgen we een uitgebreid overzicht van de modelarchitectuur met informatie over elke laag, het type, de outputvorm en het totale aantal trainbare parameters. 

Modeltraining

Alle middelen zijn eindelijk beschikbaar om de training van het model te configureren en te starten. Dit gebeurt respectievelijk met de functies compile() en fit(), die de volgende parameters gebruiken: 

• De optimizer is verantwoordelijk voor het bijwerken van de gewichten en biases van het model. In ons geval gebruiken we de Adam-optimizer. 
• De verliesfunctie meet de classificatiefouten; we gebruiken Categorical Crossentropy.
• Tot slot worden met metrics de prestaties van het model gemeten; in ons voorbeeld tonen we accuracy, precision en recall.

from tensorflow.keras.metrics import Precision, Recall

BATCH_SIZE = 32
EPOCHS = 30

METRICS = metrics=['accuracy',
               	Precision(name='precision'),
               	Recall(name='recall')]

model.compile(optimizer='adam',
          	loss='categorical_crossentropy',
          	metrics = METRICS)

# Train the model
training_history = model.fit(train_images, train_labels,
                	epochs=EPOCHS, batch_size=BATCH_SIZE,
                	validation_data=(test_images, test_labels))

Modelevaluatie

Na het trainen van het model kunnen we de prestaties op zowel de trainings- als testdataset vergelijken door de bovenstaande metrics te plotten met de hulpfunctie show_performance_curve() in twee dimensies. 

• De horizontale as (x) is het aantal epochs
• De verticale as (y) is de onderliggende prestatie van het model. 
• De curve geeft de waarde van de metrics weer bij een specifieke epoch.

Voor een betere visualisatie wordt een verticale rode lijn getekend door het snijpunt van de trainings- en validatieprestatie, samen met de optimale waarde.

def show_performance_curve(training_result, metric, metric_label):
    
	train_perf = training_result.history[str(metric)]
	validation_perf = training_result.history['val_'+str(metric)]
	intersection_idx = np.argwhere(np.isclose(train_perf,
                                            	validation_perf, atol=1e-2)).flatten()[0]
	intersection_value = train_perf[intersection_idx]
    
	plt.plot(train_perf, label=metric_label)
	plt.plot(validation_perf, label = 'val_'+str(metric))
	plt.axvline(x=intersection_idx, color='r', linestyle='--', label='Intersection')
    
	plt.annotate(f'Optimal Value: {intersection_value:.4f}',
         	xy=(intersection_idx, intersection_value),
         	xycoords='data',
         	fontsize=10,
         	color='green')
            	 
	plt.xlabel('Epoch')
	plt.ylabel(metric_label)
	plt.legend(loc='lower right')

Vervolgens passen we de functie toe voor zowel de accuracy als de precision van het model.

show_performance_curve(training_history, 'accuracy', 'accuracy')

show_performance_curve(training_history, 'precision', 'precision')

Na het trainen van het model zonder enige fine-tuning en preprocessing komen we uit op:  

• Een nauwkeurigheidsscore van 67,09%, wat betekent dat het model 67 van elke 100 voorbeelden correct classificeert. 
• En een precisie van 76,55%, wat betekent dat van elke 100 positieve voorspellingen er bijna 77 echt positief zijn en de overige 23 vals-positief. 
• Deze scores worden respectievelijk bij de derde en tweede epoch behaald voor nauwkeurigheid en precisie.

Deze twee metrics geven een globaal beeld van het modelgedrag. 

Wat als we per klasse willen weten bij welke het model goed presteert en welke het lastig vindt?

Dit kan met de confusion matrix, die per klasse het aantal correcte en foute voorspellingen toont. De implementatie staat hieronder. We beginnen met voorspellingen op de testdata, berekenen vervolgens de confusion matrix en tonen het eindresultaat.

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

test_predictions = model.predict(test_images)

test_predicted_labels = np.argmax(test_predictions, axis=1)

test_true_labels = np.argmax(test_labels, axis=1)

cm = confusion_matrix(test_true_labels, test_predicted_labels)

cmd = ConfusionMatrixDisplay(confusion_matrix=cm)

cmd.plot(include_values=True, cmap='viridis', ax=None, xticks_rotation='horizontal')
plt.show()

• Klassen 0, 1, 6, 7, 8, 9, respectievelijk airplane, automobile, frog, horse, ship, en truck, hebben de hoogste waarden op de diagonaal. Dit betekent dat het model deze klassen beter voorspelt. 
• Aan de andere kant lijkt het moeite te hebben met de overige klassen:  
• De klassen met de hoogste off-diagonale waarden zijn die waarmee het model de goede klassen verwart. Zo verwart het bijvoorbeeld birds (klasse 2) met een airplane, en automobile met trucks (klasse 9).

Leer meer over de confusion matrix in onze tutorial understanding confusion matrix in R, die lesmateriaal uit DataCamp’s Machine Learning Toolbox-cursus behandelt.

Dit model kan worden verbeterd met extra taken zoals:  

• Beeldaugmentatie
• Transfer learning met voorgetrainde modellen zoals ResNet, MobileNet of VGG. Onze tutorial over transfer learning legt uit wat transfer learning is en enkele toepassingen in de praktijk.
• Het toepassen van verschillende regularisatietechnieken zoals L1, L2 of dropout.  
• Het fijnafstellen van verschillende hyperparameters zoals learning rate, batchgrootte en het aantal lagen in het netwerk. 

Conclusie

Dit artikel heeft een volledig overzicht gegeven van CNN’s in TensorFlow, met details over elke laag van de CNN-architectuur. Ook hebben we kort geïntroduceerd hoe TensorFlow machinelearning-engineers en onderzoekers helpt om geavanceerde neurale netwerken te bouwen. 

We hebben al deze vaardigheden toegepast op een realistische use case rond een multiclass-classificatietaak.  

Onze beginnersgids voor objectdetectie is een mooie volgende stap om je kennis over computer vision verder te verdiepen. Hij verkent de kerncomponenten van objectdetectie en legt uit hoe je implementaties maakt in SSD en Faster RCNN die beschikbaar zijn in TensorFlow.