Creación de trabajos y datos de entrada para puntos de conexión por lotes

Article
09/03/2024

Los punto de conexión por lotes le permiten realizar operaciones por lotes largas con grandes cantidades de datos. Los datos se pueden ubicar en diferentes lugares, como en regiones dispersas. Algunos tipos de puntos de conexión por lotes también pueden recibir parámetros literales como entradas.

En este artículo se describe cómo especificar entradas de parámetro para puntos de conexión por lotes y crear trabajos de implementación. El proceso admite el trabajo con diferentes tipos de datos. Para obtener algunos ejemplos, vea Descripción de las entradas y salidas.

Requisitos previos

Para invocar correctamente un punto de conexión por lotes y crear trabajos, asegúrese de completar los requisitos previos siguientes:

Un punto de conexión e implementación. Si no tiene estos recursos, vea Implementación de modelos para la puntuación en puntos de conexión por lotes para crear una implementación.
Permisos para ejecutar una implementación de punto de conexión por lotes. Los roles Científico de datos, Colaborador y Propietario de AzureML se pueden usar para ejecutar una implementación. Para obtener definiciones de roles personalizados, vea Autorización en puntos de conexión por lotes para revisar los permisos específicos necesarios.
Un token de Microsoft Entra ID válido que represente una entidad de seguridad para invocar el punto de conexión. Esta entidad de seguridad puede ser una entidad de seguridad de usuario o una entidad de servicio. Después de invocar un punto de conexión, Azure Machine Learning crea un trabajo de implementación por lotes en la identidad asociada al token. Puede usar credenciales propias para la invocación, como se describe en los procedimientos siguientes.
- CLI de Azure
- Python
- REST
Use la CLI de Azure para iniciar sesión mediante la autenticación interactiva o de código de dispositivo:
```
az login
```
Use el SDK de Azure Machine Learning para Python para iniciar sesión:
```
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

ml_client = MLClient.from_config(DefaultAzureCredential())
```
Si la configuración se ejecuta fuera de un proceso de Azure Machine Learning, debe especificar el área de trabajo donde se implementa el punto de conexión:
```
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

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

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
```
La manera más sencilla de obtener un token válido para la cuenta de usuario es usar la CLI de Azure. En una consola, ejecute el siguiente comando de la CLI de Azure:
```
az account get-access-token --resource https://ml.azure.com --query "accessToken" --output tsv
```
Sugerencia

Al trabajar con REST, se recomienda invocar puntos de conexión por lotes mediante una entidad de servicio. Para más información, vea Ejecución de un trabajo mediante una entidad de servicio (REST) a fin de saber cómo obtener un token para una entidad de servicio mediante REST.
Para más información sobre cómo iniciar trabajos de implementación por lotes mediante distintos tipos de credenciales, vea Procedimiento para ejecutar trabajos mediante distintos tipos de credenciales.
El clúster de proceso donde se implementa el punto de conexión tiene acceso para leer los datos de entrada.

Sugerencia

Si usa un almacén de datos sin credenciales o una cuenta externa de Azure Storage como entrada de datos, asegúrese de configurar clústeres de proceso para el acceso a datos. La identidad administrada del clúster de proceso se usa para montar la cuenta de almacenamiento. La identidad del trabajo (invocador) se sigue usando para leer los datos subyacentes, lo que le permite lograr un control de acceso pormenorizado.

Conceptos básicos de la creación de trabajos

Para crear un trabajo a partir de un punto de conexión por lotes, se invoca el punto de conexión. La invocación se puede realizar mediante la CLI de Azure, el SDK de Azure Machine Learning para Python o una llamada a la API REST. En los ejemplos siguientes se muestran los conceptos básicos de la invocación de un punto de conexión por lotes que recibe una única carpeta de datos de entrada para su procesamiento. Para obtener ejemplos con otras entradas y salidas, vea Descripción de las entradas y salidas.

Use la operación invoke en puntos de conexión por lotes:

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
                            --input https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data

