Classification d’images à l’aide de TensorFlow en python

Ce tutoriel montre comment classer des images à l’aide de TensorFlow en Python. Dans ce projet, nous construisons un classificateur pour distinguer les différents types d’articles vestimentaires. Nous utilisons le modèle pré-formé fashion_mnist. C’est un bon exemple d’utilisation de modèles pré-formés dans TensorFlow.

Qu’est-ce que la classification d’images :

La classification d’images est une classe d’algorithmes d’apprentissage automatique qui utilisent des ordinateurs pour regarder des images et les classer en catégories. La classification des images est un moyen pour les machines d’en savoir plus sur le monde qui nous entoure. La classification d’images est bien adaptée à la reconnaissance visuelle, dans laquelle les images ont une correspondance naturelle un à un avec les données des classes. Ceci est différent de la catégorisation de texte, où les classes ont peu ou pas de correspondance naturelle avec les mots dans une description textuelle de la catégorisation.

La classification des images a été largement utilisée dans le domaine de l’astronomie pour identifier des objets tels que des galaxies, des planètes,

Pré-requis :

Anaconda:

La distribution Anaconda est une collection de packages composée de Python, R et de plus de 120 des packages open source les plus populaires pour la science et le traitement des données. Cela signifie que cette distribution peut être installée sur une seule machine, ce qui rend extrêmement pratique l’analyse de données à grande échelle ! Vous pouvez télécharger et installer le conda en allant sur le lien suivant.

https://www.anaconda.com/products/individual

Après cela, vous aurez accès au terminal que vous utiliserez pour installer toutes vos bibliothèques.

Bloc-notes Jupyter :

Le bloc-notes Jupyter est une application Web gratuite et open source. Il est couramment utilisé par les scientifiques des données et d’autres utilisateurs techniques qui cherchent à partager leur travail, mais n’importe qui peut utiliser cette plate-forme pour le partage des connaissances. Vous pouvez installer le notebook Jupyter à l’aide de la commande suivante dans votre terminal conda.

pip install jupyter notebook

Pour accéder au bloc-notes, vous pouvez utiliser cette commande.

jupyter notebook

Tensorflow:

TensorFlow est une bibliothèque logicielle open source pour le calcul numérique à l’aide de graphes de flux de données. Les nœuds de graphe représentent des opérations mathématiques, tandis que les arêtes de graphe représentent les tableaux de données multidimensionnels (tenseurs) qui circulent entre eux. L’architecture flexible vous permet de déployer des calculs sur un ou plusieurs CPU ou GPU dans un poste de travail, un serveur ou un appareil mobile avec une seule API.

Vous pouvez installer le notebook Jupyter à l’aide de la commande suivante dans votre terminal conda.

pip install --upgrade tensorflow

Numpy:

NumPy, abréviation de Numerical Python, est une bibliothèque Python utilisée pour le calcul scientifique et le traitement de données. Cette bibliothèque facilite l’exécution de code Python sur des tableaux et des matrices au lieu de listes. Il a de nombreuses fonctions pour rendre vos mathématiques plus rapides.

Vous pouvez installer le notebook Jupyter à l’aide de la commande suivante dans votre terminal conda.

pip install numpy

Code:

Importer la dépendance

import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

Charger les données

Nous utilisons le keras.datasets.fashion_mnist car il est déjà là dans Keras

fashion_mnist = keras.datasets.fashion_mnist

Le chargement des données renvoie quatre tableaux numpy et ce sont les données que le modèle utilise pour apprendre

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

Chargement des étiquettes

Chaque image est mappée sur une seule étiquette puisque la classe n’est pas incluse dans l’ensemble de données, nous devons les stocker ici

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

Explorer les données : (formater le jeu de données)

Train_images.shape

Sortir:

(60000, 28, 28)

Comme vous pouvez le voir sur la sortie, nous avons 60000 images dans l’ensemble de formation

len(train_labels)

Sortir:

60000

Et nous avons également 60000 étiquettes dans les jeux de données

Pour la classification des images avec TensorFlow, les données doivent passer par un processus appelé prétraitement pour conditionner les images afin qu’elles soient conformes aux catégories ImageNet 1k. Si vous inspectez la première image de votre ensemble de données, vous verrez qu’elle a des valeurs de pixel allant de 0 à 255 :

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

Sortir:

nous avons divisé les images d’entraînement et les images de test par 255 car il est important que l’ensemble d’apprentissage et l’ensemble de test soient prétraités de la même manière

train_images = train_images / 255.0

test_images = test_images / 255.0

Maintenant, nous allons afficher les 25 premières images de l’ensemble d’entraînement et afficher le nom de la classe ci-dessous dans 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()

Sortir:

Nous sommes maintenant prêts à construire et former le réseau

Construire le réseau :

Construire le réseau de neurones nécessite de configurer les couches du modèle puis de compiler le modèle

# setup the layer
model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10)
])
#Fitting the Model
model.fit(train_images, train_labels, epochs=10)
#Evaluating Accuracy
test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
print('\nTest accuracy:', test_acc)

Modèle de formation

#Fitting the Model
model.fit(train_images, train_labels, epochs=10)
#Evaluating Accuracy
test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
print('\nTest accuracy:', test_acc)

Sortir:

Donc, ici, vous pouvez voir que la précision est de 0,8862000107765198

Faire des prédictions:

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

Sortir:

Création d’un graphique pour examiner la prédiction

# defined the plot image
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)

  # defining the plot value array
  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')

Alors maintenant regardons le 1er nombre d’images pour vérifier la prédiction

i = 1
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()

Sortir:

Prédire toutes les images en même temps

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()

Sortir:

Ici, la prédiction de l’image avec le bleu est bonne et la prédiction avec le rouge est fausse.

Conclusion:

Cet article de blog fournit un exemple d’utilisation de TensorFlow, la bibliothèque d’apprentissage automatique Python que Google a open source, pour former un modèle capable de distinguer différents types d’images. Nous avons utilisé un ensemble de données existant appelé fashion_mnist , et plus précisément celui formé par Google, dont le but est d’identifier quel vêtement est montré dans une image donnée. J’espère que vous avez aimé le tutoriel et si vous avez des questions, n’hésitez pas à les laisser ci-dessous et je ferai de mon mieux pour y répondre !

Spread the love
 
   

Laisser un commentaire