MADALINE réseau de neurones : Guide complet — Principes, Exemples et Implémentation Python

Résumé

MADALINE (Multiple ADALINE) est l’un des premiers réseaux de neurones artificiels à utiliser une couche cachée. Introduit par Bernard Widrow et Marcian Hoff en 1960, il repose sur l’association de plusieurs neurones ADALINE disposés en parallèle, suivis d’une unité de sortie fixe. Sa contribution majeure réside dans la règle MRI (Minimum Rule of Intervention), un algorithme d’apprentissage élégant qui ne corrige que les neurones véritablement incertains, minimisant ainsi les perturbations des connaissances déjà acquises. Ce guide explore en profondeur les principes mathématiques, l’intuition, et le code Python complet du MADALINE réseau de neurones.

Principe mathématique

Architecture du MADALINE réseau de neurones

Contrairement à un simple ADALINE, le MADALINE réseau de neurones introduit une couche cachée composée de N unités ADALINE fonctionnant en parallèle :

Couche d’entrée : Le vecteur d’entrée x = (x₁, x₂, …, xₙ) est envoyé à chaque neurone ADALINE de la couche cachée.
Couche cachée : N neurones ADALINE indépendants, chacun avec ses propres poids wᵢ et son propre biais bᵢ. Chaque neurone calcule une sortie nette :

netᵢ = wᵢ · x + bᵢ = Σⱼ wᵢⱼ · xⱼ + bᵢ

La sortie discrète (signe) de chaque ADALINE est :

yᵢ = signe(netᵢ) = +1 si netᵢ ≥ 0, −1 sinon

Couche de sortie : Une fonction fixe combine les sorties des N ADALINE. Les stratégies courantes sont :
Vote majoritaire : y_sortie = signe(Σᵢ yᵢ)
Combinaison linéaire : y_sortie = signe(Σᵢ αᵢ · yᵢ) où les αᵢ sont des poids de combinaison
Fonction logique fixe : ET, OU, ou autres portes logiques déterministes

Règle de Widrow-Hoff pour chaque ADALINE

Chaque neurone ADALINE individuel de la couche cachée suit la règle de Widrow-Hoff (aussi appelée règle LMS — Least Mean Squares) :

Δwᵢ = η · (t − netᵢ) · x

où :
– η est le taux d’apprentissage (0 < η < 1)
– t est la cible souhaitée pour ce neurone (+1 ou −1)
– netᵢ est la sortie nette (continue) avant application du signe
– x est le vecteur d’entrée

Cette règle minimise l’erreur quadratique moyenne de chaque neurone par descente de gradient, contrairement au Perceptron qui ne met à jour ses poids qu’en cas d’erreur de classification.

Règle MRI (Minimum Rule of Intervention) — Le cœur de l’apprentissage

La contribution essentielle du modèle MADALINE réseau de neurones est la règle MRI (Minimum Rule of Intervention). Au lieu de mettre à jour tous les neurones ADALINE en cas d’erreur de la sortie globale, la règle MRI identifie et ne corrige que le neurone le plus « hésitant » :

Algorithme MRI :

Présenter un exemple (x, cible d) au réseau.
Chaque ADALINE i calcule sa sortie nette netᵢ. Si netᵢ ≥ 0, sa sortie discrète est +1 ; sinon −1.
Combiner les sorties pour obtenir la sortie globale y_sortie.
Si y_sortie ≠ d (erreur) :
a. Identifier l’ADALINE dont la sortie nette netᵢ est la plus proche de zéro (c’est-à-dire |netᵢ| minimale parmi ceux dont la sortie discrète est « responsable » du vote majoritaire). C’est le neurone le plus hésitant.
b. Uniquement ce neurone est mis à jour avec la règle de Widrow-Hoff pour le forcer à inverser sa sortie.
c. Recalculer la sortie globale. Si l’erreur persiste, identifier le neurone suivant le plus hésitant et le mettre à jour. Répéter jusqu’à correction ou épuisement des neurones.
Si y_sortie = d (pas d’erreur) : aucun poids n’est modifié.

Pourquoi cela fonctionne : En ne touchant qu’au neurone le plus incertain, on minimise la perturbation des autres neurones qui avaient une opinion « forte » (sortie nette éloignée de zéro). C’est l’équivalent fonctionnel du principe de moindre surprise : on ne corrige que celui qui a vraiment besoin de l’être, sans déstabiliser le reste du collectif.

