Implementación progresiva de modelos de MLflow en puntos de conexión en línea

Artigo
10/20/2023

En este artículo, aprenderá a actualizar e implementar modelos de MLflow de forma progresiva en puntos de conexión en línea sin provocar interrupciones del servicio. Usará la implementación azul-verde, también conocida como estrategia de lanzamiento seguro, para introducir una nueva versión de un servicio web en producción. Esta estrategia le permitirá implementar la nueva versión del servicio web en un pequeño subconjunto de usuarios o solicitudes antes de implementarlo por completo.

Acerca de este ejemplo

Los puntos de conexión en línea tienen los conceptos de punto de conexión e implementación. Un punto de conexión representa la API que los clientes usan para consumir el modelo, mientras que la implementación indica la implementación específica de esa API. Esta distinción permite a los usuarios desacoplar la API de la implementación y cambiar la implementación subyacente sin que ello afecte al consumidor. En este ejemplo se usarán estos conceptos para actualizar el modelo implementado en puntos de conexión sin introducir interrupciones del servicio.

El modelo que implementaremos se basa en el conjunto de datos de enfermedades cardíacas de UCI. La base de datos contiene 76 atributos, pero se usa un subconjunto de 14 de ellos. El modelo intenta predecir la presencia de enfermedades cardíacas en un paciente. Es un entero cuyo valor es 0 (sin presencia) o 1 (presencia). Se ha entrenado mediante un clasificador de XGBBoost y todo el preprocesamiento necesarios se ha empaquetado en forma de canalización de scikit-learn, lo que convierte a este modelo en una canalización de un extremo a otro que pasa de los datos sin procesar a las predicciones.

La información de este artículo se basa en ejemplos de código que se encuentran en el repositorio azureml-examples. Para ejecutar los comandos localmente sin tener que copiar y pegar los archivos, clone el repositorio y cambie los directorios a sdk/using-mlflow/deploy.

Siga estos pasos en Jupyter Notebooks

Puede seguir este ejemplo en los cuadernos siguientes. En el repositorio clonado, abra el cuaderno: mlflow_sdk_online_endpoints_progresive.ipynb.

Requisitos previos

Antes de seguir los pasos de este artículo, asegúrese de que tiene los siguientes requisitos previos:

Suscripción a Azure. Si no tiene una suscripción de Azure, cree una cuenta gratuita antes de empezar. Pruebe la versión gratuita o de pago de Azure Machine Learning.
Los controles de acceso basado en rol de Azure (RBAC de Azure) se usan para conceder acceso a las operaciones en Azure Machine Learning. Para realizar los pasos descritos en este artículo, la cuenta de usuario debe tener asignado el rol de propietario o colaborador para el área de trabajo de Azure Machine Learning, o un rol personalizado que permita Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*. Para obtener más información, consulte Administración del acceso a un área de trabajo de Azure Machine Learning.

Además, deberá:

Instale la CLI de Azure y la extensión de ml en la CLI de Azure. Para más información, consulte Instalación, configuración y uso de la CLI v2.

Instale el paquete mlflow del SDK de Mlflow y el complemento de Azure Machine Learning para MLflow azureml-mlflow.
```
pip install mlflow azureml-mlflow
```
Si no lo ejecuta en el proceso de Azure ML, configure el identificador URI de seguimiento de MLflow o el identificador URI de registro de MLflow para que apunte al área de trabajo en la que trabaja. Aprenda cómo configurar MLflow para Azure Machine Learning.

Conexión con su área de trabajo

En primer lugar, vamos a conectarnos al área de trabajo de Azure Machine Learning en la que vamos a trabajar.

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

El área de trabajo es el recurso de nivel superior para Azure Machine Learning, que proporciona un lugar centralizado para trabajar con todos los artefactos que crea al usar Azure Machine Learning. En esta sección, nos conectaremos al área de trabajo en la que realizará las tareas de implementación.

Importe las bibliotecas necesarias:

from azure.ai.ml import MLClient, Input
from azure.ai.ml.entities import ManagedOnlineEndpoint, ManagedOnlineDeployment, Model
from azure.ai.ml.constants import AssetTypes
from azure.identity import DefaultAzureCredential

Configure los detalles del área de trabajo y obtenga un manipulador para el área de trabajo:

subscription_id = "<subscription>"
resource_group = "<resource-group>"
workspace = "<workspace>"

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)

Importación de las bibliotecas necesarias

import json
import mlflow
import requests
import pandas as pd
from mlflow.deployments import get_deploy_client

Configure el cliente de MLflow y el cliente de implementación:

mlflow_client = mlflow.MLflowClient()
deployment_client = get_deploy_client(mlflow.get_tracking_uri())

Registro del modelo en el registro

Asegúrese de que el modelo está registrado en el registro de Azure Machine Learning. No se admite la implementación de modelos no registrados en Azure Machine Learning. Puede registrar un nuevo modelo mediante el SDK de MLflow:

MODEL_NAME='heart-classifier'
az ml model create --name $MODEL_NAME --type "mlflow_model" --path "model"

model_name = 'heart-classifier'
model_local_path = "model"

model = ml_client.models.create_or_update(
     Model(name=model_name, path=model_local_path, type=AssetTypes.MLFLOW_MODEL)
)

model_name = 'heart-classifier'
model_local_path = "model"

registered_model = mlflow_client.create_model_version(
    name=model_name, source=f"file://{model_local_path}"
)
version = registered_model.version

Creación de un punto de conexión en línea

Los puntos de conexión en línea son puntos de conexión que se usan para las inferencias en línea (en tiempo real). Los puntos de conexión en línea contienen implementaciones que están listas para recibir datos de los clientes y que pueden enviar respuestas en tiempo real.

Vamos a aprovechar esta funcionalidad mediante la implementación de varias versiones del mismo modelo en el mismo punto de conexión. Sin embargo, la nueva implementación recibirá el 0 % del tráfico en el retraso. Una vez que estemos seguros de que el nuevo modelo funciona correctamente, vamos a mover progresivamente el tráfico de una implementación a la otra.

Los puntos de conexión requieren un nombre, que debe ser único en la misma región. Vamos a asegurarnos de crear uno que no exista:

ENDPOINT_SUFIX=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w ${1:-5} | head -n 1)
ENDPOINT_NAME="heart-classifier-$ENDPOINT_SUFIX"

import random
import string

# Creating a unique endpoint name by including a random suffix
allowed_chars = string.ascii_lowercase + string.digits
endpoint_suffix = "".join(random.choice(allowed_chars) for x in range(5))
endpoint_name = "heart-classifier-" + endpoint_suffix

print(f"Endpoint name: {endpoint_name}")

import random
import string

# Creating a unique endpoint name by including a random suffix
allowed_chars = string.ascii_lowercase + string.digits
endpoint_suffix = "".join(random.choice(allowed_chars) for x in range(5))
endpoint_name = "heart-classifier-" + endpoint_suffix

print(f"Endpoint name: {endpoint_name}")

Configuración del punto de conexión

endpoint.yml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: heart-classifier-edp
auth_mode: key

endpoint = ManagedOnlineEndpoint(
    name=endpoint_name,
    description="An endpoint to serve predictions of the UCI heart disease problem",
    auth_mode="key",
)

Las propiedades de este punto de conexión se pueden configurar mediante un archivo de configuración. Configuramos el modo de autenticación del punto de conexión para que sea "key" en el ejemplo siguiente:

endpoint_config = {
    "auth_mode": "key",
    "identity": {
        "type": "system_assigned"
    }
}

Vamos a escribir esta configuración en un archivo JSON:

endpoint_config_path = "endpoint_config.json"
with open(endpoint_config_path, "w") as outfile:
    outfile.write(json.dumps(endpoint_config))

Creación del punto de conexión:

az ml online-endpoint create -n $ENDPOINT_NAME -f endpoint.yml

