Nous avons tous déjà entendu parler des réseau de neurones, mais très peu de personnes savent comment créer un tel réseau et comment l’utiliser. Nous allons aujourd’hui voir une mise en pratique de ces réseaux pour réaliser de la classification. Nous allons, dans cet article, nous intéresser à la mise en place d’un réseau de classification à l’aide d’un réseau de neurones. Pour ce faire, nous allons dans un premier temps voir les données que nous allons utiliser. Puis, nous verrons comment créer notre système et comment l’utiliser en cas réel. Enfin, nous verrons comment mesurer les performances de notre système.

Présentation des données

Afin de pouvoir mettre en place notre réseau de neurones, il nous faut, dans un premier temps, avoir un cas d’application. Ici, nous allons imaginer qu’un producteur de vêtements à fait un appel d’offres et vous avez été choisi pour réaliser cette tâche. L’objectif est de réaliser un logiciel qui permet en fonction de la photo d’un vêtement de sélectionner la bonne boite qui correspond à ce dernier. Vous aimeriez automatiser la sélection des boîtes. De ce fait, lorsqu’une paire de chaussures est présente, vous aimeriez que votre machine vous envoie une boîte correspondante à celle-ci. Lors de cette étude, nous allons nous concentrer sur le problème de classification liée au vêtement. Ainsi, la machine sera équipée d’un appareil photo et prendra pour chaque vêtement une photo. L’objectif va être de déterminer la catégorie d’appartenance du produit, afin que par la suite vous puissiez réaliser l’automatisation complète du système.

Afin de réaliser ce système, vous avez a votre disposition 60 000 photos des différents produits qui vous intéresses. Afin de réaliser votre modèle, vous allez séparer vos données en deux. Une base d’entraînement qui permettra d’entraîner votre modèle, et une base de validation qui permettra de dire si votre système est bon ou mauvais. Cela vous permettra de savoir si vous pouvez mettre votre système en production ou non.

Échantillon de vos données.

Si vous souhaitez réaliser ce tutoriel en même temps, je vous suggère d’utiliser Google Colab. Vous aurez ainsi une puissance de calcul plus importante et une gestion des dépendances déjà intégré. Sinon, vous pouvez le réaliser directement sur votre machine, mais il vous faudra installer Python (ici, j’utilise la version 3) et avoir un ordinateur ayant des performances assez correctes.

Afin de réaliser ce système, nous allons devoir dans un premier temps importer les différentes librairies qui seront nécessaires. Nous aurons besoin de Tensorflow et de la librairie Keras. Ces deux librairies vont nous permettre de créer notre réseau de neurones. Nous importons aussi la librairie Numpy qui nous permet de gérer nos matrices. Enfin, nous importons la librairie Matplotlib qui nous permet d’afficher des graphiques.

# TensorFlow and tf.keras
import tensorflow as tf
from tensorflow import keras

import numpy as np
import matplotlib.pyplot as plt

print(tf.__version__)

Note : la dernière ligne nous permet d’avoir la version de Python. Lors de la rédaction de cet article, nous sommes à la 1.12.0.

La prochaine étape va être de sélectionner nos données, puis de les normaliser. Dans un premier temps, nous allons récupérer nos données à l’aide de la librairie Keras. Puis, nous allons diviser nos données en deux échantillons, notre base d’entraînement et notre base de validation. Enfin, nous allons créer un tableau qui contiendra le nom de toutes les différentes catégories.

# Get our data.
fashion_mnist = keras.datasets.fashion_mnist
# Split our data into a training database and a validation database.
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
# Define an array with the name of all categories
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

Afin de visualiser le nombre de nos données, nous pouvons utiliser la fonction shape sur notre tableau. Cela nous permet d’avoir des informations sur la taille de nos données et comment elles sont formatées.

train_images.shape

Ici, nous avons : (60000, 28, 28). Cela signifie que nous avons un tableau contenant 60000 valeurs. Pour chacune de ces valeurs, nous avons un tableau de dimension 28 par 28. Ici, nous pouvons constater que nous avons des images définis par un niveau de gris. En effet, nous avons une seule information pour chacun des pixels alors que pour une image couleur, nous aurions eu 3 valeurs, une pour le rouge, le vert et le bleu.

La prochaine étape consiste à normaliser nos données. Ici, nous voulons passer nos images dans un simple réseau de neurones. Les valeurs des pixels de nos images sont comprises entre 0 et 255. Or, les réseaux de neurones sont performants pour des valeurs comprises entre 0 et 1. Ainsi, pour rendre notre système performant, nous allons transformer nos données d’entrée.

Si vous souhaitez avoir plus d’information sur les réseaux de neurones, je vous laisse aller lire un ancien article où j’aborde son fonctionnement . Bien entendu, n’hésitez pas à poser des questions, j’essaierai d’y répondre du mieux que je peux.

train_images, test_images = train_images / 255.0, test_images / 255.0

Nous avons maintenant fini de préparer nos données. Nous allons maintenant chercher à créer notre système. Pour ce faire, nous allons, dans un premier temps, créer notre réseau de neurones. Notre réseau de neurones va, dans un premier temps, aplatir nos données. Ici, nous voulons créer un réseau de neurones le plus simple possible. De ce fait, nous allons transformer notre matrice qui correspond à notre image, en un vecteur. Puis, nous allons avoir dans notre réseau de neurones deux couches de neurones. Une couche assez conséquente, nous permettant d’extraire les caractéristiques de nos données, et une seconde nous permettant de réaliser la classification sur nos 10 catégories.

def perceptron ():
    """
    Generate a basic neural network. We flatten the input data, then we set a
    hidden layer, finaly a layer for our categories.

    @return tf.keras.models.Sequential Our model for the classification
    """
    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'])
    return model

