Aide à protéger la Grande barrière de corail avec tensorflow sur Kaggle Rejoignez Défi

Classification de base : classer les images de vêtements

Voir sur TensorFlow.org Exécuter dans Google Colab Voir la source sur GitHub Télécharger le cahier

Ce guide forme un modèle de réseau neuronal pour classer des images de vêtements, comme des baskets et des chemises. Ce n'est pas grave si vous ne comprenez pas tous les détails ; il s'agit d'un aperçu rapide d'un programme TensorFlow complet avec les détails expliqués au fur et à mesure.

Ce guide utilise tf.keras , une API de haut niveau pour construire et modèles train en tensorflow.

# TensorFlow and tf.keras
import tensorflow as tf

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

print(tf.__version__)
2.5.0

Importer le jeu de données Fashion MNIST

Ce guide utilise le MNIST Fashion ensemble de données qui contient des images en niveaux de gris 70000 dans 10 catégories. Les images montrent des vêtements individuels en basse résolution (28 par 28 pixels), comme on le voit ici :

Lutin de mode MNIST
Figure 1. échantillons Mode-MNIST (par Zalando, MIT License).

Mode MNIST est destiné à remplacer sans rendez- vous pour le classique MNIST ensemble de données souvent utilisé comme « Bonjour, monde » des programmes d'apprentissage de la machine pour la vision par ordinateur. L'ensemble de données MNIST contient des images de chiffres manuscrits (0, 1, 2, etc.) dans un format identique à celui des vêtements que vous utiliserez ici.

Ce guide utilise Fashion MNIST pour la variété, et parce que c'est un problème légèrement plus difficile que le MNIST ordinaire. Les deux ensembles de données sont relativement petits et sont utilisés pour vérifier qu'un algorithme fonctionne comme prévu. Ce sont de bons points de départ pour tester et déboguer du code.

Ici, 60 000 images sont utilisées pour former le réseau et 10 000 images pour évaluer avec quelle précision le réseau a appris à classer les images. Vous pouvez accéder au Fashion MNIST directement depuis TensorFlow. Importation et charger les données MNIST mode directement à partir 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

Le chargement de l'ensemble de données renvoie quatre tableaux NumPy :

  • Les train_images et train_labels tableaux sont la formation prévue -les données les utilisations du modèle pour apprendre.
  • Le modèle est testé contre l'ensemble de test, les test_images et test_labels tableaux.

Les images sont 28x28 tableaux numpy, avec des valeurs de pixel allant de 0 à 255. Les étiquettes sont un tableau d'entiers allant de 0 à 9. Ceux - ci correspondent à la classe des vêtements de l'image représente:

Étiqueter Classer
0 T-shirt/haut
1 Pantalon
2 Arrêtez-vous
3 Robe
4 Manteau
5 Sandale
6 La chemise
7 Baskets
8 Sac
9 Bottine

Chaque image est mappée sur une seule étiquette. Étant donné que les noms de classe ne sont pas inclus dans l'ensemble de données, les stocker ici pour utiliser plus tard lors du traçage des images:

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

Explorer les données

Explorons le format de l'ensemble de données avant d'entraîner le modèle. Ce qui suit montre qu'il y a 60 000 images dans l'ensemble d'apprentissage, chaque image étant représentée en 28 x 28 pixels :

train_images.shape
(60000, 28, 28)

De même, il y a 60 000 étiquettes dans l'ensemble d'apprentissage :

len(train_labels)
60000

Chaque étiquette est un entier compris entre 0 et 9 :

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

Il y a 10 000 images dans l'ensemble de test. Encore une fois, chaque image est représentée en 28 x 28 pixels :

test_images.shape
(10000, 28, 28)

Et l'ensemble de test contient 10 000 étiquettes d'images :

len(test_labels)
10000

Prétraiter les données

Les données doivent être prétraitées avant d'entraîner le réseau. Si vous inspectez la première image de l'ensemble d'apprentissage, vous verrez que les valeurs de pixels sont comprises entre 0 et 255 :

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

