Convolutionele neurale netwerken (CNN's) worden veel gebruikt bij beeldclassificatie vanwege hun vermogen om hiërarchische kenmerken te extraheren. In deze opdracht implementeer en train je een VGG-achtig CNN met TensorFlow en Keras op de CIFAR-10 dataset. De dataset bestaat uit 60.000 afbeeldingen (32×32×3) die behoren tot 10 verschillende klassen, waaronder vliegtuigen, auto's, vogels, katten en meer.

Dit project begeleidt je bij het laden van de dataset, het preprocessen van de afbeeldingen, het definiëren van het CNN-model, het trainen ervan en het evalueren van de prestaties.

1. Gegevensvoorbewerking voor CNN's

Voor het trainen van een CNN is het voorbewerken van de gegevens een cruciale stap om betere prestaties en snellere convergentie te waarborgen. Veelgebruikte voorbewerkingsmethoden zijn:

• Normalisatie: deze methode houdt in dat de pixelwaarden van afbeeldingen worden geschaald van een bereik tussen 0 en 255 naar een bereik tussen 0 en 1. Dit wordt vaak geïmplementeerd als x_train / 255.0, x_test / 255.0;

• One-hot encoding: labels worden vaak omgezet in one-hot gecodeerde vectoren voor classificatietaken. Dit gebeurt doorgaans met de functie keras.utils.to_categorical, die gehele getallenlabels (bijv. 0, 1, 2, enz.) omzet in een one-hot gecodeerde vector, zoals [1, 0, 0, 0] voor een classificatieprobleem met 4 klassen.

2. Het opbouwen van de CNN-architectuur

Een CNN-architectuur bestaat uit meerdere lagen die verschillende taken uitvoeren om kenmerken te extraheren en voorspellingen te doen. Belangrijke CNN-lagen kunnen worden geïmplementeerd door:

Convolutionele laag (Conv2D)

keras.layers.Conv2D(filters, kernel_size, activation='relu', padding='same', input_shape=(height, width, channels))

Pooling-laag (MaxPooling2D)

keras.layers.MaxPooling2D(pool_size=(2, 2))

Flatten-laag

keras.layers.Flatten()

Dense-laag

layers.Dense(units=512, activation='relu')
layers.Dense(10, activation='softmax')

3. Modelcompilatie

Na het definiëren van de architectuur moet het model worden gecompileerd. In deze stap worden de verliesfunctie, optimizer en metriek gespecificeerd die het model tijdens het trainen zullen sturen. De volgende methoden worden vaak gebruikt bij CNN's:

Optimizer (Adam)

De optimizer past de gewichten van het model aan om de verliesfunctie te minimaliseren. De Adam-optimizer is populair vanwege zijn efficiëntie en het vermogen om het leerproces tijdens de training aan te passen.

keras.optimizers.Adam()

Verliesfunctie (Categorical Crossentropy)

Voor multi-klasse classificatie wordt doorgaans categorical crossentropy gebruikt als verliesfunctie. Dit kan als volgt worden geïmplementeerd:

keras.losses.CategoricalCrossentropy()

Metrieken

De modelprestaties worden gemonitord met behulp van metriek voor classificatietaken, zoals nauwkeurigheid, precisie, recall, enzovoort. Deze kunnen als volgt worden gedefinieerd:

metrics = [
    keras.metrics.Accuracy(), 
    keras.metrics.Precision(), 
    keras.metrics.Recall()
]

Compileren

model.compile(optimizer='adam', 
              loss='categorical_crossentropy', # Or keras.losses.CategoricalCrossentropy()
              metrics=metrics)

4. Het model trainen

Het trainen van een CNN omvat het aanbieden van de invoergegevens aan het netwerk, het berekenen van het verlies en het bijwerken van de gewichten met behulp van backpropagation. Het trainingsproces wordt aangestuurd door de volgende belangrijke methoden:

• Model trainen: de fit()-methode wordt gebruikt om het model te trainen. Deze methode neemt de trainingsgegevens, het aantal epochs en de batchgrootte als invoer. Er is ook een optionele validatiesplit om de prestaties van het model op niet eerder geziene gegevens tijdens de training te evalueren:

history = model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.2)

