Chapitre 3 : Comparaison des expériences

Comparaison efficace des expériences

Comparer efficacement les expériences est crucial pour sélectionner le meilleur modèle et comprendre ce qui influence la performance.

Comparaison des expériences avec MLflow

import mlflow
from mlflow.tracking import MlflowClient

client = MlflowClient()

# Obtenez toutes les exécutions d'une expérience
experiment = client.get_experiment_by_name("customer-churn")
runs = client.search_runs(
    experiment_ids=[experiment.experiment_id],
    filter_string="metrics.auc_roc > 0.8",
    order_by=["metrics.auc_roc DESC"],
    max_results=10
)

# Comparez les exécutions
comparison = []
for run in runs:
    comparison.append({
        "run_id": run.info.run_id,
        "run_name": run.data.tags.get("mlflow.runName", ""),
        "auc_roc": run.data.metrics.get("auc_roc"),
        "accuracy": run.data.metrics.get("accuracy"),
        "n_estimators": run.data.params.get("n_estimators"),
        "max_depth": run.data.params.get("max_depth")
    })

import pandas as pd
df_comparison = pd.DataFrame(comparison)
print(df_comparison.to_markdown())

Meilleures pratiques de visualisation

import matplotlib.pyplot as plt
import seaborn as sns

# Graphique de coordonnées parallèles pour l'analyse des hyperparamètres
from pandas.plotting import parallel_coordinates

fig, ax = plt.subplots(figsize=(12, 6))
parallel_coordinates(
    df_comparison[['n_estimators', 'max_depth', 'auc_roc']], 
    'auc_roc',
    colormap='viridis'
)
plt.title("Impact des hyperparamètres sur l'AUC-ROC")
plt.savefig("hyperparameter_analysis.png")
mlflow.log_artifact("hyperparameter_analysis.png")

Cadre de sélection des expériences

class ExperimentSelector:
    """Cadre pour sélectionner la meilleure expérience."""
    
    def __init__(self, experiments: list, weights: dict):
        self.experiments = experiments
        self.weights = weights  # ex., {"auc_roc": 0.5, "latency": 0.3, "model_size": 0.2}
    
    def calculate_score(self, exp: dict) -> float:
        """Calculez le score pondéré pour l'expérience."""
        score = 0
        for metric, weight in self.weights.items():
            value = exp.get(metric, 0)
            # Normaliser (supposer que plus c'est élevé, mieux c'est sauf pour la latence/taille)
            if metric in ["latency", "model_size"]:
                value = 1 / (value + 1)  # Inverser
            score += value * weight
        return score
    
    def select_best(self) -> dict:
        """Sélectionnez la meilleure expérience basée sur des critères pondérés."""
        scored = [(exp, self.calculate_score(exp)) for exp in self.experiments]
        return max(scored, key=lambda x: x[1])[0]

Points clés à retenir

Résumé

1. Utilisez des requêtes structurées pour filtrer et trier les expériences
2. Visualisez l'impact des hyperparamètres avec des coordonnées parallèles
3. Définissez des critères de sélection avec des métriques pondérées
4. Documentez les décisions pour la reproductibilité
5. Automatisez la comparaison dans les pipelines CI/CD

---

Suivant : Quiz du Module 3