RSVP per il tuo evento TensorFlow Everywhere locale oggi!
Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Classificazione di base: classifica le immagini degli indumenti

Visualizza su TensorFlow.org Visualizza sorgente su GitHub Scarica taccuino

Questa guida addestra un modello di rete neurale per classificare le immagini di abbigliamento, come scarpe da ginnastica e camicie. Va bene se non capisci tutti i dettagli; questa è una panoramica veloce di un programma TensorFlow completo con i dettagli spiegati man mano che procedi.

Questa guida utilizza tf.keras , un'API di alto livello per creare e addestrare modelli in TensorFlow.

# TensorFlow and tf.keras
import tensorflow as tf

# Helper libraries
import numpy as np
import matplotlib.pyplot as plt

print(tf.__version__)
2.3.1

Importa il set di dati Fashion MNIST

Questa guida utilizza il set di dati Fashion MNIST che contiene 70.000 immagini in scala di grigi in 10 categorie. Le immagini mostrano singoli capi di abbigliamento a bassa risoluzione (28 x 28 pixel), come si vede qui:

Sprite MNIST di moda
Figura 1. Campioni Fashion-MNIST (di Zalando, MIT License).

Fashion MNIST è inteso come un sostituto immediato del classico set di dati MNIST , spesso utilizzato come "Hello, World" dei programmi di machine learning per la visione artificiale . Il set di dati MNIST contiene immagini di cifre scritte a mano (0, 1, 2, ecc.) In un formato identico a quello degli articoli di abbigliamento che utilizzerai qui.

Questa guida utilizza Fashion MNIST per varietà e perché è un problema leggermente più impegnativo del normale MNIST. Entrambi i set di dati sono relativamente piccoli e vengono utilizzati per verificare che un algoritmo funzioni come previsto. Sono ottimi punti di partenza per testare ed eseguire il debug del codice.

Qui, 60.000 immagini vengono utilizzate per addestrare la rete e 10.000 immagini per valutare la precisione con cui la rete ha imparato a classificare le immagini. Puoi accedere a Fashion MNIST direttamente da TensorFlow. Importa e carica i dati Fashion MNIST direttamente da TensorFlow:

fashion_mnist = tf.keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
8192/5148 [===============================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 0s 0us/step

Il caricamento del set di dati restituisce quattro array NumPy:

  • Gli array train_images e train_labels sono l' insieme di addestramento: i dati che il modello utilizza per apprendere.
  • Il modello è testato contro l'insieme di test, i test_images e test_labels array.

Le immagini sono array NumPy 28x28, con valori di pixel compresi tra 0 e 255. Le etichette sono un array di numeri interi, compresi tra 0 e 9. Questi corrispondono alla classe di abbigliamento che l'immagine rappresenta:

Etichetta Classe
0 Maglietta / top
1 Pantaloni
2 Maglione
3 Vestito
4 Cappotto
5 Sandalo
6 Camicia
7 Sneaker
8 Borsa
9 Stivaletto

Ogni immagine è mappata su una singola etichetta. Poiché i nomi delle classi non sono inclusi nel set di dati, memorizzali qui per utilizzarli in seguito durante il tracciamento delle immagini:

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

Esplora i dati

Esploriamo il formato del set di dati prima di addestrare il modello. Quanto segue mostra che ci sono 60.000 immagini nel set di addestramento, con ciascuna immagine rappresentata come 28 x 28 pixel:

train_images.shape
(60000, 28, 28)

Allo stesso modo, ci sono 60.000 etichette nel set di formazione:

len(train_labels)
60000

Ogni etichetta è un numero intero compreso tra 0 e 9:

train_labels
array([9, 0, 0, ..., 3, 0, 5], dtype=uint8)

Ci sono 10.000 immagini nel set di prova. Anche in questo caso, ogni immagine è rappresentata come 28 x 28 pixel:

test_images.shape
(10000, 28, 28)

E il set di test contiene 10.000 etichette di immagini:

len(test_labels)
10000

Pre-elaborare i dati

I dati devono essere preelaborati prima di addestrare la rete. Se esamini la prima immagine nel set di addestramento, vedrai che i valori dei pixel rientrano nell'intervallo da 0 a 255:

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

png

Scala questi valori su un intervallo da 0 a 1 prima di inserirli nel modello di rete neurale. A tale scopo, dividere i valori per 255. È importante che il set di addestramento e il set di test siano preelaborati allo stesso modo:

train_images = train_images / 255.0

test_images = test_images / 255.0

Per verificare che i dati siano nel formato corretto e che tu sia pronto per costruire e addestrare la rete, visualizziamo le prime 25 immagini dal set di addestramento e mostriamo il nome della classe sotto ogni immagine.

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

png

Costruisci il modello

La costruzione della rete neurale richiede la configurazione dei livelli del modello, quindi la compilazione del modello.

Prepara i livelli

L'elemento costitutivo di base di una rete neurale è il livello . I livelli estraggono le rappresentazioni dai dati inseriti in essi. Si spera che queste rappresentazioni siano significative per il problema in esame.

La maggior parte del deep learning consiste nel concatenare insieme semplici livelli. La maggior parte dei livelli, come tf.keras.layers.Dense , ha parametri che vengono appresi durante l'allenamento.

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10)
])

