Partager via

Journaliser les modèles MLflow

Cet article décrit comment enregistrer vos modèles de formation automatique formés, ou artefacts, en tant que modèles MLflow. MLflow est une infrastructure open source pour la gestion des flux de travail Machine Learning. Cet article explore différentes options pour personnaliser la façon dont les modèles sont emballés et exécutés par MLflow.

Conditions préalables

  • Le paquet SDK MLflow mlflow

Pourquoi utiliser des modèles mathématiques au lieu d’artefacts ?

Un modèle MLflow est un type d’artefact. Toutefois, un modèle a une structure spécifique qui sert de contrat entre la personne qui crée le modèle et la personne qui a l’intention de l’utiliser. Ce contrat permet de créer un pont entre les artefacts eux-mêmes et leurs significations.

Pour connaître la différence entre les artefacts de journalisation ou les fichiers et la journalisation des modèles MLflow, consultez Artefacts et modèles dans MLflow.

Vous pouvez consigner les fichiers de votre modèle en tant qu’artefacts, mais la journalisation des modèles offre les avantages suivants :

  • Vous pouvez utiliser mlflow.<flavor>.load_model pour charger directement des modèles pour l’inférence, et vous pouvez utiliser la predict fonction.
  • Les entrées de pipeline peuvent utiliser directement des modèles.
  • Vous pouvez déployer des modèles sans spécifier de script de scoring ou d’environnement.
  • Swagger est automatiquement activé dans les points de terminaison déployés. Par conséquent, vous pouvez utiliser la fonctionnalité de test dans Azure Machine Learning Studio pour tester des modèles.
  • Vous pouvez utiliser le tableau de bord IA responsable. Pour plus d’informations, consultez Utiliser le tableau de bord Ia responsable dans Azure Machine Learning Studio.

Utiliser la journalisation automatique pour journaliser les modèles

Vous pouvez utiliser la fonctionnalité MLflow autolog pour journaliser automatiquement les modèles. Lorsque vous utilisez la journalisation automatique, MLflow capture toutes les métriques, paramètres, artefacts et modèles pertinents dans votre infrastructure. Les données enregistrées dépendent de la structure. Par défaut, si la journalisation automatique est activée, la plupart des modèles sont enregistrés. Dans certaines situations, certaines versions n'enregistrent pas les modèles. Par exemple, la saveur PySpark ne journalise pas les modèles qui dépassent une certaine taille.

Utilisez soit mlflow.autolog soit mlflow.<flavor>.autolog pour activer la journalisation automatique. Le code suivant utilise autolog pour journaliser un modèle classifieur formé avec XGBoost :

import mlflow
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score

mlflow.autolog()

model = XGBClassifier(use_label_encoder=False, eval_metric="logloss")
model.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)

y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

Conseil

Si vous utilisez des pipelines d'apprentissage automatique, par exemple des pipelines scikit-learn, utilisez les fonctionnalités de cette version de pipeline pour enregistrer les modèles. La journalisation des modèles est exécutée automatiquement lorsque la fit méthode est appelée sur l’objet de pipeline. Pour un notebook qui journalise un modèle, inclut le prétraitement et utilise des pipelines, consultez Formation et suivi d’un classifieur XGBoost avec MLflow.

Modèles de journal qui utilisent une signature, un environnement ou des exemples personnalisés

Vous pouvez utiliser la méthode MLflow mlflow.<flavor>.log_model pour journaliser manuellement les modèles. Ce flux de travail offre un contrôle sur différents aspects de la journalisation des modèles.

Utilisez cette méthode dans les cas suivants :

  • Vous souhaitez indiquer un environnement Conda ou des packages pip qui diffèrent des packages ou de l’environnement détectés automatiquement.
  • Vous souhaitez inclure des exemples d’entrée.
  • Vous souhaitez inclure des artefacts spécifiques dans le package dont vous avez besoin.
  • La autolog méthode ne déduit pas correctement votre signature. Ce cas se produit lorsque vous travaillez avec des entrées de tenseur, ce qui nécessite que la signature ait une forme spécifique.
  • La autolog méthode ne répond pas à tous vos besoins.

Le code suivant enregistre un modèle de classificateur XGBoost :

import mlflow
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score
from mlflow.models import infer_signature
from mlflow.utils.environment import _mlflow_conda_env

mlflow.autolog(log_models=False)

model = XGBClassifier(use_label_encoder=False, eval_metric="logloss")
model.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)
y_pred = model.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)

# Infer the signature.
signature = infer_signature(X_test, y_test)

# Set up a Conda environment.
custom_env =_mlflow_conda_env(
    additional_conda_deps=None,
    additional_pip_deps=["xgboost==1.5.2"],
    additional_conda_channels=None,
)

# Sample the data.
input_example = X_train.sample(n=1)

# Log the model manually.
mlflow.xgboost.log_model(model, 
                         artifact_path="classifier", 
                         conda_env=custom_env,
                         signature=signature,
                         input_example=input_example)

