Séance 4 : Réseaux de Neurones Multicouches et Rétropropagation

Durée : 50 minutes

Objectifs de la séance

Plan de la séance

1. Partie Théorique (15–20 minutes)

Introduction aux réseaux de neurones

Un réseau de neurones multicouches se compose d'une couche d'entrée, d'une ou plusieurs couches cachées et d'une couche de sortie. Chaque neurone applique une fonction d'activation (souvent la sigmoïde) pour modéliser la non-linéarité.

Rétropropagation

La rétropropagation permet de calculer les gradients de la fonction de coût par rapport aux poids et de mettre à jour ces derniers en fonction de l'erreur constatée.

2. Partie Pratique (30–35 minutes)

Exercice : Implémentation d'un réseau multicouches pour résoudre le problème XOR

Objectif : Construire un réseau à deux couches (une couche cachée) afin de résoudre le problème XOR, impossible à résoudre par un perceptron simple.

Consignes :
  1. Implémenter la fonction sigmoïde et sa dérivée.
  2. Initialiser aléatoirement les poids et les biais pour une architecture 2-2-1.
  3. Effectuer les passes avant et arrière pour entraîner le réseau sur les 4 exemples de XOR.
  4. Afficher les prédictions après entraînement.
Exemple de code Python :

import numpy as np

# Fonctions d'activation
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return sigmoid(x) * (1 - sigmoid(x))

# Jeu de données pour le problème XOR
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([[0], [1], [1], [0]])

np.random.seed(0)
# Architecture 2-2-1
W1 = np.random.randn(2, 2)
b1 = np.zeros((1, 2))
W2 = np.random.randn(2, 1)
b2 = np.zeros((1, 1))

learning_rate = 0.1
n_iterations = 10000

for i in range(n_iterations):
    # Forward pass
    z1 = np.dot(X, W1) + b1
    a1 = sigmoid(z1)
    z2 = np.dot(a1, W2) + b2
    a2 = sigmoid(z2)
    
    # Calcul de l'erreur
    error = y - a2
    
    # Backward pass
    d_a2 = error * sigmoid_derivative(z2)
    d_W2 = np.dot(a1.T, d_a2)
    d_b2 = np.sum(d_a2, axis=0, keepdims=True)
    
    d_a1 = np.dot(d_a2, W2.T) * sigmoid_derivative(z1)
    d_W1 = np.dot(X.T, d_a1)
    d_b1 = np.sum(d_a1, axis=0, keepdims=True)
    
    # Mise à jour des poids et biais
    W2 += learning_rate * d_W2
    b2 += learning_rate * d_b2
    W1 += learning_rate * d_W1
    b1 += learning_rate * d_b1

print("Prédictions après entraînement :")
print(a2)

Propositions de Corrections et Commentaires

Afficher/Cacher les corrections

Ouvertures et Possibilités d’Application