Conversión de modelos de ML personalizados en modelos con formato MLflow

  • Artículo

En este artículo, aprenderá a convertir el modelo de ML personalizado en formato MLflow. MLflow es una biblioteca de código abierto para administrar el ciclo de vida de los experimentos de aprendizaje automático. En algunos casos, puede usar un marco de aprendizaje automático sin su compatibilidad integrada con el tipo de modelo de MLflow. Debido a esta falta del tipo integrado de modelo de MLflow, no puede registrar ni inscribir el modelo en las API fluidas del modelo de MLflow. Para resolverlo, puede convertir el modelo en un formato MLflow, donde puede aprovechar las siguientes ventajas de los modelos de Azure Machine Learning y MLflow.

Con Azure Machine Learning, los modelos de MLflow obtienen las ventajas adicionales siguientes:

  • Implementación sin programación
  • Portabilidad como formato estándar de código abierto
  • Capacidad de implementación tanto local como en la nube

MLflow proporciona compatibilidad con una variedad de marcos de aprendizaje automático (scikit-learn, Keras, Pytorch, etc.); sin embargo, es posible que no cubra todos los casos de uso. Por ejemplo, puede que quiera crear un modelo de MLflow con un marco que MLflow no admita de forma nativa, o puede que quiera cambiar la forma en que el modelo se encarga del procesamiento previo o posterior cuando se ejecutan trabajos. Para más información sobre los modelos de MLflow, lea De artefactos a modelos en MLflow.

Si no ha entrenado el modelo con MLflow y quiere usar la oferta de implementación sin código de MLflow de Azure Machine Learning, tiene que convertir el modelo personalizado en MLflow. Obtenga más información sobre los modelos personalizados de Python y MLflow.

Prerrequisitos

Solo se necesita el paquete de MLflow instalado para convertir los modelos personalizados en un formato MLflow.

Creación de un contenedor de Python para el modelo

Para poder convertir el modelo en un formato compatible con MLflow, primero tiene que crear un contenedor de Python para el modelo. En el código siguiente se muestra cómo crear un contenedor de Python para un modelo de 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)

Creación de un entorno de Conda

A continuación, tiene que crear un entorno de Conda para el nuevo modelo de MLflow, que contenga todas las dependencias necesarias. Si no se indica, el entorno se deduce de la instalación actual. En caso contrario, se puede especificar.


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'
}

Carga del modelo con formato MLflow y las predicciones de prueba

Una vez que el entorno esté listo, puede pasar el SKlearnWrapper, el entorno de Conda y el diccionario de artefactos recién creado al método mlflow.pyfunc.save_model(). Al hacerlo, el modelo se guarda en el disco.

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)

Para asegurarse de que el modelo con formato MLflow recién guardado no cambió durante el guardado, puede cargar el modelo e imprimir una predicción de prueba para comparar con el modelo original.

El código siguiente imprime una predicción de prueba del modelo con formato MLflow y una predicción de prueba del modelo de sklearn que se guarda en el disco para la comparación.

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)

Registro del modelo con formato MLflow

Una vez que haya confirmado que el modelo se guardó correctamente, puede crear una ejecución de prueba, de modo que pueda registrar y guardar el modelo con formato MLflow en el registro de modelos.


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()

Importante

En algunos casos, puede usar un marco de aprendizaje automático sin su compatibilidad integrada con el tipo de modelo de MLflow. Por ejemplo, la biblioteca vaderSentiment es una biblioteca estándar de procesamiento de lenguaje natural (NLP) que se usa para el análisis de sentimiento. Dado que le falta el tipo integrado de modelo de MLflow, no puede registrar ni inscribir el modelo en las API fluidas del modelo de MLflow. Vea un ejemplo de cómo guardar, registrar e inscribir un modelo que no tiene integrado un tipo de modelo de MLflow compatible.

Pasos siguientes