png

Mettez ces valeurs à l'échelle sur une plage de 0 à 1 avant de les transmettre au modèle de réseau de neurones. Pour ce faire, il faut diviser les valeurs par 255. Il est important que l'ensemble de la formation et les tests ensemble prétraité de la même manière:

train_images = train_images / 255.0

test_images = test_images / 255.0

Pour vérifier que les données sont dans le format correct et que vous êtes prêt à construire et à former le réseau, nous allons afficher les 25 premières images de l'ensemble de formation et d' afficher le nom de la classe en dessous de chaque image.

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

Construire le modèle

La construction du réseau de neurones nécessite de configurer les couches du modèle, puis de compiler le modèle.

Mettre en place les calques

Le bloc de construction de base d'un réseau de neurones est la couche . Les couches extraient des représentations à partir des données qui y sont introduites. Espérons que ces représentations soient significatives pour le problème en question.

La plupart du deep learning consiste à enchaîner des couches simples. La plupart des couches, comme tf.keras.layers.Dense , ont des paramètres qui sont apprises pendant la formation.

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

La première couche de ce réseau, tf.keras.layers.Flatten , transforme le format des images à partir d' un tableau à deux dimensions (de 28 par 28 pixels) à un réseau à une dimension (28 * 28 = 784 pixels). Considérez ce calque comme un dépilage de rangées de pixels dans l'image et leur alignement. Cette couche n'a pas de paramètres à apprendre ; il reformate seulement les données.

Après que les pixels sont aplaties, le réseau est constitué d'une séquence de deux tf.keras.layers.Dense couches. Ce sont des couches neuronales densément connectées ou entièrement connectées. La première Dense couche a 128 noeuds (ou de neurones). La deuxième (et dernière) couche renvoie un tableau logits d'une longueur de 10. Chaque nœud contient un score qui indique que l'image actuelle appartient à l'une des 10 classes.

Compiler le modèle

Avant que le modèle ne soit prêt pour l'entraînement, il a besoin de quelques réglages supplémentaires. Ceux - ci sont ajoutés au cours du modèle de compilation étape:

  • Fonction de perte -Cette mesure la précision du modèle est au cours de la formation. Vous voulez minimiser cette fonction pour "orienter" le modèle dans la bonne direction.
  • Optimizer -Ce est comment le modèle est mis à jour en fonction des données qu'il voit et sa fonction de perte.
  • Metrics -Utilisé pour suivre la formation et les étapes d' essai. L'exemple suivant utilise la précision, la fraction des images correctement classées.
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

Former le modèle

La formation du modèle de réseau de neurones nécessite les étapes suivantes :

  1. Fournissez les données d'entraînement au modèle. Dans cet exemple, les données de formation est dans les train_images et train_labels tableaux.
  2. Le modèle apprend à associer des images et des étiquettes.
  3. Vous demandez au modèle de faire des prédictions sur un ensemble dans cet exemple test, le test_images tableau.
  4. Vérifiez que les prédictions correspondent aux étiquettes du test_labels tableau.

Nourrir le modèle

Pour commencer la formation, appelez la model.fit méthode appelée ainsi parce qu'elle « colle » le modèle aux données de formation:

model.fit(train_images, train_labels, epochs=10)
Epoch 1/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.4982 - accuracy: 0.8256
Epoch 2/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3747 - accuracy: 0.8658
Epoch 3/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3356 - accuracy: 0.8770
Epoch 4/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3112 - accuracy: 0.8856
Epoch 5/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2941 - accuracy: 0.8915
Epoch 6/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2776 - accuracy: 0.8972
Epoch 7/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2678 - accuracy: 0.9000
Epoch 8/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2564 - accuracy: 0.9049
Epoch 9/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2467 - accuracy: 0.9083
Epoch 10/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2399 - accuracy: 0.9103
<tensorflow.python.keras.callbacks.History at 0x7fe108a0c150>

