Connexionnisme · Apprentissage profond · IA
Un réseau de neurones artificiel est un système de calcul inspiré du cerveau biologique, composé de couches de neurones artificiels connectés par des poids apprenables, capables d'approximer n'importe quelle fonction continue.
Corps cellulaire (soma) : intégration des signaux. Dendrites : réceptions des entrées synaptiques. Axone : transmission du signal (potentiel d'action). Synapse : jonction entre neurones. Neurotransmetteurs : acétylcholine, glutamate, GABA. Plasticité : LTP/LTD.
Entrées xᵢ × poids wᵢ → somme pondérée z = Σwᵢxᵢ + b → fonction d'activation σ(z) → sortie a. Le biais b joue le rôle du seuil de déclenchement. La sortie représente le taux de firing. Réseau de tels neurones : perceptron multicouche.
Cerveaux humains : 86 milliards de neurones, 100 trillions de synapses. Traitement analogique, spikes temporels, 3D. Neurones ANN : numériques, synchrones, backward pass impossible biologiquement. L'inspiration est conceptuelle — pas une simulation fidèle.
Classifieur linéaire binaire. Règle de Hebb simplifiée : si la prédiction est fausse, ajuste les poids dans la direction de l'erreur. Convergence garantie si les données sont linéairement séparables (théorème de convergence du perceptron). Limites : XOR insoluble (Minsky & Papert, 1969).
Un réseau à une seule couche cachée avec suffisamment de neurones peut approximer n'importe quelle fonction continue sur un compact. Ne dit pas combien de neurones ni comment les trouver. Justification théorique du deep learning.
Couche d'entrée → couches cachées → couche de sortie. Fully connected : chaque neurone connecté à tous ceux de la couche suivante. Paramètres : n_in × n_hidden (poids) + n_hidden (biais) par couche. Initialisation : Xavier/Glorot, He. Notation matricielle : A = σ(WX + b).
Z¹ = W¹X + b¹ → A¹ = σ(Z¹) → Z² = W²A¹ + b² → ... → ŷ = softmax(Zᴸ). Cache pour la rétropropagation. Complexité : O(n × m) par couche. Vectorisé sur batch avec NumPy/PyTorch. Inférence = forward pass uniquement.
MSE : L=(ŷ-y)²/2. Cross-entropy binaire : -[y log(ŷ)+(1-y)log(1-ŷ)]. Cross-entropy catégorielle : -Σyₖ log(ŷₖ). MAE, Huber Loss (robuste). Focal Loss (class imbalance). Contrastive Loss (siamese nets). ELBO (VAE). Dice Loss (segmentation).
| Activation | Formule | Avantages | Inconvénients |
|---|---|---|---|
| Sigmoid | σ(z) = 1/(1+e⁻ᶻ) | Sortie [0,1], probabilité | Vanishing gradient, non-centré en 0 |
| Tanh | tanh(z) = (eᶻ-e⁻ᶻ)/(eᶻ+e⁻ᶻ) | Centré en 0, [-1,1] | Vanishing gradient |
| ReLU | max(0, z) | Pas de vanishing, rapide | Dying ReLU (neurones morts) |
| Leaky ReLU | max(αz, z), α=0.01 | Pas de neurones morts | Hyperparamètre α à choisir |
| ELU | z si z≥0, α(eᶻ-1) sinon | Lisse, centré proche 0 | Plus coûteux que ReLU |
| GELU | z·Φ(z) | Standard Transformers (BERT, GPT) | Approximation |
| Swish / SiLU | z·σ(z) | Self-gated, performant | Légèrement plus cher |
| Softmax | eᶻᵢ/Σeᶻⱼ | Probabilités (somme=1), output | Numériquement instable sans log |
Backpropagation (Rumelhart, Hinton & Williams, 1986) : application efficace de la règle de la chaîne pour calculer le gradient de la perte par rapport à tous les poids. Complexité proportionnelle au forward pass (2× environ). Différentiation automatique : PyTorch autograd, TensorFlow GradientTape.
SGD : θ ← θ - α∇L(θ;xᵢ,yᵢ). Mini-batch : compromis bruit/stabilité. Momentum : accumule le gradient passé (μ=0.9). Adam : adaptive learning rates par paramètre (m₁, m₂ moments). AdamW : Adam + weight decay découplé (Loshchilov 2019).
∂L/∂W¹ = (∏ Wˡσ'(Zˡ))·δᴸ. Si σ'<1 partout (sigmoid, tanh) et L profond → gradient → 0 exponentiellement. Solutions : ReLU, batch normalization, skip connections (ResNets), LSTM gates, initialisation appropriée, gradient clipping.
∏ Wˡ peut diverger si les poids sont grands. Gradient clipping : g̃ = g · min(1, θ_max/‖g‖). Problème aigu dans les RNN. Solutions : initialisation Glorot/He, batch norm, gradient clipping. Monitoring : ‖∇L‖ au cours de l'entraînement.
Convolution : partage de poids, invariance en translation. Opération : (f*g)[n] = Σf[m]g[n-m]. Couche conv : K filtres × H × W. Pooling : Max ou Average, réduction spatiale. Architecture : [Conv→BN→ReLU]×N → Pool. Évolution : LeNet→AlexNet→VGG→ResNet→EfficientNet→ConvNext.
F(x) + x au lieu de juste F(x). Le réseau apprend la résiduelle plutôt que le mapping complet. Permet des réseaux très profonds (152 couches) sans dégradation. Les gradients coulent directement via les skip connections. Base de la plupart des architectures modernes.
Cellule de mémoire c avec portes : oubli f=σ(Wf[h,x]+bf), entrée i=σ(...), candidat g̃=tanh(...), sortie o. Rétention d'information à long terme. GRU : version simplifiée (2 portes). Base des modèles de séquences avant les Transformers. Encore utilisé : audio, séries temporelles.
Q=XWq, K=XWk, V=XWv. Attention = softmax(QKᵀ/√dₖ)V. Parallélisable contrairement aux RNN. Multi-head : diversité d'attention. Positional encoding. Encoder-Decoder ou Decoder-only (GPT). Vision Transformer (ViT) : patches d'image comme tokens.
Générateur G(z) → images fausses. Discriminateur D(x) → probabilité d'être réel. min_G max_D V = E[logD(x)] + E[log(1-D(G(z)))]. Mode collapse, training instability. Améliorations : WGAN, WGAN-GP, StyleGAN2/3, BigGAN. Remplacés par les modèles de diffusion.
Encodeur : x → μ, σ (espace latent gaussien). Reparametrization trick : z = μ + σ·ε. Décodeur : z → x'. Loss : reconstruction + KL divergence. Espace latent continu et sémantique. Interpolation dans l'espace latent. Base de la génération contrôlée.
Désactive aléatoirement p% des neurones à chaque forward pass d'entraînement. Équivalent à entraîner un ensemble de 2ⁿ réseaux partagés. Pas de dropout à l'inférence (× (1-p) scaling). p=0.1–0.5. Spatial Dropout pour CNN. Variante : DropPath (Stochastic Depth).
Normalise les activations : μ̂ = (x - E[x])/√(Var[x]+ε). Puis : y = γx̂ + β (apprenables). Réduit le covariate shift interne. Permet des LR élevés, moins sensible à l'initialisation. Layer Norm (Transformers), Group Norm, Instance Norm.
L2 (Ridge) : L' = L + λΣw². Pénalise les grands poids, régularise implicitement. L1 (Lasso) : sparsité des poids. AdamW : weight decay découplé du gradient. Early stopping : arrête quand validation loss ne diminue plus (patience). Data augmentation : version implicite de régularisation.
Processus de débruitage en T étapes : q(xₜ|xₜ₋₁) = N(√(1-βₜ)xₜ₋₁, βₜI). Entraînement : prédire le bruit ε ajouté. Score matching. DDIM (inférence rapide). Latent Diffusion (Stable Diffusion). État de l'art : génération image (DALL-E 3), vidéo (Sora), audio (AudioLDM2).
LoRA : décompose ΔW = A·B (rang r faible). Fine-tune uniquement A et B, gèle W₀. 10 000× moins de paramètres que full fine-tuning. QLoRA : quantification 4-bit + LoRA. Prefix tuning, Prompt tuning, Adapter layers. Base des LLMs personnalisés localement.
N experts (sous-réseaux), routeur sélectionne top-k pour chaque token. Paramètres actifs fraction des paramètres totaux. Gemini 1.5 Pro, Mixtral 8×7B, GPT-4 (supposé). Sparse computation : capacité accrue sans coût FLOPs proportionnel. Load balancing.
Alternative aux Transformers pour les longues séquences. Sélective SSM : O(n) complexité vs O(n²) attention. Architecture Mamba (Gu & Dao, 2023). Performances comparables aux Transformers sur LM, 5× plus rapide en inférence. Jamba (Mixture Mamba + Attention).
import torch, torch.nn as nn from torch.optim import AdamW # ── Architecture ────────────────────────────── class MLP(nn.Module): def __init__(self, in_dim, hidden, out_dim, dropout=0.2): super().__init__() self.net = nn.Sequential( nn.Linear(in_dim, hidden), nn.BatchNorm1d(hidden), nn.GELU(), nn.Dropout(dropout), nn.Linear(hidden, hidden//2), nn.GELU(), nn.Dropout(dropout//2), nn.Linear(hidden//2, out_dim) ) def forward(self, x): return self.net(x) # ── Entraînement ────────────────────────────── model = MLP(128, 512, 10).cuda() opt = AdamW(model.parameters(), lr=3e-4, weight_decay=0.01) sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=50) loss_fn = nn.CrossEntropyLoss() for epoch in range(50): for X, y in train_loader: X, y = X.cuda(), y.cuda() opt.zero_grad() loss = loss_fn(model(X), y) loss.backward() # backprop nn.utils.clip_grad_norm_(model.parameters(), 1.0) opt.step(); sched.step() print(f"Epoch {epoch+1}: loss={loss.item():.4f}")