Il primo livello in questa rete, tf.keras.layers.Flatten , trasforma il formato delle immagini da una matrice bidimensionale (di 28 x 28 pixel) a una matrice unidimensionale (di 28 * 28 = 784 pixel). Pensa a questo livello come a separare file di pixel nell'immagine e allinearle. Questo livello non ha parametri da apprendere; riformatta solo i dati.

Dopo che i pixel sono stati appiattiti, la rete consiste in una sequenza di due tf.keras.layers.Dense . Strati tf.keras.layers.Dense . Questi sono strati neurali densamente connessi o completamente connessi. Il primo strato Dense ha 128 nodi (o neuroni). Il secondo (e ultimo) livello restituisce un array di logits con lunghezza di 10. Ogni nodo contiene un punteggio che indica che l'immagine corrente appartiene a una delle 10 classi.

Compila il modello

Prima che il modello sia pronto per l'addestramento, sono necessarie altre impostazioni. Questi vengono aggiunti durante la fase di compilazione del modello:

  • Funzione di perdita: misura l'accuratezza del modello durante l'addestramento. Si desidera ridurre al minimo questa funzione per "guidare" il modello nella giusta direzione.
  • Ottimizzatore: è il modo in cui il modello viene aggiornato in base ai dati visualizzati e alla sua funzione di perdita.
  • Metriche: utilizzate per monitorare le fasi di addestramento e test. L'esempio seguente utilizza l' accuratezza , la frazione delle immagini classificate correttamente.
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

Addestra il modello

L'addestramento del modello di rete neurale richiede i seguenti passaggi:

  1. Fornire i dati di addestramento al modello. In questo esempio, i dati di addestramento si train_images train_labels array train_images e train_labels .
  2. Il modello impara ad associare immagini ed etichette.
  3. Chiedete al modello di fare previsioni su un set di test, in questo esempio, l'array test_images .
  4. Verificare che le previsioni corrispondano alle etichette dall'array test_labels .

Nutri il modello

Per iniziare l'addestramento, chiama il metodo model.fit , così chiamato perché "adatta" il modello ai dati di addestramento:

model.fit(train_images, train_labels, epochs=10)
Epoch 1/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.4917 - accuracy: 0.8277
Epoch 2/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3702 - accuracy: 0.8674
Epoch 3/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.3328 - accuracy: 0.8793
Epoch 4/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3106 - accuracy: 0.8859
Epoch 5/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2915 - accuracy: 0.8927
Epoch 6/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2771 - accuracy: 0.8968
Epoch 7/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2666 - accuracy: 0.9008
Epoch 8/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2547 - accuracy: 0.9055
Epoch 9/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2439 - accuracy: 0.9097
Epoch 10/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2370 - accuracy: 0.9115

<tensorflow.python.keras.callbacks.History at 0x7fd5c7912b00>

Mentre il modello si addestra, vengono visualizzate le metriche di perdita e precisione. Questo modello raggiunge una precisione di circa 0,91 (o 91%) sui dati di addestramento.

Valuta l'accuratezza

Quindi, confronta le prestazioni del modello sul set di dati di test:

test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)

print('\nTest accuracy:', test_acc)
313/313 - 1s - loss: 0.3637 - accuracy: 0.8693

Test accuracy: 0.8693000078201294

