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

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.

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 :

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.

La sortie du modèle est la suivante :

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.