Remarque

  • L'appel à autolog utilise une configuration de log_models=False. Ce paramètre désactive la journalisation automatique du modèle MLflow. La log_model méthode est utilisée ultérieurement pour journaliser manuellement le modèle.
  • La infer_signature méthode est utilisée pour essayer de déduire la signature directement à partir d’entrées et de sorties.
  • La méthode mlflow.utils.environment._mlflow_conda_env est une méthode privée dans le (SDK) MLflow. Dans cet exemple, il simplifie le code. Mais utilisez cette méthode avec prudence, car elle peut changer à l’avenir. En guise d’alternative, vous pouvez générer manuellement la définition YAML en tant que dictionnaire Python.

Modèles de journaux qui utilisent un comportement de prédiction modifié

Lorsque vous utilisez mlflow.autolog ou mlflow.<flavor>.log_model pour journaliser un modèle, le type de modèle détermine la manière dont l'inférence est réalisée. La saveur détermine également ce que le modèle renvoie. MLflow n’applique pas de comportement spécifique sur la génération de predict résultats. Dans certains scénarios, vous souhaiterez peut-être prétraiter ou post-traiter vos données.

Dans ce cas, vous pouvez implémenter des pipelines Machine Learning qui passent directement des entrées aux sorties. Bien que ce type d’implémentation puisse parfois améliorer les performances, il peut être difficile d’atteindre. Dans ce cas, il peut être utile de personnaliser la façon dont votre modèle gère l’inférence. Pour plus d’informations, consultez la section suivante, Log custom models.

Journaliser des modèles personnalisés

MLflow prend en charge de nombreuses infrastructures de Machine Learning, notamment les versions suivantes :

  • CatBoost
  • FastAI
  • H₂O
  • Keras
  • LightGBM
  • MLeap
  • ONNX
  • Prophète
  • PyTorch
  • scikit-learn
  • spaCy
  • Spark MLlib
  • statsmodels, une bibliothèque Python pour la modélisation statistique
  • TensorFlow
  • XGBoost

Pour une liste complète, voir Saveurs de modèles intégrés.

Toutefois, vous devrez peut-être modifier la façon dont une saveur fonctionne ou enregistrer un modèle que MLflow ne prend pas en charge de manière native. Vous devrez peut-être enregistrer un modèle qui utilise plusieurs éléments de divers frameworks. Dans ces cas, vous pouvez créer une variante de modèle personnalisée.

Pour résoudre le problème, MLflow offre la saveur PyFunc, une interface de modèle par défaut pour les modèles Python. Cette saveur peut consigner n’importe quel objet en tant que modèle tant que cet objet satisfait à deux conditions :

  • Vous implémentez au moins la predict méthode.
  • L’objet Python hérite de la mlflow.pyfunc.PythonModel classe.

Conseil

Les modèles sérialisables qui implémentent l’API scikit-learn peuvent utiliser la saveur scikit-learn pour journaliser le modèle, que le modèle ait été créé avec scikit-learn. Si vous pouvez conserver votre modèle au format Pickle et que l’objet possède au moins les méthodes predict et predict_proba, vous pouvez utiliser mlflow.sklearn.log_model pour enregistrer le modèle dans une exécution MLflow.

Le moyen le plus simple de créer une saveur pour votre modèle personnalisé consiste à créer un wrapper autour de votre objet de modèle existant. MLflow sérialise et empaquette votre modèle pour vous. Les objets Python sont sérialisables lorsque l’objet peut être stocké dans le système de fichiers en tant que fichier généralement au format Pickle. Au moment de l’exécution, l’objet peut être chargé à partir de ce fichier. Le chargement restaure toutes les valeurs, propriétés et méthodes qui sont disponibles au moment de l'enregistrement.

Utilisez cette méthode dans les cas suivants :

  • Vous pouvez sérialiser votre modèle au format Pickle.
  • Vous souhaitez conserver l’état du modèle juste après la formation.
  • Vous souhaitez personnaliser le fonctionnement de la fonction predict.

Le code suivant encapsule un modèle créé avec XGBoost afin qu’il se comporte différemment de l’implémentation par défaut de la saveur XGBoost. Elle retourne des probabilités au lieu de classes.

from mlflow.pyfunc import PythonModel, PythonModelContext

class ModelWrapper(PythonModel):
    def __init__(self, model):
        self._model = model

    def predict(self, context: PythonModelContext, data):
        # The next line uses a prediction function. However, you could also use model.recommend(), model.forecast(), or a similar function instead.
        return self._model.predict_proba(data)

    # You can add extra functions if you need to. Because the model is serialized,
    # all of them are available when you load your model.
    def predict_batch(self, data):
        pass

Utilisez le code suivant pour enregistrer un modèle personnalisé pendant une exécution :

import mlflow
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score
from mlflow.models import infer_signature

mlflow.xgboost.autolog(log_models=False)

model = XGBClassifier(use_label_encoder=False, eval_metric="logloss")
model.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)
y_probs = model.predict_proba(X_test)

accuracy = accuracy_score(y_test, y_probs.argmax(axis=1))
mlflow.log_metric("accuracy", accuracy)

signature = infer_signature(X_test, y_probs)
mlflow.pyfunc.log_model("classifier", 
                        python_model=ModelWrapper(model),
                        signature=signature)

Conseil

Dans le code précédent, la infer_signature méthode utilise y_probs pour déduire la signature. La colonne cible contient la classe cible, mais le modèle retourne deux probabilités pour chaque classe.

Étape suivante