Les réseaux neuronaux sont un concept important dans les domaines de l’intelligence artificielle et de l’apprentissage automatique. Ils se composent de nœuds interconnectés, organisés en couches, et imitent le fonctionnement du cerveau humain. Les nœuds représentent les neurones du cerveau humain.
Vous pouvez créer votre propre réseau neuronal simple de classification multi-classes à action directe. Entraînez-le à classer des chiffres manuscrits en utilisant l’ensemble de données MNIST. Vous pouvez ensuite utiliser la vision par ordinateur pour classer vos propres chiffres manuscrits.
Qu’est-ce que la classification multi-classes ?
La classification multi-classes est un type d’apprentissage automatique qui permet de classer les données dans plus de deux catégories. Les réseaux neuronaux utilisent le classificateur softmax pour distribuer la probabilité sur les classes possibles.
Vous pouvez utiliser la classification multi-classe pour classer les images manuscrites de l’ensemble de données MNIST en 10 catégories. Ces catégories correspondront aux chiffres de 0 à 9.
Comprendre le jeu de données MNIST
Le jeu de données MNIST est un jeu de données de référence populaire pour les algorithmes d’apprentissage automatique et de vision par ordinateur. Il contient 70 000 images manuscrites en niveaux de gris d’une taille de 28 par 28 pixels. Les chiffres manuscrits sont compris entre 0 et 9.
Avant de construire un modèle d’apprentissage automatique, il est important de comprendre ce que contient votre ensemble de données. La compréhension du jeu de données vous permettra d’effectuer un meilleur prétraitement des données.
Préparation de votre environnement
Pour suivre ce tutoriel, vous devez être familier avec les bases de Python. Vous devez également avoir une connaissance de base de l’apprentissage automatique. Enfin, vous devez être à l’aise avec Jupyter Notebook ou Google Colab.
Le code source complet est disponible dans un dépôt GitHub.
Créez un nouveau Jupyter Notebook ou connectez-vous à Google Colab. Exécutez cette commande pour installer les paquets requis :
!pip install numpy matplotlib tensorflow opencv-python
Vous utiliserez :
- Matplotlib pour la visualisation des données.
- NumPy pour manipuler les tableaux.
- TensorFlow pour créer et entraîner votre modèle.
- OpenCV pour alimenter le modèle avec vos propres chiffres manuscrits.
Importation des modules nécessaires
Importez les paquets que vous avez installés dans votre environnement. Cela vous permettra plus tard d’appeler et d’utiliser leurs fonctions et modules dans votre code.
import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import cv2
La deuxième ligne de code importe le module Keras de la bibliothèque TensorFlow de Google. Vous utiliserez Keras pour former votre réseau neuronal profond avec TensorFlow comme backend.
Chargement et visualisation du jeu de données
L’ensemble de données MNIST est intégré à Keras. Chargez le jeu de données MNIST et divisez-le en jeux d’entraînement et de test. Vous utiliserez l’ensemble d’entraînement pour former votre modèle et l’ensemble de test pour évaluer la précision de votre modèle dans la classification de nouvelles images non vues.
(X_train, y_train) , (X_test, y_test) = keras.datasets.mnist.load_data()
Vérifiez la longueur des ensembles d’entraînement et de test. L’ensemble de données MNIST contient 60 000 images pour l’entraînement et 10 000 images pour le test.
len(X_train)
len(X_test)
Vérifiez la forme de la première image dans l’ensemble de données MNIST qui devrait être de 28 par 28 pixels. Ensuite, imprimez ses valeurs de pixels et visualisez-les en utilisant Matplotlib.
X_train[0].shape
X_train[0]
plt.matshow(X_train[0])
y_train[0]
Le résultat de la visualisation est le suivant :
L’image visualisée montre que la première image de l’ensemble de données contient le nombre cinq.
Prétraitement des données
Avant d’utiliser les données de l’ensemble de données pour former et tester votre modèle, vous devez les prétraiter. Le prétraitement améliore la précision d’un modèle en standardisant les données.
Normalisation des valeurs de pixel
Normaliser les valeurs de pixel des images dans l’ensemble de données en divisant chaque valeur par 255. Les valeurs de pixel de l’ensemble de données non normalisées vont de 0 à 255, zéro étant le noir et 255 le blanc. En divisant la valeur de chaque pixel par 255, on s’assure que chaque pixel se situe dans une plage comprise entre 0 et 1, ce qui permet au modèle d’apprendre plus facilement les caractéristiques et les modèles pertinents des données.
X_train = X_train / 255
X_test = X_test / 255
Imprimez ensuite les valeurs de pixel de la première image.
X_train[0]
Remarquez qu’elles sont maintenant comprises entre 0 et 1.
Convertir les matrices d’image en un tableau 1D
La couche d’entrée du réseau neuronal attend généralement des entrées 1D. Il faut donc créer un tableau 1D des valeurs de pixel de l’image. Pour ce faire, utilisez la fonction reshape() avec le nombre de raws fixé au nombre d’images de l’ensemble de données.
X_train_flattened = X_train.reshape(len(X_train), 28 * 28)
X_test_flattened = X_test.reshape(len(X_test), 28 * 28)
X_train_flattened.shape
X_train_flattened[0]
Vos images sont maintenant prêtes à entraîner et à tester le modèle.
Création du modèle de réseau neuronal profond
Créez un modèle séquentiel avec le module Keras de Tensorflow en utilisant une couche d’entrée, deux couches cachées et une couche de sortie. Définissez la forme d’entrée à 28 par 28, car il s’agit de la forme des images originales dans l’ensemble de données. Utilisez 128 nœuds pour les couches cachées. La couche de sortie ne doit comporter que 10 neurones car vous ne classez que les chiffres de 0 à 9.
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])
Compilez le modèle en utilisant la fonction adam optimiseur, sparse_categorical_crossentropy (en anglais) comme fonction de perte, et la métrique pour évaluer la performance du modèle est la suivante précision. Ajustez ensuite les données d’entraînement dans le modèle et fixez le nombre d’époques à cinq.
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(X_train, y_train, epochs=5)
L’apprentissage du modèle prendra quelques minutes. Une fois l’entraînement du modèle terminé, évaluez ses performances sur l’ensemble de test.
model.evaluate(X_test, y_test)
La fonction evaluate renvoie la perte et la précision du modèle. Le modèle produit une précision de 98%.
Utilisation du modèle pour classer vos propres chiffres manuscrits.
Pour classifier vos propres chiffres manuscrits, vous devez préparer vos images pour qu’elles correspondent à celles de l’ensemble de données MNIST. Si vous ne le faites pas, les performances de votre modèle seront médiocres.
Pour prétraiter les images :
- Chargez l’image contenant le chiffre en utilisant OpenCV.
- Convertissez-la en niveaux de gris et redimensionnez-la à 28 par 28 pixels.
- Retournez et normalisez les valeurs des pixels.
- Enfin, aplatissez l’image dans un tableau 1D.
Passez l’image prétraitée dans le modèle pour la prédiction et imprimez la valeur prédite sur l’écran.
img = cv2.imread('digits/digit1.png', cv2.IMREAD_GRAYSCALE)
img_resize = cv2.resize(img, (28, 28))
img_flip = cv2.bitwise_not(img_resize)
img_normalized = img_flip.astype('float32') / 255.0
# Flatten the image into a 1D array
input_data = img_normalized.flatten().reshape( 1,28,28)
# Make a prediction using the model
prediction = model.predict(input_data)
print (f'Prediction: {np.argmax(prediction)}')
Passage d’une image prétraitée contenant un nombre au modèle.
La sortie du modèle est la suivante :
Le modèle a été capable de classer correctement le chiffre sept.
Les réseaux neuronaux dans les chatbots
L’utilisation des réseaux neuronaux a explosé au cours des dernières années. Ils ont été principalement utilisés dans le traitement du langage naturel pour la traduction et l’IA générative.
Plus récemment, on a assisté à une augmentation du nombre de chatbots capables de communiquer à la manière d’un humain. Ils utilisent un type de réseau neuronal appelé réseau neuronal transformateur. Interagissez avec certains d’entre eux et découvrez la puissance des réseaux neuronaux.