Un modèle IA s’appuie sur des méthodes mathématiques fondamentales pour apprendre à effectuer des inférences. L’une de ces méthodes est la descente de gradient qui permet de calculer et d’ajuster les paramètres d’un modèle (i.e le poids associé à chaque entrée) de manière itérative pour minimiser l’erreur entre les estimations du modèle et les valeurs réelles. Dans cet article, nous allons utiliser cet algorithme pour entraîner un modèle à inférer la sortie de la porte logique OR.
Modélisation mathématique
La fonction booléenne OR est un problème de classification binaire. Il n’y a que 2 sorties possibles : à chaque donnée ou entrée (x1, x2), on doit associer un et un seul élément de l’ensemble {0,1}. Elle est définie par :
\(
f(x_1, x_2) =
\begin{cases}
0 & \text{si } x_1 = 0 \text{ et } x_2 = 0, \\
1 & \text{si } x_1 = 1 \text{ et } x_2 = 0, \\
1 & \text{si } x_1 = 0 \text{ et } x_2 = 1, \\
1 & \text{si } x_1 = 1 \text{ et } x_2 = 1.
\end{cases}
\)
En la représentant dans un repère, il est facile de constater que la fonction OR est linéairement séparable. Autrement dit, il est possible de tracer une droite qui sépare clairement les classes 0 et 1. La sortie peut donc être modélisée à l’aide de la règle du perceptron par une combinaison linéaire des entrées pondérées à laquelle est appliquée une fonction d’activation :
\(Y_{\text{res}} = f\left(W^T X\right) = f\left(\sum_{i=1}^{2} w_i x_i + w_b\right)\)
Où
\(f(x) = \frac{1}{1 + e^{-x}}\) est la fonction sigmoïde qui permet d’avoir en sortie un élément dans l’intervalle [0, 1]
\(w_i\) le poids de l’entrée \(x_i\)
\(w_b\), le biais (poids de l’entrée xi = 1), essentiel pour adapter le modèle aux contraintes des données d’entrée
Descente de gradient
Le principe de la descente de gradient est essentiel pour l’entraînement d’un modèle en apprentissage supervisé. L’idée ici est de mettre à jour le vecteur poids \(W_i = (w_1, w_2, w_b)\) pour les 4 exemples du corpus d’entraînement en minimisant l’erreur pour chaque vecteur entrée \(X_i = (x_1, x_2, 1)\) par la formule suivante :
\(W_i = W_i + \alpha \cdot \big(f(X_i) – Y_{\text{res}}\big) \cdot X_i\)
Où\(\alpha\) est le taux d’apprentissage
\(f(X_i)\) la sortie correcte associée à l’entrée \(X_i\)
\(Y_{\text{res}}\) la sortie prédite
Pour illustrer le fonctionnement de la descente de gradient, nous allons voir les étapes de calcul du vecteur de poids \(W_1\) pour la première exemple du corpus.
\(X_1 = \begin{pmatrix} 0 \\ 0 \\ 1 \end{pmatrix}\) et \(f(X_1) = 0\)
Initialisation des paramètres
Considérons le vecteur poids initial \(W_1 = \begin{pmatrix} 1 \\ 1 \\ -1 \end{pmatrix}\) et un taux d’apprentissage \(\alpha = 0,1\)
Ajustement du vecteur de poids
– 1ère itération
\(Y_{\text{res}} = f\left(1 \cdot 0 + 1 \cdot 0 – 1 \cdot 1\right) = f(-1) = \frac{1}{1 + e^{1}} \approx 0,268\)
Donc l’erreur entre la sortie réelle et la sortie estimée :
\(f(X_1) – Y_{\text{res}} = 0 – 0,268 = -0,268 \)
=> \(W_1 = \begin{pmatrix} 1 \\ 1 \\ -1 \end{pmatrix} + 0,1 \cdot (-0,268) \cdot \begin{pmatrix} 0 \\ 0 \\ 1 \end{pmatrix} = \begin{pmatrix} 1 \\ 1 \\ -1 \end{pmatrix} + \begin{pmatrix} 0 \\ 0 \\ -0,027 \end{pmatrix} = \begin{pmatrix} 1 \\ 1 \\ -1,027 \end{pmatrix}\)
– 2ème itération
\(Y_{\text{res}} = f\left(1 \cdot 0 + 1 \cdot 0 – 1,027 \cdot 1\right) = f(-1,027) = \frac{1}{1 + e^{1,027}} \approx 0,263\)
=> \(f(X_1) – Y_{\text{res}} = 0 – 0,263 = -0,263 \)
=> \(W_1 = \begin{pmatrix} 1 \\ 1 \\ -1,027 \end{pmatrix} + 0,1 \cdot (-0,263) \cdot \begin{pmatrix} 0 \\ 0 \\ 1 \end{pmatrix} = \begin{pmatrix} 1 \\ 1 \\ -1,027 \end{pmatrix} + \begin{pmatrix} 0 \\ 0 \\ -0,026 \end{pmatrix} = \begin{pmatrix} 1 \\ 1 \\ -1,053 \end{pmatrix}\)
– 3ème itération
\(Y_{\text{res}} = f\left(1 \cdot 0 + 1 \cdot 0 – 1,053 \cdot 1\right) = f(-1,053) = \frac{1}{1 + e^{1,053}} \approx 0,259\)
=> \(f(X_1) – Y_{\text{res}} = 0 – 0,259 = -0,259 \)
=> \(W_1 = \begin{pmatrix} 1 \\ 1 \\ -1,053 \end{pmatrix} + 0,1 \cdot (-0,259) \cdot \begin{pmatrix} 0 \\ 0 \\ 1 \end{pmatrix} = \begin{pmatrix} 1 \\ 1 \\ -1,053 \end{pmatrix} + \begin{pmatrix} 0 \\ 0 \\ -0,026 \end{pmatrix} = \begin{pmatrix} 1 \\ 1 \\ -1,079 \end{pmatrix}\)
La valeur absolue de l’erreur diminue progressivement à chaque itération. Cette même logique est donc appliquée jusqu’à convergence du modèle i.e \(f(X_1) \approx Y_{\text{res}}\). Par ailleurs, nous comprenons à travers cet exemple tout l’intérêt de l’introduction du biais à l’entrée d’un modèle IA. En effet, celui-ci a permis d’éviter l’influence trop forte de l’entrée sur le résultat d’estimation du modèle. Il est aussi important de penser au temps de traitement que peut prendre la résolution de ce problème linéaire simple avec seulement 4 exemples dans le corpus. Cela permet de comprendre facilement pourquoi l’entraînement de modèles de réseaux profonds (problèmes non linéaires ou avec un grand corpus d’entraînement) exige une puissance de calcul considérable.
Implémentation pratique avec Keras
Après avoir exploré la descente de gradient théoriquement, nous allons maintenant utiliser la bibliothèque Keras pour entraîner un modèle à inférer la sortie logique de la fonction booléene OR.
import numpy as np
from keras.layers import Input, Dense
from keras.models import Model
from keras.optimizers import SGD
data = np.array([0, 0, 0, 1, 1, 0, 1, 1]).reshape(4, 2)
labels = np.array([0, 1, 1, 1]).reshape(4, 1)
print("Corpus d'entraînement :")
for (x, y) in zip(data, labels):
print(x, "-->", y)
input_layer = Input(shape=(2,))
output_layer = Dense(1, activation='sigmoid')(input_layer)
model = Model(inputs=input_layer, outputs=output_layer)
optimizer = SGD(learning_rate=0.1)
model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])
model.fit(data, labels, epochs=300)
print("Inférences :")
y = model.predict(data)
for i in range(len(data)):
print(data[i], "-->", round(y[i][0]))
Le corpus d’entraînement (ou dataset) contient les quatre combinaisons possibles des entrées ainsi que leurs labels associés.
Pour définir le modèle, nous créons une première couche de deux nœuds correspondant aux variables d’entrées reliée à une couche de sortie dense avec une fonction d’activation sigmoïde.
L’optimisation des paramètres du modèle repose sur la descente de gradient stochastique (SGD). Nous avons entraîné le modèle sur 300 itérations avec un taux d’apprentissage fixé à 0,1 pour ajuster les poids et minimiser l’erreur entre les sorties estimées et les sorties réelles. Le nombre d’itérations (ou epochs) et le taux d’apprentissage appelés hyperparamètres sont des valeurs sur lesquelles nous pouvons jouer pour optimiser l’entraînement et améliorer la précision du modèle. Pour obtenir plus d’informations sur l’optimiseur SGD, veuillez visiter la documentation officielle de Keras. Après l’entraînement, le modèle est utilisé pour effectuer des inférences sur les exemples du corpus.
Les résultats obtenus montrent que le modèle a appris correctement la relation entre les entrées et les labels.
Nous avons exploré les bases mathématiques de l’apprentissage supervisé à travers la descente de gradient. Nous avons vu de manière théorique et pratique comment cet algorithme permet d’ajuster les paramètres d’un modèle IA pour estimer la sortie de la porte logique OR. Ceci constitue une base solide pour explorer les concepts avancés de l’apprentissage automatique tels que les réseaux de neurones profonds (RNN, CNN…).