Explorer le potentiel de l’intelligence artificielle avec les réseaux de neurones

Les réseaux de neurones sont un concept important dans les domaines de l’intelligence artificielle et de l’apprentissage automatique. Ils sont constitués 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 de classification simple, direct et multiclasse. Entraînez-le à classer les chiffres manuscrits à l’aide de 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 peut classer les données en plus de deux catégories. Les réseaux de neurones utilisent le classificateur softmax pour répartir la probabilité sur les classes possibles.

Vous pouvez utiliser la classification multiclasse pour classer les images manuscrites du jeu de données MNIST en 10 catégories. Ces catégories correspondront aux chiffres de 0 à 9.

Lire aussi :  Comprendre les 5 différences clés entre GPT-4 et GPT-3.5

Comprendre le jeu de données MNIST

L’ensemble de données MNIST est un ensemble de données de référence populaire pour l’apprentissage automatique et les algorithmes de vision par ordinateur. Il contient 70 000 images manuscrites en niveaux de gris d’une taille de 28 x 28 pixels. Les chiffres manuscrits sont compris entre 0 et 9.

Avant de créer un modèle d’apprentissage automatique, il est important de comprendre ce que contient votre ensemble de données. Comprendre l’ensemble de données vous permettra d’effectuer un meilleur prétraitement des données.

Préparez votre environnement

Pour suivre ce tutoriel, vous devez être familiarisé avec le bases de Python. Vous avez également besoin d’un connaissances de base en apprentissage automatique. Enfin, vous devez être à l’aise avec Jupyter Notebook ou Google Colab.

Créez un nouveau notebook Jupyter ou connectez-vous Google Co. Exécutez cette commande pour installer les packages requis :

 !pip install numpy matplotlib tensorflow opencv-python

Vous utiliserez :

  • Matplotlib pour la visualisation des données.
  • NumPy pour manipuler des 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 packages que vous avez installés dans votre environnement. Cela vous permettra d’appeler et d’utiliser ultérieurement 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 depuis le Bibliothèque Google TensorFlow. Vous utiliserez Keras pour former votre réseau neuronal profond avec TensorFlow comme backend.

Lire aussi :  Comment Google Brain contribue-t-il à l'avancée de l'intelligence artificielle ?

Télécharger et afficher le jeu de données

Le jeu de données MNIST est intégré à Keras. Chargez l’ensemble de données MNIST et divisez-le en ensembles d’apprentissage et de test. Vous utiliserez l’ensemble d’entraînement pour entraîner votre modèle et l’ensemble de test pour évaluer la précision de votre modèle dans la classification de nouvelles images invisibles.

 (X_train, y_train) , (X_test, y_test) = keras.datasets.mnist.load_data()

Vérifiez la durée des ensembles d’entraînement et de test. L’ensemble de données MNIST contient 60 000 images pour la formation et 10 000 images pour les tests.

 len(X_train)
len(X_test)

Vérifiez la forme de la première image dans le jeu de données MNIST qui devrait être de 28 par 28 pixels. Imprimez ensuite ses valeurs de pixels et visualisez-les avec Matplotlib.

 X_train[0].shape
X_train[0]
plt.matshow(X_train[0])
y_train[0]

La sortie de visualisation est la suivante :

numéro cinq visualisé dans Matplotlib

L’image visualisée montre que la première image de l’ensemble de données contient le chiffre cinq.

Prétraitement des données

Avant d’utiliser les données du jeu de données pour entraîner et tester votre modèle, vous devez le prétraiter. Le prétraitement améliore la précision d’un modèle en normalisant les données.

Normalisation des valeurs de pixel

Normalisez les valeurs de pixel des images dans le jeu 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 noir et 255 étant blanc. La division de chaque valeur de pixel par 255 garantit que chaque pixel de la plage est compris entre 0 et 1. Cela permet au modèle d’apprendre plus facilement les caractéristiques et les modèles pertinents dans les 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] 

Notez qu’ils sont maintenant compris entre 0 et 1.

Conversion des matrices d’image en un tableau 1D

La couche d’entrée du réseau neuronal attend généralement une entrée 1D, créant ainsi un tableau 1D des valeurs de pixels de l’image. Pour ce faire, utilisez la fonction reshape() avec le nombre de raws défini sur le nombre d’images dans 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 à former 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 sur 28 par 28 car il s’agit de la forme des images d’origine dans le jeu de données. Utilisez 128 nœuds pour les couches cachées. La couche de sortie ne devrait avoir que 10 neurones puisque vous ne classez que les nombres 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')
])

Assemblez le modèle par le Adam optimiseur, sparse_categorical_cross-entropy comme la fonction de perte, et le critère pour évaluer la performance du modèle comme précision. Ajustez ensuite les données d’apprentissage dans le modèle et définissez le nombre de périodes sur cinq.

 model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(X_train, y_train, epochs=5)

Le modèle prendra quelques minutes pour s’entraîner. Une fois la formation du modèle terminée, évaluez ses performances sur l’ensemble de test.

 model.evaluate(X_test, y_test)

La fonction d’évaluation renverra la perte et la précision du modèle. Le modèle produit une précision de 98 %.

Utilisez le modèle pour classer vos propres numéros manuscrits

Pour classer vos propres chiffres manuscrits, vous devez préparer vos images pour qu’elles correspondent à celles du jeu de données MNIST. Si vous ne le faites pas, votre modèle fonctionnera mal.

Pour prétraiter les images :

  1. Chargez l’image contenant la figure avec OpenCV.
  2. Convertissez-le en niveaux de gris et redimensionnez-le à 28 par 28 pixels.
  3. Faites pivoter et normalisez les valeurs de pixel.
  4. Enfin, aplatissez l’image dans un tableau 1D.

Alimentez 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


input_data = img_normalized.flatten().reshape( 1,28,28)


prediction = model.predict(input_data)
print (f'Prediction: {np.argmax(prediction)}')

Passez une image prétraitée contenant un nombre au modèle.

une image prétraitée contenant le chiffre 7

La sortie du modèle est la suivante :

Une valeur prédite comme sortie d'un programme dans un Jupyter Notebook

Le modèle a pu classer correctement le nombre sept.

Réseaux de neurones dans les chatbots

L’utilisation des réseaux de neurones a explosé ces dernières années. Ils ont été principalement utilisés dans le traitement du langage naturel pour la traduction linguistique et l’IA générative.

Plus récemment, il y a eu une augmentation du nombre de chatbots capables de communiquer de manière humaine. Ils utilisent un type de réseau neuronal connu sous le nom de réseau neuronal de transformateur. Interagissez avec certains d’entre eux et découvrez la puissance des réseaux de neurones.

Mathieu

Laisser un commentaire

Publicité :