# 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