Le Perceptron Simple (Couche Unique)

Un perceptron simple est l'architecture de réseau de neurones la plus basique, ne comportant qu'une seule couche de neurones de sortie. Mathématiquement, les signaux d'entrée subissent une combinaison linéaire (somme pondérée ajoutée à un biais). Le résultat est ensuite traité par une fonction d'activation.

Le rôle principal de la fonction d'activation est de introduire une non-linéarité ou de mapper la sortie vers un espace spécifique. Dans le cas d'un classifieur binaire, une fonction seuil (comme hardlim) est utilisée pour compresser la valeur continue (allant de l'infini négatif à l'infini positif) en une sortie binaire stricte (0 ou 1), simulant ainsi le comportement d'un neurone biologique qui s'active ou reste inactif.

Implémentation et Entraînement

Considérons un problème de classification logique (porte OU) avec deux caractéristiques d'entrée. Voici comment structurer les données et initialiser le réseau dans MATLAB :

% Définition des caractéristiques d'entrée et des étiquettes cibles
features_mat = [0 0 1 1; 
                0 1 0 1];
labels_vec = [0 1 1 1];

% Extraction des plages de valeurs pour chaque caractéristique
input_ranges = minmax(features_mat);

% Création du perceptron simple avec un seul neurone de sortie
single_layer_net = newp(input_ranges, 1);

La fonction newp initialise le réseau. Ses paramètres principaux incluent les plages d'entrée (PR), le nombre de neurones (S), la fonction de transfert (TF, par défaut hardlim) et la fonction d'apprentissage (LF, par défaut learnp pour la mise à jour des poids).

Une fois le modèle initialisé, nous pouvons configurer les hyperparamètres et lancer la phase d'entraînement :

% Configuration du nombre maximal d'itérations (époques)
single_layer_net.trainParam.epochs = 100;

% Entraînement du réseau avec les données fournies
trained_net = train(single_layer_net, features_mat, labels_vec);

% Simulation pour obtenir les prédictions sur le jeu d'entraînement
predictions = sim(trained_net, features_mat);

La fonction train ajuste itérativement les poids et les biais. Après l'entraînement, les poids synaptiques peuvent être inspectés via trained_net.iw et les biais via trained_net.b. L'outil graphique nntool permet également de visualiser l'architecture.

Évaluation et Visualisation

Pour tester le modèle avec de nouvelles coordonnées continues et visualiser la frontière de décision générée :

% Test avec un point de données non vu pendant l'entraînement
test_point = [0.2; 0.9];
output_label = sim(trained_net, test_point);

% Visualisation graphique des données et de l'hyperplan de séparation
figure;
plotpv(features_mat, labels_vec);
hold on;
plotpc(trained_net.iw{1}, trained_net.b{1});
title('Frontière de décision du Perceptron Simple');

Le Perceptron Multicouche (MLP)

Le perceptron multicouche surpasse les limitations du modèle simple en intégrant une ou plusieurs couches cachées entre l'entrée et la sortie. Ces couches intermédiaires agissent comme des extracteurs de caractéristiques non linéaires, permettant au réseau de résoudre des problèmes qui ne sont pas linéairement séparables.

Propagation du Signal

Dans un MLP, l'information circule de l'entrée vers la sortie (propagation avant). Contrairement à une simple somme linéaire, la sortie de chaque neurone d'une couche cachée est transformée par une fonction d'activation non linéaire (comme tansig ou logsig) avant d'être transmise comme entrée aux neurones de la couche suivante. C'est cette succession de transformations non linéaires qui confère au réseau sa capacité d'approximation universelle.

Configuration du Réseau Multicouche

La création d'un MLP dans MATLAB utilise généralement la fonction newff (ou feedforwardnet dans les versions récentes). La structure du code diffère principalement par la définition de l'architecture cachée et des algorithmes de rétropropagation :

% Préparation des données d'entrée et de sortie
input_data = features_mat;
target_data = labels_vec;

% Définition de l'architecture : 2 couches cachées (5 neurones, puis 3 neurones)
hidden_layers_size = [5 3];

% Création du réseau feedforward avec fonctions d'activation spécifiques
mlp_network = newff(minmax(input_data), [hidden_layers_size, 1], ...
                    {'tansig', 'tansig', 'purelin'}, 'trainlm');

% Configuration avancée des paramètres d'entraînement
mlp_network.trainParam.epochs = 500;
mlp_network.trainParam.goal = 1e-5; % Seuil d'erreur quadratique moyenne pour l'arrêt
mlp_network.trainParam.min_grad = 1e-10;

% Lancement de l'algorithme de rétropropagation
trained_mlp = train(mlp_network, input_data, target_data);

Les paramètres de newff permettent un contrôle fin sur l'apprentissage :

• S : Vecteur définissant le nombre de neurones par couche cachée (ex: [5, 3]).
• TF : Cellule de chaînes de caractères spécifiant la fonction de transfert pour chaque couche (ex: tansig pour les couches cachées, purelin pour la sortie).
• BTF : L'algorithme d'entraînement (ex: trainlm pour l'algorithme de Levenberg-Marquardt, très rapide pour les réseaux de taille moyenne).
• BLF : La règle d'apprentissage pour la mise à jour des poids (ex: learngdm pour la descente de gradient avec momentum).
• PF : La fonction de performance utilisée pour calculer l'erreur (ex: mse pour l'erreur quadratique moyenne).

L'ajout du paramètre net.trainParam.goal est crucial dans les réseaux multicouches. Il définit l'erreur minimale acceptable pour considérer le modèle comme convergé, permettant d'arrêter l'entraînement de manière précoce et d'éviter le surapprentissage ou les calculs inutiles une fois la précision souhaitée atteinte.