— factory / algos ML / optimisation

OPTIMISEUR ADAM.

Une descente de gradient améliorée : elle garde un élan (la moyenne des pentes récentes) et adapte le pas de chaque poids à l'ampleur de ses gradients. Adam converge vite sans réglage fin, ce qui en fait l'optimiseur par défaut pour entraîner un réseau de neurones, du score client au LLM.

OptimisationDeep learningApprentissageRéglage par défautNiveau : intermédiaire

FICHE D'IDENTITÉ

notes sur 5 · usage entreprise

PerformanceConverge vite ; SGD bien réglé généralise parfois un peu mieux

InterprétabilitéDeux moyennes mobiles, simples à expliquer

VitessePeu de passes pour atteindre un bon modèle

Facilité de réglageLes valeurs par défaut marchent dans la plupart des cas

Tolérance aux données brutesMoins sensible aux échelles que SGD, standardiser reste utile

EN 30 SECONDES

Une bille qui dévale une pente : elle prend de l'élan dans les longues descentes et ne s'arrête pas au premier replat. Et chaque direction a son propre frein, plus fort là où le terrain est accidenté.

1. L'élan

Adam garde une moyenne mobile des gradients récents. Les directions qui pointent toujours dans le même sens accélèrent, les oscillations se compensent.

2. Le pas propre à chaque poids

Adam garde aussi une moyenne mobile des gradients au carré. Un poids aux gradients forts et agités reçoit un petit pas, un poids aux gradients faibles un pas plus grand.

3. La correction de départ

Les deux moyennes partent de zéro et sont donc trop faibles au début. Adam les corrige pendant les premières étapes pour ne pas démarrer au ralenti.

4. La mise à jour

Chaque poids bouge de l'élan divisé par la racine de l'agitation, multiplié par le pas global. Par défaut 0,001, avec des coefficients de moyenne de 0,9 et 0,999.

LE CAS MÉTIER

churn · télécom / énergie / assurance

EN ENTRÉE

Une ligne par client

Ancienneté, appels au support, montant, contrat, incidents, et le départ observé. Un même petit réseau (16 puis 8 neurones) est entraîné deux fois : une fois avec SGD avec élan, une fois avec Adam.

EN SORTIE

Le même réseau, deux vitesses

Sur le jeu d'exemple, avec le même pas de 0,001 et 30 passes, le réseau entraîné par Adam atteint une AUC de 0,77 sur les clients jamais vus, contre 0,69 pour SGD, qui n'a pas fini d'apprendre.

CE QU'ON MESURE

La perte à budget égal

On compare les optimiseurs à nombre de passes égal, sur des données de validation. Ici, la perte d'entraînement après 30 passes est de 0,46 avec Adam contre 0,52 avec SGD. Le gagnant est celui qui atteint la meilleure validation dans le budget de calcul.

QUAND LE SORTIR, QUAND L'ÉVITER

OUI

Entraîner un réseau de neurones sans passer des jours à régler le pas
Données bruitées ou gradients d'ampleurs très différentes d'un poids à l'autre
Architectures lourdes : Transformers, LLM (souvent en variante AdamW)
Prototyper vite avant d'affiner

NON

Modèle classique avec solveur dédié (régression, SVM, arbres) : garder le solveur du package
Recherche du dernier point de précision en vision : un SGD avec élan bien réglé généralise parfois mieux
Régularisation L2 importante : préférer AdamW, qui l'applique correctement
Mémoire très contrainte : Adam stocke deux valeurs de plus par poids

LES 4 RÉGLAGES QUI COMPTENT

Noms donnés pour R (keras3) et Python (scikit-learn, Keras). Les valeurs par défaut suffisent souvent.

learning_rate / learning_rate_init

Le pas global, 0,001 par défaut. Le seul à régler en priorité : tester 0,0003 et 0,003 si la courbe de perte stagne ou oscille.

beta_1, beta_2

Les coefficients des deux moyennes mobiles (0,9 et 0,999). On n'y touche presque jamais.

weight_decay (AdamW)