Use el método MLClient.batch_endpoints.invoke() para especificar el nombre del experimento:

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": Input("https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data")
    }
)

Realice una solicitud POST a la dirección URL de invocación del punto de conexión. Puede obtener la dirección URL de invocación desde el portal de Azure Machine Learning en la página de detalles del punto de conexión.

Cuerpo

{
    "properties": {
        "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFolder",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
           }
        }
    }
}

Solicitar

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json

Invocación de una implementación específica

Los puntos de conexión por lotes pueden hospedar varias implementaciones en el mismo punto de conexión. Se usa el punto de conexión predeterminado, a menos que el usuario especifique lo contrario. Puede cambiar la implementación para usarla con los procedimientos siguientes.

Use el argumento --deployment-name o -d para especificar el nombre de la implementación:

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
                            --deployment-name $DEPLOYMENT_NAME \
                            --input https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data

Use el parámetro deployment_name para especificar el nombre de la implementación:

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    deployment_name=deployment.name,
    inputs={
        "heart_dataset": Input("https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data")
    }
)

Agregue el encabezado azureml-model-deployment a la solicitud, incluido el nombre de la implementación que quiere invocar:

Cuerpo

{
    "properties": {
        "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFolder",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
           }
        }
    }
}

Solicitar

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
azureml-model-deployment: DEPLOYMENT_NAME

Configuración de las propiedades del trabajo

Puede configurar algunas de las propiedades del trabajo creado en el momento de la invocación.

Nota:

La capacidad de configurar propiedades de trabajo actualmente solo está disponible en puntos de conexión por lotes con implementaciones de componentes de canalización.

Configurar el nombre del experimento

Use los procedimientos siguientes para configurar el nombre del experimento.

Use el argumento --experiment-name para especificar el nombre del experimento:

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
                            --experiment-name "my-batch-job-experiment" \
                            --input https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data

Use el parámetro experiment_name para especificar el nombre del experimento:

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    experiment_name="my-batch-job-experiment",
    inputs={
        "heart_dataset": Input("https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"),
    }
)

Indique el nombre del experimento mediante la clave experimentName de la sección properties:

Cuerpo

{
    "properties": {
        "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFolder",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
           }
        },
        "properties":
        {
            "experimentName": "my-batch-job-experiment"
        }
    }
}

Solicitar

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json

Descripción de las entradas y salidas

Los puntos de conexión por lotes proporcionan una API duradera que los consumidores pueden usar para crear trabajos por lotes. La misma interfaz se puede usar para especificar las entradas y las salidas que espera la implementación. Use entradas para pasar cualquier información que el punto de conexión necesite para realizar el trabajo.

Diagrama que muestra cómo se utilizan las entradas y salidas en los puntos de conexión de lote.

Los puntos de conexión por lotes admiten dos tipos de entradas:

Entradas de datos: punteros a una ubicación de almacenamiento específica o a un recurso de Azure Machine Learning.
Entradas literales: valores literales (como números o cadenas) que quiere pasar al trabajo.

El número y el tipo de entradas y salidas dependen del tipo de implementación por lotes. Las implementaciones de modelos siempre requieren una entrada de datos y generan una salida de datos. No se admiten entradas literales. Sin embargo, las implementaciones de componentes de canalización proporcionan una construcción más general para compilar puntos de conexión y permiten especificar cualquier número de entradas (datos y literales) y salidas.

En la tabla siguiente se resumen las entradas y salidas de las implementaciones por lotes:

Tipo de implementación	Número de entradas	Tipos de entrada admitidos	Número de salidas	Tipos de salida compatibles
Implementación de modelo	1	Entradas de datos	1	Salidas de datos
Implementación de componentes de canalización	[0..N]	Entradas de datos y entradas literales	[0..N]	Salidas de datos

Sugerencia

Las entradas y salidas siempre se denominan. Los nombres sirven como claves para identificar los datos y pasar el valor real durante la invocación. Como las implementaciones de modelos siempre necesitan una entrada y salida, el nombre se omite durante la invocación. Puede asignar el nombre que mejor describa el caso de uso, como "estimación_ventas".

