Administración del registro de modelos en Azure Machine Learning con MLflow

Azure Machine Learning admite MLflow para la administración de modelos cuando está conectado a un área de trabajo. Este enfoque es una manera cómoda de admitir todo el ciclo de vida del modelo para los usuarios familiarizados con el cliente de MLFlow.

En este artículo se describen las funcionalidades para administrar un registro de modelos con MLflow y cómo este método se compara con otras opciones de administración.

Requisitos previos

• Instale el paquete mlflow del SDK de MLflow y el complemento azureml-mlflow de Azure Machine Learning para MLflow:

  pip install mlflow azureml-mlflow
  

  Sugerencia

  Puede usar el paquete de mlflow-skinny, que es un paquete MLflow ligero sin dependencias de ciencia de datos, interfaz de usuario, servidor o almacenamiento de SQL. mlflow-skinny se recomienda para los usuarios que necesitan principalmente las funcionalidades de seguimiento y registro de MLflow sin importar el conjunto completo de características, incluidas las implementaciones.

• Un área de trabajo de Azure Machine Learning. Para crear un área de trabajo, consulte el tutorial Creación de recursos de aprendizaje automático. Revise los permisos de acceso que necesita para realizar las operaciones de MLflow en el área de trabajo.

• Si realiza el seguimiento remoto (es decir, realiza un seguimiento de los experimentos que se ejecutan fuera de Azure Machine Learning), configure MLflow para que apunte al URI de seguimiento del área de trabajo de Azure Machine Learning. Para más información sobre cómo conectar MLflow al área de trabajo, consulte Configuración de MLflow para Azure Machine Learning.

• Los procedimientos de este artículo usan un objeto client para hacer referencia al cliente de MLflow.

  Algunas operaciones se pueden ejecutar directamente mediante la API fluida de MLflow, mlflow.<method>. Otras operaciones requieren un cliente de MLflow para habilitar la comunicación con Machine Learning en el protocolo MLflow. El código siguiente crea un objeto MlflowClient:

  import mlflow
  
  client = mlflow.tracking.MlflowClient()
  

Limitaciones

• Azure Machine Learning no admite el cambio de nombre de los modelos.

• Machine Learning no permite eliminar todo el contenedor del modelo.

• Los registros organizativos no se admiten para la administración de modelos con MLflow.

• La implementación de modelos desde una fase de modelo específica no se admite actualmente en Machine Learning.

• Actualmente no se admiten operaciones entre áreas de trabajo en Machine Learning.

Registro de nuevos modelos

El registro de modelos ofrece una manera cómoda y centralizada de administrar modelos en un área de trabajo. Cada área de trabajo tiene su propio registro de modelos independientes. En las secciones siguientes se muestran dos maneras de registrar modelos en el Registro mediante el SDK de MLflow.

Creación de modelos a partir de una ejecución existente

Si tiene un modelo de MLflow registrado dentro de una ejecución y desea registrarlo en un registro, use el identificador de ejecución y la ruta de acceso donde se registra el modelo. Puede consultar esta información siguiendo las instrucciones de Administración de experimentos y ejecuciones con MLflow.

mlflow.register_model(f"runs:/{run_id}/{artifact_path}", model_name)

Creación de modelos a partir de recursos

Si tiene una carpeta con una MLModel modelo de MLflow, puede registrarla directamente. El modelo no tiene por qué estar siempre en el contexto de una ejecución. Para este enfoque, puede usar el esquema de URI file://path/to/model para registrar modelos de MLflow almacenados en el sistema de archivos local.

El código siguiente crea un modelo sencillo mediante el paquete scikit-learn y guarda el modelo en formato MLflow en el almacenamiento local:

from sklearn import linear_model

reg = linear_model.LinearRegression()
reg.fit([[0, 0], [1, 1], [2, 2]], [0, 1, 2])

mlflow.sklearn.save_model(reg, "./regressor")

El código siguiente registra el modelo mediante la ruta de acceso local:

import os

model_local_path = os.path.abspath("./regressor")
mlflow.register_model(f"file://{model_local_path}", "local-model-test")

Registros de modelos de consulta

Puede usar el SDK de MLflow para consultar y buscar modelos registrados en el registro. En las secciones siguientes se muestran dos maneras de consultar un modelo.

Consulta de todos los modelos en el Registro

Puede consultar todos los modelos registrados en el Registro mediante el cliente de MLflow.

El código siguiente imprime los nombres de todos los modelos del Registro:

for model in client.search_registered_models():
    print(f"{model.name}")

Use el método order_by para organizar la salida por una propiedad específica, como name, version, creation_timestamp, o last_updated_timestamp:

client.search_registered_models(order_by=["name ASC"])

Obtención de versiones de modelos específicas

El método search_registered_models() recupera el objeto de modelo, que contiene todas las versiones del modelo. Para obtener la última versión del modelo registrado para un modelo determinado, puede usar el método get_registered_model():

