1. Le perceptron multicouche (MLP)

Un MLP est composé de couches successives de neurones entièrement connectées (dense layers). Chaque neurone applique une transformation affine puis une non-linéarité : y = activation(Wx + b). L'empilement de couches permet d'approximer toute fonction continue (théorème d'approximation universelle, Cybenko 1989, Hornik 1991).

Source officielle : tensorflow.org/tutorials/keras/classification — Chollet F., Deep Learning with Python, Manning 2e éd. 2021.

1.1 Fonctions d'activation

2. Backpropagation et autograd

La descente de gradient stochastique (SGD) minimise la loss en propageant l'erreur en arrière (chain rule). TensorFlow et PyTorch automatisent ce calcul via le graphe computationnel.

import tensorflow as tf
from tensorflow.keras import layers, Sequential

model = Sequential([
    layers.Input(shape=(784,)),
    layers.Dense(256, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(1e-4)),
    layers.Dropout(0.3),
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.3),
    layers.Dense(10, activation='softmax')
])

model.compile(
    optimizer=tf.keras.optimizers.AdamW(learning_rate=1e-3, weight_decay=1e-4),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

history = model.fit(X_train, y_train, batch_size=128, epochs=20,
                    validation_split=0.1,
                    callbacks=[tf.keras.callbacks.EarlyStopping(patience=3, restore_best_weights=True)])

import torch
import torch.nn as nn
import torch.optim as optim

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(784, 256), nn.ReLU(), nn.Dropout(0.3),
            nn.Linear(256, 128), nn.ReLU(), nn.Dropout(0.3),
            nn.Linear(128, 10)
        )
    def forward(self, x):
        return self.net(x)

model = MLP().cuda()
optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
criterion = nn.CrossEntropyLoss()

for epoch in range(20):
    for X_batch, y_batch in train_loader:
        X_batch, y_batch = X_batch.cuda(), y_batch.cuda()
        optimizer.zero_grad()
        logits = model(X_batch)
        loss = criterion(logits, y_batch)
        loss.backward()                # autograd
        optimizer.step()

3. Optimiseurs modernes

Loshchilov & Hutter, « Decoupled Weight Decay Regularization », ICLR 2019, arXiv:1711.05101 — démontre que AdamW > Adam pour les modèles avec régularisation.

4. Schedulers de learning rate

Le learning rate (lr) est le hyperparamètre le plus critique. Un schedule progressif améliore la convergence.

• StepLR : lr *= γ tous les K epochs
• ExponentialLR : lr *= γ chaque epoch
• CosineAnnealingLR : lr suit une cosinusoïde décroissante — recommandé Transformers
• OneCycleLR : warmup + montée + descente (Smith 2018) — converge 2-4× plus vite
• ReduceLROnPlateau : divise lr quand val_loss stagne

scheduler = optim.lr_scheduler.OneCycleLR(
    optimizer, max_lr=1e-2,
    steps_per_epoch=len(train_loader), epochs=20,
    pct_start=0.1, anneal_strategy='cos'
)
for epoch in range(20):
    for batch in train_loader:
        # forward, backward, step
        optimizer.step()
        scheduler.step()

5. Régularisation et batch normalization

5.1 Dropout (Srivastava 2014)

Désactive aléatoirement une fraction p des neurones à chaque batch. Empêche la co-adaptation excessive. Taux typique : 0,2-0,5.

5.2 Batch Normalization (Ioffe & Szegedy 2015)

Normalise les activations par mini-batch. Accélère drastiquement la convergence, permet des lr plus grands, agit comme régularisation. Place : entre couche dense et activation, ou après convolution.

5.3 LayerNorm

Normalise sur la dimension feature (pas batch). Standard dans les Transformers (BERT, GPT).

6. Diagnostic : sous vs sur-apprentissage

7. Synthèse et points-clés

• ReLU/GELU en couches cachées, Sigmoid/Softmax/Linear en sortie
• AdamW est le défaut moderne (Loshchilov 2019)
• OneCycleLR ou CosineAnnealingLR pour les modèles modernes
• Dropout + weight_decay + early stopping = régularisation triple
• BatchNorm pour CNN, LayerNorm pour Transformers
• Toujours monitorer train et val loss + métriques cibles
• gradient_clipping (max_norm=1.0) protège des explosions RNN/LSTM

Pour aller plus loin

• TensorFlow — Tutorials officiels
• PyTorch — Learn the Basics
• Deep Learning Specialization (Andrew Ng, DLAI)
• Loshchilov & Hutter, AdamW, ICLR 2019
• Chollet F., Deep Learning with Python, Manning 2e éd. 2021