Exploración de las entradas de datos

Las entradas de datos hacen referencia a entradas que apuntan a una ubicación donde se colocan los datos. Como los puntos de conexión por lotes suelen consumir grandes cantidades de datos, no se pueden pasar los datos de entrada como parte de la solicitud de invocación. En su lugar, especifique la ubicación donde debería ir el punto de conexión por lotes para buscar los datos. Los datos de entrada se montan y transmiten en el proceso de destino para mejorar el rendimiento.

Los puntos de conexión por lotes admiten la lectura de archivos ubicados en las siguientes opciones de almacenamiento:

Recursos de datos de Azure Machine Learning, incluida la carpeta (uri_folder) y el archivo (uri_file).
Almacenes de datos de Azure Machine Learning, incluidos Azure Blob Storage, Azure Data Lake Storage Gen1 y Azure Data Lake Storage Gen2.
Cuentas de Azure Storage, incluidos Azure Data Lake Storage Gen1, Azure Data Lake Storage Gen2 y Azure Blob Storage.
Carpetas o archivos de datos locales (CLI de Azure Machine Learning o SDK de Azure Machine Learning para Python). Sin embargo, esa operación da lugar a que los datos locales se carguen en el almacén de datos de Azure Machine Learning predeterminado del área de trabajo en la que está trabajando.

Importante

Aviso de desuso: los conjuntos de datos de tipo FileDataset (V1) están en desuso y se retirarán en el futuro. Los puntos de conexión por lotes existentes que dependen de esta funcionalidad seguirán funcionando. Los puntos de conexión por lotes creados con la CLIv2 de disponibilidad general (2.4.0 y versiones posteriores) o la API REST de disponibilidad general (2022-05-01 y versiones posteriores) no admitirán el conjunto de datos V1.

Exploración de las entradas literales

Las entradas literales hacen referencia a entradas que se pueden representar y resolver en tiempo de invocación, como cadenas, números y valores booleanos. Normalmente, se usan entradas literales para pasar parámetros al punto de conexión como parte de una implementación de componentes de canalización. Los puntos de conexión por lotes admiten los siguientes tipos literales:

string
boolean
float
integer

Las entradas literales solo se admiten en implementaciones de componentes de canalización. Consulte Creación de trabajos con entradas literales para obtener información sobre cómo especificarlos.

Exploración de las salidas de datos

Las salidas de datos hacen referencia a la ubicación donde se deberán colocar los resultados de un trabajo por lotes. Cada salida se identifica por un nombre y Azure Machine Learning asigna automáticamente una ruta de acceso única a cada salida con nombre. Puede especificar otra ruta de acceso si es necesario.

Importante

Los puntos de conexión de Batch solo admiten la escritura de salidas en almacenes de datos de Azure Blob Storage. Si necesita escribir en una cuenta de almacenamiento con espacios de nombres jerárquicos habilitados (también conocida como Azure Datalake Gen2 o ADLS Gen2),puede registrar el servicio de almacenamiento como un almacén de datos de Azure Blob Storage, ya que los servicios son totalmente compatibles. De este modo, puede escribir salidas de puntos de conexión por lotes en ADLS Gen2.

Creación de trabajos con entradas de datos

En los siguientes ejemplos se muestra cómo crear trabajos que toman entradas de datos de recursos de datos, almacenes de datos y cuentas de Azure Storage.

Uso de entrada de datos desde un recurso de datos

Los recursos de datos de Azure Machine Learning (anteriormente conocidos como conjuntos de datos) se admiten como entradas para trabajos. Siga estos pasos para ejecutar un trabajo de punto de conexión por lotes mediante datos almacenados en un recurso de datos registrado en Azure Machine Learning.

Advertencia

Actualmente no se admiten los recursos de datos de tipo Table (MLTable).

Primero, cree el recurso de datos. Este recurso de datos consta de una carpeta con varios archivos CSV que se procesan en paralelo mediante puntos de conexión por lotes. Puede omitir este paso si los datos ya están registrados como un recurso de datos.
- CLI de Azure
- Python
- REST
Cree una definición de recurso de datos en YAML:

heart-dataset-unlabeled.yml
```
$schema: https://azuremlschemas.azureedge.net/latest/data.schema.json
name: heart-dataset-unlabeled
description: An unlabeled dataset for heart classification.
type: uri_folder
path: heart-classifier-mlflow/data
```
A continuación, cree el recurso de datos:
```
az ml data create -f heart-dataset-unlabeled.yml
```
Cree una definición de recurso de datos:
```
data_path = "heart-classifier-mlflow/data"
dataset_name = "heart-dataset-unlabeled"

heart_dataset_unlabeled = Data(
    path=data_path,
    type=AssetTypes.URI_FOLDER,
    description="An unlabeled dataset for heart classification",
    name=dataset_name,
)
```
Cree el recurso de datos:
```
ml_client.data.create_or_update(heart_dataset_unlabeled)
```
Para obtener el recurso de datos recién creado, use el comando siguiente:
```
heart_dataset_unlabeled = ml_client.data.get(name=dataset_name, label="latest")
```
Use la CLI de Azure Machine Learning, el SDK de Azure Machine Learning para Python o el Estudio de Azure Machine Learning para obtener la ubicación (región), el área de trabajo y el nombre y la versión del recurso de datos. Necesita estos elementos para procedimientos posteriores.

Cree la entrada o solicitud:

DATASET_ID=$(az ml data show -n heart-dataset-unlabeled --label latest | jq -r .id)

input = Input(path=heart_dataset_unlabeled.id)

Cuerpo

{
    "properties": {
        "InputData": {
            "heart_dataset": {
                "JobInputType" : "UriFolder",
                "Uri": "azureml://locations/<location>/workspaces/<workspace>/data/<dataset_name>/versions/labels/latest"
            }
        }
    }
}

El identificador del recurso de datos es similar a /subscriptions/<subscription>/resourcegroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/data/<data-asset>/versions/<version>. También puede usar el formato azureml:<datasset_name>@latest para especificar la entrada.

Ejecute el punto de conexión:
- CLI de Azure
- Python
- REST
Use el argumento --set para especificar la entrada:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$DATASET_ID
```
Para un punto de conexión que atiende una implementación de modelo, puede usar el argumento --input para especificar la entrada de datos, ya que una implementación de modelos siempre necesita una entrada de datos.
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $DATASET_ID
```
El argumento --set tiende a generar comandos largos cuando se especifican varias entradas. En esos casos, coloque las entradas en un archivo YAML y use el argumento --file para especificar las entradas que necesita para la invocación del punto de conexión.

inputs.yml
```
inputs:
  heart_dataset: azureml:/<datasset_name>@latest
```
Ejecute el siguiente comando:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
Sugerencia

¿Cuál es la diferencia entre el parámetro inputs y input al invocar un punto de conexión?

En general, puede usar un parámetro de diccionario inputs = {} con el método invoke para proporcionar un número arbitrario de entradas necesarias a un punto de conexión por lotes que contenga una implementación de modelo o una implementación de canalización.

Para una implementación de modelo, puede usar el parámetro input como una forma más corta de especificar la ubicación de los datos de entrada para la implementación. Este enfoque funciona porque una implementación de modelo siempre toma una entrada de datos.