Une fois notre fonction réalisée, il ne nous reste plus qu’à initialiser notre modèle en réalisant la phase d’apprentissage et de le vérifier en faisant notre phase de validation.

# Get our model.
model = perceptron()

# Train our model.
model.fit(train_images, train_labels, epochs=5)
# Evaluate our model.
model.evaluate(test_images, test_labels)

Lors de la phase d’apprentissage, nous avons mis 5 époques. Cela signifie que notre système va parcourir l’ensemble de nos données 5 fois. Lors de la première époque, nous obtenons une valeur pour la perte de 0.4773 et une valeur pour la précision de notre modèle de 0.8287.

Message de notre système :

Epoch 1/5
60000/60000 [==============================] - 14s 227us/step - loss: 0.4773 - acc: 0.8287

Concernant la phase de validation, nous obtenons une valeur pour la perte de 0.3487 et une précision de 0.8752.

10000/10000 [==============================] - 1s 57us/step
[0.3486395077705383, 0.8752]

Il est à noter que les données qui sont présentes dans la phase de validation sont inconnues pour notre système. Ainsi, il ne connaît pas ces données. Cela nous permet de bien vérifier l’apprentissage de notre système et d’éviter les problèmes comme celui du sur-apprentissage. En effet, à force d’entraîner notre système, il se peut qu’il soit extrêmement performant sur nos données d’entraînement, mais inefficace sur nos données de validation. Cela est dû au fait que notre système a appris par cœur nos données d’entraînement sans chercher à généraliser les concepts qu’il a appris pour de nouveaux exemples.

Mode en production

Nous avons vu précédemment comment entraîner notre système. Nous allons dans cette partie voir comment nous pouvons réaliser la classification d’une donnée. Pour ce faire, nous allons nous munir d’une image que nous souhaitons classifier.

# Show our data.
plt.imshow(test_images[0])

Image que nous souhaitons classifier.

Afin de classifier cette image, nous allons appeler la fonction predict de notre modèle. Cette fonction nous renvoie une matrice nous indiquant pour chaque catégorie une probabilité d’appartenance à cette même catégorie. Il nous suffira de sélectionner la catégorie la plus importante pour définir la catégorie que notre système aura prédit.

# Resize our data because the predict function expects an array of data
image_to_predict = test_images[0].reshape(1,28,28)
# Get the prediction of our model
prediction = model.predict(image_to_predict)

# Get the number of the category
id_category = np.argmax(prediction)
# Print the category predicted
class_names[id_category]

Nous obtenons comme résultat : Ankle boot. Ce qui correspond bien à notre image.

Analyse de nos résultats

Nous avons vu comment entraîner notre système et comment l’utiliser sur d’autres données. Cependant, nous n’avons pas regardé les performances de notre système. Afin de visualiser les résultats de notre système, nous allons nous servir d’une matrice de confusion. Avec cette matrice, nous allons avoir d’un côté la vérité terrain et de l’autre la prédiction de notre système. Ainsi, nous allons avoir un aperçu de l’ensemble des prédictions de notre système.

Matrice de confusion non-normalisée.

Matrice de confusion normalisée.

Grâce à ces matrices de confusion, nous pouvons apercevoir que notre système est plutôt performant sur l’ensemble de nos catégories et plus particulièrement sur les Ankle boot, Bag, Trouser. Cependant, nous pouvons apercevoir que nous avons des problèmes vis-à-vis de la catégorie shirt, coat et pullover. Par exemple, pour le cas de la catégorie coat nous avons eu 215 images qui on été classifié comme pullover sur 1/5 de nos données.

L’objectif de cet article n’est pas de rentrer dans le détail sur la partie analyse du modèle, mais simplement de montrer un petit aperçu. En fonction du système et du degré d’importance que vous accordez à la bonne prédiction de votre modèle, vous continuerez l’apprentissage de votre système. Ici, dans notre cas, le fait qu’un pull-over ou qu’un manteau soit dans la même catégorie peut ne pas être un problème. En effet, il se peut que pour notre étude, nous pouvons regrouper ces deux catégories dans une seule, si elles ont les même boite (si nous reprenons notre exemple de départ). Cependant, la phase d’étude de notre système n’est en aucun cas à négliger. Elle requiert beaucoup d’attention et est cruciale pour le fonctionnement de votre système en condition réel. En effet, si vous avez un système plutôt moyen, mais que vous décidez quand même de le mettre en production, cela peut avoir de lourdes conséquences !

Conclusion

Dans cet article, nous avons vu comment à l’aide de la librairie Keras, nous pouvions implémenter un système de réseau de neurones classique pour de la classification d’images. Nous avons obtenu des résultats correctes qui peuvent tout de même être améliorer. L’une des solutions envisageable serait de refaire des catégories qui regroupent un manteau et les pulls par exemple. Cependant, nous aurons au problème si nous devons obligatoirement les séparer. La seconde option consiste à entraîner davantage notre système. Ainsi, nous pourrions espérer de meilleur résultat. Enfin, la troisième option que l’on pourrait envisager serait de changer notre modèle et de passer sur un réseau de neurones à convolution. Ces réseaux ont comme particularité d’être performant sur le traitement d’image. Ainsi, on pourrait s’attendre à de meilleurs résultats. Cependant, il faut prendre en compte qu’ils sont un peu plus complexe et donc le temps d’entraînement et le temps d’exécution sera un peu plus important que pour un simple réseau de neurones.

Source

• https://keras.io/
• https://www.tensorflow.org/
• https://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html#sphx-glr-auto-examples-model-selection-plot-confusion-matrix-py
• https://fr.wikipedia.org/wiki/R%C3%A9seau_de_neurones_artificiels