Après avoir détaillé le fonctionnement d’un neurone artificiel, nous allons en utiliser plusieurs pour créer et entrainer une intelligence artificielle. C’est à la portée de tous, sans avoir besoin de connaissances ou d’installer des programmes en particulier. Une connexion à Internet et un navigateur sont suffisants.

• IA : c’est quoi exactement un neurone (informatique), comment ça marche

Première étape : un notebook sur Google Colab

Dans le cadre de notre petite démonstration, nous utilisons Google Colab (Colaboratory), un compte Google sera donc nécessaire. Colab permet d’héberger sur les serveurs de Google des notebooks Jupyter. On peut y écrire du code Python et l’exécuter directement depuis son navigateur, sur les serveurs de Google. Le fonctionnement est très simple et vous pouvez aussi utiliser d’autres notebooks si vous le désirez.

• À la découverte de Jupyter, un logiciel scientifique libre aux millions d’utilisateurs

Google Colab dispose de tout ce dont nous avons besoin pour nous lancer dans l’intelligence artificielle. Il permet aussi d’exécuter notre code, au choix, sur des CPU, des GPU ou des TPU (Tensor Processing Unit pensés pour l’intelligence artificielle).

Une fois sur le site de Google Colab, cliquez sur « New Notebook » pour arriver sur un notebook vierge où il suffit de copier/coller les lignes de code que nous allons vous donner et expliquer.

Tensorflow, keras et un jeu de données (MNIST)

Remarque très importante pour ce petit tuto : nous allons à peine effleurer le développement d’une intelligence artificielle, mais nous aurons l’occasion de rentrer davantage dans les détails par la suite. On s’est dit que commencer par la partie pratique avant de se pencher sur la théorie (les calculs de matrices, les dérivées…) pourrait vous permettre de directement mettre les mains dans le cambouis et de comprendre, dans les grandes lignes, comment fonctionne une IA.

Bien évidemment, nous allons nous appuyer sur des bibliothèques existantes pour créer notre IA, on ne part pas d’une feuille blanche. Première chose dont nous avons besoin : Tensorflow, un outil open source d'apprentissage automatique développé par Google. Deuxième élément qui va avec le premier : keras, une « API de haut niveau de TensorFlow permettant de créer et d'entraîner des modèles de deep learning ».

Enfin, il nous faut des données, un élément indispensable pour une intelligence artificielle, comme on le répète à longueur d’actu sur les IA. Par défaut, une intelligence artificielle ne sait rien faire. Nous allons en développer une capable de reconnaitre des chiffres de 0 à 9. Il faut donc d’abord lui donner des séries d’images étiquetées, c’est-à-dire avec une légende précisant quel chiffre se trouve dans l’image.

Nous utilisons pour cela la base de données MNIST (Modified ou Mixed National Institute of Standards and Technology). Elle comprend 60 000 images d'apprentissage et 10 000 images de test pour vérifier les performances de son programme. Les images sont en noir et blanc et de petite taille (28 x 28 pixels).

Et si on se lançait ? Trois lignes pour préparer le terrain

Dans un nouveau notebook de Google Colab, on commence par importer tensorflow dans notre notebook afin de pouvoir l’utiliser (on l’appelle tf pour simplifier le code par la suite). On récupère ensuite keras et le jeu de données MNIST. Les deux sont intégrés à Tensorflow, cela ne prend donc que trois lignes de code :

import tensorflow as tf
from tensorflow import keras
mnist = tf.keras.datasets.mnist

Une ligne pour séparer les données test de celles d’entrainement

Les 70 000 images et le chiffre correspondant sont désormais rattachées à la variable « mnist ». Les concepteurs de cette dernière ont bien fait les choses et d’une seule ligne on peut récupérer et séparer les images d’entrainement de celles de test :

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

Désormais x_train comprend les 60 000 images, y_train le chiffre correspondant à chaque image. X_train comprend donc 60 000 tableaux (array) de 28 x 28 (c’est-à-dire de la taille de l’image, avec une case par pixel) et y_train est un tableau de 60 000 entiers chacun compris entre 0 et 9. Avec x_test et y_test c’est la même chose pour les images de tests, une fois que notre modèle sera entrainé.

On ajoute d’ailleurs quelques lignes bonus (elles ne sont pas nécessaires pour développer notre IA), mais permettent de vérifier qu’on ne raconte pas que des bêtises :

print ('Que contient x_train : ',x_train.shape)
print ('Que contient y_train : ',y_train.shape)
print ('Que contient x_test : ',x_test.shape)
print ('Que contient y_test : ',y_test.shape)

Vous pouvez les mettre dans votre notebook, les exécuter, puis les supprimer pour continuer notre tuto, cela n’a pas d’importance. Ce n’est que de l’affichage.

Un peu d’ASCII art pour la route

On peut aussi regarder ce qu’il se passe à l’intérieur d’un seul tableau. Deux lignes de code permettent de faire un peu d’ASCII art et de vérifier qu’on ne s’est pas trompé :

