Partager via

Convertir des modèles ML personnalisés en modèles mis au format MLflow

  • Article

Dans cet article, découvrez comment convertir votre modèle ML personnalisé au format MLflow. MLFlow est une bibliothèque open source permettant de gérer le cycle de vie de vos expériences Machine Learning. Dans certains cas, vous pouvez utiliser une infrastructure Machine Learning sans sa prise en charge intégrée des versions de modèle MLflow. En raison de ce manque de saveur de modèle MLflow intégrée, vous ne pouvez pas journaliser ou inscrire le modèle avec les API Fluent du modèle MLflow. Pour résoudre ce problème, vous pouvez convertir votre modèle en format MLflow, où vous pouvez tirer parti des avantages suivants des modèles Azure Machine Learning et MLflow.

Avec Azure Machine Learning, les modèles MLflow bénéficient des avantages supplémentaires suivants :

  • Déploiement sans code
  • Portabilité en tant que format standard open source
  • Possibilité de déployer à la fois localement et sur le cloud

MLflow offre une prise en charge de divers frameworks Machine Learning (scikit-learn, Keras, Pytorch, etc.) ; toutefois, il peut ne pas couvrir tous les cas d’usage. Par exemple, vous pouvez créer un modèle MLflow avec un framework que MLflow ne prend pas en charge en mode natif, ou vous pouvez modifier la façon dont votre modèle effectue le prétraitement ou le post-traitement lors de l’exécution de travaux. Pour en savoir plus sur les modèles MLflow, lisez Des artefacts aux modèles dans MLflow.

Si vous n’avez pas entraîné votre modèle avec MLFlow et que vous souhaitez utiliser l’offre de déploiement sans code MLflow d’Azure Machine Learning, vous devez convertir votre modèle personnalisé en MLFLow. En savoir plus sur les modèles Python personnalisés et MLflow.

Prérequis

Seul le package mlflow installé est nécessaire pour convertir vos modèles personnalisés en format MLflow.

Créer un wrapper Python pour votre modèle

Avant de pouvoir convertir votre modèle dans un format pris en charge par MLflow, vous devez d’abord créer un wrapper Python pour votre modèle. Le code suivant montre comment créer un wrapper Python pour un modèle sklearn.


# Load training and test datasets
from sys import version_info
import sklearn
import mlflow.pyfunc


PYTHON_VERSION = "{major}.{minor}.{micro}".format(major=version_info.major,
                                                  minor=version_info.minor,
                                                  micro=version_info.micro)

# Train and save an SKLearn model
sklearn_model_path = "model.pkl"

artifacts = {
    "sklearn_model": sklearn_model_path
}

# create wrapper
class SKLearnWrapper(mlflow.pyfunc.PythonModel):

    def load_context(self, context):
        import pickle
        self.sklearn_model = pickle.load(open(context.artifacts["sklearn_model"], 'rb'))
    
    def predict(self, model, data):
        return self.sklearn_model.predict(data)

Créer un environnements Conda

Ensuite, vous devez créer un environnement Conda pour le nouveau modèle MLflow qui contient toutes les dépendances nécessaires. S’il n’est pas indiqué, l’environnement est déduit de l’installation actuelle. Sinon, il peut être spécifié.


import cloudpickle
conda_env = {
    'channels': ['defaults'],
    'dependencies': [
      'python={}'.format(PYTHON_VERSION),
      'pip',
      {
        'pip': [
          'mlflow',
          'scikit-learn=={}'.format(sklearn.__version__),
          'cloudpickle=={}'.format(cloudpickle.__version__),
        ],
      },
    ],
    'name': 'sklearn_env'
}

Charger le modèle mis au format MLFlow et tester les prédictions

Une fois votre environnement prêt, vous pouvez passer le SKlearnWrapper, l’environnement Conda et le dictionnaire des artefacts nouvellement créés à la méthode mlflow.pyfunc.save_model(). Cela permet d’enregistrer le modèle sur votre disque.

mlflow_pyfunc_model_path = "sklearn_mlflow_pyfunc_custom"
mlflow.pyfunc.save_model(path=mlflow_pyfunc_model_path, python_model=SKLearnWrapper(), conda_env=conda_env, artifacts=artifacts)

Pour vous assurer que votre modèle mis au format MLflow nouvellement enregistré n’a pas changé pendant l’enregistrement, vous pouvez charger votre modèle et imprimer une prédiction de test pour comparer votre modèle d’origine.

Le code suivant imprime une prédiction de test à partir du modèle mis au format mlflow et une prédiction de test du modèle sklearn enregistré sur votre disque à des fins de comparaison.

loaded_model = mlflow.pyfunc.load_model(mlflow_pyfunc_model_path)

input_data = "<insert test data>"
# Evaluate the model
import pandas as pd
test_predictions = loaded_model.predict(input_data)
print(test_predictions)

# load the model from disk
import pickle
loaded_model = pickle.load(open(sklearn_model_path, 'rb'))
result = loaded_model.predict(input_data)
print(result)

Inscrire le modèle mis au format MLflow

Une fois que vous avez confirmé que votre modèle a été correctement enregistré, vous pouvez créer une série de tests, afin de pouvoir inscrire et enregistrer votre modèle mis au format MLflow dans votre registre de modèles.


mlflow.start_run()

mlflow.pyfunc.log_model(artifact_path=mlflow_pyfunc_model_path, 
                        loader_module=None, 
                        data_path=None, 
                        code_path=None,
                        python_model=SKLearnWrapper(),
                        registered_model_name="Custom_mlflow_model", 
                        conda_env=conda_env,
                        artifacts=artifacts)
mlflow.end_run()

Important

Dans certains cas, vous pouvez utiliser une infrastructure Machine Learning sans sa prise en charge intégrée des versions de modèle MLflow. Par exemple, la bibliothèque vaderSentiment est une bibliothèque de traitement en langage naturel (NLP) standard utilisée pour l’analyse des sentiments. En raison d’un manque de saveur de modèle MLflow intégrée, vous ne pouvez pas journaliser ou inscrire le modèle avec les API Fluent du modèle MLflow. Consultez un exemple sur l’enregistrement, la journalisation et l’inscription d’un modèle qui n’a pas de saveur de modèle MLflow intégrée prise en charge.

Étapes suivantes