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

2025-05-06

SE APLICA A:Extensión de ML de la CLI de Azure v2 (actual)

En este artículo, verá cómo implementar el modelo de MLflow en un punto de conexión en línea para la inferencia en tiempo real. Al implementar el modelo de MLflow en un punto de conexión en línea, no es necesario especificar un script de puntuación o un entorno. Esta funcionalidad se conoce como implementación sin código.

En la implementación sin código, Azure Machine Learning hace lo siguiente:

Instala dinámicamente los paquetes de Python que se enumeran en un archivo conda.yaml. Como resultado, las dependencias se instalan durante el tiempo de ejecución del contenedor.
Proporciona una imagen base de MLflow o un entorno mantenido que contiene los siguientes elementos:
- Paquete azureml-inference-server-http
- Paquete mlflow-skinny
- Un script de puntuación para la inferencia

Sugerencia

En áreas de trabajo sin acceso a la red pública, antes de poder implementar modelos de MLflow en puntos de conexión en línea sin conectividad de salida, debe empaquetar los modelos. La funcionalidad de empaquetado del modelo está en versión preliminar. Al empaquetar un modelo, puede evitar la necesidad de una conexión a Internet, que Azure Machine Learning de otro modo requiere para instalar dinámicamente los paquetes de Python necesarios para los modelos de MLflow.

Requisitos previos

