docs: Ajout du guide d'introduction au Machine Learning

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