Informazioni su questo codelab
1. Prima di iniziare
In questo codelab, creerai un modello di visione artificiale in grado di riconoscere i capi di abbigliamento con TensorFlow.
Prerequisiti
- Una solida conoscenza di Python
- Competenze di programmazione di base
Cosa imparerai a fare:
In questo codelab, utilizzerai:
- Addestrare una rete neurale a riconoscere articoli di abbigliamento
- Completa una serie di esercizi per guidarti negli esperimenti con i diversi livelli della rete
Cosa imparerai a realizzare
- Una rete neurale che identifica articoli di abbigliamento
Che cosa ti serve
Se non hai mai creato una rete neurale per la visione artificiale con TensorFlow, puoi utilizzare Colaboratory, un ambiente basato su browser che contiene tutte le dipendenze richieste. Puoi trovare il codice per il resto del codelab in esecuzione in Colab.
In caso contrario, il linguaggio principale che utilizzerai per l'addestramento dei modelli è Python, quindi dovrai installarlo. Inoltre, avrai bisogno anche di TensorFlow e della libreria NumPy. Scopri di più sull'installazione di TensorFlow qui. Installa NumPy qui.
2. Inizia programmazione
Innanzitutto, esplora il blocco note Colab eseguibile.
Inizia importando TensorFlow.
import tensorflow as tf
print(tf.__version__)
Addestrarai una rete neurale a riconoscere gli articoli di abbigliamento da un set di dati comune chiamato Fashion MNIST. Contiene 70.000 capi di abbigliamento in 10 diverse categorie. Ogni capo di abbigliamento è raffigurato in un'immagine in scala di grigi di 28 x 28. Puoi vedere alcuni esempi qui:
Le etichette associate al set di dati sono le seguenti:
Etichetta | Descrizione |
0 | Maglietta/top |
1 | Pantaloni |
2 | Pullover |
3 | Abito |
4 | Cappotto |
5 | Sandalo |
6 | Maglietta |
7 | Sneaker |
8 | Borsa |
9 | Stivaletto |
I dati Fashion MNIST sono disponibili nell'API tf.keras.datasets. Caricalo in questo modo:
mnist = tf.keras.datasets.fashion_mnist
Una chiamata a load_data dell'oggetto fornisce due insiemi di due elenchi: valori di addestramento e valori di test, che rappresentano immagini che mostrano gli articoli di abbigliamento e le relative etichette.
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
Che aspetto hanno questi valori? Stampa un'immagine di addestramento e un'etichetta di addestramento per visualizzare. Puoi sperimentare diversi indici nell'array.
import matplotlib.pyplot as plt
plt.imshow(training_images[0])
print(training_labels[0])
print(training_images[0])
La stampa dei dati per l'articolo 0 ha il seguente aspetto:
Noterai che tutti i valori sono numeri interi compresi tra 0 e 255. Quando addestri una rete neurale, è più facile trattare tutti i valori tra 0 e 1, un processo chiamato normalizzazione. Fortunatamente, Python offre un modo semplice per normalizzare un elenco di questo tipo senza creare loop.
training_images = training_images / 255.0
test_images = test_images / 255.0
Potresti anche guardare 42, un avvio diverso da quello dell'indice 0.
Forse ti starai chiedendo perché esistono due set di dati: addestramento e test.
L'idea è quella di avere un set di dati per l'addestramento e un altro di dati che il modello non ha ancora riscontrato per riuscire a classificare i valori. Dopo tutto, quando hai finito, dovrai utilizzare il modello con dati che non aveva mai visto prima! Inoltre, senza dati di test separati, corri il rischio che la rete conservi solo i dati di addestramento senza assorbire le sue conoscenze.
3. Progetta il modello
Ora progetta il modello. Avrai tre livelli. Analizzali uno per volta ed esplora i diversi tipi di livelli e i parametri utilizzati per ciascuno.
model = tf.keras.models.Sequential([tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation=tf.nn.relu),
tf.keras.layers.Dense(10, activation=tf.nn.softmax)])
Sequentialdefinisce una sequenza di livelli nella rete neurale.Flattentrasforma un quadrato in un monodimensionale.Denseaggiunge un livello di neuroni.- Le funzioni
Activationindicano a ogni livello di neuroni cosa fare. Esistono moltissime opzioni, ma per adesso li utilizzi: Reluin modo efficace significa che se X è maggiore di 0, restituisce X, altrimenti restituisce 0. Passa solo i valori pari a 0 o superiori al livello successivo nella rete.Softmaxprende una serie di valori e sceglie in modo efficace quello più grande. Ad esempio, se l'output dell'ultimo livello è simile a [0.1, 0.1, 0.05, 0.1, 9.5, 0.1, 0.05, 0.05, 0.05], non devi ordinare il valore più grande: restituisce [0,0,0,1,0,0,0,0].
4. Compilare e addestrare il modello
Ora che il modello è definito, la prossima cosa da fare è crearlo. Crea un modello compilando innanzitutto una funzione optimizer e una funzione loss, quindi addestralo sui dati e sulle etichette dell'addestramento. L'obiettivo è fare in modo che il modello capisca la relazione tra i dati di addestramento e le relative etichette di addestramento. In seguito, vuoi che il modello visualizzi dati simili ai tuoi dati di addestramento e fai una previsione sull'aspetto di questi dati.
Nota l'utilizzo di metrics= come parametro, che permette a TensorFlow di segnalare l'accuratezza dell'addestramento confrontando i risultati previsti con le risposte note (le etichette).
model.compile(optimizer = tf.keras.optimizers.Adam(),
loss = 'sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=5)
Quando viene eseguito model.fit, puoi vedere la perdita e la precisione:
Epoch 1/5 60000/60000 [=======] - 6s 101us/sample - loss: 0.4964 - acc: 0.8247 Epoch 2/5 60000/60000 [=======] - 5s 86us/sample - loss: 0.3720 - acc: 0.8656 Epoch 3/5 60000/60000 [=======] - 5s 85us/sample - loss: 0.3335 - acc: 0.8780 Epoch 4/5 60000/60000 [=======] - 6s 103us/sample - loss: 0.3134 - acc: 0.8844 Epoch 5/5 60000/60000 [=======] - 6s 94us/sample - loss: 0.2931 - acc: 0.8926
Una volta completato l'addestramento del modello, visualizzerai un valore di accuratezza alla fine del periodo finale. Potrebbe avere un aspetto simile a 0,8926 come sopra. Questo valore indica che la rete neurale è precisa all'89% circa nella classificazione dei dati di addestramento. In altre parole, ha individuato una corrispondenza di schema tra l'immagine e le etichette che hanno funzionato l'89% delle volte. Non male, ma non male considerando che è stato fatto solo per cinque periodi e che è stato fatto in poco tempo.
5. Testa il modello
Qual è il rendimento del modello sui dati che non ha mai visto? Ecco perché hai l'insieme di test. Chiama il numero model.evaluate e trasmetti i due insiemi; viene segnalata la perdita di ognuno. Fai una prova:
model.evaluate(test_images, test_labels)
E questo è l'output:
10000/10000 [=====] - 1s 56us/sample - loss: 0.3365 - acc: 0.8789 [0.33648381242752073, 0.8789]
L'esempio ha restituito un'accuratezza di 0,8789, il che significa che la precisione è circa l'88%. Potresti avere valori leggermente diversi.
Come previsto, il modello con i dati sconosciuti non è così preciso come con i dati su cui è stato addestrato. Man mano che scopri di più su TensorFlow, troverai modi per migliorarlo.
Per saperne di più, prova gli esercizi successivi.
6. Esercizi di esplorazione
Attività fisica 1
Per il primo esercizio, esegui il seguente codice:
classifications = model.predict(test_images)
print(classifications[0])
Viene creata una serie di classificazioni per ciascuna delle immagini di prova, quindi stampa la prima voce delle classificazioni. L'output dopo l'esecuzione è un elenco di numeri. A cosa è dovuto e dove rappresentano questi numeri?
Prova a eseguire print(test_labels[0]) e riceverai un 9. Ti aiuta a capire perché l'elenco ha il suo aspetto?
L'output del modello è un elenco di dieci numeri. Questi numeri corrispondono alla probabilità che il valore classificato sia l'etichetta corrispondente. Ad esempio, il primo valore nell'elenco è la probabilità che l'abbigliamento sia di classe 0 e il successivo sia 1. Tieni presente che tutte sono molto basse, tranne una. Inoltre, a causa di Softmax, tutte le probabilità nell'elenco sono pari a 1,0.
L'elenco e le etichette sono basate su 0, quindi lo stivaletto con etichetta 9 indica che è la decima delle dieci classi. L'elenco con il decimo elemento più alto significa che la rete neurale ha previsto che l'elemento che sta classificando è molto probabilmente uno stivaletto.
Attività fisica 2
Osserva i livelli del tuo modello. Prova diversi valori per il livello ad alta densità con 512 neuroni.
Quali risultati diversi ottieni per la perdita e il tempo di addestramento? Perché ritieni che sia così?
Ad esempio, se aumenti fino a 1024 neuroni, devi eseguire più calcoli, rallentando il processo. In questo caso, tuttavia, hanno un buon impatto perché il modello è più preciso. Questo non significa che sia sempre meglio. Puoi farti valere la legge di riduzione dei resi molto rapidamente.
Esercizio 3
Che cosa succede se rimuovi il livello Flatten(). Perché ritieni che sia così?
Viene visualizzato un errore sulla forma dei dati. I dettagli dell'errore potrebbero sembrare vaghi in questo momento, ma rafforza la regola generale secondo cui il primo livello della rete deve avere la stessa forma dei dati. Al momento i tuoi dati sono di 28 x 28 immagini e 28 strati di 28 neuroni non sarebbero fattibili, quindi è più logico suddividere questi 28,28 in un formato di 784 x 1.
Anziché scrivere tutto il codice, aggiungi il livello Flatten() all'inizio. Quando gli array vengono caricati nel modello in un secondo momento, vengono suddivisi automaticamente.
Esercizio 4
Considera i livelli finali (output). Perché ce ne sono 10? Che cosa succederebbe se avessi un importo diverso da 10?
Prova ad addestrare la rete con 5. Ricevi un errore non appena trova un valore imprevisto. Un'altra regola generale: il numero di neuroni nell'ultimo livello deve corrispondere al numero di classi per cui stai effettuando la classificazione. In questo caso, sono le cifre da 0 a 9, quindi ce ne sono 10, quindi dovresti avere 10 neuroni nel tuo livello finale.
Attività fisica 5
Esamina gli effetti dei livelli aggiuntivi nella rete. Cosa accade se si aggiunge un altro livello tra 512 e 10?
Non c'è alcun impatto significativo, perché si tratta di dati relativamente semplici. Per dati molto più complessi, spesso sono necessari livelli aggiuntivi.
Attività fisica 6
Prima dell'addestramento, hai normalizzato i dati, passando da valori compresi tra 0 e 255 a valori compresi tra 0 e 1. Che effetto avrebbe sulla rimozione? Ecco il codice completo per provare (tieni presente che le due righe che normalizzano i dati vengono commentate).
Perché pensi di ottenere risultati diversi? C'è un'ottima risposta qui su Stack Overflow.
import tensorflow as tf
print(tf.__version__)
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
#training_images=training_images/255.0
#test_images=test_images/255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(512, activation=tf.nn.relu),
tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(training_images, training_labels, epochs=5)
model.evaluate(test_images, test_labels)
classifications = model.predict(test_images)
print(classifications[0])
print(test_labels[0])
7. Esplora i callback
In precedenza, quando hai completato la formazione per i periodi aggiuntivi, hai avuto un problema in cui la tua perdita potrebbe cambiare. Potrebbe essere stato necessario un po' di tempo per aspettare la formazione e potresti aver pensato che sarebbe bello se potessi interrompere l'addestramento quando raggiungi un valore desiderato, ad esempio la precisione del 95%. Se raggiungi questo periodo dopo tre periodi, perché aspettare che finisca molto di più?
Come in qualsiasi altro programma, hai richiamata! Guardali in azione:
import tensorflow as tf
class myCallback(tf.keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs={}):
if(logs.get('accuracy')>0.95):
print("\nReached 95% accuracy so cancelling training!")
self.model.stop_training = True
callbacks = myCallback()
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images/255.0
test_images=test_images/255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(512, activation=tf.nn.relu),
tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=5, callbacks=[callbacks])
8. Complimenti
Hai creato il tuo primo modello di visione artificiale! Per scoprire come migliorare i modelli della visione artificiale, consulta Sviluppare le convoluzioni ed eseguire il pool.