Suscripción a Azure. Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.
Una cuenta de usuario que tenga al menos uno de los siguientes roles de control de acceso basado en rol de Azure (RBAC de Azure):
- Un rol de propietario para el área de trabajo de Azure Machine Learning
- Un rol colaborador para el área de trabajo de Azure Machine Learning
- Un rol personalizado que tiene Microsoft.MachineLearningServices/workspaces/onlineEndpoints/* permisos
Para obtener más información, consulte Administración del acceso a un área de trabajo de Azure Machine Learning.
Acceso a Azure Machine Learning:
Instalar la CLI de Azure y la extensión ml en la CLI de Azure. Para conocer los pasos de instalación, consulte Instalación y configuración de la CLI (v2).
Instale el SDK de Azure Machine Learning para Python.
```
pip install azure-ai-ml azure-identity
```
- Instale el paquete del SDK de MLflow, mlflowy el paquete de integración de Azure Machine Learning para MLflow, azureml-mlflow.
```
pip install mlflow azureml-mlflow
```
- Si no ejecuta código en una instancia de proceso de Azure Machine Learning, configure el URI de seguimiento de MLflow o el URI del registro de MLflow para que apunte al área de trabajo de Azure Machine Learning en la que trabaja. Para más información sobre cómo conectar MLflow al área de trabajo, consulte Configuración de MLflow para Azure Machine Learning.
No hay otros requisitos previos al trabajar en Azure Machine Learning Studio.

Acerca del ejemplo

En el ejemplo de este artículo se muestra cómo implementar un modelo de MLflow en un punto de conexión en línea para realizar predicciones. En el ejemplo se usa un modelo de MLflow basado en el conjunto de datos Diabetes. Este conjunto de datos contiene 10 variables de línea base: edad, sexo, índice de masa corporal, presión arterial media y 6 mediciones de suero sanguíneo obtenidos de 442 pacientes con diabetes. También contiene la respuesta de interés, una medida cuantitativa del avance de la enfermedad un año después de la fecha de los datos iniciales.

El modelo se entrenó mediante un scikit-learn regresor. Todo el preprocesamiento necesario se empaqueta como una canalización, por lo que este modelo es una canalización de un extremo a otro que va de datos sin procesar a predicciones.

La información de este artículo se basa en ejemplos de código del repositorio azureml-examples . Si clona el repositorio, puede ejecutar los comandos de este artículo localmente sin tener que copiar o pegar archivos YAML y otros archivos. Use los siguientes comandos para clonar el repositorio y ir a la carpeta del lenguaje de codificación:

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/sdk/python/endpoints/online/mlflow

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/sdk/python/endpoints/online/mlflow

Siga en los cuadernos de Jupyter Notebooks

Para seguir los pasos descritos en este artículo, consulte el cuaderno Deploy MLflow model to online endpoints (Implementación del modelo de MLflow en puntos de conexión en línea ) en el repositorio de ejemplos.

Conexión con su área de trabajo

Conéctese al área de trabajo de Azure Machine Learning:

az account set --subscription <subscription-ID>
az configure --defaults workspace=<workspace-name> group=<resource-group-name> ___location=<___location>

Importe las bibliotecas necesarias:

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

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

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

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

Importe las bibliotecas necesarias:

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

Inicialice el cliente MLflow:
```
mlflow_client = MlflowClient()
```

Configure el cliente de implementación:

deployment_client = get_deploy_client(mlflow.get_tracking_uri())

Registro del modelo

Solo puede implementar modelos registrados en puntos de conexión en línea. Los pasos de este artículo usan un modelo entrenado para el conjunto de datos Diabetes. En este caso, ya tiene una copia local del modelo en el repositorio clonado, por lo que solo debe publicar el modelo en el registro en el área de trabajo. Puede omitir este paso si el modelo que desea implementar ya está registrado.

MODEL_NAME='sklearn-diabetes'
az ml model create --name $MODEL_NAME --type "mlflow_model" --path "endpoints/online/ncd/sklearn-diabetes/model"

model_name = 'sklearn-diabetes'
model_local_path = "sklearn-diabetes/model"
model = ml_client.models.create_or_update(
        Model(name=model_name, path=model_local_path, type=AssetTypes.MLFLOW_MODEL)
)

model_name = 'sklearn-diabetes'
model_local_path = "sklearn-diabetes/model"

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

¿Qué ocurre si el modelo se registró dentro de una ejecución?

Si su modelo se registró dentro de una ejecución, puede registrarlo directamente.

Para registrar el modelo, debe conocer su ubicación de almacenamiento:

Si usa la característica MLflow autolog , la ruta de acceso al modelo depende del tipo de modelo y del marco de trabajo. Compruebe la salida del trabajo para identificar el nombre de la carpeta del modelo. Esta carpeta contiene un archivo denominado MLModel.
Si usa el log_model método para registrar manualmente los modelos, pase la ruta de acceso al modelo como argumento para ese método. Por ejemplo, si usa mlflow.sklearn.log_model(my_model, "classifier") para registrar el modelo, classifier es la ruta de acceso en la que se almacena el modelo.

Puede usar la CLI de Azure Machine Learning v2 para crear un modelo a partir de la salida del trabajo de entrenamiento. El código siguiente usa los artefactos de un trabajo con identificador $RUN_ID para registrar un modelo denominado $MODEL_NAME. $MODEL_PATH es la ruta de acceso que usa el trabajo para almacenar el modelo.

az ml model create --name $MODEL_NAME --path azureml://jobs/$RUN_ID/outputs/artifacts/$MODEL_PATH

Puede usar el SDK de Python para crear un modelo a partir de la salida del trabajo de entrenamiento. El código siguiente usa los artefactos de un trabajo con identificador RUN_ID para registrar un modelo denominado sklearn-diabetes. MODEL_PATH es la ruta de acceso que usa el trabajo para almacenar el modelo.

model_name = 'sklearn-diabetes'

ml_client.models.create_or_update(
    Model(
        path=f"azureml://jobs/{RUN_ID}/outputs/artifacts/{MODEL_PATH}",
        name=model_name,
        type=AssetTypes.MLFLOW_MODEL
    )
)

Puede usar el SDK de MLflow de Python para crear un modelo a partir de la salida del trabajo de entrenamiento. El código siguiente usa los artefactos de un trabajo con identificador RUN_ID para registrar un modelo denominado sklearn-diabetes. MODEL_PATH es la ruta de acceso que usa el trabajo para almacenar el modelo.

model_name = 'sklearn-diabetes'

registered_model = mlflow_client.create_model_version(
    name=model_name, source=f"runs://{RUN_ID}/{MODEL_PATH}"
)
version = registered_model.version

Implementación de un modelo de MLflow en un punto de conexión en línea

Use el código siguiente para configurar el nombre y el modo de autenticación del punto de conexión en el que desea implementar el modelo:

Establezca un nombre de punto de conexión ejecutando el comando siguiente. En primer lugar, reemplace YOUR_ENDPOINT_NAME por un nombre único.

export ENDPOINT_NAME="<YOUR_ENDPOINT_NAME>"

Para configurar el punto de conexión, cree un archivo YAML denominado create-endpoint.yaml que contenga las siguientes líneas:

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: my-endpoint
auth_mode: key

# To create a unique endpoint name, use a time stamp of the current date and time.
import datetime

endpoint_name = "sklearn-diabetes-" + datetime.datetime.now().strftime("%m%d%H%M%f")

endpoint = ManagedOnlineEndpoint(
    name=endpoint_name,
    description="An online endpoint to generate predictions for the diabetes dataset",
    auth_mode="key",
    tags={"env": "dev"},
)

Puede usar un archivo de configuración para configurar las propiedades del punto de conexión. En este caso, configurará el modo de autenticación del punto de conexión para que sea key.


# To create a unique endpoint name, use a time stamp of the current date and time.
import datetime

endpoint_name = "sklearn-diabetes-" + datetime.datetime.now().strftime("%m%d%H%M%f")

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

Use el código siguiente para escribir esta información de 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 --name $ENDPOINT_NAME -f endpoints/online/ncd/create-endpoint.yaml

ml_client.begin_create_or_update(endpoint)

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

Configure la implementación. Una implementación es un conjunto de recursos necesarios para hospedar el modelo que realiza la inferencia real.
Cree un archivo YAML denominado sklearn-deployment.yaml que contenga las siguientes líneas:
```
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: sklearn-deployment
endpoint_name: my-endpoint
model:
  name: mir-sample-sklearn-ncd-model
  version: 2
  path: sklearn-diabetes/model
  type: mlflow_model
instance_type: Standard_DS3_v2
instance_count: 1
```
```
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_F4s_v2",
    instance_count=1
)
```
De manera alternativa, si el punto de conexión no tiene conectividad de salida, use el empaquetado de modelos (versión preliminar) mediante la inclusión del argumento with_package=True:
```
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_F4s_v2",
    instance_count=1,
    with_package=True,
)
```
```
blue_deployment_name = "blue"
```
Para configurar los requisitos de hardware de la implementación, cree un archivo JSON con la configuración deseada:
```
deploy_config = {
    "instance_type": "Standard_F4s_v2",
    "instance_count": 1,
}
```
Nota

Para obtener información sobre la especificación completa de esta configuración, consulte Esquema YAML de implementación en línea administrada de la CLI (v2).

Use el código siguiente para escribir 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))
```
Este paso se realiza en la fase de implementación.
Nota

La generación automática de scoring_script y environment solo se admite para el modelo PyFunc flavor. Para usar otro tipo de modelo, consulte Personalización de implementaciones de modelos de MLflow.
Creación de la implementación:
```
az ml online-deployment create --name sklearn-deployment --endpoint $ENDPOINT_NAME -f endpoints/online/ncd/sklearn-deployment.yaml --all-traffic
```
Si el punto de conexión no tiene conectividad de salida, use el empaquetado del modelo (versión preliminar) mediante la marca --package-model:
```
az ml online-deployment create --package-model --name sklearn-deployment --endpoint $ENDPOINT_NAME -f endpoints/online/ncd/sklearn-deployment.yaml --all-traffic
```
```
ml_client.online_deployments.begin_create_or_update(blue_deployment)
```
```
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},
)    
```
1. Seleccione Puntos de conexión. Vaya a la pestaña Puntos de conexión en tiempo real y seleccione Crear.
2. Seleccione el modelo de MLflow que registró anteriormente y, a continuación, seleccione Seleccionar.
  
  Nota
  
  La página de configuración incluye una nota para informarle de que el script de puntuación y el entorno se generan automáticamente para el modelo MLflow seleccionado.
3. En Punto de conexión, seleccione Nuevo para implementar en un nuevo punto de conexión.
4. En Nombre del punto de conexión, escriba un nombre para el punto de conexión o mantenga el nombre predeterminado.
5. En Nombre de implementación, escriba un nombre para la implementación o mantenga el nombre predeterminado.
6. Seleccione Implementar para implementar el modelo en el punto de conexión.
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.
Este paso no es necesario en la CLI de Azure si usa la bandera --all-traffic durante la creación. Si necesita cambiar el tráfico, puede usar el az ml online-endpoint update --traffic comando . Para obtener más información sobre cómo actualizar el tráfico, consulte Actualización progresiva del tráfico.
```
endpoint.traffic = {"blue": 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))
```
Este paso no es necesario en el estudio.
Actualice la configuración del punto de conexión:
Este paso no es necesario en la CLI de Azure si usa la marca --all-traffic durante la creación. Si necesita cambiar el tráfico, puede usar el az ml online-endpoint update --traffic comando . Para obtener más información sobre cómo actualizar el tráfico, consulte Actualización progresiva del tráfico.
```
ml_client.begin_create_or_update(endpoint).result()
```
```
deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)
```
Este paso no es necesario en el estudio.

Invocación del punto de conexión

Cuando la implementación esté lista, puede usarla para atender solicitudes. Una manera de probar la implementación es mediante la funcionalidad de invocación integrada en el cliente de implementación. En el repositorio de ejemplos, el archivo sample-request-sklearn.json contiene el siguiente código JSON. Puede usarlo como un archivo de solicitud de ejemplo para la implementación.

{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}

{
  "input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ]
    ],
    "index": [0]
  }
}

{
  "input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ]
    ],
    "index": [0]
  }
}

{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}

Nota

Este archivo usa la clave input_data en lugar de inputs, que utiliza MLflow para el servicio. Azure Machine Learning requiere un formato de entrada diferente para poder generar automáticamente los contratos de Swagger para los puntos de conexión. Para más información sobre los formatos de entrada esperados, consulte Implementación en el servidor integrado de MLflow frente a la implementación en el servidor de inferencia de Azure Machine Learning.

Envíe una solicitud al punto de conexión:

az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file endpoints/online/ncd/sample-request-sklearn.json

response = ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    request_file="sample-request-sklearn.json",
)

# Read the sample request that's in the JSON file, and then construct a pandas data frame.
with open("sample-request-sklearn.json", "r") as f:
    sample_request = json.loads(f.read())
    samples = pd.DataFrame(**sample_request["input_data"])

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

La respuesta debe ser similar al texto siguiente:

[ 
  11633.100167144921,
  8522.117402884991
]

[ 
  11633.100167144921
]

[ 
  11633.100167144921
]

[ 
  11633.100167144921,
  8522.117402884991
]

Importante

En el caso de la implementación sin código de MLflow, actualmente no se admite la prueba a través de puntos de conexión locales .

Personalización de las implementaciones de modelos de MLflow

No es necesario especificar un script de puntuación en la definición de implementación de un modelo de MLflow en un punto de conexión en línea. Pero puede especificar un script de puntuación si desea personalizar el proceso de inferencia.

Normalmente, quiere personalizar la implementación del modelo de MLflow en los casos siguientes:

El modelo no tiene un PyFunc tipo.
Necesitas personalizar cómo ejecutas el modelo. Por ejemplo, debe usar para usar mlflow.<flavor>.load_model() un tipo específico para cargar el modelo.
Debe realizar el preprocesamiento o postprocesamiento en la rutina de puntuación, ya que el modelo no realiza este procesamiento.
La salida del modelo no se puede representar correctamente en datos tabulares. Por ejemplo, la salida es un tensor que representa una imagen.

Importante

Si especifica un script de puntuación para una implementación de modelo de MLflow, también debe especificar el entorno en el que se ejecuta la implementación.

Implementación de un script de puntuación personalizado

Para implementar un modelo de MLflow que use un script de puntuación personalizado, siga los pasos descritos en las secciones siguientes.

Identificar la carpeta del modelo

Identifique la carpeta que contiene el modelo de MLflow siguiendo estos pasos:

Vaya a Azure Machine Learning Studio.
Vaya a la sección Modelos.
Seleccione el modelo que desea implementar y vaya a su pestaña Artefactos .
Tome nota de la carpeta que se muestra. Al registrar un modelo, especifique esta carpeta.

Crear un script de puntuación

El siguiente script de puntuación, score.py, proporciona un ejemplo de cómo realizar la inferencia con un modelo de MLflow. Puede adaptar este script a sus necesidades o cambiar cualquiera de sus partes para reflejar su escenario. Observe que el nombre de carpeta que identificó anteriormente, model, se incluye en la init() función .

import logging
import os
import json
import mlflow
from io import StringIO
from mlflow.pyfunc.scoring_server import infer_and_parse_json_input, predictions_to_json


def init():
    global model
    global input_schema
    # "model" is the path of the mlflow artifacts when the model was registered. For automl
    # models, this is generally "mlflow-model".
    model_path = os.path.join(os.getenv("AZUREML_MODEL_DIR"), "model")
    model = mlflow.pyfunc.load_model(model_path)
    input_schema = model.metadata.get_input_schema()


def run(raw_data):
    json_data = json.loads(raw_data)
    if "input_data" not in json_data.keys():
        raise Exception("Request must contain a top level key named 'input_data'")

    serving_input = json.dumps(json_data["input_data"])
    data = infer_and_parse_json_input(serving_input, input_schema)
    predictions = model.predict(data)

    result = StringIO()
    predictions_to_json(predictions, result)
    return result.getvalue()

Advertencia

Aviso de MLflow 2.0: el script de puntuación de ejemplo funciona con MLflow 1.X y MLflow 2.X. Sin embargo, los formatos de entrada y salida esperados en esas versiones pueden variar. Compruebe la definición del entorno para ver qué versión de MLflow usa. MLflow 2.0 solo se admite en Python 3.8 y versiones posteriores.

Creación de un entorno

El siguiente paso es crear un entorno en el que pueda ejecutar el script de puntuación. Dado que el modelo es un modelo de MLflow, los requisitos de Conda también se especifican en el paquete del modelo. Para obtener más información sobre los archivos incluidos en un modelo de MLflow, vea El formato MLmodel. Construyes el entorno usando las dependencias de conda desde el archivo. Sin embargo, también debe incluir el azureml-inference-server-http paquete, que es necesario para las implementaciones en línea en Azure Machine Learning.

Puede crear un archivo de definición de conda denominado conda.yaml que contenga las siguientes líneas:

channels:
- conda-forge
dependencies:
- python=3.9
- pip
- pip:
  - mlflow
  - scikit-learn==1.2.2
  - cloudpickle==2.2.1
  - psutil==5.9.4
  - pandas==2.0.0
  - azureml-inference-server-http
name: mlflow-env

Nota

La dependencies sección de este archivo de Conda incluye el azureml-inference-server-http paquete.

Use este archivo de dependencias de Conda para crear el entorno:

El entorno se crea directamente en la configuración de implementación.

environment = Environment(
    conda_file="sklearn-diabetes/environment/conda.yaml",
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04:latest",
)

Crea la implementación

En la carpeta endpoints/online/ncd, cree un archivo de configuración de implementación, deployment.yml, que contenga las siguientes líneas:

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: sklearn-diabetes-custom
endpoint_name: my-endpoint
model: azureml:sklearn-diabetes@latest
environment: 
    image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04
    conda_file: sklearn-diabetes/environment/conda.yaml
code_configuration:
    code: sklearn-diabetes/src
    scoring_script: score.py
instance_type: Standard_F2s_v2
instance_count: 1

Creación de la implementación:

az ml online-deployment create -f endpoints/online/ncd/deployment.yml

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    environment=environment,
    code_configuration=CodeConfiguration(
        code="sklearn-diabetes/src",
        scoring_script="score.py"
    ),
    instance_type="Standard_F4s_v2",
    instance_count=1,
)

ml_client.online_deployments.begin_create_or_update(blue_deployment)

Atender solicitudes

Una vez completada la implementación, está listo para atender solicitudes. Una manera de probar la implementación es usar el invoke método con un archivo de solicitud de ejemplo, como el siguiente, sample-request-sklearn.json:

{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}

{
  "input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ]
    ],
    "index": [0]
  }
}

{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}

Envíe una solicitud al punto de conexión:

az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file endpoints/online/ncd/sample-request-sklearn.json

response = ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=deployment.name,
    request_file="sample-request-sklearn.json",
)

La respuesta debe ser similar al texto siguiente:

{
    "predictions": [ 
    1095.2797413413252,
    1134.585328803727
    ]
}

{
    "predictions": [ 
    1095.2797413413252
    ]
}

{
    "predictions": [ 
    1095.2797413413252,
    1134.585328803727
    ]
}

Advertencia

Aviso de MLflow 2.0: en MLflow 1.X, la respuesta no contiene la predictions clave.

Limpieza de recursos

Si ya no necesita el punto de conexión, elimine sus recursos asociados:

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

ml_client.online_endpoints.begin_delete(endpoint_name)

deployment_client.delete_endpoint(endpoint_name)

Compartir a través de

Configuración de las opciones iniciales

Configuración personalizada