Variante RRI et MRI

Widrow a proposé trois algorithmes associés au MADALINE réseau de neurones :

MRI (Minimum Rule of Intervention) : Décrit ci-dessus. Sélectionne un neurone à la fois et le corrige individuellement.
RRI (Random Rule of Intervention) : Sélectionne au hasard un neurone dont la sortie est compatible avec l’inversion nécessaire, puis le corrige. Moins déterministe mais parfois utile pour éviter des minima locaux.
MRI-II : Version améliorée qui permet de corriger simultanément plusieurs neurones si nécessaire, mais toujours en respectant le principe d’intervention minimale.

Pour ce guide, nous nous concentrons sur la règle MRI originale, la plus élégante et la plus enseignée.

Intuition : l’équipe d’experts

Imaginez une équipe de N experts réunis pour résoudre un problème de classification. Chaque expert (ADALINE) examine les données sous un angle légèrement différent — c’est-à-dire avec ses propres poids wᵢ — et rend un verdict : +1 ou −1. La décision finale est prise par vote majoritaire.

Maintenant, imaginez que le vote donne un résultat incorrect. Comment corriger l’équipe ?

Approche naïve (réseau classique) : On demande à tous les experts de réviser leur opinion. C’est brutal : les experts qui avaient des arguments solides (sortie nette très positive ou très négative) voient aussi leurs connaissances modifiées, ce qui peut déstabiliser ce qu’ils avaient bien appris.

Approche MADALINE réseau de neurones (règle MRI) : On identifie l’expert le plus hésitant — celui dont le verdict était le plus proche de l’indécision (sortie nette proche de zéro). On ne demande qu’à cet expert de changer d’avis. Les experts confiants conservent leurs positions. C’est la minimum intervention : on touche le moins possible à ce qui fonctionnait déjà.

Cette analogie explique pourquoi le MADALINE réseau de neurones converge souvent plus rapidement qu’un Perceptron multicouche classique : en préservant les connaissances acquises par les neurones « sûrs d’eux », l’apprentissage est plus stable et nécessite moins d’itérations.

Implémentation Python complète

Résoudre le problème XOR avec un MADALINE réseau de neurones

Le problème XOR est le benchmark classique : il n’est pas linéairement séparable, donc un simple ADALINE ou Perceptron échoue. Avec 2 ou 3 ADALINE en couche cachée, le MADALINE réseau de neurones peut néanmoins le résoudre.

import numpy as np


class Madaline:
    """
    MADALINE réseau de neurones — Implémentation from scratch.
    Couche cachée de N ADALINE avec règle MRI.
    """

    def __init__(self, n_inputs, n_adalines=3, eta=0.1,
                 n_iter=1000, threshold=0.0):
        self.n_inputs = n_inputs
        self.n_adalines = n_adalines
        self.eta = eta
        self.n_iter = n_iter
        self.threshold = threshold

        # Chaque ADALINE a ses propres poids + biais
        np.random.seed(42)
        self.weights = np.random.randn(n_adalines, n_inputs) * 0.5
        self.biases = np.random.randn(n_adalines) * 0.5

    def _net_output(self, x):
        """Sortie nette (continue) de chaque ADALINE."""
        return np.dot(self.weights, x) + self.biases

    def _discrete_output(self, net):
        """Sortie discrète (signe) de chaque ADALINE."""
        return np.where(net >= self.threshold, 1, -1)

    def _combine(self, discrete):
        """Vote majoritaire."""
        total = np.sum(discrete)
        return 1 if total >= 0 else -1

    def _mri_update(self, x, nets, discrete, target):
        """
        Règle MRI : trie les ADALINE par |net| croissant
        et corrige le plus hésitant en premier.
        """
        order = np.argsort(np.abs(nets))

        for idx in order:
            # Règle de Widrow-Hoff pour ce neurone seul
            error = target - nets[idx]
            self.weights[idx] += self.eta * error * x
            self.biases[idx] += self.eta * error

            # Vérifier si le vote majoritaire est maintenant correct
            new_nets = self._net_output(x)
            new_discrete = self._discrete_output(new_nets)
            new_output = self._combine(new_discrete)

            if new_output == target:
                return True  # Correction réussie

        return False

    def fit(self, X, y, verbose=True):
        """
        Apprentissage avec règle MRI.
        X : matrice (n_samples, n_inputs)
        y : vecteur cible (n_samples,) valeurs +1 ou -1
        """
        n_samples = X.shape[0]
        self.errors_history = []

        for epoch in range(self.n_iter):
            epoch_errors = 0
            for i in range(n_samples):
                nets = self._net_output(X[i])
                discrete = self._discrete_output(nets)
                output = self._combine(discrete)

                if output != y[i]:
                    epoch_errors += 1
                    self._mri_update(X[i], nets, discrete, y[i])

            self.errors_history.append(epoch_errors)

            if verbose and (epoch + 1) % 100 == 0:
                print(f"Époque {epoch+1:>4d}/{self.n_iter} "
                      f"— Erreurs : {epoch_errors}/{n_samples}")

            if epoch_errors == 0:
                if verbose:
                    print(f"\nConvergence atteinte à l'époque {epoch+1} !")
                break

        return self

    def predict(self, X):
        """Prédiction pour un ensemble d'échantillons."""
        preds = []
        for x in X:
            nets = self._net_output(x)
            discrete = self._discrete_output(nets)
            preds.append(self._combine(discrete))
        return np.array(preds)

    def score(self, X, y):
        """Précision."""
        return np.mean(self.predict(X) == y)


