Salut tout le monde, ici Nina, de retour sur agntbox.com ! Nous sommes le 13 mars 2026, et si vous êtes comme moi, votre boîte de réception déborde probablement d’annonces concernant de nouveaux outils d’IA. Le rythme de l’innovation est juste fou, n’est-ce pas ?
Aujourd’hui, je veux parler de quelque chose qui me trotte dans la tête depuis un moment, surtout après quelques nuits blanches à me battre avec un projet en particulier. Nous allons explorer le monde de l’évaluation des modèles d’IA, en nous concentrant spécifiquement sur un cadre qui a gagné en popularité : les API d’évaluation des modèles de MLflow. Je sais ce que certains d’entre vous pensent – “MLflow ? N’est-ce pas pour MLOps et le suivi ?” Et oui, c’est exactement ça. Mais ils ont discrètement déployé des capacités d’évaluation vraiment réfléchies qui méritent, selon moi, un examen plus attentif, surtout quand vous essayez de dépasser le simple score de précision.
Pour vous donner un peu de contexte, j’ai récemment terminé un projet client impliquant un modèle d’analyse de sentiments personnalisé pour des retours clients. Le client n’était pas seulement intéressé par un sentiment “bon” ou “mauvais” ; il avait besoin d’insights nuancés sur pourquoi un sentiment était positif ou négatif, et à quel point le modèle était cohérent à travers différentes catégories de produits. Mon approche initiale, comme c’est souvent le cas, a été de concocter quelques scripts Python, de calculer quelques métriques et de les balancer dans un CSV. Vous connaissez la recette – `sklearn.metrics` pour la précision, la précision, le rappel, F1, peut-être un graphique de matrice de confusion avec Matplotlib. Ça fonctionne, c’est bien. Mais ensuite, le client a demandé une comparaison avec un modèle de référence, puis une autre itération, et soudain, j’avais une douzaine de CSV et de graphiques, tous légèrement différents, et aucune manière claire de les comparer systématiquement.
C’est alors que je me suis souvenu avoir vu quelque chose au sujet des fonctionnalités d’évaluation étendues de MLflow. J’utilisais MLflow pour le suivi des expériences depuis des lustres, mais je n’avais pas vraiment exploré le côté évaluation. Et laissez-moi vous dire, ça a été un peu un moment “eureka”. Au lieu de réinventer la roue pour chaque comparaison, je pouvais intégrer mon évaluation directement dans mes runs MLflow existants, rendant tout beaucoup plus organisé et comparable.
Au-delà d’une seule métrique : Pourquoi une évaluation structurée est importante
Soyons honnêtes : lorsque vous construisez des modèles d’IA, surtout pour des applications réelles, un seul score de précision raconte rarement toute l’histoire. Vous devez comprendre :
- Biais : Votre modèle fonctionne-t-il également bien à travers différents groupes démographiques, catégories de produits ou types d’entrées ?
- Solidité : Comment gère-t-il les données bruyantes ou les légères variations d’entrée ?
- Explicabilité : Pouvez-vous comprendre pourquoi le modèle a fait une prédiction particulière ?
- Modes d’échec spécifiques : Où se trompe-t-il de manière cohérente ?
Mon projet d’analyse des sentiments a mis cela en lumière parfaitement. Une précision globale de 85 % semblait bonne sur le papier. Mais lorsque nous l’avons décomposée par catégorie de produit, nous avons découvert que le modèle avait des difficultés significatives avec les retours liés au “support technique” – classant systématiquement les expériences négatives comme neutres. Sans une manière structurée d’évaluer et de comparer, repérer ces problèmes aurait été un casse-tête bien plus important.
L’approche traditionnelle : Bonne, mais désordonnée
Avant d’explorer MLflow, reconnaissons rapidement la façon standard dont nous faisons souvent cela. Cela implique généralement une boucle, des calculs de métriques, puis une agrégation manuelle. Quelque chose comme ceci :
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
# ... autres imports ...
# Supposons que X, y soient vos caractéristiques et labels
# X_train, X_test, y_train, y_test = train_test_split(...)
# Un modèle de base
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)
predictions = model.predict(X_test)
# Calculer les métriques
accuracy = accuracy_score(y_test, predictions)
precision = precision_score(y_test, predictions, average='weighted')
recall = recall_score(y_test, predictions, average='weighted')
f1 = f1_score(y_test, predictions, average='weighted')
print(f"Précision : {accuracy:.4f}")
print(f"Précision : {precision:.4f}")
print(f"Rappel : {recall:.4f}")
print(f"Score F1 : {f1:.4f}")
# Vous pourriez ensuite enregistrer ces résultats dans un CSV, tracer une matrice de confusion, etc.
# metrics_df = pd.DataFrame({"metric": ["accuracy", "precision", "recall", "f1"],
# "value": [accuracy, precision, recall, f1]})
# metrics_df.to_csv("model_metrics_v1.csv", index=False)
C’est bien pour un seul run, mais imaginez faire cela pour 10 modèles différents, ou 5 versions différentes du même modèle, avec des hyperparamètres différents. Vous finissez avec `model_metrics_v1.csv`, `model_metrics_v2_tuned.csv`, `model_metrics_baseline.csv`, et ainsi de suite. Ça devient vite ingérable.
Les API d’évaluation des modèles de MLflow : Un nouveau regard
Les capacités d’évaluation des modèles de MLflow visent à apporter structure et standardisation à ce processus. L’idée principale est que lorsque vous enregistrez un modèle avec `mlflow.log_model()`, vous pouvez également déclencher un run d’évaluation qui stocke les métriques, graphiques, et même des artefacts d’évaluation personnalisés aux côtés de votre modèle. Cela signifie que tous vos résultats d’évaluation sont directement liés à la version du modèle et au run d’expérience qui les ont produits.
Les acteurs clés ici sont `mlflow.evaluate()` et les classes `mlflow.models.EvaluationMetric` et `mlflow.models.EvaluationArtifact`. Décomposons comment j’ai utilisé cela pour mon projet d’analyse des sentiments.
Exemple 1 : Intégration d’évaluation de base
Tout d’abord, vous avez besoin de votre modèle et de quelques données de test. Pour mon modèle de sentiments, j’avais un objet `pipeline` (un pipeline scikit-learn avec un TfidfVectorizer et un classificateur LogisticRegression) et un `test_df` avec des colonnes `text` et `true_sentiment`.
import mlflow
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, ConfusionMatrixDisplay
import matplotlib.pyplot as plt
import numpy as np
# Supposons que vous avez vos données chargées
# Pour la démonstration, créons quelques données fictives
data = {
'text': [
"Le produit est incroyable, je l'adore !",
"Service terrible, réponse très lente.",
"C'est correct, rien de spécial.",
"Meilleur achat jamais, à recommander fortement.",
"Le support client était inutile et impoli.",
"Fonctionne comme prévu, assez standard.",
"Absolument ravi de cet appareil !",
"Casse sur arrivée, très déçu.",
"Qualité décente pour le prix.",
"Une si belle expérience !",
"Pire expérience, plus jamais.",
"Sentiment neutre à ce sujet, ni mauvais, ni bon."
],
'sentiment': [
'positif', 'négatif', 'neutre', 'positif', 'négatif',
'neutre', 'positif', 'négatif', 'neutre', 'positif',
'négatif', 'neutre'
]
}
df = pd.DataFrame(data)
# Séparer les données
X_train, X_test, y_train, y_test = train_test_split(
df['text'], df['sentiment'], test_size=0.3, random_state=42, stratify=df['sentiment']
)
# Construire un pipeline simple
pipeline = Pipeline([
('tfidf', TfidfVectorizer()),
('logreg', LogisticRegression(max_iter=1000, random_state=42))
])
pipeline.fit(X_train, y_train)
# Préparer les données de test sous forme de DataFrame pour mlflow.evaluate
test_df = pd.DataFrame({'text': X_test, 'true_sentiment': y_test})
with mlflow.start_run(run_name="Sentiment_Model_Evaluation_v1") as run:
# Enregistrer le modèle (optionnel, mais bonne pratique)
mlflow.sklearn.log_model(pipeline, "sentiment_model")
# Effectuer l'évaluation
mlflow.evaluate(
model=pipeline,
data=test_df,
targets="true_sentiment",
model_type="text_classification",
evaluators=["default"], # Utilisez les évaluateurs par défaut pour text_classification
# Vous pouvez ajouter des métriques ou artefacts personnalisés ici
# extra_metrics=[mlflow.models.EvaluationMetric(...), ...],
# extra_artifacts=[mlflow.models.EvaluationArtifact(...), ...]
)
print(f"ID de Run MLflow : {run.info.run_id}")
Lorsque vous exécutez cela, MLflow calcule automatiquement les métriques de classification standards (précision, précision, rappel, F1) et les enregistre. Il génère également un graphique de matrice de confusion, une courbe PR et une courbe ROC, les stockant en tant qu’artefacts dans le run. C’est déjà un grand pas en avant par rapport à la génération et l’enregistrement manuels de ces résultats !
Le paramètre `model_type=”text_classification”` est important car l’évaluateur `default` de MLflow saura alors quelles métriques et graphiques standards sont les plus pertinents. Il existe également des évaluateurs par défaut pour `regressor`, `classifier`, et `question_answering` (à ma dernière vérification).
Exemple 2 : Métriques et artefacts personnalisés pour un aperçu approfondi
Le véritable pouvoir, pour moi, est venu lorsque j’ai eu besoin d’aller au-delà des métriques par défaut. N’oubliez pas la demande de mon client de voir la performance décomposée par catégorie de produit ? MLflow vous permet de définir des `extra_metrics` et `extra_artifacts`. C’est ici que vous pouvez intégrer vos évaluations spécifiques au domaine.
Pour mon modèle de sentiments, je voulais voir le score F1 spécifiquement pour les retours liés au “support technique”. Je voulais également enregistrer un DataFrame montrant des exemples mal classés pour facilement revoir les erreurs courantes.
# ... (configuration précédente pour le pipeline, X_train, X_test, y_train, y_test, df) ...
# Simulons les catégories de produits pour les données de test
# Pour simplifier, nous allons juste ajouter une colonne 'category' au test_df
# Dans un scénario réel, cela proviendrait de vos données réelles
test_df['category'] = np.random.choice(['product_A', 'product_B', 'technical_support', 'billing'], size=len(test_df))
def f1_score_tech_support(eval_df, _builtin_metrics):
# Cette fonction de métrique personnalisée reçoit le DataFrame d'évaluation
# qui contient 'targets' (étiquettes réelles) et 'predictions'
tech_support_df = eval_df[eval_df['category'] == 'technical_support']
if len(tech_support_df) == 0:
return np.nan # Ou 0, selon votre préférence
return f1_score(tech_support_df['targets'], tech_support_df['predictions'], average='weighted')
def log_misclassified_examples(eval_df, _builtin_metrics):
misclassified_df = eval_df[eval_df['targets'] != eval_df['predictions']]
# Enregistrer les exemples mal classés dans un CSV
misclassified_path = "misclassified_examples.csv"
misclassified_df.to_csv(misclassified_path, index=False)
return misclassified_path # Retourner le chemin à consigner comme un artefact
with mlflow.start_run(run_name="Sentiment_Model_Evaluation_v2_Custom") as run:
mlflow.sklearn.log_model(pipeline, "sentiment_model")
mlflow.evaluate(
model=pipeline,
data=test_df,
targets="true_sentiment", # La colonne dans test_df qui contient les étiquettes réelles
model_type="text_classification",
evaluators=["default"],
extra_metrics=[
mlflow.models.EvaluationMetric(
name="f1_tech_support",
func=f1_score_tech_support,
greater_is_better=True,
# L'exemple d'entrée est optionnel mais aide MLflow à comprendre la signature de la fonction
input_example=pd.DataFrame({'targets': ['positive'], 'predictions': ['neutral'], 'category': ['technical_support']})
)
],
extra_artifacts=[
mlflow.models.EvaluationArtifact(
name="misclassified_samples",
func=log_misclassified_examples,
# exemple d'entrée similaire à ci-dessus
input_example=pd.DataFrame({'targets': ['positive'], 'predictions': ['neutral'], 'category': ['technical_support']})
)
]
)
print(f"ID d'exécution MLflow avec métriques personnalisées : {run.info.run_id}")
Dans cet exemple :
- `f1_score_tech_support` : Cette fonction prend le `eval_df` (que MLflow construit à partir de vos `data` et des prédictions du modèle, ajoutant les colonnes ‘targets’ et ‘predictions’) et calcule le score F1 uniquement pour les lignes où la `category` est ‘technical_support’.
- `log_misclassified_examples` : Cette fonction identifie les lignes mal classées, les enregistre dans un CSV et retourne le chemin. MLflow consigne ensuite ce CSV en tant qu’artefact.
Lorsque vous consultez cette exécution dans l’interface MLflow, vous verrez ‘f1_tech_support’ listé aux côtés de vos autres métriques, et vous trouverez ‘misclassified_samples.csv’ dans la section des artefacts. Cela rend les comparaisons entre les exécutions incroyablement simples. Je pouvais facilement voir si mon modèle affiné améliorait le F1 pour les retours de support technique par rapport à la référence, puis télécharger rapidement les exemples mal classés pour voir quel type d’erreurs se produisaient encore.
Ce que j’ai appris et pourquoi c’est important
Mon incursion dans les API d’évaluation de MLflow a été un changement significatif pour ce projet d’analyse de sentiment. Voici pourquoi je reste avec :
- Comparaison centralisée : Tous mes résultats d’évaluation – métriques standard, métriques personnalisées et graphiques – sont stockés au même endroit, liés directement à l’exécution du modèle. Fini les recherches à travers des dossiers ou des feuilles de calcul séparés.
- Reproductibilité : Parce que l’évaluation fait partie de l’exécution MLflow, elle est intrinsèquement liée au modèle, au code et aux données exacts utilisés. Cela facilite la reproduction des résultats et la compréhension des changements.
- La personnalisation est essentielle : La capacité d’injecter des métriques et des artefacts personnalisés signifie que je ne suis pas limité à des évaluations génériques. Je peux adapter l’évaluation aux besoins spécifiques de mon projet et de mon client. Cela a été crucial pour examiner la performance spécifique à une catégorie de produit.
- Amélioration de la collaboration : Lorsqu’on travaille en équipe, tout le monde peut voir les mêmes résultats d’évaluation dans l’interface MLflow. Cela facilite les discussions sur la performance du modèle et les améliorations potentielles. Mon client pouvait accéder directement à l’interface MLflow et voir la répartition par catégorie, ce qui a renforcé la confiance bien plus que d’envoyer des rapports statiques.
Une petite chose à noter : lorsque vous définissez des fonctions de métrique/artefact personnalisées, assurez-vous qu’elles sont autonomes et ne dépendent pas de variables globales en dehors de ce qui leur est passé (comme `eval_df`). Cela garantit qu’elles se comportent de manière prévisible dans le contexte de MLflow.
Conseils pratiques pour votre prochain projet d’IA
Si vous travaillez avec des modèles d’IA et recherchez un moyen plus structuré de les évaluer, je recommande vivement d’essayer les API d’évaluation de MLflow. Voici comment vous pouvez commencer :
- Commencez simplement : Commencez par intégrer `mlflow.evaluate()` avec l’évaluateur `default` pour votre `model_type`. Voyez quelles métriques et artefacts il génère automatiquement.
- Identifiez les métriques personnalisées clés : Réfléchissez à ce qui définit réellement le « succès » pour votre modèle spécifique dans votre cas d’utilisation particulier. Est-ce la performance sur une tranche de données particulière ? Un type d’erreur spécifique ? Créez des fonctions de métrique personnalisées pour celles-ci.
- Consignez des artefacts informatifs : Ne vous arrêtez pas aux métriques. Quels graphiques, dataframes (comme les exemples mal classés) ou rapports vous aideraient à mieux comprendre le comportement de votre modèle ? Consignez-les en tant qu’artefacts personnalisés.
- Explorez l’interface MLflow : Passez du temps dans l’interface MLflow à comparer les exécutions. Regardez les graphiques de métriques et les artefacts consignés. C’est là que la véritable valeur d’une évaluation organisée brille.
- Gardez vos données d’évaluation cohérentes : Assurez-vous que le jeu de données de test que vous utilisez pour l’évaluation est cohérent à travers différentes versions de modèles ou expériences. C’est fondamental pour des comparaisons significatives.
Aller au-delà de simples scores de précision et intégrer une évaluation approfondie directement dans votre workflow MLOps n’est pas qu’un simple luxe ; c’est essentiel pour construire des systèmes d’IA solides, équitables et véritablement utiles. Les API d’évaluation de MLflow offrent un cadre solide pour y parvenir.
C’est tout pour moi aujourd’hui ! J’espère que cette plongée approfondie vous aidera à rationaliser vos évaluations de modèles d’IA. Faites-moi savoir dans les commentaires si vous avez utilisé MLflow pour l’évaluation ou si vous avez d’autres frameworks que vous appréciez particulièrement !
🕒 Published: