DEEP LEARNING : RECONNAISSANCE DE CHIFFRES AVEC TENSORFLOW

Développement d'un modèle de classification de chiffres manuscrits avec TensorFlow et le dataset MNIST

I - Pourquoi développer un modèle de classification de chiffres ?

I.1 - Un problème simple s'inscrivant dans un contexte plus complexe

La reconnaissance de chiffres manuscrits représente un problème important dans le domaine du machine learning. Bien qu’un tel problème semble triviale, il est directement applicable à des systèmes pratiques comme la lecture automatique de chèques bancaires, la reconnaissance de codes postaux pour les services postaux, et bien d'autres. Résoudre un problème simple comme la classification de chiffres permet de mettre en œuvre des concepts généraux pouvant être appliqués à des problématiques plus complexes, comme la reconnaissance de caractères manuscrits dans différentes langues, la compréhension d’écriture cursive ou encore l’analyse de documents numérisés. En progressant dans ces problématiques, les modèles peuvent être adaptés pour des applications plus avancées comme la lecture automatique d'articles scientifiques ou l'identification de schémas complexes dans des bases de données manuscrites. Ce cas d’utilisation illustre également la manière dont les réseaux de neurones convolutionnels (CNN), peuvent être appliqués efficacement à des images en exploitant leurs caractéristiques spatiales et visuelles.

I.2 - Le dataset MNIST

Le dataset MNIST (Modified National Institute of Standards and Technology) est une référence dans le domaine du machine learning, spécialement pour les tâches de classification d’images. Il s'agit d'une base de données contenant 70 000 images de chiffres manuscrits en niveaux de gris, réparties en deux ensembles :

Ensemble d’entraînement : 60 000 images utilisées pour former les modèles.
Ensemble de test : 10 000 images utilisées pour évaluer les performances des modèles.

Chaque image a une résolution de 28 x 28 pixels, soit 784 pixels par image, ce qui en fait un dataset relativement léger et facile à manipuler. Chaque pixel est représenté par une intensité de gris allant de 0 (noir) à 255 (blanc).

II - Utilisation de Tensorflow pour classifier les images

TensorFlow est une bibliothèque open-source optimisée pour le développement et l'entraînement de modèles de deep learning, intégrant une gestion avancée des tenseurs et des opérations différentiables. Sa compatibilité native avec Keras permet de concevoir des modèles en utilisant une API haut niveau, tout en offrant une flexibilité pour personnaliser des graphes computationnels bas-niveau. TensorFlow exploite efficacement les GPU et TPU pour accélérer l'entraînement grâce à sa prise en charge de calculs parallèles.

II.1 - Importation des librairies python

        import pandas as pd
        import numpy as np
        import matplotlib.pyplot as plt
        import tensorflow as tf
        import tensorflow_datasets as tfds

NumPy : pour les calculs numériques et les manipulations de données sous forme de tableaux.
Matplotlib : pour la visualisation des images ou des résultats.
TensorFlow : pour la création, l'entraînement et l'évaluation du modèle de machine learning.
TensorFlow Datasets : pour accéder facilement aux jeux de données, comme MNIST, pour entraîner et tester le modèle.

II.2 - Séparation des datasets de train / test

        
                mnist = tf.keras.datasets.mnist

        (x_train, y_train), (x_test, y_test) = mnist.load_data()

        x_train = tf.keras.utils.normalize(x_train, axis=1)
        x_test = tf.keras.utils.normalize(x_test, axis=1)

II.3 - Création du modèle

        
                model = tf.keras.models.Sequential()

        model.add(tf.keras.layers.Flatten(input_shape=(28, 28)))
        model.add(tf.keras.layers.Dense(128, activation='relu'))
        model.add(tf.keras.layers.Dense(128, activation='relu'))
        model.add(tf.keras.layers.Dense(10, activation='softmax'))
            
        model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
            
        model.fit(x_train, y_train, epochs=3)
        model.save('handwrittenRecognition.keras')

tf.keras.models.Sequential : Crée un modèle séquentiel dans lequel les couches sont empilées les unes après les autres.
tf.keras.layers.Flatten : Applique une transformation de l'image 28x28 (matrice 2D) en un vecteur unidimensionnel afin qu'il puisse être utilisé par les couches suivantes du réseau de neurones.
tf.keras.layers.Dense : Une couche de neurones entièrement connectée. Chaque neurone reçoit des entrées de toutes les couches précédentes.
- 128 : Le nombre de neurones dans chaque couche dense.
- activation='relu' : La fonction d'activation ReLU (Rectified Linear Unit) est utilisée pour introduire des non-linéarités et aider le modèle à apprendre des relations complexes.
- activation='softmax' : Fonction d'activation softmax dans la couche de sortie, utilisée pour normaliser les sorties du modèle en une distribution de probabilités (une pour chaque classe de chiffres de 0 à 9).
model.compile : Prépare le modèle en spécifiant l'optimiseur, la fonction de perte et les métriques à suivre pendant l'entraînement.
- optimizer='adam' : Utilisation de l'optimiseur Adam, qui est efficace pour l'entraînement des réseaux de neurones.
- loss='sparse_categorical_crossentropy' : Fonction de perte adaptée pour les problèmes de classification multiclasse avec des étiquettes d'entraînement sous forme d'entiers (comme dans MNIST).
- metrics=['accuracy'] : La métrique d'évaluation de l'entraînement est la précision du modèle.
model.fit : Lance l'entraînement du modèle sur les données d'entraînement x_train et y_train pendant 3 époques (iterations complètes sur l'ensemble des données d'entraînement).
model.save : Sauvegarde le modèle entraîné dans un fichier afin qu'il puisse être utilisé ultérieurement sans avoir à être réentraîné.

II.4 - Évaluation du modèle

                model = tf.keras.models.load_model('handwrittenRecognition.keras')
        loss, accuracy = model.evaluate(x_test, y_test)

Loss et Accuracy

Loss : 0.0967
Accuracy : 96.79%

Calcul de la Loss

La fonction de perte utilisée est l'entropie croisée catégorique, souvent employée dans les tâches de classification. Voici comment elle est calculée :

Pour un échantillon individuel \(i\), la perte est définie par : \[ \text{Loss}_i = - \sum_{k=1}^{C} y_{i,k} \cdot \log(\hat{y}_{i,k}) \]
- \(y_{i,k}\) : Indicateur binaire (1 si l'échantillon appartient à la classe \(k\), sinon 0).
- \(\hat{y}_{i,k}\) : Probabilité prédite pour la classe \(k\) par la fonction softmax.
La perte totale moyenne pour \(N\) échantillons est donnée par : \[ \text{Loss} = \frac{1}{N} \sum_{i=1}^{N} \text{Loss}_i \]

Fonction d'activation Softmax

Les probabilités prédites \(\hat{y}_{i,k}\) sont calculées avec la fonction softmax :

\[ \hat{y}_{i,k} = \frac{\exp(z_{i,k})}{\sum_{j=1}^{C} \exp(z_{i,j})} \]

Où \(z_{i,k}\) est la sortie brute (logit) du modèle pour la classe \(k\).