Llame al método invoke con el parámetro inputs para especificar las entradas necesarias:
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": input,
    }
)
```
Simplifique aún más la llamada a invoke para una implementación de modelo mediante el parámetro input para especificar la ubicación de los datos de entrada:
```
job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   input=input,
)
```
Solicitar
```
POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
```

Uso de la entrada de datos desde almacenes de datos

Puede hacer referencia directamente a datos de almacenes de datos registrados de Azure Machine Learning con trabajos de implementaciones por lotes. En este ejemplo, primero va a cargar algunos datos en el almacén de datos predeterminado del área de trabajo de Azure Machine Learning y, a continuación, ejecutar una implementación por lotes en él. Siga estos pasos para ejecutar un trabajo de punto de conexión por lotes mediante los datos almacenados en un almacén de datos.

Acceda al almacén de datos predeterminado del área de trabajo de Azure Machine Learning. Si los datos están en un almacén diferente, puede usar ese almacén en su lugar. No es necesario usar el almacén de datos predeterminado.
- CLI de Azure
- Python
- REST
```
DATASTORE_ID=$(az ml datastore show -n workspaceblobstore | jq -r '.id')
```
El identificador de los almacenes de datos es similar a /subscriptions/<subscription>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>.
```
default_ds = ml_client.datastores.get_default()
```
Use la CLI de Azure Machine Learning, el SDK de Azure Machine Learning para Python o Estudio para obtener la información del almacén de datos.
Sugerencia

El almacén de datos de blobs predeterminado en un área de trabajo se denomina workspaceblobstore. Puede omitir este paso si ya conoce el identificador de recurso del almacén de datos predeterminado en el área de trabajo.
Cargue algunos datos de ejemplo en el almacén de datos.

En este ejemplo se supone que ya ha cargado los datos de ejemplo incluidos en el repositorio de la carpeta sdk/python/endpoints/batch/deploy-models/heart-classifier-mlflow/data en la carpeta heart-disease-uci-unlabeled de la cuenta de Blob Storage. Asegúrese de completar este paso antes de continuar.
Cree la entrada o solicitud:
- CLI de Azure
- Python
- REST
Coloque la ruta de acceso del archivo en la variable INPUT_PATH:
```
DATA_PATH="heart-disease-uci-unlabeled"
INPUT_PATH="$DATASTORE_ID/paths/$DATA_PATH"
```
Coloque la ruta de acceso del archivo en la variable input:
```
data_path = "heart-disease-uci-unlabeled"
input = Input(type=AssetTypes.URI_FOLDER, path=f"{default_ds.id}/paths/{data_path})
```
Si los datos son un archivo, cambie el tipo de entrada a type=AssetTypes.URI_FILE.
Cuerpo
```
{
    "properties": {
        "InputData": {
            "heart_dataset": {
                "JobInputType" : "UriFolder",
                "Uri": "azureml:/subscriptions/<subscription>/resourceGroups/<resource-group/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>/paths/<data-path>"
            }
        }
    }
}
```
Si los datos son un archivo, use el tipo UriFile para la entrada en su lugar.
Observe cómo la variable paths de la ruta de acceso se anexa al identificador de recurso del almacén de datos. Este formato indica que el valor siguiente es una ruta de acceso.

Sugerencia

También puede usar el formato azureml://datastores/<data-store>/paths/<data-path> para especificar la entrada.
Ejecute el punto de conexión:
- CLI de Azure
- Python
- REST
Use el argumento --set para especificar la entrada:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$INPUT_PATH
```
Para un punto de conexión que atiende una implementación de modelo, puede usar el argumento --input para especificar la entrada de datos, ya que una implementación de modelos siempre necesita una entrada de datos.
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $INPUT_PATH --input-type uri_folder
```
El argumento --set tiende a generar comandos largos cuando se especifican varias entradas. En esos casos, coloque las entradas en un archivo YAML y use el argumento --file para especificar las entradas que necesita para la invocación del punto de conexión.

inputs.yml
```
inputs:
  heart_dataset:
    type: uri_folder
    path: azureml://datastores/<data-store>/paths/<data-path>
```
Ejecute el siguiente comando:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
Si los datos son un archivo, use el tipo uri_file para la entrada en su lugar.
Sugerencia

¿Cuál es la diferencia entre el parámetro inputs y input al invocar un punto de conexión?

En general, puede usar un parámetro de diccionario inputs = {} con el método invoke para proporcionar un número arbitrario de entradas necesarias a un punto de conexión por lotes que contenga una implementación de modelo o una implementación de canalización.

Para una implementación de modelo, puede usar el parámetro input como una forma más corta de especificar la ubicación de los datos de entrada para la implementación. Este enfoque funciona porque una implementación de modelo siempre toma una entrada de datos.

Llame al método invoke con el parámetro inputs para especificar las entradas necesarias:
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": input,
    }
)
```
Simplifique aún más la llamada a invoke para una implementación de modelo mediante el parámetro input para especificar la ubicación de los datos de entrada:
```
job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   input=input,
)
```
Solicitar
```
POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
```

Uso de la entrada de datos desde cuentas de Azure Storage

Los puntos de conexión por lotes de Azure Machine Learning pueden leer datos de ubicaciones en la nube en cuentas de Azure Storage, tanto públicas como privadas. Siga estos pasos para ejecutar un trabajo de punto de conexión por lotes con datos almacenados en una cuenta de almacenamiento.

Para más información sobre la configuración adicional necesaria para leer datos de cuentas de almacenamiento, vea Configuración de clústeres de proceso para el acceso a datos.

Cree la entrada o solicitud:

Establezca la variable INPUT_DATA:

INPUT_DATA = "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"

Si los datos son un archivo, establezca la variable con el formato siguiente:

INPUT_DATA = "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data/heart.csv"

Establezca la variable input:

input = Input(
    type=AssetTypes.URI_FOLDER, 
    path="https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
)

Si los datos son un archivo, cambie el tipo de entrada a type=AssetTypes.URI_FILE:

input = Input(
    type=AssetTypes.URI_FILE,
    path="https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data/heart.csv"
)

Cuerpo

{
   "properties": {
       "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFolder",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
           }
       }
   }
}