# =============================================
# Test sur le problème XOR
# =============================================
if __name__ == "__main__":
    X_xor = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
    y_xor = np.array([-1, 1, 1, -1])

    print("=" * 60)
    print("MADALINE réseau de neurones — Problème XOR")
    print("=" * 60)

    model = Madaline(n_inputs=2, n_adalines=3, eta=0.3, n_iter=2000)
    model.fit(X_xor, y_xor, verbose=True)

    print("\n" + "=" * 60)
    print("Résultats finaux :")
    print("=" * 60)
    for x, t in zip(X_xor, y_xor):
        nets = model._net_output(x)
        disc = model._discrete_output(nets)
        out = model._combine(disc)
        mark = "✓" if out == t else "✗"
        print(f"  Entrée {list(x)} → nets = {np.round(nets, 3)}, "
              f"ADALINE = {disc}, "
              f"MADALINE = {out} (att. {t}) {mark}")

    acc = model.score(X_xor, y_xor)
    print(f"\nPrécision sur XOR : {acc * 100:.1f}%")

Analyse de convergence

La convergence du MADALINE réseau de neurones repose sur des fondements théoriques solides :

Garantie de correction : La règle de Widrow-Hoff minimise l’erreur quadratique moyenne de chaque ADALINE. Si le problème est linéairement séparable dans l’espace induit par la couche cachée, la convergence est garantie.
Stabilité : Contrairement à la rétropropagation qui modifie simultanément tous les poids, la règle MRI ne touche qu’à un neurone à la fois, ce qui réduit le risque de divergence.
Vitesse : Le nombre d’itérations nécessaires dépend du nombre d’ADALINE (il en faut au moins 2 pour le XOR), du taux d’apprentissage η, et de la complexité de la frontière de décision.

Comparaison : Perceptron multicouche vs MADALINE

Algorithme d’apprentissage : Rétropropagation (MLP) vs Règle MRI / Widrow-Hoff (MADALINE)
Fonction d’activation : Sigmoïde / ReLU (MLP) vs Signe binaire (MADALINE)
Mise à jour des poids : Tous les neurones simultanément (MLP) vs Seulement l’ADALINE le plus hésitant (MRI)
Stabilité : Peut diverger sans régularisation (MLP) vs Très stable : préserve les poids sûrs (MADALINE)
Convergence : Souvent plus rapide avec ReLU (MLP) vs Plus lente mais plus robuste (MADALINE)
Complexité : O(n² par couche) (MLP) vs O(N_adalines × n_entrées) (MADALINE)
Usage principal : Deep learning moderne (MLP) vs Classification binaire à couche cachée (MADALINE)

Hyperparamètres

Le MADALINE réseau de neurones possède quatre hyperparamètres principaux :

n’adalines (nombre d’ADALINE en couche cachée)

Rôle : Détermine la capacité du réseau à modéliser des frontières non linéaires.
Valeur typique : 2 à 10 pour des problèmes simples. Pour le XOR, 2 ADALINE suffisent théoriquement, mais 3 offrent plus de robustesse.
Règle empirique : Le nombre minimum d’ADALINE est le nombre de régions linéairement séparables nécessaires pour couvrir la classe positive. On peut commencer par 3 et ajuster.

