Explication des réseaux neuronaux à action directe : Un guide complet

Lorsqu'on examine les algorithmes d'apprentissage automatique, il est essentiel de comprendre algorithmes d'apprentissage automatique, il existe très peu de concepts aussi fondamentaux que le réseau neuronal à propagation directe (FFNN). Si vous avez déjà construit votre premier réseau neuronal, il y a de fortes chances qu'il s'agisse d'un réseau à propagation directe. On les retrouve pratiquement partout, des problèmes de classification simples aux plus complexes. de simples problèmes de classification aux couches d'alimentation dans les architectures profondes.

Permettez-moi tout d'abord de vous présenter la place qu'occupent les réseaux neuronaux à action directe dans le schéma général :

Dans ce tutoriel, je vais expliquer ce qu'est réellement un réseau neuronal à propagation directe, comment il a évolué et pourquoi il reste pertinent aujourd'hui, et je vais également présenter des exemples concrets.

Qu'est-ce qu'un réseau neuronal à propagation directe ?

Intuitivement, la meilleure façon de décrire une telle architecture réseau est la suivante : « Les données circulent uniquement vers l'avant, sans boucles. »

À la base, un réseau neuronal à couche unique (FFNN) traite les données de manière à ce qu'elles circulent dans un seul sens, de l'entrée vers la sortie. Il n'y a pas de boucle, pas de récursivité et pas de cycles (à l'exception dela rétropropagation d' , que nous aborderons sous peu).

Lorsque j'ai découvert ce concept, l'image mentale qui m'a le plus aidé était celle d'un tapis roulant dans une usine. 

Pourquoi ? 

Étant donné que chaque étape du processus (ou chaque couche du réseau) effectue une opération simple sur l'entrée avant de la transmettre à la suivante.

Voici comment cela fonctionne :

