diff --git a/GUIDE_DEBUTANT.md b/GUIDE_DEBUTANT.md new file mode 100644 index 0000000..2cc8b6c --- /dev/null +++ b/GUIDE_DEBUTANT.md @@ -0,0 +1,304 @@ +# Guide d'Introduction - Généralisation en Machine Learning + +## Objectif + +Ce guide explique les concepts fondamentaux de la généralisation des modèles et les techniques pour prévenir l'overfitting. Il complète le README.md en détaillant les mécanismes sous-jacents. + +--- + +## Généralisation : Le Problème Central + +### Définition + +La **généralisation** est la capacité d'un modèle à prédire correctement sur des données qu'il n'a jamais vues pendant l'entraînement. C'est la métrique la plus importante en ML : un modèle qui mémorise ses données d'entraînement mais échoue sur de nouvelles données est inutile en production. + +### Overfitting vs Underfitting + +**Overfitting (Surapprentissage)** +- Le modèle capture le bruit dans les données d'entraînement au lieu des patterns généraux +- Performance : Train >> Test +- Cause : Modèle trop complexe ou entraînement trop long + +**Underfitting (Sous-apprentissage)** +- Le modèle ne capture pas les patterns sous-jacents +- Performance : Train ≈ Test (mais les deux sont basses) +- Cause : Modèle trop simple ou entraînement insuffisant + +**Optimal** +- Le modèle capture les patterns généraux +- Performance : Train ≈ Test (et les deux sont élevées) + +--- + +## Split Train/Validation/Test + +### Pourquoi 3 ensembles distincts ? + +**Train (64%)** : Données utilisées pour l'optimisation des poids du modèle +- Le modèle voit ces données à chaque epoch +- La loss est calculée et utilisée pour la backpropagation + +**Validation (16%)** : Données utilisées pour le tuning des hyperparamètres +- Le modèle voit ces données mais ne met pas à jour ses poids avec +- Utilisé pour détecter l'overfitting pendant l'entraînement +- Les callbacks (Early Stopping, LR Scheduler) surveillent la `val_loss` + +**Test (20%)** : Données utilisées pour l'évaluation finale +- Le modèle ne voit jamais ces données pendant l'entraînement +- Aucun hyperparamètre ne doit être ajusté après avoir vu les résultats du test +- Estimation non biaisée de la performance réelle + +### Erreur critique à éviter + +Ne **jamais** utiliser le test set pour ajuster les hyperparamètres. Cela introduit un biais : vous optimisez indirectement pour le test set, ce qui invalide son rôle d'évaluation non biaisée. + +--- + +## Early Stopping + +### Principe + +L'Early Stopping arrête l'entraînement lorsque la performance sur le validation set cesse de s'améliorer, même si la loss du train set continue de diminuer. Cela prévient l'overfitting. + +### Mécanisme + +```python +EarlyStopping( + monitor='val_loss', # Métrique surveillée + patience=3, # Nombre d'epochs sans amélioration + min_delta=0.01, # Amélioration minimale significative + restore_best_weights=True # Revenir aux meilleurs poids +) +``` + +**Fonctionnement** : +1. À chaque epoch, la `val_loss` est calculée +2. Si `val_loss` ne diminue pas d'au moins `min_delta` pendant `patience` epochs consécutifs +3. L'entraînement s'arrête et les poids de la meilleure epoch sont restaurés + +### Pourquoi ça marche + +Durant l'entraînement, le modèle passe par trois phases : +1. **Underfit** : Train loss et val loss diminuent ensemble +2. **Sweet spot** : Performance optimale sur les deux +3. **Overfit** : Train loss continue de diminuer, val loss augmente + +Early Stopping détecte le début de la phase 3 et revient à la phase 2. + +--- + +## Learning Rate Scheduler + +### Principe + +Le **learning rate** contrôle la taille des ajustements des poids à chaque itération. Un learning rate adaptatif améliore la convergence. + +### Stratégie : ReduceLROnPlateau + +```python +ReduceLROnPlateau( + monitor='val_loss', + factor=0.5, # Multiplie LR par 0.5 + patience=2, + min_lr=1e-5 +) +``` + +**Fonctionnement** : +- Début d'entraînement : LR = 0.05 (exploration rapide de l'espace des solutions) +- Si val_loss stagne pendant 2 epochs : LR = 0.025 (affinage) +- Si val_loss stagne encore : LR = 0.0125, puis 0.00625, etc. +- Minimum : 1e-5 (évite de ralentir complètement) + +### Pourquoi ça marche + +**Learning rate élevé** : +- Avantages : Convergence rapide, échappe aux minima locaux +- Inconvénient : Peut "sauter" au-dessus de l'optimum + +**Learning rate faible** : +- Avantages : Convergence précise vers l'optimum +- Inconvénient : Lent, risque de bloquer dans un minimum local + +La stratégie adaptative combine les avantages des deux. + +--- + +## Normalisation des Features + +### Problème + +Les features ont des échelles différentes. Exemple : +- Age : [20, 80] → plage de 60 +- Revenu : [20000, 150000] → plage de 130000 + +Sans normalisation, le gradient descent est dominé par les features à grande échelle, ce qui ralentit ou empêche la convergence. + +### Solution : StandardScaler + +```python +scaler = StandardScaler() +X = scaler.fit_transform(X) +``` + +Transforme chaque feature pour avoir : +- Moyenne = 0 +- Écart-type = 1 + +Formula : `z = (x - μ) / σ` + +### Impact + +Toutes les features contribuent équitablement au gradient, ce qui accélère la convergence et améliore la stabilité de l'entraînement. + +--- + +## Métriques d'Évaluation + +### Accuracy + +``` +Accuracy = (TP + TN) / (TP + TN + FP + FN) +``` + +Pourcentage de prédictions correctes. Simple mais peut être trompeuse avec des classes déséquilibrées. + +### Precision et Recall + +**Precision** : Parmi les prédictions positives, combien sont correctes ? +``` +Precision = TP / (TP + FP) +``` + +**Recall** : Parmi les vrais positifs, combien ont été détectés ? +``` +Recall = TP / (TP + FN) +``` + +### Trade-off + +Haute precision, bas recall : Le modèle est conservatif (peu de faux positifs mais rate des vrais positifs) +Bas precision, haut recall : Le modèle est agressif (détecte beaucoup mais avec des erreurs) + +### Matrice de Confusion + +``` + Prédictions + 0 1 +Réel 0 [[TN FP] + 1 [FN TP]] +``` + +Permet de visualiser où le modèle fait des erreurs : +- **TN** (True Negative) : Correct négatif +- **FP** (False Positive) : Faux positif (Type I error) +- **FN** (False Negative) : Faux négatif (Type II error) +- **TP** (True Positive) : Correct positif + +--- + +## Architecture du Réseau + +### Structure + +``` +Input (20) → Dense(64, ReLU) → Dense(32, ReLU) → Dense(1, Sigmoid) +``` + +### Justification + +**ReLU (Rectified Linear Unit)** +- Fonction : `f(x) = max(0, x)` +- Rôle : Introduit la non-linéarité, permettant au réseau d'apprendre des fonctions complexes +- Avantages : Pas de vanishing gradient, calcul rapide + +**Sigmoid** +- Fonction : `f(x) = 1 / (1 + e^(-x))` +- Rôle : Transforme la sortie en probabilité [0, 1] +- Utilisation : Classification binaire + +**Architecture progressive (64 → 32 → 1)** +- Extraction de features de haut niveau dans les premières couches +- Compression progressive vers la décision finale + +--- + +## Diagnostic de l'Overfitting + +### Signes positifs (Bonne généralisation) + +1. **Gap minimal** : Train accuracy ≈ Test accuracy (< 5% de différence) +2. **Courbes parallèles** : train_loss et val_loss diminuent ensemble +3. **Stabilité** : val_loss se stabilise sans fluctuer +4. **Early stopping précoce** : Arrêt avant d'atteindre max_epochs (ex: epoch 10/100) + +### Signes négatifs (Overfitting) + +1. **Gap important** : Train accuracy >> Test accuracy (> 10% de différence) +2. **Divergence** : train_loss diminue mais val_loss augmente +3. **Instabilité** : val_loss fluctue fortement +4. **Mémorisation** : Le modèle atteint ~100% sur train mais ~70% sur test + +### Actions correctives si overfitting détecté + +1. **Plus de données** : La solution la plus efficace +2. **Régularisation** : L2 (weight decay), Dropout +3. **Simplifier le modèle** : Moins de couches ou de neurones +4. **Early stopping** : Réduire patience +5. **Data augmentation** : Si applicable (images, texte) + +--- + +## Glossaire Technique + +| Terme | Définition | +|-------|------------| +| **Epoch** | Une passe complète sur l'ensemble du training set | +| **Batch** | Sous-ensemble de données traité simultanément | +| **Gradient Descent** | Algorithme d'optimisation qui ajuste les poids pour minimiser la loss | +| **Backpropagation** | Méthode de calcul des gradients via la chaîne des dérivées | +| **Loss Function** | Fonction mesurant l'écart entre prédictions et vraies valeurs | +| **Optimizer** | Algorithme implémentant le gradient descent (SGD, Adam, RMSprop) | +| **Hyperparamètres** | Paramètres définis avant l'entraînement (learning rate, architecture) | +| **Poids/Weights** | Paramètres appris pendant l'entraînement | +| **Activation Function** | Fonction non-linéaire appliquée aux neurones (ReLU, Sigmoid, Tanh) | +| **Forward Pass** | Propagation des données de l'input vers l'output | +| **Callback** | Fonction exécutée à certains moments de l'entraînement | + +--- + +## Résultats du Lab + +### Performance + +- Accuracy : 97% +- Precision : 95-99% selon la classe +- Recall : 95-99% selon la classe +- Arrêt : Epoch 10/100 (early stopping activé) + +### Interprétation + +Le gap minimal entre train et test confirme une bonne généralisation. L'early stopping à epoch 10 indique que le modèle a convergé rapidement sans surapprentissage. Les métriques équilibrées (precision ≈ recall) suggèrent l'absence de biais vers une classe. + +--- + +## Pour Aller Plus Loin + +**Techniques avancées de régularisation** : +- Dropout : Désactive aléatoirement des neurones pendant l'entraînement +- L2 Regularization : Pénalise les poids élevés dans la loss function +- Batch Normalization : Normalise les activations entre les couches + +**Optimizers alternatifs** : +- SGD with momentum : Accélère la convergence +- RMSprop : Adapte le learning rate par paramètre +- Adam : Combine momentum et RMSprop (utilisé dans ce lab) + +**Cross-validation** : +- K-fold CV : Validation plus robuste pour petits datasets +- Stratified CV : Maintient la distribution des classes + +**Tuning automatique** : +- Grid Search : Teste toutes les combinaisons d'hyperparamètres +- Random Search : Échantillonnage aléatoire (plus efficace) +- Bayesian Optimization : Recherche intelligente de l'optimum