ml_client.online_endpoints.begin_create_or_update(endpoint).result()

endpoint = deployment_client.create_endpoint(
    name=endpoint_name,
    config={"endpoint-config-file": endpoint_config_path},
)

Obtención del secreto de autenticación del punto de conexión.
```
ENDPOINT_SECRET_KEY=$(az ml online-endpoint get-credentials -n $ENDPOINT_NAME | jq -r ".accessToken")
```
```
endpoint_secret_key = ml_client.online_endpoints.list_keys(
    name=endpoint_name
).access_token
```
Esta funcionalidad no está disponible en el SDK de MLflow. Vaya a Estudio de Azure Machine Learning, luego al punto de conexión y recupere desde allí la clave secreta.

Creación de una implementación azul

Hasta el momento, el punto de conexión está vacío. No hay implementaciones en él. Vamos a crear la primera. Para ello, implementaremos el mismo modelo en el que estábamos trabajando. Llamaremos a esta implementación "default", que representa nuestra "blue deployment".

Configurar la implementación

blue-deployment.yml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: default
endpoint_name: heart-classifier-edp
model: azureml:heart-classifier@latest
instance_type: Standard_DS2_v2
instance_count: 1

blue_deployment_name = "default"

Configure los requisitos de hardware de la implementación:

blue_deployment = ManagedOnlineDeployment(
    name=blue_deployment_name,
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_DS2_v2",
    instance_count=1,
)

Si el punto de conexión no tiene conectividad de salida, use empaquetado de modelos (versión preliminar) mediante la inclusión del argumento with_package=True:

blue_deployment = ManagedOnlineDeployment(
    name=blue_deployment_name,
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_DS2_v2",
    instance_count=1,
    with_package=True,
)

blue_deployment_name = "default"

Para configurar los requisitos de hardware de la implementación, es preciso crear un archivo JSON con la configuración deseada:

deploy_config = {
    "instance_type": "Standard_DS2_v2",
    "instance_count": 1,
}

Nota

La especificación completa de esta configuración se puede consultar en Esquema YAML de implementación en línea administrada de la CLI (v2).

Escriba la configuración en un archivo:

deployment_config_path = "deployment_config.json"
with open(deployment_config_path, "w") as outfile:
    outfile.write(json.dumps(deploy_config))

Creación de la implementación

az ml online-deployment create --endpoint-name $ENDPOINT_NAME -f blue-deployment.yml --all-traffic

Si el punto de conexión no tiene conectividad de salida, use el empaquetado del modelo (versión preliminar) mediante la marca --with-package:

az ml online-deployment create --with-package --endpoint-name $ENDPOINT_NAME -f blue-deployment.yml --all-traffic

Sugerencia

Establecemos la marca --all-traffic en el comando create, que asignará todo el tráfico a la nueva implementación.

ml_client.online_deployments.begin_create_or_update(blue_deployment).result()

blue_deployment = deployment_client.create_deployment(
    name=blue_deployment_name,
    endpoint=endpoint_name,
    model_uri=f"models:/{model_name}/{version}",
    config={"deploy-config-file": deployment_config_path},
)

Asigne todo el tráfico a la implementación

Hasta el momento, el punto de conexión tiene una implementación, pero no se le asigna ningún tráfico. Vamos a asignarlo.
Este paso no es necesario en la CLI de Azure, ya que se usó --all-traffic durante la creación.
```
endpoint.traffic = { blue_deployment_name: 100 }
```
```
traffic_config = {"traffic": {blue_deployment_name: 100}}
```
Escriba la configuración en un archivo:
```
traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))
```
Actualice la configuración del punto de conexión:
Este paso no es necesario en la CLI de Azure, ya que se usó --all-traffic durante la creación.
```
ml_client.begin_create_or_update(endpoint).result()
```
```
deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)
```

Cree una entrada de ejemplo para probar la implementación

sample.yml

