Introduction aux Réseaux de Neurones — Comment l'IA Pense en Couches

L'Algorithme Inspiré du Cerveau 👋

Dans la dernière leçon, vous avez découvert les arbres de décision, KNN et la régression linéaire. Ils sont puissants — mais ils peinent avec des tâches complexes comme la reconnaissance faciale ou la compréhension du langage.

Pour ces tâches, nous avons besoin de réseaux de neurones — des algorithmes inspirés du fonctionnement de votre cerveau.

---

Des Neurones aux Neurones Artificiels 🔬

Votre cerveau possède environ 86 milliards de neurones. Chacun :

1. Reçoit des signaux d'autres neurones
2. Traite ces signaux (les additionne)
3. Décide s'il doit s'activer (envoyer un signal)

Un neurone artificiel fait la même chose, avec des nombres :

1. Reçoit des nombres en entrée
2. Multiplie chaque entrée par un poids
3. Additionne le tout
4. Décide s'il s'active via une fonction d'activation

Entrées         Poids          Somme       Activation      Sortie
──────          ─────          ─────       ──────────      ──────
x₁ = 0.5  ──→  w₁ = 0.8  ─┐
                             ├──→ 1.25 ──→ f(1.25) ──→  0.78
x₂ = 0.3  ──→  w₂ = 1.5  ─┘

Somme = (0.5 × 0.8) + (0.3 × 1.5) = 0.40 + 0.85 = 1.25

---

Les Couches : Comment les Neurones s'Organisent 🏗️

Un seul neurone ne peut pas faire grand-chose. La puissance vient de l'organisation en couches.

1. Couche d'entrée — Les yeux et les oreilles 👀

• Reçoit les données brutes
• Un neurone par caractéristique d'entrée

2. Couche(s) cachée(s) — Le cerveau pensant 🧠

• Là où l'apprentissage se fait réellement
• Chaque neurone trouve un motif dans les données
• Plus de couches = motifs plus complexes

3. Couche de sortie — La réponse 💡

• Produit la prédiction finale
• Pour la classification : un neurone par catégorie
• Pour la régression : un neurone avec un nombre

COUCHE D'ENTRÉE   COUCHE CACHÉE 1   COUCHE CACHÉE 2    COUCHE DE SORTIE
(3 features)       (4 neurones)      (4 neurones)       (2 classes)

  [x₁] ──────→    [h₁] ──────→     [h₅] ──────→       [Chat : 0.92]
  [x₂] ──────→    [h₂] ──────→     [h₆] ──────→       [Chien : 0.08]
  [x₃] ──────→    [h₃] ──────→     [h₇]
                   [h₄] ──────→     [h₈]

---

Fonctions d'Activation — Les Décideurs 💧

Après qu'un neurone additionne ses entrées, il doit décider : dois-je m'activer ou non ?

L'analogie du flux d'eau 🚿

Imaginez un tuyau avec une valve :

