Seguimiento de modelos de Machine Learning con MLflow y Azure Machine Learning

SE APLICA A:SDK de Azure Machine Learning v1 para Python

En este artículo, obtendrá información sobre cómo habilitar MLflow Tracking, para conectar Azure Machine Learning como el back-end de experimentos de MLflow.

MLflow es una biblioteca de código abierto para administrar el ciclo de vida de los experimentos de aprendizaje automático. MLFlow Tracking es un componente de MLflow que lleva a cabo un registro y un seguimiento de las métricas de ejecución de entrenamiento y de los artefactos del modelo, independientemente del entorno del experimento (localmente en su equipo, en un destino de proceso remoto, en una máquina virtual o en un clúster de Azure Databricks).

Consulte MLflow y Azure Machine Learning para ver todas las funcionalidades admitidas de MLflow y Azure Machine Learning, incluida la compatibilidad con MLflow Project (versión preliminar) y la implementación de modelos.

Requisitos previos

• Instale el paquete mlflow.

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

• Instale el paquete azureml-mlflow.

• Cree un área de trabajo de Azure Machine Learning.

  • Consulte qué permisos de acceso necesita para realizar las operaciones de MLflow con el área de trabajo.

• Instale y configure la CLI de Azure Machine Learning (v1) y asegúrese de instalar la extensión ml.

  Importante

  Algunos de los comandos de la CLI de Azure de este artículo usan la extensión azure-cli-ml o v1 para Azure Machine Learning. La compatibilidad con la extensión v1 finalizará el 30 de septiembre de 2025. Puede instalar y usar la extensión v1 hasta esa fecha.

  Se recomienda pasar a la extensión ml, o v2, antes del 30 de septiembre de 2025. Para más información sobre la extensión v2, consulte extensión de la CLI de Azure Machine Learning y SDK de Python v2.

• Instale y configure el SDK de Azure Machine Learning para Python.

Seguimiento de ejecuciones desde la máquina local o el proceso remoto

El seguimiento mediante MLflow con Azure Machine Learning permite almacenar las métricas registradas y las ejecuciones de artefactos que se ejecutaron en la máquina local en el área de trabajo de Azure Machine Learning.

Configuración del entorno de seguimiento

Para realizar un seguimiento de una ejecución que no se ejecuta en el proceso de Azure Machine Learning (a partir de ahora denominado "proceso local"), debe apuntar el proceso local al URI de seguimiento de MLflow de Azure Machine Learning.

export MLFLOW_TRACKING_URI=$(az ml workspace show --query mlflow_tracking_uri | sed 's/"//g') 

import mlflow

region = ""
subscription_id = ""
resource_group = ""
workspace_name = ""

azureml_mlflow_uri = f"azureml://{region}.api.azureml.ms/mlflow/v1.0/subscriptions/{subscription_id}/resourceGroups/{resource_group}/providers/Microsoft.MachineLearningServices/workspaces/{workspace_name}"
mlflow.set_tracking_uri(azureml_mlflow_uri)

Establecimiento del nombre del experimento

Todas las ejecuciones de MLflow se registran en el experimento activo. Las ejecuciones se registran de manera predeterminada en un experimento denominado Default que se crea automáticamente. Para configurar el experimento en el que desea trabajar, use el comando mlflow.set_experiment() de MLflow.

experiment_name = 'experiment_with_mlflow'
mlflow.set_experiment(experiment_name)

Iniciar ejecución de entrenamiento

Tras establecer el nombre del experimento de MLflow, puede iniciar la ejecución del entrenamiento con start_run(). A continuación, use log_metric() para activar la API de registro de MLflow y empezar a registrar las métricas de ejecución de entrenamiento.

import os
from random import random

with mlflow.start_run() as mlflow_run:
    mlflow.log_param("hello_param", "world")
    mlflow.log_metric("hello_metric", random())
    os.system(f"echo 'hello world' > helloworld.txt")
    mlflow.log_artifact("helloworld.txt")