{
    "input_data": {
        "columns": [
            "age",
            "sex",
            "cp",
            "trestbps",
            "chol",
            "fbs",
            "restecg",
            "thalach",
            "exang",
            "oldpeak",
            "slope",
            "ca",
            "thal"
        ],
        "data": [
            [ 48, 0, 3, 130, 275, 0, 0, 139, 0, 0.2, 1, 0, "normal" ]
        ]
    }
}

En los siguientes ejemplos de código cinco observaciones del conjunto de datos de entrenamiento, se quita la columna target (como el modelo lo predecirá) y se crea una solicitud en el archivo sample.json que se puede usar con la implementación del modelo.

samples = (
    pd.read_csv("data/heart.csv")
    .sample(n=5)
    .drop(columns=["target"])
    .reset_index(drop=True)
)

with open("sample.json", "w") as f:
    f.write(
        json.dumps(
            {"input_data": json.loads(samples.to_json(orient="split", index=False))}
        )
    )

En los siguientes ejemplos de código cinco observaciones del conjunto de datos de entrenamiento, se quita la columna target (como el modelo lo predecirá) y se crea una solicitud.

samples = (
    pd.read_csv("data/heart.csv")
    .sample(n=5)
    .drop(columns=["target"])
    .reset_index(drop=True)
)

Prueba de la implementación

az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file sample.json

ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    request_file="sample.json",
)

deployment_client.predict(
    endpoint=endpoint_name, 
    df=samples
)

Cree una implementación verde debajo del punto de conexión

Imaginemos que hay una nueva versión del modelo creada por el equipo de desarrollo y está lista para estar en producción. Primero podemos intentar utilizar este modelo y, una vez que estemos seguros, podemos actualizar el punto de conexión para enrutar el tráfico a él.

Registre una nueva versión del modelo

MODEL_NAME='heart-classifier'
az ml model create --name $MODEL_NAME --type "mlflow_model" --path "model"

Vamos a obtener el número de versión del nuevo modelo:

VERSION=$(az ml model show -n heart-classifier --label latest | jq -r ".version")

model_name = 'heart-classifier'
model_local_path = "model"

model = ml_client.models.create_or_update(
     Model(name=model_name, path=model_local_path, type=AssetTypes.MLFLOW_MODEL)
)
version = model.version

model_name = 'heart-classifier'
model_local_path = "model"

registered_model = mlflow_client.create_model_version(
    name=model_name, source=f"file://{model_local_path}"
)
version = registered_model.version

Configure una nueva implementación

green-deployment.yml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: xgboost-model
endpoint_name: heart-classifier-edp
model: azureml:heart-classifier@latest
instance_type: Standard_DS2_v2
instance_count: 1

Asignaremos el nombre a la implementación de la siguiente manera:

GREEN_DEPLOYMENT_NAME="xgboost-model-$VERSION"

green_deployment_name = f"xgboost-model-{version}"

Configure los requisitos de hardware de la implementación:

green_deployment = ManagedOnlineDeployment(
    name=green_deployment_name,
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_DS2_v2",
    instance_count=1,
)

Si el punto de conexión no tiene conectividad de salida, use empaquetado de modelos (versión preliminar) mediante la inclusión del argumento with_package=True:

green_deployment = ManagedOnlineDeployment(
    name=green_deployment_name,
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_DS2_v2",
    instance_count=1,
    with_package=True,
)

green_deployment_name = f"xgboost-model-{version}"

Para configurar los requisitos de hardware de la implementación, es preciso crear un archivo JSON con la configuración deseada:

deploy_config = {
    "instance_type": "Standard_DS2_v2",
    "instance_count": 1,
}

Sugerencia

Vamos a usar la misma confirmación de hardware indicada en deployment-config-file. Sin embargo, no hay requisitos para tener la misma configuración. Puede configurar diferente hardware para diferentes modelos en función de los requisitos.

Escriba la configuración en un archivo:

deployment_config_path = "deployment_config.json"
with open(deployment_config_path, "w") as outfile:
    outfile.write(json.dumps(deploy_config))

Cree la nueva implementación

