Partager via

Enregistrer, charger, inscrire et déployer des modèles MLflow

  • Article

Un modèle MLflow est un format standard pour l’empaquetage de modèles Machine Learning qui peuvent être utilisés dans divers outils en aval, par exemple l’inférence par lots sur Apache Spark ou la mise en service en temps réel via une API REST. Le format définit une convention qui vous permet d’enregistrer un modèle dans différentes saveurs (python-function, pytorch, sklearn, etc.), qui peuvent être comprises par différentes plateformes d’inférence et de mise en service de modèle.

Journaliser et charger des modèles

Lorsque vous journalisez un modèle, MLflow journalise automatiquement des fichiers requirements.txt et conda.yaml. Vous pouvez utiliser ces fichiers pour recréer l’environnement de développement de modèle et réinstaller les dépendances en utilisant virtualenv (recommandé) ou conda.

Important

Anaconda Inc. a mis à jour ses conditions d’utilisation du service pour les canaux anaconda.org. Les nouvelles conditions d’utilisation du service peuvent vous imposer d’avoir une licence commerciale pour utiliser une distribution et des packages Anaconda. Pour plus d’informations, consultez le Forum aux questions sur l’édition commerciale d’Anaconda. Votre utilisation des canaux Anaconda est régie par leurs conditions d’utilisation du service.

