diff --git a/GUIDE_DEBUTANT.md b/docs/GUIDE_DEBUTANT.md similarity index 100% rename from GUIDE_DEBUTANT.md rename to docs/GUIDE_DEBUTANT.md diff --git a/docs/INSTRUCTIONS.md b/docs/INSTRUCTIONS.md new file mode 100644 index 0000000..7f583ee --- /dev/null +++ b/docs/INSTRUCTIONS.md @@ -0,0 +1,166 @@ +# Instructions du Lab - Généralisation des Modèles ML + +## Étape 1 : Introduction à la Généralisation des Modèles ML + +### Introduction + +Bienvenue dans le lab "Introduction à la Généralisation des Modèles ML" ! + +Ce lab est conçu pour vous donner une compréhension fondamentale de la généralisation dans les modèles de Machine Learning, et comment prévenir le sur-apprentissage (overfitting) ou le sous-apprentissage (underfitting) des modèles. + +### Objectifs d'Apprentissage + +- Réviser la généralisation et l'importance de ne pas sur-apprendre ou sous-apprendre les modèles +- Pratiquer l'implémentation de l'arrêt précoce (early stopping) et de la décroissance du taux d'apprentissage (learning rate decay) + +### Prérequis + +Familiarité avec les principes de base du ML et les concepts clés autour des taux d'apprentissage et de la structure des modèles. + +--- + +## Étape 2 : Génération de Données Synthétiques + +### Génération de Données Synthétiques + +Ci-dessous se trouve une fonction de base pour créer des données synthétiques pour la classification. Ces données auront 2000 échantillons, chacun avec 20 caractéristiques (features), où 5 caractéristiques n'affectent pas le résultat de la classification et 15 sont directement corrélées à la classification. Les options de classification correcte seront seulement entre deux options. Plus important encore, l'état aléatoire (random state) est défini pour permettre la reproductibilité de la génération du modèle. + +```python +X, y = make_classification(n_samples=2000, + n_features=20, + n_classes=2, + n_informative=15, + n_redundant=5, + random_state=42) +scaler = StandardScaler() +X = scaler.fit_transform(X) +``` + +### Divisions Train/Validation/Test + +Pour diviser les données, vous allez d'abord séparer les ensembles de test et d'entraînement/validation. De là, vous allez séparer l'entraînement/validation en leurs ensembles distincts d'entraînement et de validation, résultant en une distribution de données de train (64%), val (16%), test (20%). + +```python +X_trainval, X_test, y_trainval, y_test = train_test_split(X, y, test_size=0.2, random_state=42) +X_train, X_val, y_train, y_val = train_test_split(X_trainval, y_trainval, test_size=0.2, random_state=42) +``` + +En pratique, il est préférable de définir votre ensemble de données de test avant que la création du modèle ne commence et de le garder hors des environnements de production entièrement pour s'assurer qu'il n'y a pas de fuite de données ou de sur-apprentissage du modèle. + +--- + +## Étape 3 : Configuration du Modèle et des Fonctionnalités de Généralisation + +### Introduction + +Pour ce lab, vous utiliserez un réseau de neurones feedforward basique car les réseaux de neurones vous permettent d'implémenter des fonctionnalités supplémentaires telles que les planificateurs de taux d'apprentissage et l'arrêt précoce, que les modèles plus traditionnels comme la régression linéaire n'ont pas. + +### Configuration du Modèle + +Pour ce modèle, vous utiliserez deux couches denses de fonctions d'activation ReLU, permettant d'apprendre des patterns plus complexes, et terminant le modèle avec une sigmoïde. Lors de la configuration du modèle, vous pourriez également inclure des techniques de généralisation supplémentaires telles que le dropout, qui désactive sélectivement un certain pourcentage de neurones pour s'assurer qu'aucun neurone unique dans le réseau de neurones n'apprenne à effectuer un seul aspect de la prédiction. + +**Note :** ReLU est utilisé pour introduire la non-linéarité dans l'apprentissage d'un réseau de neurones, et sigmoid est utilisé comme fonction de classification. + +```python +model = tf.keras.Sequential([ + tf.keras.layers.Dense(64, activation='relu', input_shape=(20,)), + tf.keras.layers.Dense(32, activation='relu'), + tf.keras.layers.Dense(1, activation='sigmoid') +]) +``` + +### Fonction de Perte et Paramètres d'Initialisation du Modèle + +Pour ce lab, vous utiliserez l'optimiseur Adam car Adam est un bon optimiseur de départ pour la plupart des problèmes. Adam prend un paramètre qui est le taux d'apprentissage de départ. La plupart des modèles commencent avec un taux d'apprentissage inférieur à 0.3 et généralement plus proche de 0.1 au maximum. Ici, vous définissez également la fonction de perte comme `binary_crossentropy` qui est une fonction de perte simple qui compare simplement si les valeurs prédites correspondent aux valeurs réelles. + +```python +model.compile( + optimizer=tf.keras.optimizers.Adam(learning_rate=0.05), + loss='binary_crossentropy', + metrics=['accuracy'] +) +``` + +#### Planificateur de Taux d'Apprentissage + +Pour votre planificateur de taux d'apprentissage dans ce lab, vous utiliserez "ReduceLROnPlateau" de la bibliothèque Keras qui définit la décroissance du taux d'apprentissage pour atteindre un plateau à un certain montant, garantissant que le modèle ne ralentit jamais complètement pendant l'entraînement. Ci-dessous, les paramètres de la fonction sont définis : + +- `val_loss` est la perte appliquée sur l'ensemble de validation +- `factor` est le facteur par lequel le taux d'apprentissage sera réduit +- `patience` est le nombre d'époques entre les réductions de taux d'apprentissage +- `min_lr` définit la valeur la plus basse possible du taux d'apprentissage +- `verbose` a 3 valeurs possibles : 0 qui ne retourne rien, 1 qui retourne une barre de progression, et 2 qui affiche les valeurs pour chaque époque individuellement sur sa propre ligne. + +```python +lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau( + monitor='val_loss', # métrique à surveiller + factor=0.5, # réduire par un facteur + patience=2, # attendre 2 époques avant de réduire LR + min_lr=1e-5, # ne pas réduire en dessous de cela + verbose=1 +) +``` + +#### Arrêt Précoce (Early Stopping) + +Ensuite dans le code, vous implémenterez l'aspect d'arrêt précoce du modèle. Cette fonction empêchera le modèle de sur-apprendre en revenant aux paramètres d'un modèle précédent dans l'entraînement si la valeur surveillée n'augmente pas d'un incrément spécifique. Dans votre cas, la valeur surveillée est à nouveau la perte de validation. Une patience de 3 est définie, indiquant que le modèle a 3 fois sans changement suffisamment important avant que le modèle précédent qui l'a fait soit sélectionné comme modèle final. `min_delta` définit combien la valeur doit changer pour être considérée comme une différence de valeur suffisamment importante pour garder le modèle. Enfin, `restore_best_weights` mis à true permet au modèle de restaurer le dernier modèle qui a performé le mieux, dans les cas où le `min_delta` du modèle n'a pas été atteint. Cette fonctionnalité est importante pour s'assurer que le modèle ne sur-apprend pas les données d'entraînement et conserve un certain aspect de généralisation. + +```python +early_stop = tf.keras.callbacks.EarlyStopping( + monitor='val_loss', + patience=3, + min_delta=0.01, # changement minimum pour être considéré comme une amélioration + restore_best_weights=True, + verbose=1 +) +``` + +--- + +## Étape 4 : Entraînement du Modèle + +### Entraînement du Modèle + +Finalement, passons à l'entraînement du modèle. Vous utiliserez la méthode fit basique et définirez l'ensemble de validation dans les hyperparamètres. Cela permet à la `val_loss` d'être correctement utilisée par le planificateur de taux d'apprentissage et le mécanisme d'arrêt précoce. Pour ce cas, les époques sont définies par défaut à 100 et le verbose est défini à 2. Cela garantira que vous avez beaucoup d'époques pour terminer tôt et que les informations d'entraînement du modèle ligne par ligne peuvent vous aider à mieux comprendre les valeurs de `val_loss` et comment elles changent par époque. Lorsque vous exécutez le modèle, portez une attention particulière au changement de `val_loss` et à la façon dont il est corrélé au moment où le modèle initie l'arrêt précoce et le retour aux modèles précédents. + +```python +model.fit( + X_train, y_train, + validation_data=(X_val, y_val), + epochs=100, + callbacks=[early_stop, lr_scheduler], # votre arrêt précoce personnalisé + planificateur LR + verbose=2 +) +``` + +--- + +## Étape 5 : Évaluation des Résultats du Modèle + +### Évaluation des Résultats du Modèle + +Le code suivant fournit un test de métriques de base de votre réseau de neurones. Selon le domaine du modèle, différents niveaux de précision sont acceptables. Il est plus important de voir une augmentation considérable de la précision dans les prédictions par rapport aux méthodes existantes, que d'atteindre un seuil particulier de précision. Une précision supérieure à 99,5% pour la validation peut être un peu préoccupante car elle peut être un signe de sur-apprentissage, et une précision inférieure aux méthodes précédentes peut être un signe de sous-apprentissage. + +```python +y_pred_probs = model.predict(X_test).flatten() +y_pred = (y_pred_probs >= 0.5).astype(int) + +print("\n Test Set Evaluation:") +print(classification_report(y_test, y_pred)) +print("Confusion Matrix:") +print(confusion_matrix(y_test, y_pred)) +``` + +--- + +## Conclusion + +Vous avez maintenant complété le lab sur la généralisation des modèles ML ! Vous avez appris à : + +- Créer et diviser des données synthétiques pour l'entraînement, la validation et le test +- Construire un réseau de neurones avec des techniques de généralisation +- Implémenter l'arrêt précoce pour prévenir le sur-apprentissage +- Utiliser un planificateur de taux d'apprentissage pour améliorer la convergence +- Évaluer les performances du modèle avec des métriques appropriées + +Pour approfondir ces concepts, consultez le `README.md` et le `GUIDE_DEBUTANT.md` qui fournissent des explications détaillées et des visualisations.