Comprendre les Réseaux de Neurones

Pourquoi le Deep Learning ?

Le Machine Learning classique (arbres de décision, SVM, régression) fonctionne très bien sur des données tabulaires (lignes et colonnes). Mais dès qu''on travaille avec des images, du texte ou du son, ces méthodes atteignent leurs limites.

Le Deep Learning résout ce problème en empilant des couches de neurones artificiels capables d''apprendre automatiquement les bonnes représentations des données.

Ce que le Deep Learning a rendu possible

Le Neurone Artificiel

Du biologique à l''artificiel

Un neurone biologique reçoit des signaux via ses dendrites, les traite dans le corps cellulaire, et envoie un signal via l''axone si le seuil d''activation est atteint.

Le neurone artificiel fonctionne de la même manière :

1. Entrées (x₁, x₂, ..., xₙ) : les données
2. Poids (w₁, w₂, ..., wₙ) : l''importance de chaque entrée
3. Somme pondérée : z = w₁·x₁ + w₂·x₂ + ... + wₙ·xₙ + b
4. Fonction d''activation : transforme z en sortie

Les fonctions d''activation

La fonction d''activation introduit de la non-linéarité. Sans elle, empiler 100 couches reviendrait à n''en avoir qu''une seule (car une combinaison linéaire de combinaisons linéaires reste linéaire).

Assembler un Réseau : le Perceptron Multi-Couches (MLP)

Un MLP est constitué de couches de neurones empilées :

• Couche d''entrée : reçoit les données brutes
• Couches cachées : extraient des patterns de plus en plus abstraits
• Couche de sortie : produit la prédiction

Pourquoi "profond" ?

Plus le réseau a de couches, plus il peut apprendre des abstractions de haut niveau :

• Couche 1 : détecte des bords dans une image
• Couche 2 : combine les bords en formes (cercles, lignes)
• Couche 3 : combine les formes en objets (yeux, roues)
• Couche 4 : reconnaît des concepts (visage, voiture)

Comment un Réseau Apprend : la Rétropropagation

Le processus d''apprentissage en 4 étapes

1. Forward Pass : les données traversent le réseau, couche par couche, pour produire une prédiction.

2. Fonction de perte (Loss) : on mesure l''écart entre la prédiction et la vérité. Plus la loss est basse, meilleur est le modèle.

3. Backward Pass (rétropropagation) : on calcule la dérivée de la loss par rapport à chaque poids, en remontant du bout du réseau vers le début. C''est la règle de la chaîne du calcul différentiel.

4. Mise à jour des poids : on ajuste chaque poids dans la direction qui réduit l''erreur, avec un pas contrôlé par le learning rate.

nouveau_poids = ancien_poids - learning_rate × gradient

Exercice Pratique : Classifier des Chiffres Manuscrits

Le dataset MNIST contient 70 000 images de chiffres (0-9) en 28×28 pixels. C''est le "Hello World" du Deep Learning.

Étape 1 : Charger les données

import numpy as np
from tensorflow import keras
from tensorflow.keras import layers

# Charger MNIST
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Normaliser les pixels entre 0 et 1
x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0

# Aplatir les images 28x28 en vecteurs de 784
x_train = x_train.reshape(-1, 784)
x_test = x_test.reshape(-1, 784)

print(f"Train : {x_train.shape}, Test : {x_test.shape}")
print(f"Classes : {np.unique(y_train)}")

Étape 2 : Construire le modèle

model = keras.Sequential([
    layers.Dense(128, activation="relu", input_shape=(784,)),
    layers.Dense(64, activation="relu"),
    layers.Dense(10, activation="softmax")  # 10 classes (0-9)
])

model.summary()

Ce que fait chaque couche :

• Dense(128, relu) : 128 neurones qui apprennent des patterns dans les pixels
• Dense(64, relu) : 64 neurones qui combinent ces patterns
• Dense(10, softmax) : 10 sorties, une probabilité par chiffre

Étape 3 : Compiler et entraîner

model.compile(
    optimizer="adam",
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"]
)

history = model.fit(
    x_train, y_train,
    epochs=10,
    batch_size=32,
    validation_split=0.1,
    verbose=1
)

Vocabulaire :

• Epoch : un passage complet sur toutes les données d''entraînement
• Batch size : nombre d''exemples traités avant chaque mise à jour des poids
• Validation split : portion des données réservée pour évaluer pendant l''entraînement

Étape 4 : Évaluer

test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Précision sur le test : {test_acc:.4f}")

# Visualiser quelques prédictions
import matplotlib.pyplot as plt

x_test_images = x_test.reshape(-1, 28, 28)
predictions = model.predict(x_test[:8])

fig, axes = plt.subplots(2, 4, figsize=(10, 5))
for i, ax in enumerate(axes.flat):
    ax.imshow(x_test_images[i], cmap="gray")
    pred = np.argmax(predictions[i])
    true = y_test[i]
    color = "green" if pred == true else "red"
    ax.set_title(f"Prédit: {pred} (Vrai: {true})", color=color, fontsize=10)
    ax.axis("off")
plt.tight_layout()
plt.savefig("mnist_predictions.png", dpi=150)
plt.show()

Les Pièges du Débutant

Overfitting vs Underfitting

Dropout : la régularisation star du DL

Le Dropout éteint aléatoirement une fraction des neurones à chaque étape d''entraînement. Cela force le réseau à ne pas dépendre d''un seul neurone.

model = keras.Sequential([
    layers.Dense(128, activation="relu"),
    layers.Dropout(0.3),  # Éteint 30% des neurones
    layers.Dense(64, activation="relu"),
    layers.Dropout(0.2),
    layers.Dense(10, activation="softmax")
])

Visualiser l''entraînement

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))

ax1.plot(history.history["loss"], label="Train")
ax1.plot(history.history["val_loss"], label="Validation")
ax1.set_title("Loss")
ax1.legend()

ax2.plot(history.history["accuracy"], label="Train")
ax2.plot(history.history["val_accuracy"], label="Validation")
ax2.set_title("Accuracy")
ax2.legend()

plt.tight_layout()
plt.savefig("training_curves.png", dpi=150)
plt.show()

Pour Aller Plus Loin

• Exercice bonus : remplacez MNIST par Fashion-MNIST (vêtements au lieu de chiffres) — même format, plus difficile
• Expérimentez : changez le nombre de couches, de neurones, le learning rate, et observez l''impact
• Prochain cours : les CNN (réseaux convolutifs) qui exploitent la structure spatiale des images