🧠 Cours 4 — Réseaux de Neurones

Introduction

Rappel du cours 3 : Monade option (gestion d'erreur), Monade Writer (journalisation), Pattern général retour / >>=.

Ce cours : on implémente un mini-réseau de neurones en OCaml pur — neurone, couche, réseau, gradient, descente.

Tous les programmes présentés ici sont disponibles dans le répertoire du cours.

Neurone artificiel

f(x, w, b) = σ(∑ w_i x_i + b)

type neurone = { w : float list; b : float }

let sigmoid x =
  1.0 /. (1.0 +. exp (-. x))

let forward n x =
  let sum = List.fold_left (+.) 0.0
    (List.map2 ( *. ) n.w x) in
  sigmoid (sum +. n.b)

Propagation avant (forward)

Une couche = une liste de neurones.

type layer = { neurones : neurone list }

let forward_layer l x =
  List.map (fun n -> forward n x) l.neurones

Réseau = liste de couches.

type reseau = { couches : layer list }

let forward_network r x =
  List.fold_left (fun x layer ->
    forward_layer layer x) x r.couches

Fonction de coût (loss)

On mesure l'erreur entre prédiction et cible — Erreur quadratique moyenne (MSE) :

let mse pred target =
  List.map2 (fun p t -> (p -. t) ** 2.0) pred target
  |> List.fold_left (+.) 0.0
  |> (fun s -> s /. float_of_int (List.length pred))

Gradient : dérivée de la sigmoïde

Pour corriger les poids, on suit le gradient.

let sigmoid_deriv sigma =
  sigma *. (1.0 -. sigma)

Pourquoi c'est utile : σ'(x) s'exprime facilement à partir de σ(x).

Gradient pas à pas

Pour un neurone de sortie :

• Erreur : δ_o = (p - t) · σ'(x)
• Mise à jour poids : w_i ← w_i - α · δ_o · x_i
• Mise à jour biais : b ← b - α · δ_o

let gradient_sortie n x p t =
  let delta = (p -. t) *. sigmoid_deriv p in
  let dw = List.map (fun xi ->
    -. alpha *. delta *. xi) x in
  let db = -. alpha *. delta in
  (dw, db)

Rétropropagation (backpropagation)

Pour une couche cachée, δ_j se propage :

let gradient_cache n inputs deltas_next w_next =
  let sum = List.fold_left2 (fun acc d w ->
    acc +. d *. w) 0.0 deltas_next w_next in
  let out = forward n inputs in
  let delta = sum *. sigmoid_deriv out in
  let dw = List.map (fun i ->
    -. alpha *. delta *. i) inputs in
  let db = -. alpha *. delta in
  (dw, db, delta)

Descente de gradient stochastique (SGD)

Algorithme complet :

1. Forward : calculer toutes les sorties
2. Backward : calculer les δ de la sortie vers l'entrée
3. Mettre à jour tous les poids et biais
4. Recommencer (epoch)

let rec train r data epochs alpha =
  if epochs <= 0 then r
  else
    let r' = List.fold_left (fun r (x, t) ->
      let activations = forward_all r x in
      let gradients =
        backward_all r x activations t alpha in
      update_weights r gradients
    ) r data in
    train r' data (epochs - 1) alpha

Test : XOR avec un réseau 2 → 2 → 1

let data = [
  ([0.0;0.0], [0.0]);  ([0.0;1.0], [1.0]);
  ([1.0;0.0], [1.0]);  ([1.0;1.0], [0.0]);
]

let reseau_xor = init_reseau [2; 2; 1]
let trained = train reseau_xor data 10000 0.5

Après entraînement :

# forward_network trained [1.0;0.0]  -> ~0.95 (proche de 1)
# forward_network trained [0.0;0.0]  -> ~0.05 (proche de 0)

Conclusion

Félicitations ! Vous avez survécu aux 4 cours. Vous êtes capables d'écrire un réseau de neurones en OCaml pur, sans bibliothèque externe, sans boucle while, sans effet de bord.