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 simplement incroyable, non ?
Aujourd’hui, je veux parler de quelque chose qui me trotte dans la tête depuis un moment, surtout après quelques nuits tardives à m’attaquer à un projet 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. Maintenant, je sais ce que certains d’entre vous pensent – « MLflow ? N’est-ce pas pour MLOps et le suivi ? » Et oui, c’est tout à fait ça. Mais ils ont discrètement déployé des fonctionnalités d’évaluation vraiment intéressantes qui, à mon avis, méritent un examen plus approfondi, surtout quand on essaie d’aller au-delà d’un simple score d’exactitude.
Pour contexte, j’ai récemment terminé un projet client impliquant un modèle d’analyse de sentiment personnalisé pour les 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 de la manière dont le modèle performait de manière cohérente à travers différentes catégories de produits. Mon approche initiale, comme elle l’est souvent, était de concocter quelques scripts Python, de calculer quelques métriques et de les déverser dans un CSV. Vous savez comment ça se passe – `sklearn.metrics` pour l’exactitude, la précision, le rappel, le F1, peut-être un tracé de matrice de confusion avec Matplotlib. Cela fonctionne, c’est correct. Mais ensuite, le client a demandé une comparaison avec un modèle de référence, puis une autre itération, et soudainement, j’avais une douzaine de CSV et de graphiques, tous légèrement différents, et pas de moyen clair pour les comparer systématiquement.
C’est alors que je me suis souvenu avoir vu quelque chose sur les fonctionnalités d’évaluation élargies de MLflow. J’utilisais MLflow pour le suivi des expériences depuis des lustres, mais je ne m’étais pas vraiment plongé dans le côté évaluation. Et laissez-moi vous dire, c’était un peu comme un moment d’illumination. Au lieu de réinventer la roue pour chaque comparaison, je pouvais intégrer mon évaluation directement dans mes exécutions MLflow existantes, 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 du monde réel, un seul score d’exactitude ne raconte que très rarement toute l’histoire. Vous devez comprendre :
- Biais : Votre modèle performe-t-il de manière égale à travers différents groupes démographiques, catégories de produits ou types d’entrée ?
- Solidité : Comment gère-t-il les données bruitées ou de légères variations dans l’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 de sentiment a parfaitement mis cela en évidence. Une exactitude globale de 85 % avait fière allure sur le papier. Mais lorsque nous l’avons décomposée par catégorie de produit, nous avons découvert que le modèle peinait considérablement avec les retours liés à « l’assistance technique » – classant systématiquement des 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 bien plus gros casse-tête.
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, quelques 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 sont vos caractéristiques et étiquettes
# X_train, X_test, y_train, y_test = train_test_split(...)
# Un modèle bidon
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"Exactitude : {accuracy:.4f}")
print(f"Précision : {precision:.4f}")
print(f"Rappel : {recall:.4f}")
print(f"Score F1 : {f1:.4f}")
# Vous pourriez ensuite sauvegarder ces données 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 une seule exécution, mais imaginez faire cela pour 10 modèles différents, ou 5 versions différentes du même modèle, avec différents hyperparamètres. Vous vous retrouvez avec `model_metrics_v1.csv`, `model_metrics_v2_tuned.csv`, `model_metrics_baseline.csv`, et ainsi de suite. Cela devient rapidement ingérable.
Les APIs d’évaluation des modèles de MLflow : Un nouvel aperçu
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 une exécution d’évaluation qui stocke les métriques, les 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 à l’exécution de l’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écortiquons comment j’ai utilisé cela pour mon projet d’analyse de sentiment.
Exemple 1 : Intégration de l’évaluation de base
Tout d’abord, vous avez besoin de votre modèle et de certaines données de test. Pour mon modèle de sentiment, j’avais un objet `pipeline` (un pipeline scikit-learn avec un TfidfVectorizer et un classificateur LogisticRegression) et un `test_df` avec les 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 ayez vos données chargées
# Pour la démonstration, créons des données bidon
data = {
'text': [
"Le produit est incroyable, je l'adore !",
"Service terrible, réponse très lente.",
"C'est moyen, rien de spécial.",
"Meilleur achat de tous les temps, fortement recommandé.",
"Le support client était inutile et impoli.",
"Fonctionne comme prévu, assez standard.",
"Absolument ravi de cet appareil !",
"Cassé à l'arrivée, très déçu.",
"Qualité correcte pour le prix.",
"Une expérience tellement géniale !",
"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)
# Division des 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 (facultatif, mais bon usage)
mlflow.sklearn.log_model(pipeline, "sentiment_model")
# Effectuer une é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 des artefacts personnalisés ici
# extra_metrics=[mlflow.models.EvaluationMetric(...), ...],
# extra_artifacts=[mlflow.models.EvaluationArtifact(...), ...]
)
print(f"ID de l'exécution MLflow : {run.info.run_id}")
Lorsque vous exécutez cela, MLflow calcule automatiquement les métriques de classification standard (exactitude, précision, rappel, F1) et les enregistre. Il génère également un tracé de matrice de confusion, une courbe PR, et une courbe ROC, les stockant comme artefacts au sein de l’exécution. C’est déjà une énorme avancée par rapport à la génération et à la sauvegarde manuelles de ceux-ci !
Le hint `model_type=”text_classification”` est important car l’évaluateur `default` de MLflow saura alors quelles métriques et quels graphiques standard 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 plus approfondi
Le vrai pouvoir, pour moi, est venu lorsque j’ai besoin d’aller au-delà des métriques par défaut. Vous vous souvenez de la demande de mon client de voir les performances décomposées par catégorie de produit ? MLflow vous permet de définir des `extra_metrics` et des `extra_artifacts`. C’est ici que vous pouvez brancher vos évaluations spécifiques au domaine.
Pour mon modèle de sentiment, je voulais voir le score F1 spécifiquement pour les retours liés à « l’assistance technique ». Je voulais également enregistrer un DataFrame montrant des exemples mal classés pour passer en revue facilement 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 la simplicité, nous allons juste ajouter une colonne 'category' à 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 les 'cibles' (étiquettes vraies) et les 'prédictions'
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']]
# Enregistrez les exemples mal classés dans un CSV
misclassified_path = "misclassified_examples.csv"
misclassified_df.to_csv(misclassified_path, index=False)
return misclassified_path # Retournez le chemin à enregistrer 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 vraies
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' 'input_example' est facultatif 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,
# input_example similaire à ci-dessus
input_example=pd.DataFrame({'targets': ['positive'], 'predictions': ['neutral'], 'category': ['technical_support']})
)
]
)
print(f"ID d'exécution MLflow avec des 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 enregistre ensuite ce CSV comme un artefact.
Lorsque vous visualisez cette exécution dans l’interface MLflow, vous verrez ‘f1_tech_support’ listé à côté de vos autres métriques, et vous trouverez ‘misclassified_samples.csv’ sous la section des artefacts. Cela rend les comparaisons entre exécutions incroyablement simples. Je pourrais facilement voir si mon modèle affiné a amélioré le F1 pour les retours de soutien technique par rapport à la ligne de base, puis rapidement télécharger 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 APIs d’évaluation de MLflow a été un changement significatif pour ce projet d’analyse de sentiment. Voici pourquoi je reste avec cela :
- Comparaison Centralisée : Tous mes résultats d’évaluation – métriques standard, métriques personnalisées et graphiques – sont stockés en un seul endroit, liés directement à l’exécution du modèle. Fini de chercher dans des dossiers ou des tableurs séparés.
- Reproductibilité : Étant donné que l’évaluation fait partie de l’exécution MLflow, elle est intrinsèquement liée au modèle exact, au code et aux données utilisés. Cela rend la reproduction des résultats et la compréhension des changements beaucoup plus faciles.
- La Personnalisation est Clé : La capacité d’injecter des métriques et 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 par catégorie de produit.
- Collaboration Améliorée : Lorsqu’on travaille en équipe, tout le monde peut voir les mêmes résultats d’évaluation dans l’interface MLflow. Cela rationalise 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 suscité beaucoup plus de confiance que de simplement envoyer des rapports statiques.
Une petite chose à noter : Lorsque vous définissez des fonctions de métriques/artefacts personnalisés, 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 MLflow.
Actions Concrètes pour Votre Prochain Projet AI
Si vous travaillez avec des modèles AI et recherchez un moyen plus structuré de les évaluer, je vous recommande vivement d’essayer les APIs d’évaluation de MLflow. Voici comment vous pouvez commencer :
- Commencez Simple : 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 : Pensez à ce qui définit réellement le “succès” pour votre modèle spécifique dans votre cas d’utilisation spécifique. Est-ce la performance sur un extrait de données particulier ? Un type d’erreur spécifique ? Créez des fonctions de métriques personnalisées pour cela.
- Enregistrez des Artefacts Informatiques : 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 ? Enregistrez-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 enregistrés. C’est là que la vraie 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 entre différentes versions ou expériences de modèles. C’est fondamental pour des comparaisons significatives.
Aller au-delà des scores de précision de base et intégrer une évaluation approfondie directement dans votre workflow MLOps n’est pas qu’un simple ajout ; c’est essentiel pour construire des systèmes AI solides, équitables et véritablement utiles. Les APIs d’évaluation de MLflow fournissent un cadre solide pour cela.
C’est tout pour moi aujourd’hui ! J’espère que cette plongée approfondie vous aidera à rationaliser vos évaluations de modèles AI. Faites-moi savoir dans les commentaires si vous avez utilisé MLflow pour l’évaluation ou si vous avez d’autres cadres que vous privilégiez !
🕒 Published: