Sfida: Costruzione di una CNN
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))
Il parametro input_shape
deve essere specificato solo nello strato di input.
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')
L'ultimo livello dense di solito ha un numero di unità uguale al numero di classi e utilizza una funzione di attivazione softmax per restituire una distribuzione di probabilità tra le classi.
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
ebatch_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.
Grazie per i tuoi commenti!
Chieda ad AI
Chieda ad AI
Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione
Awesome!
Completion rate improved to 3.45
Sfida: Costruzione di una CNN
Scorri per mostrare il menu
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))
Il parametro input_shape
deve essere specificato solo nello strato di input.
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')
L'ultimo livello dense di solito ha un numero di unità uguale al numero di classi e utilizza una funzione di attivazione softmax per restituire una distribuzione di probabilità tra le classi.
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
ebatch_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.
Grazie per i tuoi commenti!