Si los datos son un archivo, cambie el tipo de entrada a JobInputType:

Cuerpo

{
   "properties": {
       "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFile",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data/heart.csv"
           }
       }
   }
}

Ejecute el punto de conexión:
- CLI de Azure
- Python
- REST
Use el argumento --set para especificar la entrada:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$INPUT_DATA
```
Para un punto de conexión que atiende una implementación de modelo, puede usar el argumento --input para especificar la entrada de datos, ya que una implementación de modelos siempre necesita una entrada de datos.
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $INPUT_DATA --input-type uri_folder
```
El argumento --set tiende a generar comandos largos cuando se especifican varias entradas. En esos casos, coloque las entradas en un archivo YAML y use el argumento --file para especificar las entradas que necesita para la invocación del punto de conexión.

inputs.yml
```
inputs:
  heart_dataset:
    type: uri_folder
    path: https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data
```
Ejecute el siguiente comando:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
Si los datos son un archivo, use el tipo uri_file para la entrada en su lugar.
Sugerencia

¿Cuál es la diferencia entre el parámetro inputs y input al invocar un punto de conexión?

En general, puede usar un parámetro de diccionario inputs = {} con el método invoke para proporcionar un número arbitrario de entradas necesarias a un punto de conexión por lotes que contenga una implementación de modelo o una implementación de canalización.

Para una implementación de modelo, puede usar el parámetro input como una forma más corta de especificar la ubicación de los datos de entrada para la implementación. Este enfoque funciona porque una implementación de modelo siempre toma una entrada de datos.

