Découvrir l’IA Connexionniste avec le Perceptron

Exemple de mise en oeuvre en Python avec Keras

Ecrit par Vincent

En hommage au Prix Nobel de John Hopfield et Geoffrey Hilton récompensés pour « leur découvertes fondamentales et inventions qui ont rendu possible l’apprentissage automatique et les réseaux de neurones artificiels », je vous propose d’explorer les fondements de l’IA connexionniste et notamment comment en s’inspirant du mode de fonctionnement du cerveaux humain nous arrivons à convevoir des algorithmes capable d’apprendre à partir de nos données.

Le Perceptron

Le Perceptron, inventé en 1957 par Frank Rosenblatt, est un algorithme d’apprentissage supervisé. C’est un modèle de machine learning de base utilisé principalement pour les tâches de classification. Il est l’un des algorithmes les plus simples du domaine des réseaux de neurones et est souvent considéré comme une brique fondatrice des modèles plus complexes, tels que les réseaux de neurones multicouches.

Les principes du Perceptron

Le perceptron est un classificateur binaire qui permet de séparer des données en deux classes distinctes. Il fonctionne de la manière suivante :

Il prend un vecteur d’entrée X=(X1,…,Xn), chaque composante représentant une caractéristique de l’objet à classer.
Chaque caractéristique est pondérée par un poids associé W=(W1,…Wn), qui est ajusté au cours de l’apprentissage.
Le produit scalaire W.X est calculé, auquel on ajoute un biais B.
Une fonction de seuil, ou fonction d’activation (souvent une fonction de Heaviside), est appliquée pour déterminer la classe de sortie.
Si le résultat est supérieur à un certain seuil, la sortie est 1 (classe positive), sinon elle est 0 (classe négative).

En résumé, le perceptron applique une règle simple : il multiplie chaque caractéristique de l’entrée par un poids, les additionne, et si la somme dépasse un seuil, il attribue une classe positive, sinon une classe négative.

L’entraînement du Perceptron

L’entraînement du perceptron se fait par ajustement des poids à travers un processus itératif.

Initialisation des poids et du biais : Ils sont souvent initialisés à des petites valeurs aléatoires.
Prédiction : Pour chaque échantillon d’entraînement, le perceptron calcule la sortie (classe prédite) en fonction de ses poids actuels.
Mise à jour des poids : Si la prédiction est incorrecte, les poids sont mis à jour en fonction de l’erreur observée.

Ce processus est répété sur tous les exemples d’entraînement jusqu’à ce que le modèle converge, c’est-à-dire que les poids ne changent plus ou que l’erreur soit suffisamment faible.

Exemple d’implémentation du Perceptron en Python

class Perceptron:
    def __init__(self, input_size, learning_rate=0.01, epochs=1000):
        self.weights = np.zeros(input_size + 1)  # +1 pour le biais
        self.learning_rate = learning_rate
        self.epochs = epochs

    def activation_function(self, x):
        return 1 if x >= 0 else 0

    def predict(self, x):
        z = self.weights.T.dot(np.insert(x, 0, 1))  # Ajouter le biais
        return self.activation_function(z)

    def train(self, X, y):
        for _ in range(self.epochs):
            for xi, target in zip(X, y):
                prediction = self.predict(xi)
                update = self.learning_rate * (target - prediction)
                self.weights[1:] += update * xi
                self.weights[0] += update  # Mise à jour du biais

Exemple d’entrainement pour simuler la fonction logique ET:

# Données d'entraînement (AND logique)
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 0, 0, 1])

perceptron = Perceptron(input_size=2)

print("Entraînement du perceptron...")
perceptron.train(X, y)

print("Prédictions...")
for xi in X:
    print(f"Entrée: {xi}, Prédiction: {perceptron.predict(xi)}")

Sortie:

Entraînement du perceptron...
Prédictions...
Entrée: [0 0], Prédiction: 0
Entrée: [0 1], Prédiction: 0
Entrée: [1 0], Prédiction: 0
Entrée: [1 1], Prédiction: 1

Les limites du Perceptron

Bien que le perceptron soit simple et rapide à entraîner, il présente une limite importante. Il ne peut séparer que des données linéairement séparables. Si les données sont non linéairement séparables (comme dans le cas du problème XOR), le perceptron ne pourra pas les classer correctement.

# Données d'entraînement (XOR logique)
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 1, 1, 0])

Nous pouvons facilement constater que la sortie n’est pas correcte.

Entraînement du perceptron...
Prédictions...
Entrée: [0 0], Prédiction: 1
Entrée: [0 1], Prédiction: 1
Entrée: [1 0], Prédiction: 0
Entrée: [1 1], Prédiction: 0

Cette limitation a conduit au développement des réseaux de neurones multicouches (MLP) et de l’algorithme de rétropropagation, qui permettent de modéliser des relations plus complexes.

Les réseaux de neurones multicouche

Les réseaux de neurones multicouche (ou MLP, pour « Multilayer Perceptron ») sont une extension des perceptrons simples. Ils sont capables de modéliser des relations non linéaires complexes et sont constitués de plusieurs couches de neurones, ce qui leur permet de résoudre des problèmes plus difficiles, comme la fonction XOR.

