ML-Model-Generalization/docs/INSTRUCTIONS.md

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.

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%).

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.

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.

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.

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.

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.

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.

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.