Les modèles MLflow enregistrés avant la version 1.18 (Databricks Runtime 8.3 ML ou version antérieure) étaient enregistrés par défaut avec le canal conda defaults (https://repo.anaconda.com/pkgs/) en tant que dépendance. En raison de cette modification de licence, Databricks a arrêté l’utilisation du canal defaults pour les modèles enregistrés à l’aide de MLflow v1.18 et versions ultérieures. Le canal par défaut journalisé est maintenant conda-forge, qui pointe vers https://conda-forge.org/, géré par la communauté.

Si vous avez enregistré un modèle avant MLflow v1.18 sans exclure le canal defaults de l’environnement conda pour le modèle, ce modèle peut avoir une dépendance sur le canal defaults que vous n’avez peut-être pas prévue. Pour vérifier manuellement si un modèle a cette dépendance, vous pouvez examiner la valeur channel dans le fichier conda.yaml empaqueté avec le modèle journalisé. Par exemple, les modèles conda.yaml avec une dépendance de canal defaults peuvent ressembler à ceci :

channels:
- defaults
dependencies:
- python=3.8.8
- pip
- pip:
    - mlflow
    - scikit-learn==0.23.2
    - cloudpickle==1.6.0
      name: mlflow-env

Étant donné que Databricks ne peut pas déterminer si votre utilisation du référentiel Anaconda pour interagir avec vos modèles est autorisée dans votre relation avec Anaconda, Databricks n’oblige pas ses clients à apporter des modifications. Si votre utilisation du référentiel Anaconda.com par le biais de l’utilisation de Databricks est autorisée selon les conditions d’Anaconda, vous n’avez pas besoin d’effectuer d’action.

Si vous souhaitez modifier le canal utilisé dans l’environnement d’un modèle, vous pouvez réinscrire le modèle dans le registre de modèles avec un nouveau conda.yaml. Pour ce faire, spécifiez le canal dans le paramètre conda_env de log_model().

Pour plus d’informations sur l’API log_model(), consultez la documentation MLflow pour la version de modèle que vous utilisez, par exemple, log_model pour scikit-learn.

Pour plus d’informations sur les fichiers conda.yaml, consultez la documentation MLflow.

Commandes d’API

Pour journaliser un modèle sur le serveur de suivi MLflow, utilisez mlflow.<model-type>.log_model(model, ...).

Pour charger un modèle journalisé en vue d’une inférence ou d’un développement supplémentaire, utilisez mlflow.<model-type>.load_model(modelpath) , où modelpath est l’un des éléments suivants :

  • Un chemin relatif à l’exécution (par exemple, runs:/{run_id}/{model-path})
  • Un chemin DBFS
  • Un chemin de modèle inscrit (tel que models:/{model_name}/{model_stage}).

Pour obtenir la liste complète des options de chargement des modèles MLflow, consultez Référencement d’artefacts dans la documentation MLflow.

Pour les modèles Python MLflow, une autre option consiste à utiliser mlflow.pyfunc.load_model() pour charger le modèle en tant que fonction Python générique. Vous pouvez utiliser l’extrait de code suivant pour charger le modèle et noter les points de données.

model = mlflow.pyfunc.load_model(model_path)
model.predict(model_input)

Vous pouvez également exporter le modèle en tant que fonction définie par l’utilisateur Apache Spark à utiliser pour le scoring sur un cluster Spark, sous forme de programme de traitement par lots ou de travail de streaming Spark en temps réel.

# load input data table as a Spark DataFrame
input_data = spark.table(input_table_name)
model_udf = mlflow.pyfunc.spark_udf(spark, model_path)
df = input_data.withColumn("prediction", model_udf())

Enregistrer les dépendances du modèle

Pour charger avec précision un modèle, vous devez vérifier que les dépendances du modèle sont chargées avec les versions appropriées dans l’environnement de notebook. Dans Databricks Runtime 10.5 ML et ultérieur, MLflow vous avertit en cas d’incompatibilité entre l’environnement actuel et les dépendances du modèle.

Des fonctionnalités supplémentaires pour simplifier la restauration des dépendances de modèle sont incluses dans Databricks Runtime 11.0 ML et versions ultérieures. Dans Databricks Runtime 11.0 ML et versions ultérieures, pour les modèles de saveur pyfunc, vous pouvez appeler mlflow.pyfunc.get_model_dependencies pour récupérer et télécharger les dépendances de modèle. Cette fonction retourne un chemin au fichier de dépendances que vous pouvez ensuite installer avec %pip install <file-path>. Quand vous chargez un modèle en tant qu’UDF PySpark, spécifiez env_manager="virtualenv" dans l’appel mlflow.pyfunc.spark_udf. Cela restaure les dépendances du modèle dans le contexte de l’UDF PySpark et n’affecte pas l’environnement extérieur.

Vous pouvez également utiliser cette fonctionnalité dans Databricks Runtime 10.5 ou version inférieure en installant manuellement MLflow version 1.25.0 ou version ultérieure :

%pip install "mlflow>=1.25.0"

Si vous souhaitez obtenir plus d’informations sur la journalisation des dépendances de modèle (Python et non-Python) et des artefacts, consultez Dépendances de modèle de journal.

Découvrez comment journaliser des dépendances de modèle et des artefacts personnalisés pour un service de modèle :

Extraits de code générés automatiquement dans l’interface utilisateur MLflow

Quand vous journalisez un modèle dans un notebook Azure Databricks, Azure Databricks génère automatiquement des extraits de code que vous pouvez copier et utiliser pour charger et exécuter le modèle. Pour afficher ces extraits de code :

  1. Accédez à l’écran Exécutions pour l’exécution qui a généré le modèle. (Consultez Afficher l’expérience du notebook pour savoir comment afficher l’écran Exécutions.)
  2. Faites défiler jusqu’à la section Artefacts.
  3. Cliquez sur le nom du modèle journalisé. Un panneau s’ouvre à droite avec le code que vous pouvez utiliser pour charger le modèle journalisé et effectuer des prédictions sur les DataFrames Spark ou pandas.

Extraits de code du volet d’artefact

Exemples

Pour obtenir des exemples de journalisation de modèles, consultez les exemples fournis dans Exemples de suivi d’exécutions d’entraînement de Machine Learning. Pour obtenir un exemple de chargement d’un modèle journalisé à des fins d’inférence, consultez l’exemple d’inférence de modèle.

Inscrire des modèles dans le registre des modèles

Vous pouvez inscrire des modèles dans le registre des modèles MLflow, magasin de modèles centralisé qui fournit une interface utilisateur et un ensemble d’API permettant de gérer le cycle de vie complet des modèles MLflow. Pour savoir comment utiliser le Registre des modèles afin de gérer les modèles dans Unity Catalog de Databricks, consultez Gérer le cycle de vie des modèles dans Unity Catalog. Pour utiliser le registre de modèles d’espace de travail, consultez Gérer le cycle de vie du modèle avec le registre de modèles d’espace de travail (hérité).

Pour inscrire un modèle à l’aide de l’API, utilisez mlflow.register_model("runs:/{run_id}/{model-path}", "{registered-model-name}").

Enregistrer les modèles dans DBFS

Pour enregistrer un modèle localement, utilisez mlflow.<model-type>.save_model(model, modelpath). modelpath doit être un chemin DBFS. Par exemple, si vous utilisez un emplacement DBFS dbfs:/my_project_models pour stocker votre travail de projet, vous devez utiliser le chemin de modèle /dbfs/my_project_models :

modelpath = "/dbfs/my_project_models/model-%f-%f" % (alpha, l1_ratio)
mlflow.sklearn.save_model(lr, modelpath)

Pour les modèles MLlib, utilisez les pipelines ML.

Télécharger les artefacts de modèle

Vous pouvez télécharger les artefacts de modèle journalisé (tels que les fichiers de modèle, les tracés et les métriques) pour un modèle inscrit avec différentes API.

Exemple d’API Python :

from mlflow.store.artifact.models_artifact_repo import ModelsArtifactRepository

model_uri = MlflowClient.get_model_version_download_uri(model_name, model_version)
ModelsArtifactRepository(model_uri).download_artifacts(artifact_path="")

Exemple d’API Java :

MlflowClient mlflowClient = new MlflowClient();
// Get the model URI for a registered model version.
String modelURI = mlflowClient.getModelVersionDownloadUri(modelName, modelVersion);

// Or download the model artifacts directly.
File modelFile = mlflowClient.downloadModelVersion(modelName, modelVersion);

Exemple de commande CLI :

mlflow artifacts download --artifact-uri models:/<name>/<version|stage>

Déployer des modèles pour la mise en service en ligne

Vous pouvez utiliser le Service de modèle pour héberger des modèles Machine Learning à partir du registre des modèles en tant que points de terminaison REST. Ces points de terminaison sont mis à jour automatiquement en fonction de la disponibilité des versions de modèle et de leurs phases.

Vous pouvez aussi déployer un modèle sur des frameworks de service de tiers en utilisant les outils de déploiement intégrés de MLflow. Consultez l’exemple qui suit.