1. Les entrées sont transmises à la première couche (la couche d'entrée).
2. Ils sont transformés par des poids et des biais, puis passent par une fonction d'activation.
3. Ceci se poursuit à travers une ou plusieurs couches cachées.
4. Enfin, la couche de sortie effectue une prédiction.

Avant de vous présenter l'architecture d'un tel réseau, je souhaite clarifier une idée fausse courante :

Les réseaux neuronaux à action directe sont identiques aux réseauxLes réseaux neuronaux à action directe sont identiques aux réseaux neuronaux multi-couches. »

Afin de dissiper ce malentendu, il est nécessaire d'examiner les débuts de l'histoire du Deep Learning. 

Les débuts de l'apprentissage profond

Perceptron : Nous commençons par leperceptron d' , inventé dans les années 1950 par Frank Rosenblatt. Il s'agissait d'un classificateur binaire à couche unique qui, bien qu'il ne puisse pas résoudre tous les problèmes (comme les problèmes XOR), a posé les bases des réseaux neuronaux.

En termes simples, un perceptron fonctionnait de la manière suivante :

1. s sur les entrées: Chaque entrée (telle que x_1, x_2, etc.) est associée à un poids (w_1, w_2, etc.).
2. s de la somme pondérée: Les entrées sont multipliées par leurs poids et additionnées, avec un terme de biais : z = w1*x1 + w2*x2+ ... + b.
3. s d'activation: Le résultat est soumis à une fonction en escalier (une activation). Si la valeur est supérieure à un seuil, le perceptron produit un 1 ; sinon, il produit un 0.

Essentiellement, le perceptron est un classificateur linéaire, ce qui signifie qu'il ne peut tracer que des frontières de décision en ligne droite (ou hyperplan). D'une part, le perceptron présentait des avantages, notamment sa simplicité et son élégance (puisqu'il s'inspirait de la biologie), ainsi que son faible coût de calcul. Cependant, il n'était pas en mesure de résoudre les problèmes qui ne sont pas linéairement séparables, tels que le problème XOR. 

Perceptrons multicouches (MLP) : Quelques décennies plus tard, dans les années 1980, les chercheurs ont découvert qu'en empilant plusieurs perceptrons et en ajoutant des fonctions d'activation non linéaires, il était possible de résoudre des problèmes plus complexes. Cette structure est devenue connue sous le nom de perceptron multicouche.

Voici comment cela fonctionnait : 

1. s de la couche d'entrée: Nous avons intégré les caractéristiques brutes issues de l'ensemble de données.
2. s cachées: Une ou plusieurs couches de perceptrons qui appliquent des transformations. Chaque neurone a effectuél' e z = w*x + b et l'a soumise à une fonction d'activation non linéaire telle que sigmoïde, tanh, etc.
3. s de la couche de sortie: La couche finale a généré la prédiction finale (par exemple, probabilités de classe, valeurs de régression).

L'ajout de ces activations non linéaires s'est avéré crucial. Sans eux, l'empilement des couches s'effondrerait en une simple transformation linéaire. Grâce à eux, les MLP peuvent représenter des fonctions non linéaires extrêmement complexes.

Cela a conduit à l'un des résultats les plus célèbres de la théorie des réseaux neuronaux : le Théorème d'approximation universelle.

Ce théorème stipule qu'un réseau neuronal comportant ne serait-ce qu'une seule couche cachée, à condition qu'il dispose d'une fonction d'activation non linéaire et d'un nombre suffisant de neurones, peut approximer n'importe quelle fonction continue sur un domaine borné. 

L'ère de l'apprentissage profond : En entrant dans les années 2010, nous accédons à l'ère de l'apprentissage profond. Grâce aux GPU et au big data, les FFNN ont évolué vers des architectures plus profondes et plus puissantes, formant ainsi la base des CNN, RNN et Transformers, qui constituent essentiellement l'état actuel de la technologie.

Revenant à l'idée fausse initiale, nous savons désormais que :

• Réseau neuronal à propagation directe (FFNN). Catégorie générale de tout réseau neuronal dans lequel les données circulent dans un seul sens (entrée → couche cachée → sortie), sans boucles.
• s du perceptron multicouche (MLP). Type de réseau neuronal profond (FFN) à propagation arrière ( ) qui comporte au moins une couche cachée de perceptrons (neurones avec poids, biais et activation).

En d'autres termes, tous les MLP sont des FFNN, mais tous les FFNN ne sont pas des MLP. Il est essentiel de garder cela à l'esprit. Une autre idée fausse courante concerne le perceptron à une seule couche (c'est-à-dire uniquement de l'entrée à la sortie).

Un perceptron à couche unique est un réseau neuronal à couche fixe (FFNN), mais pas un réseau neuronal multi-couches (MLP). Ce n'est qu'une fois que nous ajoutons des couches cachées que cela devient un MLP.

Cette distinction est importante, car les MLP sont capables d' approximer des fonctions universelles (avec suffisamment d'unités cachées et de fonctions d'activation non linéaires), tandis que les perceptrons simples à couche unique sont limités dans ce qu'ils peuvent représenter.

Architecture d'un réseau neuronal à propagation directe

Dans la section précédente, nous avons beaucoup appris sur les FFNN, mais pour simplifier, on peut les considérer comme une pile de transformations simples. Il existe de nombreux composants différents qui constituent un FFNN, nous allons donc les examiner plus en détail, en particulier la structure MLP. 

Dans un MLP, il existe trois types de couches : la couche d'entrée, la couche cachée et la couche de sortie, que nous avons brièvement mentionnées précédemment. 

Veuillez examiner le schéma ci-dessus pendant que nous explorons ces couches plus en détail. 

Couche d'entrée

Il s'agit du point d'entrée du réseau.  Chaque neurone représente icil' d'une caractéristique de l'ensemble de données. Il est important de noter que la couche d'entrée n'effectue aucun calcul elle-même — elle transmet simplement les chiffres bruts. Dans notre exemple, étant donné qu'il n'y a que deux neurones dans la couche d'entrée, cela signifie que notre ensemble de données contient deux caractéristiques (ou que nous ne prenons en compte que deux caractéristiques de notre ensemble de données). 

Couches cachées

Ces sont les éléments où s'effectuent les calculs réels. Nous avons deux couches cachées, chacune contenant quatre neurones. Chaque neurone d'une couche cachée effectue les trois opérations suivantes :

1. Somme pondérée : Chaque entrée est multipliée par un coefficient, puis toutes les entrées sont additionnées. 
2. Biais : Un biais constant est ajouté afin d'offrir une certaine flexibilité dans le déplacement de la fonction.
3. Fonction d'activation : Une fonction de compression non linéaire telle que ReLU, tanh ou sigmoid est appliquée. Cette étape permet au réseau d'apprendredes modèles complexes et non linéaires d' .

Couche de sortie

La couche de sortie génère la prédiction finale, et sa conception dépend du problème que nous essayons de résoudre :

• Problèmes de régression , comme la prévision des prix de l'immobilier. Dans ce cas, la couche de sortie contiendra un neurone sans activation (linéaire). Pourquoi linéaire ? Étant donné que nous ne souhaitons pas écraser les valeurs, les prix immobiliers peuvent être n'importe quel nombre réel.
• Problèmes de classification binaire (décisions oui/non), comme prédire si un e-mail est un spam ou non. Dans ce cas, la couche de sortie serait constituée d'un seul neurone avec une activation sigmoïde. Pourquoi sigmoïde ? En effet, nous souhaitons que notre réseau produise des valeurs comprises entre 0 et 1 (puisque nous prédisons des probabilités). 
• Problèmes de classification multi-classes (3 classes ou plus) - par exemple, classer (3 classes ou plus), comme la classification d'une image en différents animaux. La couche de sortie comporterait un neurone par classe, avec une activation softmax. Pourquoi utiliser la fonction softmax ? Parce qu'il transforme les scores bruts en probabilités qui totalisent 1 (par exemple, 70 % chat, 20 % chien, 10 % cheval).

À titre de référence, voici un diagramme illustrant neuf formes courantes de fonctions d'activation utilisées dans les réseaux neuronaux feed-forward (FFNN) et l'apprentissage profond en général. 

Avant de poursuivre, il est également important de noter ici que chaque neurone d'une couche est connecté à chaque neurone de la couche suivante (c'est pourquoi on parle de connexion complète).