Para más información sobre cómo registrar métricas, parámetros y artefactos en una ejecución mediante la vista de MLflow, consulte Registro y visualización de métricas.

Seguimiento de ejecuciones que se ejecutan en Azure Machine Learning

SE APLICA A:SDK de Azure Machine Learning v1 para Python

Las ejecuciones remotas (trabajos) permiten entrenar los modelos de forma más sólida y repetitiva. También pueden aprovechar computadoras más potentes, como los clústeres de cómputo de aprendizaje automático. Consulte Usar destinos de cómputo para el entrenamiento de modelos para obtener información sobre las distintas opciones de cómputo.

Al enviar ejecuciones, Azure Machine Learning configura automáticamente MLflow para que funcione con el área de trabajo en la que se ejecuta la ejecución. Esto significa que no es necesario configurar el URI de seguimiento de MLflow. Además, los experimentos se denominan automáticamente en función de los detalles de la realización del experimento.

Creación de una rutina de entrenamiento

En primer lugar, debe crear un subdirectorio src y crear un archivo con el código de entrenamiento en un archivo train.py en el subdirectorio src. Todo el código de entrenamiento entrará en el subdirectorio src, incluido train.py.

El código de entrenamiento se toma de este ejemplo de MLfLow en el repositorio de ejemplo de Azure Machine Learning.

Copie este código en el archivo:

# imports
import os
import mlflow

from random import random

# define functions
def main():
    mlflow.log_param("hello_param", "world")
    mlflow.log_metric("hello_metric", random())
    os.system(f"echo 'hello world' > helloworld.txt")
    mlflow.log_artifact("helloworld.txt")


# run functions
if __name__ == "__main__":
    # run main function
    main()

Configuración del experimento

Deberá usar Python para enviar el experimento a Azure Machine Learning. En un cuaderno o archivo de Python, configure el entorno de ejecución de proceso y entrenamiento con la clase Environment.

from azureml.core import Environment
from azureml.core.conda_dependencies import CondaDependencies

env = Environment(name="mlflow-env")

# Specify conda dependencies with scikit-learn and temporary pointers to mlflow extensions
cd = CondaDependencies.create(
    conda_packages=["scikit-learn", "matplotlib"],
    pip_packages=["azureml-mlflow", "pandas", "numpy"]
    )

env.python.conda_dependencies = cd

A continuación, construya ScriptRunConfig con el proceso remoto como destino de proceso.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory="src",
                      script=training_script,
                      compute_target="<COMPUTE_NAME>",
                      environment=env)

Con esta configuración de ejecución de proceso y entrenamiento, use el método Experiment.submit() para enviar una ejecución. Este método establece automáticamente la URI de seguimiento de MLflow y redirige el registro de MLflow a tu área de trabajo.

from azureml.core import Experiment
from azureml.core import Workspace
ws = Workspace.from_config()

experiment_name = "experiment_with_mlflow"
exp = Experiment(workspace=ws, name=experiment_name)

run = exp.submit(src)

Ver métricas y artefactos en tu área de trabajo

Se realiza un seguimiento de las métricas y artefactos del registro de MLflow en el área de trabajo. Para verlos en cualquier momento, vaya al área de trabajo y busque el experimento por su nombre en el área de trabajo en Azure Machine Learning Studio. O bien, ejecute el código siguiente:

Recupere la métrica de ejecución usando get_run() de MLflow.

from mlflow.tracking import MlflowClient

# Use MlFlow to retrieve the run that was just completed
client = MlflowClient()
run_id = mlflow_run.info.run_id
finished_mlflow_run = MlflowClient().get_run(run_id)

metrics = finished_mlflow_run.data.metrics
tags = finished_mlflow_run.data.tags
params = finished_mlflow_run.data.params

print(metrics,tags,params)

Para ver los artefactos de una ejecución, puede usar MlFlowClient.list_artifacts()

client.list_artifacts(run_id)