• L'eau entre (la somme pondérée des entrées)
• La valve contrôle ce qui sort (la fonction d'activation)

Fonctions courantes

ReLU — La porte simple

• Si l'entrée est positive → la laisser passer
• Si l'entrée est négative → la bloquer (sortie zéro)

def relu(x):
    return max(0, x)

print(relu(3.5))   # 3.5 (positif → passe)
print(relu(-2.0))  # 0.0 (négatif → bloqué)

Sigmoïde — Le compresseur doux

• Compresse toute entrée entre 0 et 1
• Parfait pour les probabilités : « Il y a 0,87 de chance que ce soit un chat »

import math

def sigmoid(x):
    return 1 / (1 + math.exp(-x))

print(sigmoid(5.0))    # 0.993 (très confiant "oui")
print(sigmoid(0.0))    # 0.500 (complètement incertain)
print(sigmoid(-5.0))   # 0.007 (très confiant "non")

Softmax — Le compteur de votes

• Utilisé en couche de sortie pour la classification
• Convertit des valeurs en probabilités qui totalisent 1

Sorties brutes :  [2.0, 1.0, 0.5]
Après softmax :   [0.59, 0.24, 0.17]  → Chat (59 %), Chien (24 %), Oiseau (17 %)

---

Propagation Avant — Les Données Traversent le Réseau 🌊

Pensez à une course de relais :

1. La couche d'entrée reçoit les données et les passe à la première couche cachée
2. Chaque neurone multiplie, additionne et active
3. Les résultats passent à la couche suivante
4. Cela continue jusqu'à la couche de sortie
5. La couche de sortie donne la prédiction finale

Un exemple concret

Classifions si un fruit est une pomme ou une orange :

Entrée : poids = 150g, couleur = 0.8 (orangé)

Étape 1 — La couche d'entrée transmet :
  x₁ = 150 (poids), x₂ = 0.8 (couleur)

Étape 2 — Neurone caché 1 :
  somme = (150 × 0.01) + (0.8 × 2.0) + biais(0.1) = 3.2
  sortie = ReLU(3.2) = 3.2

Étape 3 — Neurone caché 2 :
  somme = (150 × -0.005) + (0.8 × 1.5) + biais(0.3) = 0.75
  sortie = ReLU(0.75) = 0.75

Étape 4 — Couche de sortie :
  score_pomme  = (3.2 × -0.5) + (0.75 × 0.8) = -1.0
  score_orange = (3.2 × 0.7) + (0.75 × 0.3) = 2.465

Étape 5 — Softmax :
  Pomme :  18 %
  Orange : 82 %  ← Prédiction : Orange ! 🍊

---

Rétropropagation — Apprendre de ses Erreurs 🔄

La propagation avant donne une prédiction. Mais si elle est fausse ? C'est là que la rétropropagation intervient.

L'analogie du lancer de fléchettes 🎯

1. Lancez une fléchette (propagation avant — faire une prédiction)
2. On vous dit à quel point vous êtes loin (calculer l'erreur)
3. Ajustez votre visée (mettre à jour les poids)
4. Relancez — cette fois vous êtes plus proche !
5. Répétez des milliers de fois

Propagation avant :   Données → Réseau → Prédiction
                                           ↓
Comparer :            Prédiction vs Réponse réelle = Erreur
                                           ↓
Rétropropagation :    L'erreur remonte EN ARRIÈRE dans le réseau
                                           ↓
Mise à jour :         Ajuster les poids pour réduire l'erreur
                                           ↓
Répéter :             Faire cela des milliers de fois !

---

Interactif : Tracer les Données dans un Réseau 🔍

Traçons les données dans un petit réseau qui classifie les e-mails spam.

Caractéristiques :

• x₁ = nombre de points d'exclamation (5)
• x₂ = contient le mot « gratuit » (1 = oui)

import math

# Entrées
x1, x2 = 5, 1

# Neurone caché 1
z1 = (x1 * 0.6) + (x2 * 0.9) + 0.1    # = 4.0
h1 = max(0, z1)                          # ReLU → 4.0

# Neurone caché 2
z2 = (x1 * 0.3) + (x2 * 0.4) + 0.2    # = 2.1
h2 = max(0, z2)                          # ReLU → 2.1

# Neurone de sortie
z_out = (h1 * 0.7) + (h2 * 0.5) - 0.5  # = 3.35
output = 1 / (1 + math.exp(-z_out))      # Sigmoïde → 0.966

print(f"Couche cachée : h1={h1}, h2={h2}")
print(f"Sortie brute : {z_out:.2f}")
print(f"Probabilité de spam : {output:.1%}")   # 96,6 % → SPAM ! 🚫

---

Vue d'Ensemble 🗺️

Données (Leçon 1) → Algorithme (Leçon 2) → Réseau de Neurones (Leçon 3)
      📊                   🧮                        🧠

Les réseaux de neurones alimentent :

• 🗣️ ChatGPT — comprendre et générer du langage
• 🎨 DALL-E / Midjourney — créer des images à partir de texte
• 🚗 Voitures autonomes — voir et comprendre la route
• 🔬 AlphaFold — prédire les structures de protéines

---

Résumé Rapide 🎯

1. Les neurones artificiels reçoivent des entrées, multiplient par des poids, additionnent et appliquent une activation
2. Les réseaux ont trois types de couches : entrée, cachée(s) et sortie
3. Les fonctions d'activation ajoutent la non-linéarité — sans elles, le réseau ne peut apprendre que des lignes droites
4. La propagation avant pousse les données à travers le réseau pour produire une prédiction
5. La rétropropagation renvoie les erreurs en arrière pour ajuster les poids
6. Les réseaux de neurones alimentent l'IA moderne — des chatbots aux voitures autonomes

---

Prochaine Étape 🚀

Félicitations — vous comprenez maintenant les trois piliers de l'IA : données, algorithmes et réseaux de neurones ! Dans les prochaines leçons, nous explorerons les outils d'IA et l'IA responsable 🌱