Deep Learning
Réseaux de neurones profonds et architectures modernes
Le Deep Learning (apprentissage profond) est un sous-domaine du Machine Learning qui utilise des réseaux de neurones artificiels à plusieurs couches pour apprendre des représentations hiérarchiques des données.
Qu'est-ce que le Deep Learning ?
Le Deep Learning se distingue par sa capacité à apprendre automatiquement des features à partir des données brutes, sans ingénierie manuelle.
MACHINE LEARNING CLASSIQUE
Données → Feature Engineering → Algorithme → Prédiction
(manuel)
DEEP LEARNING
Données → Réseau de neurones profond → Prédiction
(apprentissage automatique des features)"Deep" fait référence à la profondeur du réseau : le nombre de couches entre l'entrée et la sortie.
Pourquoi ça marche maintenant ?
Le Deep Learning existe depuis les années 1980, mais n'a explosé qu'après 2012. Trois facteurs clés :
| Facteur | Avant | Maintenant |
|---|---|---|
| Données | Peu de données | Big Data, Internet |
| Calcul | CPU lents | GPUs puissants (NVIDIA) |
| Algorithmes | Vanishing gradient | ReLU, BatchNorm, Dropout |
Architectures principales
┌─────────────────────────────────────────────────────────────┐
│ ARCHITECTURES DEEP LEARNING │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────────────┐ │
│ │ MLP │ │ CNN │ │ RNN │ │ Transformer │ │
│ │ │ │ │ │ │ │ │ │
│ │ Données │ │ Images │ │Séquences│ │ Texte, Images, │ │
│ │tabulaires│ │ Vision │ │ Temps │ │ Multimodal │ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────────────┘ │
│ │
│ 1980s 1990s 1990s 2017+ │
│ │
└─────────────────────────────────────────────────────────────┘Perceptron multicouche (MLP)
Le réseau de neurones le plus simple : couches entièrement connectées.
Entrée → Couche 1 → Couche 2 → ... → SortieRéseaux convolutifs (CNN)
Spécialisés pour les images. Utilisent des filtres pour détecter des motifs.
Image → Convolutions → Pooling → ... → ClassificationRéseaux récurrents (RNN/LSTM)
Spécialisés pour les séquences (texte, audio, séries temporelles).
Mot₁ → Mot₂ → Mot₃ → ... → Prédiction
↓ ↓ ↓
État caché partagéTransformers
Architecture moderne basée sur l'attention. Domine le NLP et gagne du terrain en vision.
Entrée → Attention → Feed Forward → ... → Sortie
(parallèle)Composants d'un réseau
Neurone artificiel
x₁ ──w₁──┐
│
x₂ ──w₂──┼──→ Σ ──→ f(z) ──→ Sortie
│
x₃ ──w₃──┘
│
biais ─┘
z = w₁x₁ + w₂x₂ + w₃x₃ + b
Sortie = f(z) où f = fonction d'activationFonctions d'activation
| Fonction | Formule | Usage |
|---|---|---|
| ReLU | max(0, x) | Standard, couches cachées |
| Sigmoid | 1/(1+e⁻ˣ) | Sortie binaire (0-1) |
| Tanh | (eˣ-e⁻ˣ)/(eˣ+e⁻ˣ) | Sortie (-1 à 1) |
| Softmax | eˣⁱ/Σeˣʲ | Classification multiclasse |
| GELU | x·Φ(x) | Transformers |
Couches courantes
| Couche | Description |
|---|---|
| Dense/Linear | Entièrement connectée |
| Conv2D | Convolution pour images |
| MaxPool | Réduction de dimension |
| Dropout | Régularisation |
| BatchNorm | Normalisation |
| Attention | Pondération contextuelle |
Entraînement
Forward Pass
Propagation de l'entrée vers la sortie à travers toutes les couches.
x → Couche 1 → h₁ → Couche 2 → h₂ → ... → ŷLoss (Perte)
Mesure l'écart entre la prédiction et la réalité.
| Tâche | Loss |
|---|---|
| Régression | MSE, MAE |
| Classification binaire | Binary Cross-Entropy |
| Classification multiclasse | Categorical Cross-Entropy |
Backpropagation
Calcule les gradients de la loss par rapport à chaque poids, en remontant du bout vers l'entrée.
Loss → ∂L/∂w₃ → ∂L/∂w₂ → ∂L/∂w₁
(règle de la chaîne)Optimiseurs
Mettent à jour les poids pour minimiser la loss.
| Optimiseur | Description |
|---|---|
| SGD | Descente de gradient stochastique |
| Adam | Adaptive moments, le plus utilisé |
| AdamW | Adam avec weight decay |
| RMSprop | Adaptatif, bon pour RNN |
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)Régularisation
Techniques pour éviter le surapprentissage.
Dropout
Désactive aléatoirement des neurones pendant l'entraînement.
Entraînement : ● ○ ● ● ○ ● (○ = désactivé)
Inférence : ● ● ● ● ● ● (tous actifs, poids × p)nn.Dropout(p=0.5) # 50% des neurones désactivésBatch Normalization
Normalise les activations de chaque couche.
nn.BatchNorm2d(num_features=64)Data Augmentation
Augmente artificiellement le dataset.
transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(10),
transforms.ColorJitter(brightness=0.2),
])Early Stopping
Arrête l'entraînement quand la validation ne s'améliore plus.
Frameworks
PyTorch
import torch
import torch.nn as nn
class SimpleNet(nn.Module):
def __init__(self):
super().__init__()
self.layers = nn.Sequential(
nn.Linear(784, 256),
nn.ReLU(),
nn.Dropout(0.2),
nn.Linear(256, 10)
)
def forward(self, x):
return self.layers(x)
model = SimpleNet()TensorFlow/Keras
import tensorflow as tf
model = tf.keras.Sequential([
tf.keras.layers.Dense(256, activation='relu', input_shape=(784,)),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')Hardware
GPUs
Les GPUs (NVIDIA) sont essentiels pour le Deep Learning grâce à leur parallélisme massif.
| Composant | CPU | GPU |
|---|---|---|
| Cœurs | 8-64 | 10 000+ |
| Optimisé pour | Séquentiel | Parallèle |
| Deep Learning | Lent | Rapide (10-100x) |
TPUs
Les TPUs (Google) sont des puces spécialisées pour les tenseurs.
Cloud
- AWS : EC2 avec GPUs, SageMaker
- Google Cloud : Vertex AI, TPUs
- Azure : Machine Learning
- Hugging Face : Spaces, Inference API