Para descargar un artefacto en el directorio actual, puede usar MLFlowClient.download_artifacts()

client.download_artifacts(run_id, "helloworld.txt", ".")

Para más información sobre cómo recuperar información de experimentos y ejecuciones en Azure Machine Learning mediante la vista de MLflow Administración de experimentos y ejecuciones con MLflow.

Comparación y consulta

Compare y consulte todas las ejecuciones de MLflow en el área de trabajo de Azure Machine Learning con el código siguiente. Obtenga más información sobre cómo consultar ejecuciones con MLflow.

from mlflow.entities import ViewType

all_experiments = [exp.experiment_id for exp in MlflowClient().list_experiments()]
query = "metrics.hello_metric > 0"
runs = mlflow.search_runs(experiment_ids=all_experiments, filter_string=query, run_view_type=ViewType.ALL)

runs.head(10)

Registro automático

Con Azure Machine Learning y MLFlow, los usuarios pueden registrar métricas, parámetros de modelo y artefactos de modelo automáticamente al entrenar un modelo. Se admiten diversas bibliotecas de aprendizaje automático populares.

Para habilitar el registro automático, inserte el código siguiente antes del código de entrenamiento:

mlflow.autolog()

Obtenga más información sobre el registro automático con MLflow.

Administración de modelos

Registre y realice un seguimiento de los modelos con el registro de modelos de Azure Machine Learning, que admite el registro de modelos de MLflow. Los modelos de Azure Machine Learning se alinean con el esquema de modelos de MLflow, lo que facilita la exportación e importación de estos modelos en diferentes flujos de trabajo. Los metadatos relacionados con MLflow, como la identificación de ejecución, también se supervisan con el modelo registrado para asegurar la trazabilidad. Los usuarios pueden enviar las ejecuciones de entrenamiento, registrar e implementar los modelos generados a partir de las ejecuciones de MLflow.

Si quiere implementar y registrar el modelo preparado para producción en un solo paso, consulte Implementación y registro de modelos de MLflow.

Para registrar y ver un modelo a partir de una ejecución, siga estos pasos:

1. Una vez completada la ejecución, llame al método register_model().

   # the model folder produced from a run is registered. This includes the MLmodel file, model.pkl and the conda.yaml.
   model_path = "model"
   model_uri = 'runs:/{}/{}'.format(run_id, model_path) 
   mlflow.register_model(model_uri,"registered_model_name")
   

2. Vea el modelo registrado en su área de trabajo con Azure Machine Learning Studio

   En el ejemplo siguiente, el modelo registrado my-model tiene etiquetados metadatos de seguimiento de MLflow.

   

3. Seleccione la pestaña Artefactos para ver todos los archivos de modelo que se alinean con el esquema de modelos de MLflow (conda.yaml, MLmodel, model.pkl).

   

4. Seleccione MLmodel para ver el archivo MLmodel generado por la ejecución.

   

Limpieza de recursos

Si no tiene pensado usar los artefactos o las métricas registradas en el área de trabajo, la funcionalidad para eliminarlos de forma individual no está disponible actualmente. Por ello, deberá eliminar el grupo de recursos que contiene la cuenta de almacenamiento y el área de trabajo para no incurrir en cargos:

1. En el portal de Azure, seleccione Grupos de recursos en el extremo izquierdo.

   

2. En la lista, seleccione el grupo de recursos que creó.

3. Seleccione Eliminar grupo de recursos.

4. Escriba el nombre del grupo de recursos. A continuación, seleccione Eliminar.

Cuadernos de ejemplo

El MLflow con cuadernos de Azure Machine Learning demostrar y ampliar los conceptos presentados en este artículo. Consulte también el repositorio controlado por la comunidad, AzureML-Examples.

Pasos siguientes

• Implementación de modelos con MLflow.
• Supervise los modelos de producción para el desfase de datos.
• Seguimiento de las ejecuciones de Azure Databricks con MLflow.
• Administra sus modelos.