Revenons à notre exemple : nous avons :

Params = (2⋅4+4)+(4⋅4+4)+(4⋅1+1)=12+20+5=37

Chaque parenthèse indique le nombre de paramètres entre les couches consécutives, où le nombre de neurones de la couche précédente et celui de la couche actuelle sont multipliés ensemble, puis le nombre de biais (c'est-à-dire le nombre de neurones dans la couche actuelle) est également ajouté. Veuillez essayer d'effectuer ces calculs sur d'autres exemples de réseaux neuronaux à des fins d'entraînement.

Formation d'un réseau neuronal à propagation directe

Dans le Deep Learning, l'entraînement est divisé en deux étapes : la propagation avant et la rétropropagation. En termes simples, la propagation vers l'avant nous fournit des prédictions, tandis que la rétropropagation représente la manière dont nousapprenons de nos erreurs.

Propagation vers l'avant 

Tout ce que nous avons abordé jusqu'à présent relève de la propagation vers l'avant. En résumé, lorsque les données transitent par un MLP, chaque couche effectue les deux mêmes étapes, qui peuvent être exprimées mathématiquement par les équations suivantes :

Ici z est la sortie obtenue après avoir multiplié la sortie de la couche précédente par les poids de la couche actuelle et ajouté le biais, également appelé étape linéaire.

Naturellement, si la couche précédente est la couche d'entrée, alors ce serait x au lieu de al-1. La prochaine étape estl'activation de l' . Veuillez suivre le lien suivant :. Pour rendre cela plus rigoureux mathématiquement, nous pouvons écrire les poids et les biais comme suit :

rétropropagation

Une fois que nous avons reçu une sortie, comment pouvons-nous déterminer si elle est correcte ou non pour notre réseau ? Ou mieux encore, comment pouvons-nous améliorer le réseau pour qu'il remplisse mieux sa mission ? C'est ici que la rétropropagation entre en jeu. intervient la rétropropagation entre en jeu. Nous pouvons le considérer comme le système de rétroaction du réseau, qui indique au modèle son degré d'écart et comment s'ajuster. Nous pouvons décomposer cela comme suit :

1. Veuillez comparer les prévisions: Veuillez examiner ce que le modèle a prédit (ŷ) et quelle était la réponse correcte (y).
2. Veuillez calculer l'erreur: Nous utilisons une fonction de perte pour mesurerl' ,c'est-à-dire l'erreur de prédiction, telle que l'erreur quadratique moyenne (MSE).
3. Propager en arrière (via la règle de dérivation en chaîne): Les gradients relatifs à tous les biais et poids sont calculés. ∂L/∂w,∂L/∂b .
4. Mise à jour de la descente de gradient: Les paramètres respectifs sont mis à jour afin de réduire les pertes selon la règle suivante :

Ici, η est le taux d'apprentissage, un paramètre qui peut être modifié pour déterminer l'ampleur du changement des paramètres à chaque mise à jour.

Au fil de nombreux cycles de ce processus, le réseau apprend progressivement et s'améliore dans l'exécution de la tâche.

Pour clarifier les choses, examinons ensemble un exemple très simple. Supposons que nous ayons :

• Entrée : x = 2
• Résultat visé : y=4
• Prévision : ŷ = 3

Maintenant, passons en revue les étapes. 

1. Veuillez comparer la prédiction : ŷ = 3, y = 4
2. Erreur : Pour cet exemple, nous allons utiliser le MSE : L=(y−y^​)2=(4−3)2=1
3. Rétropropagation : Le réseau détermine l'impact de chaque poids et biais sur cette erreur à l'aide de dérivées, puis nous actualisons chacun des paramètres à l'aide de l'étape d'actualisation par descente de gradient. 

Programmation d'un réseau neuronal à propagation directe dans PyTorch

Nous avons abordé les mathématiques pertinentes pour construire un FFNN (plus précisément un MLP). Pour aller plus loin, nous allons coder ceci dans PyTorch.

Perceptron multicouche

# Imports we will be needing
import torch
import torch.nn as nn
import torch.optim as optim

X,y = dataset # Here will be our dataset 

# We have created a MLP here using nn.Sequential()
model = nn.Sequential(
    nn.Linear(2, 4),  # input layer → hidden layer (2 → 4)
    nn.ReLU(),        # relu activation function
    nn.Linear(4, 4), # hidden layer 1 → hidden layer 2 (4 → 4)
    nn.ReLU(), 
    nn.Linear(4, 1)   # hidden layer 2 → output (4 → 1)
)


criterion = nn.MSELoss()         # regression loss, i.e our loss function
optimizer = optim.SGD(model.parameters(), lr=0.1) # Optimizer using the Stochastic Gradient Descent

# Training Loop
EPOCHS = 200 # Number of epochs we will be training for
for epoch in range(EPOCHS):
    # Forward pass
    outputs = model(X)
    loss = criterion(outputs, y)

    # Backward pass
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

À ce stade, vous devriez être en mesure de mettre en correspondance le code PyTorch avec les étapes mathématiques que nous avons examinées précédemment. Cependant, vous pourriez avoir une question concernant les époques.

Une époqu, c'est un passage complet de l'ensemble des données d'apprentissage à travers le réseau neuronal. Par exemple, supposons que nous disposions de 1 000 points de données d'entraînement et que la taille du lot soit de 100. Une fois que le réseau aura examiné les 1 000 images (soit 10 lots), cela correspondra à une époque. La formation nécessite généralement de nombreuses époques afin que le modèle puisse continuer à améliorer ses poids.

Réseau neuronal convolutif

Je souhaite également mentionner brièvement d'autres FFNN, dont l'un des plus connus est le réseau neuronal convolutif (CNN).

Bien qu'un CNN contienne également un MLP à la fin, il comprend au début des couches spéciales appelées couches convolutives et couches de pooling. En ce qui concerne les couches convolutives, elles sont essentielles car elles ne considèrent que de petites régions locales de l'entrée à la fois à l'aide d'unfiltre (ou noyau)d' .

Ceci est particulièrement utile pour classer des images, car :

• Les couches denses auraient traité chaque pixel séparément, en ignorant la structure spatiale.
• Les couches convolutives, quant à elles, peuvent détecter les contours, les textures et les formes dans de petites zones, puis les combiner en motifs plus complexes à mesure que nous approfondissons l'analyse.

Outre les couches convolutives, les CNN utilisent également des couches de regroupement.

Il est important de noter que les couches de regroupement n'apprennent pas les paramètres, mais procèdent plutôt à un sous-échantillonnent les cartes de caractéristiques afin de les rendre plus petites et plus faciles à gérer.

• Le plus courant est le Max Pooling, qui prend la valeur maximale de chaque petite région (par exemple, une fenêtre 2×2).
• Le regroupement rend le réseau plus efficace et permet également d'obtenir une invariance de traduction. invariance de traduction (le réseau s'intéresse davantage à l'existence d'une caractéristique qu'à son emplacement exact).

Nous pouvons coder un CNN à l'aide de PyTorch comme suit :

class SimpleCNN(nn.Module): # Define our model as a class
    def __init__(self):
        super().__init__()
        self.conv = nn.Conv2d(1, 8, 3)     # 1→8 channels, 3x3 kernel
        self.pool = nn.MaxPool2d(2, 2)
        self.fc   = nn.Linear(8*13*13, 10) # flatten → 10 classes

    def forward(self, x): # Forward propagation function 
        x = self.pool(torch.relu(self.conv(x)))
        x = x.view(x.size(0), -1)          # flatten
        return self.fc(x)

Dans le code ci-dessus, nous avons créé un CNN très simple, composé d'une seule couche de convolution, d'une seule couche de pooling et d'une seule couche linéaire. 

Autres exemples de réseaux neuronaux à propagation directe

Nous avons abordé deux exemples très connus et importants de FFNN, mais il existe de nombreux autres exemples qui ont révolutionné leurs domaines respectifs, tels que :

1. Transformers: chaque bloc contient une partie MLP/FFN (après l'auto-attention, la « couche feed-forward » élargit et réduit les dimensions).
2. Transformateurs de vision (ViT) : appliquent des blocs de transformateurs (contenant des FFNN) à des fragments d'images.
3. Autoencodeurs (de base) : encodeur + décodeur tous deux construits à partir de FFNN.
4. Systèmes de recommandation (basés sur les réseaux neuronaux multi-couches) : par exemple, modèles Wide & Deep pour le classement et les prédictions.

Conclusions finales

Nous espérons que vous avez pris conscience de l'importance des FFNN dans le domaine de l'IA. Sans ces éléments, le paysage actuel de l'apprentissage profond n'existerait pas.

Pour poursuivre, je recommande vivement la maîtrise de la rétropropagation. de maîtriser la rétropropagation et d'approfondir vos connaissances sur les fonctions d'activation. Étant donné qu'il s'agit de la base du Deep Learning, je recommanderais également d'étudier le Deep Learning avec PyTorch.