Sfida: Costruire una CNN

Le reti neurali convoluzionali (CNN) sono ampiamente utilizzate nella classificazione delle immagini grazie alla loro capacità di estrarre caratteristiche gerarchiche. In questo compito, implementazione e addestramento di 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 altro.

Questo progetto guida attraverso caricamento del dataset, preprocessamento delle immagini, definizione del modello CNN, addestramento ed valutazione delle prestazioni.

1. Preprocessamento dei dati per le CNN

Prima di addestrare una CNN, il preprocessamento dei dati è un passaggio cruciale per garantire migliori prestazioni e una convergenza più rapida. I metodi di preprocessamento 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. Spesso viene 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 fare previsioni. È possibile implementare i principali strati delle 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. Questo passaggio 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 diffuso 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 multiclasse, la funzione di perdita tipicamente utilizzata è la categorical crossentropy. 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 loss 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)

• Batch Size ed Epoche: la dimensione del batch determina il numero di campioni elaborati prima di aggiornare i 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 valori reali e previsti dal dataset di test. Include precisione, recall e F1 score per ogni classe. Tuttavia, i metodi richiedono solo le etichette delle classi, 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 verificarne la capacità di generalizzazione. La valutazione fornisce metriche, che sono state 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 previsioni di veri positivi, falsi positivi, veri negativi e falsi negativi per ogni 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ò quindi essere visualizzata utilizzando 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()

Compito

1. Caricamento e preprocessamento del dataset

• Importazione del dataset CIFAR-10 da Keras;
• Normalizzazione dei valori dei pixel nell'intervallo [0,1] per una migliore convergenza;
• Conversione delle etichette di classe in formato one-hot encoded per la classificazione categoriale.

2. Definizione del modello CNN

Implementazione di 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 (Prevenzione dell'overfitting disabilitando casualmente i neuroni):

• Tasso di dropout: 25%.

Layer di flatten - conversione delle feature map 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.

Compilazione del 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, è possibile aggiungere altre metriche a piacere).

3. Addestramento del modello

• Specificare i parametri epochs e batch_size per l'addestramento (es. epochs=20, batch_size=64);
• Specificare 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;
• Salvare la cronologia dell'addestramento per visualizzare l'andamento di accuratezza e perdita.

4. Valutazione e visualizzazione dei risultati

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

PROGETTO CNN COLAB