print ('Quel est le premier tableau x_train : ',x_test[0])
print ('Quel est le chiffre associé dans la base : ',y_test[0])

Pour rappel, les tableaux en informatique commencent parfois/souvent à 0 (enfin ça dépend, les joies du code…) alors qu’un humain débute généralement à 1. Cela ne change rien, mais la variable x_test va de 0 à 59 999 et pas de 1 à 60 000.

Après un peu de remise en page pour un affichage plus agréable à regarder, voici ce qu’on obtient :

Actuellement, le niveau de gris de chaque pixel correspond à un nombre, compris entre 0 et 255, soit 256 valeurs possibles. On pourrait aussi l’écrire sous la forme 2⁸ et ainsi voir que cela correspond à un octet ou huit bits.

Une ligne de plus pour normaliser les variables

Pour que les systèmes d’entrainement des IA fonctionnent au mieux, il vaut mieux avoir des valeurs entre 0 et 1. Nous allons donc les normaliser, avec une méthode simple et rapide, même si ce n’est pas la plus efficace, mais c’est une autre histoire :

x_train, x_test = x_train / 255.0, x_test / 255.0

Dans nos tableaux x_train et x_test on divise simplement le chiffre associé à chaque pixel par 255. Ainsi, chaque valeur du niveau de gris se trouve désormais entre 0 et 1. Si vous déplacez la ligne de code « print ('Quel est le premier tableau x_train : ',x_test[0]) » en dessous de l’étape de normalisation des données, vous verrez que toutes les valeurs sont comprises entre 0 et 1.

On ne dirait pas, mais toute la phase préparatoire est terminée. On est déjà à la moitié du chemin.

Créons notre modèle avec deux couches de neurones

Passons maintenant à la création de notre modèle d’entrainement pour notre intelligence artificielle. Cela ne demande qu’une seule ligne de code. Le mode séquentiel signifie que toutes les couches sont reliées entre elles de manière séquentielle. Chaque couche, pour rappel, n’a pas obligatoirement le même nombre de neurones, mais tous les neurones d’une couche sont reliés aux neurones de la couche précédente.

model = keras.models.Sequential()

On ajoute ensuite notre première couche de neurones qui fait office d’entrée pour notre modèle. La commande Flatten permet de remettre l’image à plat : au lieu d’avoir un tableau de 28 x 28 on a une seule ligne de 784 éléments (28 x 28 = 784).

model.add(keras.layers.Flatten(input_shape=[28,28]))

Ensuite, nous ajoutons une couche de 25 neurones avec la fonction d’activation « relu ». Si vous êtes un peu perdu, on vous conseille une lecture de notre article sur les neurones artificiels. Et soyons joueur, ajoutons une seconde couche de 10 neurones qui sera la dernière. Le nombre de neurones en sortie (10) n’est pas choisi au hasard : il correspond au nombre de cas à identifier pour notre IA : les chiffres de 0 à 9 (et donc 10 possibilités).

model.add(keras.layers.Dense(25, activation="relu"))
model.add(keras.layers.Dense(10, activation="softmax"))

Pour la dernière couche, on utilise la fonction d’activation « softmax », parfaitement adaptée puisqu’elle donne un résultat entre 0 et 1, avec en plus la somme de toutes les sorties égale à 1. Notre IA sortira donc la probabilité qu’une image corresponde à un chiffre. On prendra simplement la sortie la plus élevée comme résultat probable.

Le détail de notre modèle et son nombre de paramètres

Vous savez quoi ? Notre modèle est terminé. Avant de passer à la phase d’entrainement, une dernière vérification avec la commande suivante :

model.summary()

Nous avons ainsi un résumé de notre modèle : une première couche d’entrée mise à plat (flatten) avec 784 valeurs, ensuite une couche dense de 25 neurones avec… 19 625 paramètres. Chaque neurone est relié à chaque entrée pour rappel, soit 25 x 784 poids à calculer, et 25 variables de plus pour le biais de chaque neurone, soit 19 625 au total, le compte est bon.

Nous avons ensuite une seconde couche de 10 neurones, avec 260 paramètres. Chaque neurone est encore une fois relié à tous les neurones précédents (10 x 25, soit 250) et on ajoute 10 paramètres pour les biais, soit un total de 260.

On est donc à quasiment 20 000 paramètres pour une IA avec deux couches de neurones ne traitant que des images de de 28 x 28 pixels avec des niveaux de gris.

Cette ligne de commande n’est pas nécessaire pour le bon fonctionnement de notre programme, vous pouvez la supprimer.

Allez hop, place à l’entrainement

Passons à la création de notre modèle d’entrainement – c’est-à-dire le compiler en langage informatique – avec les paramètres à utiliser lors de son apprentissage. C’est la fonction model.compile () et nous reviendrons juste après sur les paramètres.