Principes de réseaux de neurones multicouche

Un réseau de neurones multicouche est composé d’au moins 3 couches :

Couche d’entrée : Chaque neurone de cette couche correspond à une des caractéristiques du jeu de données.
Couches cachées : Il peut y avoir une ou plusieurs couches cachées entre la couche d’entrée et la couche de sortie Chaque neurone dans ces couches est connecté aux neurones de la couche précédente et à ceux de la couche suivante. Les fonctions d’activation non linéaires (comme ReLU, sigmoïde, etc.) sont utilisées pour modéliser la complexité.
Couche de sortie : La dernière couche qui produit la sortie du réseau (la prédiction).

L’information circule de la couche d’entrée, à travers les couches cachées, vers la couche de sortie. Ce sont des réseaux propagation directe (feedforward).

L’entraînement d’un réseaux de neurones multicouche

Le processus d’apprentissage du MLP repose sur un algorithme appelé rétropropagation.

Propagation avant : Les données d’entrée sont propagées à travers le réseau de neurones. Chaque neurone combine les entrées pondérées, applique une fonction d’activation, et transmet le résultat à la couche suivante.
Calcul de l’erreur : Une fois les prédictions générées, l’erreur est calculée en fonction de la différence entre la prédiction et la sortie réelle (via une fonction de perte, comme la perte binaire ou MSE).
Rétropropagation : L’erreur est ensuite propagée en arrière dans le réseau, ajustant les poids pour minimiser cette erreur. Cela se fait à l’aide de l’algorithme de descente de gradient.
Mise à jour des poids : Les poids sont ajustés via une méthode d’optimisation (comme Adam, RMSprop ou SGD) pour améliorer progressivement les prédictions du réseau.

Implémentation d’un réseaux de neurones multicouche

class MLPerceptron:
    def __init__(self, input_size, learning_rate=0.05, epochs=2000):
        self.input_size = input_size
        self.learning_rate = learning_rate
        self.epochs = epochs
        self.model = Sequential()
        self.model.add(Input((input_size,)))
        self.model.add(Dense(2, activation="tanh", ))  # Couche cachée avec 2 neurones
        self.model.add(Dense(1, activation="sigmoid"))  # Couche de sortie
        self.model.compile(
            loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"]
        )

    def train(self, X, y):
        self.model.fit(X, y, epochs=self.epochs, verbose=0)

    def predict(self, x):
        prediction = self.model.predict(np.array([x]))
        return 1 if prediction >= 0.5 else 0

Limites et considérations des réseaux de neurones multicouche

Bien que les réseaux de neurones multicouche soient beaucoup plus puissants que les perceptrons simples, ils présentent aussi certaines limites et défis :

Dépendance aux données d’entraînement : Comme pour tout modèle de machine learning, les performances d’un MLP dépendent fortement de la qualité et de la quantité des données d’entraînement.
Hyperparamètres : Le choix du nombre de neurones dans les couches cachées, du nombre de couches, du taux d’apprentissage, et de l’optimiseur peut avoir un impact significatif sur la performance et la convergence du modèle. Cela nécessite souvent un ajustement fin.
Temps d’entraînement : Les MLP peuvent nécessiter beaucoup de temps d’entraînement, en particulier pour les grands ensembles de données et les architectures plus profondes.
Vulnérabilité à l’overfitting : Avec trop de neurones ou de couches, les MLP peuvent apprendre des détails spécifiques aux données d’entraînement (overfitting), ce qui conduit à des performances médiocres sur de nouvelles données.

Conclusion

Le perceptron et les réseaux de neurones multicouche ont marqué un tournant majeur dans l’évolution de l’intelligence artificielle en s’inspirant directement du fonctionnement du cerveau humain. En modélisant des neurones artificiels interconnectés capables d’apprendre à partir des données, ces systèmes ont permis d’approcher, à petite échelle, la manière dont le cerveau traite l’information et s’adapte aux stimuli.

Le perceptron, bien qu’étant un modèle simple, a introduit l’idée fondamentale de l’apprentissage supervisé, où les machines ajustent leurs paramètres pour améliorer leurs performances. Mais c’est l’apparition des réseaux de neurones multicouche, capables de capturer des relations non linéaires et d’abstraire des concepts complexes à partir de données brutes, qui a véritablement élargi le champ des possibles en intelligence artificielle. Ces modèles ont permis d’appliquer l’IA à des domaines variés comme la reconnaissance d’images, le traitement du langage naturel, ou encore la prévision de tendances économiques.

En mimant les mécanismes d’apprentissage du cerveau, les réseaux de neurones ont permis à l’IA de passer d’une approche déterministe et codée manuellement à une approche plus souple et adaptative. Cette avancée a jeté les bases de la révolution actuelle de l’IA, ouvrant la voie aux systèmes d’apprentissage profond (deep learning) et aux architectures complexes qui continuent de repousser les limites de ce que les machines peuvent accomplir.

Vous souhaitez transformer vos données en un avantage compétitif avec des applications d’IA avancées ? Contactez-nous pour discuter de la manière dont nous pouvons intégrer ces technologies dans vos projets et vous aider à optimiser vos processus métier, tout en améliorant l’expérience utilisateur et la qualité de vos services.