Au fur et à mesure que le modèle s'entraîne, les mesures de perte et de précision sont affichées. Ce modèle atteint une précision d'environ 0,91 (ou 91 %) sur les données d'entraînement.

Évaluer la précision

Ensuite, comparez les performances du modèle sur l'ensemble de données de test :

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

print('\nTest accuracy:', test_acc)
313/313 - 0s - loss: 0.3413 - accuracy: 0.8814

Test accuracy: 0.8813999891281128

Il s'avère que la précision sur l'ensemble de données de test est un peu inférieure à la précision sur l'ensemble de données d'entraînement. Cet écart entre la précision de la formation et la précision du test représente surapprentissage. Le surapprentissage se produit lorsqu'un modèle d'apprentissage automatique fonctionne moins bien sur de nouvelles entrées inédites que sur les données d'entraînement. Un modèle surajusté « mémorise » le bruit et les détails dans l'ensemble de données d'entraînement à un point où il a un impact négatif sur les performances du modèle sur les nouvelles données. Pour plus d'informations, consultez les éléments suivants :

Faire des prédictions

Avec le modèle formé, vous pouvez l'utiliser pour faire des prédictions sur certaines images. Sorties linéaires du modèle logits . Attachez une couche softmax pour convertir les logits en probabilités, qui sont plus faciles à interpréter.

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

Ici, le modèle a prédit l'étiquette pour chaque image dans l'ensemble de test. Jetons un coup d'œil à la première prédiction :

predictions[0]
array([2.9212106e-07, 1.6208847e-10, 1.3363140e-08, 2.7341349e-09,
       5.5379962e-10, 4.5457238e-04, 4.2226111e-06, 4.4925120e-03,
       5.8868943e-07, 9.9504781e-01], dtype=float32)

Une prédiction est un tableau de 10 nombres. Ils représentent la "confiance" du modèle que l'image correspond à chacun des 10 articles vestimentaires différents. Vous pouvez voir quelle étiquette a la valeur de confiance la plus élevée :

np.argmax(predictions[0])
9

Ainsi, le modèle est plus confiant que cette image est une bottine ou class_names[9] . L'examen de l'étiquette d'essai montre que cette classification est correcte :

test_labels[0]
9

Représentez graphiquement l'ensemble des 10 prédictions de 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')

Vérifier les prédictions

Avec le modèle formé, vous pouvez l'utiliser pour faire des prédictions sur certaines images.

Regardons la 0e image, les prédictions et le tableau de prédiction. Les étiquettes de prédiction correctes sont bleues et les étiquettes de prédiction incorrectes sont rouges. Le nombre donne le pourcentage (sur 100) pour l'étiquette prédite.

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

Traçons plusieurs images avec leurs prédictions. Notez que le modèle peut se tromper même lorsqu'il est très confiant.

# 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

Utiliser le modèle entraîné

Enfin, utilisez le modèle entraîné pour faire une prédiction sur une seule image.

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

print(img.shape)
(28, 28)

tf.keras modèles sont optimisés pour faire des prédictions sur un lot, ou la collecte, des exemples à la fois. Par conséquent, même si vous utilisez une seule image, vous devez l'ajouter à une liste :

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

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

Prédisez maintenant l'étiquette correcte pour cette image :

predictions_single = probability_model.predict(img)

print(predictions_single)
[[8.8914348e-05 1.3264636e-13 9.9108773e-01 1.2658383e-10 8.1463791e-03
  1.6905785e-08 6.7695131e-04 2.7492119e-17 5.1699739e-10 7.1339325e-17]]
plot_value_array(1, predictions_single[0], test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)
plt.show()

png

tf.keras.Model.predict renvoie une liste de la liste des listes, une pour chaque image de la série de données. Saisissez les prédictions pour notre (seule) image dans le lot :

np.argmax(predictions_single[0])
2

Et le modèle prédit une étiquette comme prévu.

# 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.