Aller au contenu
Hacktion Wiki IA

Réseaux de Neurones (Neural Networks)

Ce que vous saurez dans 3 minutes

Les Réseaux de Neurones (NN) sont le moteur de la révolution IA actuelle.

  • Décideurs : Comprendre que “Deep Learning” signifie simplement “Réseau de Neurones avec beaucoup de couches” et que c’est ce qui a permis de passer de 80% à 99% de précision en vision par ordinateur.
  • Experts Techniques : Revoir les fondamentaux du Perceptron Multi-Couches (MLP) et pourquoi les fonctions d’activation non-linéaires (ReLU) sont le secret de leur puissance.
  • Opérationnels : Visualiser le flux de données : Entrée -> Couches Cachées (Magie) -> Sortie.

1. Comprendre

L’informatique classique, c’est comme une recette de cuisine : “Si A alors B, sinon C”. C’est parfait pour la comptabilité, mais nul pour reconnaître un chat sur une photo (il y a trop de règles possibles). Les Réseaux de Neurones approchent le problème différemment : ils apprennent par l’exemple, comme un enfant. Vous montrez 10 000 photos de chats et 10 000 photos de chiens. Au début, le réseau répond au hasard. À chaque erreur, il s’auto-corrige légèrement. Après 20 000 corrections, il “sait” reconnaître un chat, même s’il est incapable de vous expliquer pourquoi (c’est la “Boîte Noire”).

Définition

Contexte & Enjeux

L’idée date de 1943 (McCulloch & Pitts), mais elle est restée une curiosité de laboratoire pendant 70 ans à cause du manque de puissance de calcul.

  • Le point de bascule (2012) : Le réseau “AlexNet” écrase la concurrence au concours ImageNet grâce aux cartes graphiques (GPU). C’est le début de l’ère du Deep Learning.
  • Aujourd’hui : Tout ce qui est “IA moderne” (GPT, Midjourney, Tesla Autopilot) est un réseau de neurones géant.

2. Appliquer

L’Architecture : Anatomie d’un Réseau

Un réseau classique (Perceptron Multi-Couches ou MLP) est un sandwich à trois étages :

graph LR
    subgraph Input["Couche d'Entrée (Rétine)"]
        I1((x1))
        I2((x2))
        I3((x3))
    end
    
    subgraph Hidden["Couches Cachées (Cerveau)"]
        H1((h1))
        H2((h2))
        H3((h3))
        H4((h4))
    end
    
    subgraph Output["Couche de Sortie (Décision)"]
        O1((y1))
        O2((y2))
    end
    
    I1 --> H1 & H2 & H3 & H4
    I2 --> H1 & H2 & H3 & H4
    I3 --> H1 & H2 & H3 & H4
    H1 & H2 & H3 & H4 --> O1 & O2
    
    style Input fill:#e1f5fe,stroke:#01579b
    style Hidden fill:#fff9c4,stroke:#fbc02d
    style Output fill:#e8f5e9,stroke:#2e7d32
  1. Couche d’Entrée : Reçoit les données brutes (ex: les pixels d’une image).
  2. Couches Cachées : Là où la magie opère. Elles extraient des caractéristiques de plus en plus abstraites (bords -> formes -> yeux -> visages).
  3. Couche de Sortie : Donne le résultat final (ex: “Chat à 98%”).

Le Mécanisme d’Apprentissage (La Boucle Sacrée)

Comment le réseau devient-il intelligent ? Par un cycle infini en 4 temps :

  1. Forward Pass (Prédiction) Les données traversent le réseau. Le réseau fait une prédiction (souvent fausse au début).

    • Exemple : Il voit un Chat, il dit “Chien 60%”.

  2. Calcul de l’Erreur (Loss) On compare la prédiction à la réalité.

    • Maths : Erreur=(Preˊdiction−Reˊaliteˊ)2Erreur = (Prédiction - Réalité)^2.

  3. Backward Pass (Rétropropagation) C’est l’étape de génie (inventée en 1986). On remonte le réseau à l’envers pour trouver quel neurone est responsable de l’erreur.

    • Analogie : “C’est la faute du neurone 3 de la couche 2 qui a trop crié ‘Chien’”.

  4. Mise à jour des Poids (Descente de Gradient) On ajuste légèrement les connexions pour réduire l’erreur la prochaine fois.

    • Action : “Baisse un peu le volume du neurone 3”.