Risulta che la precisione sul set di dati di test è leggermente inferiore alla precisione sul set di dati di addestramento. Questo divario tra l'accuratezza dell'addestramento e l'accuratezza del test rappresenta un overfitting . L'overfitting si verifica quando un modello di apprendimento automatico ha prestazioni peggiori con input nuovi e precedentemente non visti rispetto ai dati di addestramento. Un modello overfitted "memorizza" il rumore e i dettagli nel set di dati di addestramento fino al punto in cui ha un impatto negativo sulle prestazioni del modello sui nuovi dati. Per ulteriori informazioni, vedere quanto segue:

Fare previsioni

Con il modello addestrato, puoi usarlo per fare previsioni su alcune immagini. Output lineari del modello, logit . Allega un livello softmax per convertire i logit in probabilità, che sono più facili da interpretare.

probability_model = tf.keras.Sequential([model, 
                                         tf.keras.layers.Softmax()])
predictions = probability_model.predict(test_images)

Qui, il modello ha previsto l'etichetta per ogni immagine nel set di test. Diamo uno sguardo alla prima previsione:

predictions[0]
array([5.1698703e-07, 5.0422708e-11, 1.0513627e-06, 4.2676376e-08,
       4.1753174e-07, 8.8213873e-04, 1.4294442e-06, 8.9591898e-02,
       3.7699414e-07, 9.0952224e-01], dtype=float32)

Una previsione è una matrice di 10 numeri. Rappresentano la "fiducia" del modello che l'immagine corrisponda a ciascuno dei 10 diversi articoli di abbigliamento. Puoi vedere quale etichetta ha il valore di confidenza più alto:

np.argmax(predictions[0])
9

Quindi, il modello è più sicuro che questa immagine sia uno stivaletto o class_names[9] . L'esame dell'etichetta del test mostra che questa classificazione è corretta:

test_labels[0]
9

Rappresenta il grafico per esaminare il set completo di 10 previsioni di classe.

def plot_image(i, predictions_array, true_label, img):
  true_label, img = true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])

  plt.imshow(img, cmap=plt.cm.binary)

  predicted_label = np.argmax(predictions_array)
  if predicted_label == true_label:
    color = 'blue'
  else:
    color = 'red'

  plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[true_label]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  true_label = true_label[i]
  plt.grid(False)
  plt.xticks(range(10))
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1])
  predicted_label = np.argmax(predictions_array)

  thisplot[predicted_label].set_color('red')
  thisplot[true_label].set_color('blue')

Verifica le previsioni

Con il modello addestrato, puoi usarlo per fare previsioni su alcune immagini.

Diamo un'occhiata alla 0a immagine, alle previsioni e all'array di previsioni. Le etichette di previsione corrette sono blu e le etichette di previsione errate sono rosse. Il numero fornisce la percentuale (su 100) per l'etichetta prevista.

i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

png

i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

png

Tracciamo diverse immagini con le loro previsioni. Nota che il modello può essere sbagliato anche se molto sicuro.

# Plot the first X test images, their predicted labels, and the true labels.
# Color correct predictions in blue and incorrect predictions in red.
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions[i], test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

png

Usa il modello addestrato

Infine, usa il modello addestrato per fare una previsione su una singola immagine.

# Grab an image from the test dataset.
img = test_images[1]

print(img.shape)
(28, 28)

tf.keras modelli tf.keras sono ottimizzati per fare previsioni su un batch , o raccolta, di esempi contemporaneamente. Di conseguenza, anche se stai utilizzando una singola immagine, devi aggiungerla a un elenco:

# Add the image to a batch where it's the only member.
img = (np.expand_dims(img,0))

print(img.shape)
(1, 28, 28)

Ora prevedi l'etichetta corretta per questa immagine:

predictions_single = probability_model.predict(img)

print(predictions_single)
[[1.2673076e-05 1.9937504e-13 9.9978513e-01 1.8617269e-11 1.3060638e-04
  2.2522463e-12 7.1663781e-05 1.4157123e-21 3.1792444e-11 1.6293697e-13]]

plot_value_array(1, predictions_single[0], test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)

png

tf.keras.Model.predict restituisce un elenco di elenchi, un elenco per ogni immagine nel batch di dati. Prendi le previsioni per la nostra (unica) immagine nel batch:

np.argmax(predictions_single[0])
2

E il modello prevede un'etichetta come previsto.

# MIT License
#
# Copyright (c) 2017 François Chollet
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.