Le reti neurali convoluzionali (CNN) sono ampiamente utilizzate nella classificazione delle immagini grazie alla loro capacità di estrarre caratteristiche gerarchiche. In questa attività, verrà implementata e addestrata una CNN simile a VGG utilizzando TensorFlow e Keras sul dataset CIFAR-10. Il dataset è composto da 60.000 immagini (32×32×3) appartenenti a 10 classi differenti, tra cui aerei, automobili, uccelli, gatti e altre.

Questo progetto guiderà attraverso le fasi di caricamento del dataset, preprocessamento delle immagini, definizione del modello CNN, addestramento e valutazione delle prestazioni.

1. Preprocessamento dei dati per le CNN

Prima di addestrare una CNN, il preprocessamento dei dati è un passaggio fondamentale per garantire migliori prestazioni e una convergenza più rapida. I metodi di preprocessamento più comuni includono:

• Normalizzazione: questo metodo consiste nello scalare i valori dei pixel delle immagini da un intervallo compreso tra 0 e 255 a un intervallo tra 0 e 1. Viene spesso implementato come x_train / 255.0, x_test / 255.0;

• One-Hot Encoding: le etichette vengono spesso convertite in vettori one-hot encoded per i compiti di classificazione. Questo viene tipicamente realizzato tramite la funzione keras.utils.to_categorical, che trasforma le etichette intere (ad esempio, 0, 1, 2, ecc.) in un vettore one-hot encoded, come [1, 0, 0, 0] per un problema di classificazione a 4 classi.

2. Costruzione dell'Architettura CNN

Un'architettura CNN è composta da diversi strati che svolgono compiti differenti per estrarre caratteristiche e formulare previsioni. È possibile implementare i principali strati di una CNN tramite:

Strato Convoluzionale (Conv2D)

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

Strato di Pooling (MaxPooling2D)

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

Livello Flatten

keras.layers.Flatten()

Livello Dense

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

3. Compilazione del Modello

Dopo aver definito l'architettura, è necessario compilare il modello. Questa fase prevede la specifica della funzione di perdita, dell'ottimizzatore e delle metriche che guideranno il modello durante l'addestramento. I seguenti metodi sono comunemente utilizzati nelle CNN:

Ottimizzatore (Adam)

L'ottimizzatore regola i pesi del modello per minimizzare la funzione di perdita. L'ottimizzatore Adam è molto utilizzato grazie alla sua efficienza e alla capacità di adattare il tasso di apprendimento durante l'addestramento.

keras.optimizers.Adam()

Funzione di Perdita (Categorical Crossentropy)

Per la classificazione multi-classe, si utilizza tipicamente la categorical crossentropy come funzione di perdita. Può essere implementata come segue:

keras.losses.CategoricalCrossentropy()

Metriche

Le prestazioni del modello vengono monitorate utilizzando metriche per i compiti di classificazione, come accuratezza, precisione, richiamo, ecc. Queste possono essere definite come segue:

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

Compilazione

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

4. Addestramento del Modello

L'addestramento di una CNN consiste nell'inviare i dati di input alla rete, calcolare la funzione di perdita e aggiornare i pesi tramite backpropagation. Il processo di addestramento è gestito dai seguenti metodi principali:

• Adattamento del Modello: il metodo fit() viene utilizzato per addestrare il modello. Questo metodo richiede i dati di addestramento, il numero di epoche e la dimensione del batch. Include anche una suddivisione opzionale di validazione per valutare le prestazioni del modello su dati non visti durante l'addestramento:

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

• Dimensione del batch ed epoche: la dimensione del batch determina il numero di campioni elaborati prima dell'aggiornamento dei pesi del modello, mentre il numero di epoche indica quante volte l'intero dataset viene passato attraverso il modello.

5. Valutazione

Report di Classificazione

sklearn.metrics.classification_report() confronta i valori veri e predetti dal dataset di test. Include precisione, richiamo e F1 score per ogni classe. Tuttavia, i metodi richiedono solo le etichette di classe, quindi ricordarsi di convertirle dai vettori ([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)

Valutazione

Una volta che il modello è stato addestrato, viene valutato sul dataset di test per misurare la sua capacità di generalizzazione. La valutazione fornisce metriche, già menzionate nel metodo .compile(). La valutazione viene eseguita utilizzando .evaluate():

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

Matrice di Confusione

Per ottenere ulteriori informazioni sulle prestazioni del modello, è possibile visualizzare la matrice di confusione, che mostra le predizioni vere positive, false positive, vere negative e false negative per ciascuna classe. La matrice di confusione può essere calcolata utilizzando TensorFlow:

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

Questa matrice può essere quindi visualizzata utilizzando delle heatmap per osservare quanto bene il modello si comporta su ciascuna classe:

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. Carica e preelabora il dataset

• Importa il dataset CIFAR-10 da Keras;
• Normalizza i valori dei pixel nell'intervallo [0,1] per una migliore convergenza;
• Converti le etichette di classe in formato one-hot encoded per la classificazione categoriale.

2. Definisci il modello CNN

Implementa un'architettura CNN simile a VGG con i seguenti livelli chiave:

Layer convoluzionali:

• Dimensione kernel: 3×3;
• Funzione di attivazione: ReLU;
• Padding: 'same'.

Layer di pooling:

• Tipo di pooling: max pooling;
• Dimensione pooling: 2×2.

Layer di dropout (Prevengono l'overfitting disabilitando casualmente i neuroni):

• Tasso di dropout: 25%.

Layer di flatten - converte le mappe di caratteristiche 2D in un vettore 1D per la classificazione.

Layer completamente connessi - layer densi per la classificazione finale, con un layer di output relu o softmax.

Compila il modello utilizzando:

• Adam optimizer (per un apprendimento efficiente);
• Funzione di perdita Categorical cross-entropy (per classificazione multi-classe);
• Accuracy metric per misurare le prestazioni (le classi sono bilanciate, puoi aggiungere altre metriche a tua discrezione).

3. Allena il modello

• Specifica i parametri epochs e batch_size per l'addestramento (ad es. epochs=20, batch_size=64);
• Specifica il parametro validation_split per definire la percentuale di dati di training che diventa di validazione per monitorare le prestazioni del modello su immagini non viste;
• Salva la cronologia dell'addestramento per visualizzare l'andamento di accuratezza e perdita.

4. Valuta e visualizza i risultati

• Testa il modello sui dati di test CIFAR-10 e stampa l'accuratezza;
• Traccia training loss vs. validation loss per verificare l'overfitting;
• Traccia training accuracy vs. validation accuracy per assicurare la progressione dell'apprendimento.

PROGETTO COLAB CNN