client.get_registered_model(model_name)

Para obtener una versión específica de un modelo, use el código siguiente:

client.get_model_version(model_name, version=2)

Carga de modelos desde el registro

Puede cargar modelos directamente desde el Registro para restaurar objetos de modelos registrados. Para esta tarea, use las funciones mlflow.<flavor>.load_model() o mlflow.pyfunc.load_model() indique el URI del modelo que se va a cargar.

Puede implementar estas funciones con la sintaxis siguiente:

• models:/<model-name>/latest: cargue la última versión del modelo.
• models:/<model-name>/<version-number>: cargue una versión específica del modelo.
• models:/<model-name>/<stage-name>: cargue una versión específica en una fase determinada para un modelo. Para obtener más información, consulte Trabajar con fases de modelo.

Para comprender las diferencias entre las funciones mlflow.<flavor>.load_model() y mlflow.pyfunc.load_model(), consulte Flujos de trabajo para cargar modelos de MLflow.

Trabajar con fases del modelo

MLflow admite fases de un modelo para administrar el ciclo de vida del modelo. La versión del modelo puede pasar de una fase a otra. Las fases se asignan a versiones específicas de un modelo. Un modelo puede tener varias versiones en distintas fases.

Fases del modelo de consulta

El código siguiente usa el cliente de MLflow para comprobar todas las fases posibles de un modelo:

client.get_model_version_stages(model_name, version="latest")

Puede ver las versiones del modelo para cada fase del modelo recuperando el modelo del registro. El código siguiente obtiene la versión del modelo que se encuentra actualmente en la fase de Staging:

client.get_latest_versions(model_name, stages=["Staging"])

Varias versiones del modelo pueden estar en la misma fase al mismo tiempo en MLflow. En el ejemplo anterior, el método devuelve la versión más reciente (más reciente) entre todas las versiones de la fase.

Versión del modelo de transición

La transición de una versión del modelo a una fase determinada se puede realizar mediante el cliente de MLflow:

client.transition_model_version_stage(model_name, version=3, stage="Staging")

Al realizar la transición de una versión de modelo a una fase determinada, si la fase ya tiene otras versiones del modelo, las versiones existentes permanecen sin cambios. Este comportamiento se aplica de manera predeterminada.

Otro enfoque consiste en establecer el parámetro archive_existing_versions=True durante la transición. Este enfoque indica a MLflow que mueva las versiones de modelo existentes a la fase Archived:

client.transition_model_version_stage(
    model_name, version=3, stage="Staging", archive_existing_versions=True
)

Carga de modelos desde fases

Puede cargar un modelo en una fase determinada directamente desde Python mediante la función load_model y el siguiente formato de URI. Para que este método se realice correctamente, todas las bibliotecas y dependencias deben instalarse en el entorno de trabajo.

Cargue el modelo desde la fase Staging:

model = mlflow.pyfunc.load_model(f"models:/{model_name}/Staging")

Edición y eliminación de modelos

La edición de modelos registrados se admite en MLflow y Azure Machine Learning, pero hay algunas diferencias importantes. En las secciones siguientes se describen algunas opciones.

Editar la descripción y las etiquetas del modelo

Puede editar la descripción y las etiquetas de un modelo mediante el SDK de MLflow:

client.update_model_version(model_name, version=1, description="My classifier description")

Para editar etiquetas, use los métodos set_model_version_tag y remove_model_version_tag:

client.set_model_version_tag(model_name, version="1", key="type", value="classification")

Para quitar una etiqueta, use el método delete_model_version_tag:

client.delete_model_version_tag(model_name, version="1", key="type")

Eliminación de versión de modelo

Puede eliminar cualquier versión del modelo en el Registro mediante el cliente de MLflow:

client.delete_model_version(model_name, version="2")

Revisión de las funcionalidades admitidas para administrar modelos

El cliente de MLflow expone varios métodos para recuperar y administrar modelos. En la tabla siguiente se enumeran los métodos admitidos actualmente en MLflow cuando están conectados a Azure Machine Learning. La tabla también compara MLflow con otras funcionalidades de administración de modelos en Azure Machine Learning.

Notas al pie de tabla:

• ¹ Use identificadores uniformes de recursos (URI) con el formato runs:/<ruin-id>/<path>.
• ² Use URI con el formato azureml://jobs/<job-id>/outputs/artifacts/<path>.
• ³ Los modelos registrados son objetos inmutables en Azure Machine Learning.
• ⁴ Use el cuadro de búsqueda en Estudio de Azure Machine Learning. Se admite la coincidencia parcial.
• ⁵ Use registros para mover modelos entre diferentes áreas de trabajo y conservar el linaje.

Contenido relacionado

• Exploración del registro de modelos de MLflow
• Consulta y comparación de experimentos y ejecuciones con MLflow
• Revise las directrices para implementar modelos de MLflow