• Batchgrootte en epochs: de batchgrootte bepaalt het aantal voorbeelden dat wordt verwerkt voordat de modelgewichten worden bijgewerkt, en het aantal epochs verwijst naar hoe vaak de volledige dataset door het model wordt gehaald.

5. Evaluatie

Classificatierapport

sklearn.metrics.classification_report() vergelijkt ware en voorspelde waarden uit de testdataset. Het bevat precisie, recall en F1-score voor elke klasse. De methoden vereisen alleen klassenlabels, dus vergeet niet deze terug te converteren van vectoren ([0,0,1,0] -> 2):

y_pred = model.predict(x_test)
y_pred_classes = np.argmax(y_pred,axis = 1)
y_test_classes = np.argmax(y_test, axis = 1)

report = classification_report(y_test_classes, y_pred_classes, target_names=class_names)
print(report)

Evalueren

Nadat het model is getraind, wordt het geëvalueerd op de testdataset om het generalisatievermogen te beoordelen. De evaluatie levert metriek op, die werden genoemd in de .compile()-methode. De evaluatie wordt uitgevoerd met .evaluate():

results = model.evaluate(x_test, y_test, verbose=2, return_dict=True)

Confusiematrix

Voor meer inzicht in de prestaties van het model kan de confusiematrix worden gevisualiseerd, die de true positive, false positive, true negative en false negative voorspellingen voor elke klasse toont. De confusiematrix kan worden berekend met TensorFlow:

confusion_mtx = tf.math.confusion_matrix(y_test_classes, y_pred_classes)

Deze matrix kan vervolgens worden gevisualiseerd met behulp van heatmaps om te observeren hoe goed het model presteert op elke klasse:

plt.figure(figsize=(12, 9))
c = sns.heatmap(confusion_mtx, annot=True, fmt='g')
c.set(xticklabels=class_names, yticklabels=class_names)

plt.show()

1. Laad en preprocess het dataset

• Importeer de CIFAR-10 dataset vanuit Keras;
• Normaliseer de pixelwaarden naar het bereik [0,1] voor betere convergentie;
• Zet de klasse-labels om naar one-hot encoded formaat voor categorische classificatie.

2. Definieer het CNN-model

Implementeer een VGG-achtige CNN-architectuur met de volgende kernlagen:

Convolutionele lagen:

• Kernelgrootte: 3×3;
• Activatiefunctie: ReLU;
• Padding: 'same'.

Pooling-lagen:

• Poolingtype: max pooling;
• Poolinggrootte: 2×2.

Dropout-lagen (Voorkom overfitting door willekeurig neuronen uit te schakelen):

• Dropout-percentage: 25%.

Flatten-laag - zet 2D feature maps om naar een 1D vector voor classificatie.

Volledig verbonden lagen - dense lagen voor uiteindelijke classificatie, met een relu- of softmax-uitvoerlaag.

Compileer het model met:

• Adam optimizer (voor efficiënte training);
• Categorical cross-entropy verliesfunctie (voor multi-class classificatie);
• Accuracy metric om prestaties te meten (klassen zijn gebalanceerd, en je kunt zelf andere metrics toevoegen).

3. Train het model

• Specificeer de parameters epochs en batch_size voor training (bijv. epochs=20, batch_size=64);
• Specificeer de parameter validation_split om het percentage trainingsdata dat validatie wordt te bepalen, zodat de modelprestaties op ongeziene afbeeldingen gevolgd kunnen worden;
• Sla de trainingsgeschiedenis op om trends in nauwkeurigheid en verlies te visualiseren.

4. Evalueer en visualiseer resultaten

• Test het model op CIFAR-10 testdata en print de nauwkeurigheid;
• Plot trainingsverlies versus validatieverlies om te controleren op overfitting;
• Plot trainingsnauwkeurigheid versus validatienauwkeurigheid om de voortgang van het leren te waarborgen.

COLAB CNN PROJECT