La deuxième ligne de code model.fit () lance justement la phase d’entrainement à proprement parler, en se basant sur le jeu de données MNIST et les variables d’entrainement que nous avons normalisées. Le nombre d’epoch (époque en français, vous l’avez ?) correspond au nombre de fois où le modèle va s’entrainer sur la totalité du jeu de données.

10 epoch cela signifie repasser 10 fois les 60 000 images pour affiner les paramètres de notre IA (les poids et biais de chaque neurone).

model.compile(loss="sparse_categorical_crossentropy", metrics=['accuracy'])
model.fit(x_train, y_train, epochs=10)

Deux explications avant d’aller plus loin. loss, c’est la fonction de coût, c’est-à-dire la manière dont le programme va calculer l’erreur entre le résultat obtenu et celui attendu. Mathématiquement, il y a plusieurs manières de calculer la performance du modèle.

Pour la classification (comme dans notre cas), sparse_categorical_crossentropy est généralement bien adapté. On peut y ajouter un optimiseur pour améliorer encore le résultat : optimizer=keras.optimizers.SGD(lr=0.001) et optimizer='adam' sont des paramètres que l’on retrouve souvent dans les exemples. Pour de plus amples détails, consultez la documentation de keras.

Comme son nom l’indique, metrics permet d’obtenir des données sur des informations que le modèle devra évaluer au cours de son entrainement. Nous demandons la valeur accuracy afin d’avoir la précision du modèle.

Notre programme est terminé !

Si maintenant on exécute l’ensemble des lignes de notre programme, on arrive au résultat suivant :

import tensorflow as tf
from tensorflow import keras
mnist = tf.keras.datasets.mnist
(x_train, y_train),(x_test, y_test)= mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape=[28,28]))
model.add(keras.layers.Dense(25, activation="relu"))
model.add(keras.layers.Dense(10, activation="softmax"))
model.summary()
model.compile(loss="sparse_categorical_crossentropy", metrics=['accuracy'])
model.fit(x_train, y_train, epochs=10)

Alors oui, notre programme fait 12 lignes et pas 10, mais c’est parce que nous avons ajouté model.summary() (bien pratique pour voir notre modèle d’IA) et une seconde couche de neurones. Nous pourrions tout mettre sur une seule ligne, mais cela nous semble un peu moins lisible et facile à comprendre d’un coup d’œil :

model = keras.models.Sequential([keras.layers.Flatten(input_shape=(28, 28)),keras.layers.Dense(25, activation='relu'),keras.layers.Dense(10, activation='softmax')])

Et maintenant ?

Bonne question, on a un modèle, il est entrainé, et donc c’est terminé ? Oui, mais avant de vous laisser profiter de votre week-end, on regarde ses performances sur le jeu de test de la base de données MNIST.

Une seule ligne de code suffit :

model.evaluate(x_test, y_test)

Après entrainement, on a donc un model avec une précision (accuracy) de 0,9595, soit environ 96 % sur les données de test. On peut voir que lors de la première epoch la précision sur les données d’entrainement était de 89 % puis qu’elle est doucement montée jusqu’à 96 %.

Un graphique pour la route ?

Avant de vous laisser partir pour de bon, voici quelques lignes pour ajouter un graphique avec l’évolution de la précision sur les différentes « epoch ».

Au début, on ajoute une ligne pour importer la bibliothèque matplotlib.pyplo. Sur la ligne model.fit on va associer le résultat à une variable afin de pouvoir réutiliser les résultats. On l’appelle history. Les dernières lignes permettent d’afficher la courbe de la précision de chacun de nous epoch.

Voici le code que nous avons désormais :

import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt

mnist = tf.keras.datasets.mnist
(x_train, y_train),(x_test, y_test)= mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape=[28,28]))
model.add(keras.layers.Dense(25, activation="relu"))
model.add(keras.layers.Dense(10, activation="softmax"))
model.summary()

model.compile(loss="sparse_categorical_crossentropy", metrics=['accuracy'])
history = model.fit(x_train, y_train, epochs=10)
model.evaluate(x_test, y_test)

plt.plot(history.history["accuracy"], label="train")
plt.legend(loc='upper left')
plt.title("Accuracy")
plt.show()

Et le résultat :

Amusez-vous !

Vous pouvez maintenant modifier des variables comme bon vous semble, et vérifier en direct les conséquences sur votre modèle. Vous pouvez ajouter des couches de neurones, changer le nombre de neurones par couche, les fonctions d’activation des neurones, le nombre d’epoch, la fonction de coût, ajouter un optimizer, etc.

Notez que si vous lancez deux fois de suite exactement le même entrainement, vous n’aurez pas à chaque fois le même résultat. La raison est simple : les paramètres sont fixés de manière aléatoire lors de la première époque, puis s’affinent ensuite.

Voici un dernier résultat avec une couche d’entrée, puis trois couches de 200, 100 et 10 neurones, le tout avec 25 epoch. Le temps est bien plus long, avec plus de 178 000 paramètres à ajuster. Notre précision sur les données d’entraînement est bien meilleure, comme la précision finale sur les données de test.