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

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 appliquer les 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 fournit la prise en charge de plusieurs infrastructures de machine learning, telles que scikit-learn, Keras et Pytorch. MLflow peut ne pas couvrir chaque cas d’utilisation. Par exemple, vous pouvez créer un modèle MLflow avec une infrastructure que MLflow ne prend pas en charge en mode natif. Vous pouvez modifier la façon dont votre modèle effectue un prétraitement ou un post-traitement lors de l’exécution de travaux. Pour en savoir plus sur les modèles MLflow, consultez 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. Pour plus d’informations, consultez Modèles Python personnalisés.

Prérequis

• Installez le package 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 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, créez 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, passez le SKlearnWrapper, l’environnement Conda et votre dictionnaire d’artefacts nouvellement créé à 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, chargez 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. Il enregistre les prédictions de test 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

Après avoir vérifié que votre modèle a été enregistré correctement, vous pouvez créer une exécution de test. Inscrivez et enregistrez votre modèle 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()

Contenu connexe

• Déployer des modèles MLflow sur des points de terminaison en ligne
• MLflow et Azure Machine Learning