Analyser les hyperparamètres de fine-tuning

Quand tu lances un fine-tuning, tu ne choisis pas seulement tes données. Tu choisis aussi des hyperparamètres qui contrôlent comment le modèle apprend. Les trois plus importants sont le nombre d'epochs, le learning rate multiplier et le batch size. Un mauvais choix d'hyperparamètres peut ruiner ton fine-tuning : le modèle peut sur-apprendre (overfitting) ou sous-apprendre (underfitting).

Le nombre d'epochs, c'est le nombre de fois que le modèle parcourt tout le dataset. Trop peu : il n'a pas eu le temps d'apprendre. Trop : il mémorise les exemples par coeur au lieu de généraliser.

Le learning rate multiplier contrôle la vitesse d'apprentissage. Trop haut : le modèle oscille et ne converge pas. Trop bas : il apprend trop lentement et le fine-tuning ne change presque rien.

Le signal d'alarme du sur-apprentissage, c'est quand la loss d'entraînement continue de baisser mais la loss de validation remonte. Ça veut dire que le modèle mémorise les données d'entraînement au lieu d'apprendre des patterns généraux.

Écris une fonction analyser_hyperparametres(resultats) qui prend une liste de résultats d'expériences de fine-tuning. Chaque résultat est un dictionnaire avec :
- "nom" : le nom de l'expérience (ex: "run_1")
- "epochs" : nombre d'epochs
- "learning_rate" : le learning rate multiplier
- "batch_size" : la taille du batch
- "train_losses" : liste de floats (la loss d'entraînement à chaque epoch)
- "val_losses" : liste de floats (la loss de validation à chaque epoch)

La fonction renvoie un dictionnaire avec :
- "analyses" : une liste de dicts pour chaque expérience, contenant :
- "nom" : le nom de l'expérience
- "train_loss_finale" : la dernière valeur de train_losses
- "val_loss_finale" : la dernière valeur de val_losses
- "overfitting" : True si la val_loss du dernier epoch est supérieure à la val_loss minimale de plus de 10%
- "convergence" : True si la train_loss diminue entre le premier et le dernier epoch
- "ecart_train_val" : différence entre val_loss_finale et train_loss_finale, arrondi à 4 décimales
- "meilleur" : le nom de l'expérience avec la val_loss_finale la plus basse ET pas d'overfitting. Si toutes sur-apprennent, prend celle avec la val_loss minimale la plus basse.
- "recommandations" : une liste de chaînes avec des conseils basés sur l'analyse

Les recommandations à générer :
- Si le meilleur modèle a de l'overfitting : "Réduire le nombre d'epochs ou augmenter le dataset"
- Si le meilleur modèle n'a pas convergé : "Augmenter le learning rate ou le nombre d'epochs"
- Si l'écart train/val du meilleur dépasse 0.5 : "Le modèle généralise mal, envisager plus de données"
- Si aucun overfitting et bonne convergence : "Configuration optimale trouvée"

Exemple :

resultats = [
{"nom": "run_1", "epochs": 3, "learning_rate": 1.0, "batch_size": 4, "train_losses": [2.0, 1.5, 1.0], "val_losses": [2.1, 1.6, 1.2]},
{"nom": "run_2", "epochs": 5, "learning_rate": 2.0, "batch_size": 4, "train_losses": [2.0, 1.2, 0.5, 0.2, 0.1], "val_losses": [2.1, 1.3, 0.8, 1.0, 1.5]},
]
r = analyser_hyperparametres(resultats)
r["meilleur"] renvoie "run_1" (pas d'overfitting, bonne val_loss)
r["analyses"][1]["overfitting"] renvoie True (val_loss remonte de 0.8 à 1.5)

Tests (4/6)

Pas d'overfitting

resultats = [{'nom': 'run_1', 'epochs': 3, 'learning_rate': 1.0, 'batch_size': 4, 'train_losses': [2.0, 1.5, 1.0], 'val_losses': [2.1, 1.6, 1.2]}]
r = analyser_hyperparametres(resultats)
assert r['analyses'][0]['overfitting'] == False
assert r['analyses'][0]['convergence'] == True
assert r['meilleur'] == 'run_1'

Détecte l'overfitting

resultats = [{'nom': 'overfit', 'epochs': 5, 'learning_rate': 2.0, 'batch_size': 4, 'train_losses': [2.0, 1.2, 0.5, 0.2, 0.1], 'val_losses': [2.1, 1.3, 0.8, 1.0, 1.5]}]
r = analyser_hyperparametres(resultats)
assert r['analyses'][0]['overfitting'] == True, 'val_loss remonte de 0.8 a 1.5, overfitting detecte'

Choisit le meilleur sans overfitting

resultats = [
    {'nom': 'bon', 'epochs': 3, 'learning_rate': 1.0, 'batch_size': 4, 'train_losses': [2.0, 1.5, 1.0], 'val_losses': [2.1, 1.6, 1.2]},
    {'nom': 'overfit', 'epochs': 5, 'learning_rate': 2.0, 'batch_size': 4, 'train_losses': [2.0, 0.5, 0.1, 0.05, 0.01], 'val_losses': [2.1, 0.8, 0.6, 0.9, 1.5]}
]
r = analyser_hyperparametres(resultats)
assert r['meilleur'] == 'bon', 'Doit choisir le run sans overfitting'

Écart train/val calculé

resultats = [{'nom': 'test', 'epochs': 2, 'learning_rate': 1.0, 'batch_size': 4, 'train_losses': [2.0, 0.5], 'val_losses': [2.1, 1.3]}]
r = analyser_hyperparametres(resultats)
assert r['analyses'][0]['ecart_train_val'] == 0.8

+ 0 tests cachés

Indices (3 disponibles)

Solution officielle

def analyser_hyperparametres(resultats):
    analyses = []

    for res in resultats:
        train_losses = res["train_losses"]
        val_losses = res["val_losses"]

        train_loss_finale = train_losses[-1]
        val_loss_finale = val_losses[-1]
        val_loss_min = min(val_losses)

        overfitting = val_loss_finale > val_loss_min * 1.1
        convergence = train_losses[-1] < train_losses[0]
        ecart = round(val_loss_finale - train_loss_finale, 4)

        analyses.append({
            "nom": res["nom"],
            "train_loss_finale": train_loss_finale,
            "val_loss_finale": val_loss_finale,
            "overfitting": overfitting,
            "convergence": convergence,
            "ecart_train_val": ecart,
        })

    # Trouver le meilleur : pas d'overfitting et val_loss la plus basse
    sans_overfit = [a for a in analyses if not a["overfitting"]]
    if sans_overfit:
        meilleur = min(sans_overfit, key=lambda a: a["val_loss_finale"])
    else:
        # Si tous sur-apprennent, prendre la val_loss_min la plus basse
        meilleur_idx = 0
        meilleur_val_min = float("inf")
        for i, res in enumerate(resultats):
            vm = min(res["val_losses"])
            if vm < meilleur_val_min:
                meilleur_val_min = vm
                meilleur_idx = i
        meilleur = analyses[meilleur_idx]

    recommandations = []
    if meilleur["overfitting"]:
        recommandations.append("Réduire le nombre d'epochs ou augmenter le dataset")
    if not meilleur["convergence"]:
        recommandations.append("Augmenter le learning rate ou le nombre d'epochs")
    if meilleur["ecart_train_val"] > 0.5:
        recommandations.append("Le modèle généralise mal, envisager plus de données")
    if not meilleur["overfitting"] and meilleur["convergence"] and meilleur["ecart_train_val"] <= 0.5:
        recommandations.append("Configuration optimale trouvée")

    return {
        "analyses": analyses,
        "meilleur": meilleur["nom"],
        "recommandations": recommandations,
    }

← Évaluer un embedding fine-tuné

solution.py

Bravo!

Analyser les hyperparamètres de fine-tuning

Tests (4/6)

Indices (3 disponibles)

Solution officielle