az ml online-deployment create -n $GREEN_DEPLOYMENT_NAME --endpoint-name $ENDPOINT_NAME -f green-deployment.yml

Si el punto de conexión no tiene conectividad de salida, use el empaquetado del modelo (versión preliminar) mediante la marca --with-package:

az ml online-deployment create --with-package -n $GREEN_DEPLOYMENT_NAME --endpoint-name $ENDPOINT_NAME -f green-deployment.yml

ml_client.online_deployments.begin_create_or_update(green_deployment).result()

new_deployment = deployment_client.create_deployment(
    name=green_deployment_name,
    endpoint=endpoint_name,
    model_uri=f"models:/{model_name}/{version}",
    config={"deploy-config-file": deployment_config_path},
)

Pruebe la implementación sin cambiar el tráfico

az ml online-endpoint invoke --name $ENDPOINT_NAME --deployment-name $GREEN_DEPLOYMENT_NAME --request-file sample.json

ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=green_deployment_name
    request_file="sample.json",
)

deployment_client.predict(
    endpoint=endpoint_name, 
    deployment_name=green_deployment_name, 
    df=samples
)

Sugerencia

Observe que ahora se indica el nombre de la implementación que queremos invocar.

Actualización progresiva del tráfico

Una vez que estemos familiarizados con la nueva implementación, podemos actualizar el tráfico para enrutar parte una de ella a la nueva implementación. El tráfico se configura en el nivel de punto de conexión:

Configure el tráfico:

Este paso no es necesario en la CLI de Azure

endpoint.traffic = {blue_deployment_name: 90, green_deployment_name: 10}

traffic_config = {"traffic": {blue_deployment_name: 90, green_deployment_name: 10}}

Escriba la configuración en un archivo:

traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))

Actualización del punto de conexión

az ml online-endpoint update --name $ENDPOINT_NAME --traffic "default=90 $GREEN_DEPLOYMENT_NAME=10"

ml_client.begin_create_or_update(endpoint).result()

deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)

Si decide cambiar todo el tráfico a la nueva implementación, actualice todo el tráfico:

Este paso no es necesario en la CLI de Azure

endpoint.traffic = {blue_deployment_name: 0, green_deployment_name: 100}

traffic_config = {"traffic": {blue_deployment_name: 0, green_deployment_name: 100}}

Escriba la configuración en un archivo:

traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))

Actualización del punto de conexión

az ml online-endpoint update --name $ENDPOINT_NAME --traffic "default=0 $GREEN_DEPLOYMENT_NAME=100"

ml_client.begin_create_or_update(endpoint).result()

deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)

Al no recibir tráfico, la implementación antigua se puede eliminar de forma segura:
```
az ml online-deployment delete --endpoint-name $ENDPOINT_NAME --name default
```
```
ml_client.online_deployments.begin_delete(
    name=blue_deployment_name, 
    endpoint_name=endpoint_name
)
```
```
deployment_client.delete_deployment(
    blue_deployment_name, 
    endpoint=endpoint_name
)
```
Sugerencia

Observe que, en este momento, se ha eliminado la "implementación azul" anterior y la nueva "implementación verde" ha ocupado el lugar de ella.

Limpieza de recursos

az ml online-endpoint delete --name $ENDPOINT_NAME --yes

ml_client.online_endpoints.begin_delete(name=endpoint_name)

deployment_client.delete_endpoint(endpoint_name)

Importante

Tenga en cuenta que al eliminar un punto de conexión se eliminan también todas las implementaciones que contiene.

Compartir por

Implementación progresiva de modelos de MLflow en puntos de conexión en línea

Acerca de este ejemplo

Siga estos pasos en Jupyter Notebooks

Requisitos previos

Conexión con su área de trabajo

Registro del modelo en el registro

Creación de un punto de conexión en línea

Creación de una implementación azul

Cree una implementación verde debajo del punto de conexión

Actualización progresiva del tráfico

Limpieza de recursos

Pasos siguientes

Comentarios

Comentarios

Recursos adicionais