eta (taux d’apprentissage)

Rôle : Contrôle l’amplitude de chaque mise à jour de la règle de Widrow-Hoff.
Plage recommandée : 0.01 à 0.5.
Comportement : Un η trop petit entraîne une convergence lente ; un η trop grand peut causer des oscillations autour de la solution optimale.

n’iter (nombre maximal d’itérations)

Rôle : Limite supérieure du nombre d’époques d’apprentissage.
Plage recommandée : 500 à 5 000.
Critère d’arrêt anticipé : L’apprentissage s’arrête dès que l’erreur sur l’ensemble d’entraînement atteint zéro (convergence).

threshold (seuil de décision)

Rôle : Valeur à partir de laquelle un ADALINE passe de −1 à +1.
Valeur par défaut : 0.0.
Note : Le biais (bias) de chaque ADALINE joue un rôle similaire ; le seuil est donc rarement modifié en pratique.

Avantages et limites

Avantages du MADALINE réseau de neurones

Stabilité d’apprentissage : La règle MRI préserve les connaissances des neurones « sûrs », réduisant le phénomène d’oubli catastrophique.
Simplicité conceptuelle : Chaque neurone suit la règle de Widrow-Hoff, facile à comprendre et à implémenter, sans avoir besoin de calculer de gradients en chaîne (contrairement à la rétropropagation).
Pas de plateau de saturation : L’ADALINE utilise des sorties nettes continues pour l’apprentissage, évitant ainsi les problèmes de saturation de la fonction sigmoïde.
Importance historique : Le MADALINE réseau de neurones fut le premier modèle à démontrer qu’une couche cachée pouvait résoudre des problèmes non linéairement séparables, pavant la voie aux réseaux multicouches modernes.

Limites du MADALINE réseau de neurones

Capacité limitée : Avec une seule couche cachée et une fonction de sortie fixe, le MADALINE ne peut pas modéliser des fonctions aussi complexes qu’un MLP profond avec rétropropagation.
Pas de généralisation profonde : L’architecture ne s’étend pas naturellement à plusieurs couches cachées, ce qui limite sa puissance d’expression.
Performance sur grands jeux de données : La règle MRI, bien que stable, est plus lente que la rétropropagation mini-lot (mini-batch SGD) sur de grands ensembles.
Binaire : Le MADALINE réseau de neurones est intrinsèquement un classifieur binaire. L’extension au multiclasse nécessite des stratégies de type un-versus-le-reste (one-vs-rest).

4 cas d’usage pratiques

1. Reconnaissance de caractères manuscrits (OCR simplifié)

Le MADALINE réseau de neurones peut être utilisé pour distinguer deux caractères spécifiques, par exemple les chiffres « 1 » et « 7 » dans des images binarisées. Chaque ADALINE de la couche cachée détecte un motif différent (barre verticale, diagonale, etc.), et le vote majoritaire fournit la classification finale.

2. Classification de signaux radar / sonar

Dans les applications militaires et de navigation, le MADALINE réseau de neurones a historiquement été utilisé par Widrow pour classer les échos radar en « objet détecté » ou « bruit de fond ». La stabilité de la règle MRI est cruciale dans ces contextes : on ne veut pas que le système « oublie » ce qu’il a appris sur des échos clairs.

3. Détection d’anomalies industrielles

Pour surveiller un processus industriel (température, pression, vibration), le MADALINE réseau de neurones peut apprendre le comportement « normal » et signaler les anomalies. Chaque ADALINE surveille un aspect différent du signal, et l’intervention minimale garantit que la détection reste stable même en présence de bruit.

4. Filtrage adaptatif de parole (annulation d’écho)

C’était l’application originale de Widrow : les ADALINE individuels agissent comme des filtres adaptatifs dans un banc de filtres en parallèle. La règle MRI permet d’ajuster uniquement les filtres les plus incertains, ce qui préserve la qualité globale du signal tout en réduisant l’écho acoustique.

MADALINE : Guide Complet — Principes, Exemples et Implémentation Python

MADALINE réseau de neurones : Guide complet — Principes, Exemples et Implémentation Python

Résumé

Principe mathématique