La régularisation des poids. Dans Adam classique, elle se mélange au pas adaptatif ; AdamW l'applique à part, ce qui marche mieux. C'est le choix standard des Transformers.

Calendrier du pas

Faire baisser le pas au fil de l'entraînement, ou le monter progressivement au début (warm-up) sur les gros modèles. Souvent plus utile que de toucher aux betas.

LE CODE MINIMAL

jeu d'exemple : clients_churn.csv ↓

# Churn clients : Adam contre SGD en R (keras3)
library(keras3)

clients <- read.csv("clients_churn.csv")
X <- scale(model.matrix(~ anciennete + appels_support + montant + contrat + incidents_3m, data = clients)[, -1])
y <- clients$churn
set.seed(42)
idx <- sample(nrow(X), round(0.7 * nrow(X)))

entrainer <- function(optimiseur) {
  set_random_seed(42)                          # mêmes poids de départ pour les deux
  reseau <- keras_model_sequential(input_shape = ncol(X))
  reseau <- layer_dense(reseau, units = 16, activation = "relu")
  reseau <- layer_dense(reseau, units = 8, activation = "relu")
  reseau <- layer_dense(reseau, units = 1, activation = "sigmoid")
  compile(reseau, optimizer = optimiseur, loss = "binary_crossentropy", metrics = list(metric_auc(name = "auc")))
  histo <- fit(reseau, X[idx, ], y[idx], epochs = 30, batch_size = 200, verbose = 0,
               validation_data = list(X[-idx, ], y[-idx]))
  round(histo$metrics$val_auc[c(1, 10, 30)], 3)
}
# Même pas de départ (0,001), même budget de 30 passes : seul l'optimiseur change
cat("SGD avec élan, AUC test passes 1, 10, 30 :", entrainer(optimizer_sgd(learning_rate = 0.001, momentum = 0.9, nesterov = TRUE)), "\n")
cat("Adam,          AUC test passes 1, 10, 30 :", entrainer(optimizer_adam(learning_rate = 0.001)), "\n")

# Churn clients : Adam contre SGD en Python
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import roc_auc_score

clients = pd.read_csv("clients_churn.csv")
X = pd.get_dummies(clients[["anciennete", "appels_support", "montant", "contrat", "incidents_3m"]], dtype=float)
y = clients["churn"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
echelle = StandardScaler().fit(X_train)
X_train, X_test = echelle.transform(X_train), echelle.transform(X_test)

# Même réseau, même pas de départ (0,001), même budget de 30 passes : seul l'optimiseur change
for optimiseur in ["sgd", "adam"]:
    reseau = MLPClassifier(hidden_layer_sizes=(16, 8), solver=optimiseur, learning_rate_init=0.001,
                           max_iter=30, random_state=42)
    reseau.fit(X_train, y_train)   # avertissement de non-convergence attendu pour SGD
    auc = roc_auc_score(y_test, reseau.predict_proba(X_test)[:, 1])
    print(optimiseur.upper(), "| perte aux passes 1, 10, 30 :", np.round(np.array(reseau.loss_curve_)[[0, 9, 29]], 3),
          "| AUC test :", round(auc, 3))

QUESTIONS FRÉQUENTES

Que signifie Adam ?

Adaptive Moment Estimation. Le « moment » désigne les deux moyennes mobiles que l'algorithme tient à jour : celle des gradients (l'élan) et celle des gradients au carré (l'agitation). Adam a été publié par Kingma et Ba en 2014.

Adam ou SGD ?

Adam converge plus vite et demande peu de réglages : c'est le bon choix par défaut. Un SGD avec élan et un calendrier de pas bien réglé atteint parfois une meilleure généralisation, notamment en vision, mais au prix de beaucoup d'essais.

Quelle différence entre Adam et AdamW ?

Les deux optimisent de la même manière. AdamW applique la régularisation des poids (weight decay) séparément de la mise à jour adaptative, alors qu'Adam la mélange au gradient, ce qui l'affaiblit sur les poids aux gradients forts. AdamW est devenu le standard pour les Transformers et les LLM.