Llame al método invoke con el parámetro inputs para especificar las entradas necesarias:
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": input,
    }
)
```
Simplifique aún más la llamada a invoke para una implementación de modelo mediante el parámetro input para especificar la ubicación de los datos de entrada:
```
job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   input=input,
)
```
Solicitar
```
POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
```

Creación de trabajos con entradas literales

Las implementaciones de componentes de canalización pueden tomar entradas literales. En el ejemplo siguiente, se muestra cómo especificar una entrada denominada score_mode, de tipo string, con un valor de append:

Coloque las entradas en un archivo YAML y use --file para especificar las entradas necesarias para invocar el punto de conexión.

inputs.yml

inputs:
  score_mode:
    type: string
    default: append

Ejecute el siguiente comando:

az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml

También puede usar el argumento --set para especificar el valor. Pero este enfoque tiende a generar comandos largos cuando se especifican varias entradas:

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.score_mode.type="string" inputs.score_mode.default="append"

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name, 
    inputs = { 
        'score_mode': Input(type="string", default="append")
        }
)

Cuerpo

{
    "properties": {
        "InputData": {
            "score_mode": {
                "JobInputType" : "Literal",
                "Value": "append"
            }
        }
    }
}

Solicitud

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json

Creación de trabajos con salidas de datos

En el ejemplo siguiente, se muestra cómo cambiar la ubicación en la cual se coloca una salida denominada score. Por motivos de exhaustividad, estos ejemplos también configuran una entrada denominada heart_dataset.

Guarde la salida con el almacén de datos predeterminado en el área de trabajo de Azure Machine Learning. Puede usar cualquier otro almacén de datos del área de trabajo siempre que sea una cuenta de Blob Storage.
- CLI de Azure
- Python
- REST
```
DATASTORE_ID=$(az ml datastore show -n workspaceblobstore | jq -r '.id')
```
El identificador de los almacenes de datos es similar a /subscriptions/<subscription>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>.
```
default_ds = ml_client.datastores.get_default()
```
Use la CLI de Azure Machine Learning, el SDK de Azure Machine Learning para Python o Estudio para obtener la información del almacén de datos.

Creación de una salida de datos:

Establezca la variable OUTPUT_PATH:

DATA_PATH="batch-jobs/my-unique-path"
OUTPUT_PATH="$DATASTORE_ID/paths/$DATA_PATH"

Para mayor exhaustividad, cree también una entrada de datos:

INPUT_PATH="https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"

Establezca la variable de ruta de acceso output:

data_path = "batch-jobs/my-unique-path"
output = Output(type=AssetTypes.URI_FILE, path=f"{default_ds.id}/paths/{data_path})

Para mayor exhaustividad, creemos también una entrada de datos:

input="https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"

Cuerpo

{
    "properties": {
        "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFolder",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
           }
        },
        "OutputData": {
            "score": {
                "JobOutputType" : "UriFile",
                "Uri": "azureml:/subscriptions/<subscription>/resourceGroups/<resource-group/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>/paths/<data-path>"
            }
        }
    }
}

Nota:

Observe cómo la variable paths de la ruta de acceso se anexa al identificador de recurso del almacén de datos. Este formato indica que el valor siguiente es una ruta de acceso.

Ejecute la implementación:

Use el argumento --set para especificar la entrada:

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.path=$INPUT_PATH \
    --set outputs.score.path=$OUTPUT_PATH

job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   inputs={ "heart_dataset": input },
   outputs={ "score": output }
)

Solicitar

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json

Comparteix a través de

Creación de trabajos y datos de entrada para puntos de conexión por lotes

Requisitos previos

Conceptos básicos de la creación de trabajos

Invocación de una implementación específica

Configuración de las propiedades del trabajo

Configurar el nombre del experimento

Descripción de las entradas y salidas

Exploración de las entradas de datos

Exploración de las entradas literales

Exploración de las salidas de datos

Creación de trabajos con entradas de datos

Uso de entrada de datos desde un recurso de datos

Uso de la entrada de datos desde almacenes de datos

Uso de la entrada de datos desde cuentas de Azure Storage

Creación de trabajos con entradas literales

Creación de trabajos con salidas de datos

Comentaris

Recursos addicionals

Comparteix a través de

Creación de trabajos y datos de entrada para puntos de conexión por lotes

Requisitos previos

Conceptos básicos de la creación de trabajos

Invocación de una implementación específica

Configuración de las propiedades del trabajo

Configurar el nombre del experimento

Descripción de las entradas y salidas

Exploración de las entradas de datos

Exploración de las entradas literales

Exploración de las salidas de datos

Creación de trabajos con entradas de datos

Uso de entrada de datos desde un recurso de datos

Uso de la entrada de datos desde almacenes de datos

Uso de la entrada de datos desde cuentas de Azure Storage

Creación de trabajos con entradas literales

Creación de trabajos con salidas de datos

Contenido relacionado

Comentaris

Recursos addicionals