Construction d'un perceptron multicouche en Python : guide pratique

Cet article vous guide à travers un programme Python qui entraîne un réseau de neurones pour une classification avancée.

C'est la 12e entrée de la série développement de réseaux de neurones d'AAC. Voyez ce que la série offre d'autre ci-dessous :

1. Comment effectuer une classification avec un réseau de neurones : qu'est-ce que le perceptron ?
2. Comment utiliser un exemple simple de réseau de neurones perceptron pour classifier des données
3. Comment entraîner un perceptron de base
4. Comprendre l'entraînement simple de réseau de neurones
5. Introduction à la théorie de l'entraînement pour réseaux de neurones
6. Comprendre le taux d'apprentissage dans les réseaux de neurones
7. Apprentissage automatique avancé avec le perceptron multicouche
8. La fonction d'activation sigmoïde : activation dans les réseaux de neurones perceptron multicouches
9. Comment entraîner un perceptron multicouche
10. Comprendre les formules d'entraînement et la rétropropagation pour perceptrons multicouches
11. Architecture de réseau de neurones pour une implémentation Python
12. Comment créer un perceptron multicouche en Python
13. Traitement du signal avec réseaux de neurones : validation dans la conception de réseaux de neurones
14. Jeux de données d'entraînement pour réseaux de neurones : comment entraîner et valider un réseau de neurones Python

Dans cet article, nous construirons sur notre travail avec les réseaux perceptron simples et l'étendrons à un perceptron multicouche (MLP) pleinement fonctionnel implémenté en Python.

Développement de code Python compréhensible pour réseaux de neurones

Après avoir examiné de nombreuses ressources en ligne, j'ai trouvé que beaucoup d'implémentations sont soit trop complexes, soit manquent de clarté. Mon but était de créer un programme à la fois éducatif et intuitif, permettant aux lecteurs de voir comment la théorie se traduit en code.

Bien que ce script privilégie la lisibilité sur la performance brute, il reste une base solide pour l'expérimentation. Les applications réelles exigent souvent du code optimisé pour gérer de grands jeux de données, mais pour l'apprentissage et les projets à petite échelle, la clarté est plus précieuse.

Le code source Python complet est disponible en image ci-dessous et peut être téléchargé comme MLP_v1.py. Le code effectue l'entraînement et la validation, avec le focus de cet article sur le processus d'entraînement.

 

Préparation des fonctions et variables

La bibliothèque NumPy gère toutes les opérations numériques, tandis que Pandas facilite l'import facile des données d'entraînement depuis Excel. Nous utilisons la fonction sigmoïde logistique pour l'activation et sa dérivée pour la rétropropagation. Le taux d'apprentissage, la dimensionalité d'entrée, la taille de la couche cachée et le nombre d'époques sont définis ici. Les poids initiaux aléatoires sont générés avec np.random.uniform(-1, 1), et une graine fixe assure la reproductibilité. Des tableaux vides pour les valeurs de pré-activation et post-activation cachées sont aussi initialisés.

Importation des données d'entraînement

Suivant la procédure de la Partie 4, nous lisons le jeu de données depuis Excel, séparons la colonne cible, l'enlevons de la matrice de caractéristiques, convertissons les données restantes en tableau NumPy, et stockons le nombre d'échantillons dans training_count.

Traitement de propagation avant

La phase de propagation avant calcule la sortie du réseau en propageant les entrées à travers la couche cachée vers le nœud de sortie. Le code ci-dessous démontre la boucle multi-époques, les calculs par échantillon, la pré-activation et l'activation de la couche cachée, et le calcul final de la sortie.

À l'intérieur de chaque époque, nous itérons sur tous les échantillons. Pour chaque échantillon, nous calculons les activations des nœuds cachés via produits scalaires, appliquons la sigmoïde, puis calculons la pré-activation et post-activation du nœud de sortie. L'erreur est la différence entre la cible et la sortie.

Rétropropagation

Après la propagation avant, la rétropropagation ajuste les poids dans l'ordre inverse, propageant les signaux d'erreur de la sortie vers la couche cachée. L'image suivante illustre les boucles imbriquées et les mises à jour de poids.

Nous calculons d'abord le terme d'erreur de sortie S_ERROR, puis mettons à jour les poids cachés-vers-sortie. Ensuite, pour chaque nœud caché, nous calculons sa contribution aux mises à jour des poids entrée-vers-caché en utilisant le poids caché-vers-sortie actuel. Cet ordre préserve les calculs de gradient corrects.

Conclusion

Ce script concis encapsule les principes de base d'un MLP : ingestion de données, propagation avant, calcul d'erreur, et ajustement des poids via rétropropagation. J'espère qu'il sert de pont clair entre la théorie des réseaux de neurones et l'implémentation pratique.

Voici le code complet pour référence :

Télécharger le code