Mise en œuvre pratique (Code PyTorch)

Définir un réseau de neurones moderne se fait en quelques lignes de Python.

import torch
import torch.nn as nn


class MonIA(nn.Module):
    def __init__(self):
        super().__init__()
        # Couche 1 : De l'entrée (784 pixels) vers 128 neurones cachés
        self.couche_entree = nn.Linear(784, 128)
        # Activation : La "juge" qui décide si le neurone s'allume
        self.relu = nn.ReLU()
        # Couche 2 : Des 128 neurones vers la sortie (10 chiffres)
        self.couche_sortie = nn.Linear(128, 10)


    def forward(self, x):
        # Le trajet de la donnée
        x = self.couche_entree(x) # Transformation linéaire
        x = self.relu(x)          # Non-linéarité (Indispensable !)
        x = self.couche_sortie(x) # Prédiction finale
        return x


# Création d'une instance
mon_cerveau = MonIA()
print(mon_cerveau)

Le Secret : La Non-Linéarité (ReLU)

Si on utilisait juste des additions et des multiplications (linéaire), empiler 100 couches reviendrait mathématiquement à une seule couche. Le réseau serait bête. Pour apprendre des formes complexes (courbes), il faut tordre l’espace. C’est le rôle de la Fonction d’Activation.

  • ReLU (Rectified Linear Unit) : Si x < 0, alors 0. Sinon x. C’est bête comme chou, mais c’est ce qui a permis le Deep Learning. Elle “éteint” les neurones inutiles.

3. Aller plus loin

Les Grandes Familles d’Architectures

Tous les réseaux ne se ressemblent pas. Selon la donnée, l’architecture change :

ArchitectureNom CompletSpécialitéExemple
MLPMulti-Layer PerceptronDonnées Tabulaires (Excel)Prédiction de Churn, Fraude bancaire
CNNConvolutional Neural NetworkImages (Grilles de pixels)Reconnaissance faciale, Diagnostic Rayons X
RNN / LSTMRecurrent Neural NetworkSéquences (Temps, Son)Traduction (avant 2017), Analyse météo
TransformerTransformerAttention (Contexte global)ChatGPT, Gemini, Claude (Le roi actuel)

Le Problème du “Vanishing Gradient”

Plus un réseau est profond (Deep), plus il est dur à entraîner. Pourquoi ? Lors de la rétropropagation, le signal d’erreur doit traverser toutes les couches. S’il est multiplié par des petits nombres (ex: 0.1) à chaque couche, il disparaît avant d’arriver au début. Les premières couches n’apprennent rien.

  • Solution 1 : ReLU (qui ne multiplie pas par < 1).
  • Solution 2 : ResNet (Residual Connections) qui crée des “autoroutes” pour le signal.

Neurones Biologiques vs Artificiels

Attention à ne pas prendre la métaphore au pied de la lettre.

  • Biologique : Fonctionne par “Spikes” (impulsions temporelles), chimie complexe, plasticité permanente, consommation 20 Watts.
  • Artificiel : Fonctionne par “Flots continus” (nombres réels), maths pures, figé après entraînement, consommation 400 Watts (une carte GPU). Le cerveau humain est encore 10 000 fois plus efficace énergétiquement qu’un GPU.

Prospective

Vers où allons-nous ?

  1. Spiking Neural Networks (SNN) : Des réseaux qui imitent vraiment les impulsions du cerveau pour consommer ultra-peu d’énergie (Intel Loihi).
  2. Liquid Neural Networks : Des réseaux capables de changer leur architecture en temps réel (liquidité) pour s’adapter à de nouvelles situations sans ré-entraînement.

Questions Fréquentes

Est-ce qu’un réseau de neurones “pense” ?

Non. Il calcule. C’est une immense fonction mathématique statistique. Il n’a ni conscience, ni intention, ni compréhension du monde. Il a juste trouvé des corrélations très complexes dans les données.

Pourquoi appelle-t-on ça “Deep” Learning ?

“Deep” fait référence à la profondeur du réseau, c’est-à-dire le nombre de couches cachées.

  • 1990 : 2 ou 3 couches (“Shallow Learning”).
  • 2015 : 152 couches (ResNet).
  • 2024 : Des centaines de couches pour les LLM.

Notions Liées (Spider Web)

Ressources Externes