Compartir a través de

Implementación de modelos con REST

  • Artículo

En este artículo se describe cómo usar la API de REST de Azure Machine Learning para implementar modelos mediante puntos de conexión en línea. Los puntos de conexión en línea permiten implementar el modelo sin tener que crear y administrar la infraestructura subyacente y los clústeres de Kubernetes. Los procedimientos siguientes muestran cómo crear un punto de conexión en línea y una implementación y validarlo invocando.

Hay muchas maneras de crear un punto de conexión en línea de Azure Machine Learning. Puede usar la CLI de Azure, la Estudio de Azure Machine Learning, o la API de REST. La API REST utiliza verbos HTTP estándar para crear, recuperar, actualizar y eliminar recursos. Funciona con cualquier lenguaje o herramienta que pueda realizar solicitudes HTTP. La estructura sencilla de la API de REST lo convierte en una buena opción en entornos de scripting y para la automatización de operaciones de aprendizaje automático.

Requisitos previos

Establecimiento de un nombre de punto de conexión

Los nombres de punto de conexión deben ser únicos en el nivel de región de Azure. Un nombre de punto de conexión, como my-endpoint, debe ser el único extremo con ese nombre dentro de una región especificada.

Cree un nombre de punto de conexión único llamando a la utilidad RANDOM, que agrega un número aleatorio como sufijo al valor endpt-rest:

export ENDPOINT_NAME=endpt-rest-`echo $RANDOM`

Crear recursos de aprendizaje automático

Para prepararse para la implementación, configure los recursos de Azure Machine Learning y configure el trabajo. Puede registrar los recursos necesarios para la implementación, incluido el modelo, el código y el entorno.

Sugerencia

Las llamadas a la API REST de los procedimientos siguientes usan $SUBSCRIPTION_ID, $RESOURCE_GROUP, $LOCATION (región) y Azure Machine Learning $WORKSPACE como marcadores de posición para algunos argumentos. Al implementar el código de la implementación, reemplace los marcadores de posición del argumento por los valores de implementación específicos.

Las REST administrativa solicita un token de autenticación de entidad de servicio. Al implementar el código de la implementación, reemplace las instancias del marcador de posición $TOKEN por el token de entidad de servicio de la implementación. Este token se puede recuperar con el siguiente comando:

response=$(curl -H "Content-Length: 0" --location --request POST "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME/token?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN")
accessToken=$(echo $response | jq -r '.accessToken')

El proveedor de servicios utiliza el argumento api-version para garantizar la compatibilidad. El argumento api-version varía de un servicio a otro.

Establezca la variable API_version para dar cabida a versiones futuras:

API_VERSION="2022-05-01"

Obtención de los detalles de una cuenta de almacenamiento

Para registrar el modelo y el código, primero debe cargar estos elementos en una cuenta de Azure Storage. Los detalles de la cuenta de Azure Storage están disponibles en el almacén de datos. En este ejemplo, obtendrá el almacén de datos predeterminado y la cuenta de Azure Storage para el área de trabajo. Consulte el área de trabajo con una solicitud GET para obtener un archivo JSON con la información.

Puede usar la herramienta de jq para analizar el resultado JSON y obtener los valores necesarios. También puede usar Azure Portal para buscar la misma información:

# Get values for storage account
response=$(curl --location --request GET "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/datastores?api-version=$API_VERSION&isDefault=true" \
--header "Authorization: Bearer $TOKEN")
AZUREML_DEFAULT_DATASTORE=$(echo $response | jq -r '.value[0].name')
AZUREML_DEFAULT_CONTAINER=$(echo $response | jq -r '.value[0].properties.containerName')
export AZURE_STORAGE_ACCOUNT=$(echo $response | jq -r '.value[0].properties.accountName')

Carga y registro de código

Ahora que tiene el almacén de datos, puede cargar el script de puntuación. Use Azure Storage CLI para cargar un blob en el contenedor predeterminado:

az storage blob upload-batch -d $AZUREML_DEFAULT_CONTAINER/score -s endpoints/online/model-1/onlinescoring

Sugerencia

Puede usar otros métodos para completar la carga, como Azure Portal o Explorador de Azure Storage.

Después de cargar el código, puede especificar el código con una solicitud PUT y hacer referencia al almacén de datos con el identificador de datastoreId:

curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/codes/score-sklearn/versions/1?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{
  \"properties\": {
    \"codeUri\": \"https://$AZURE_STORAGE_ACCOUNT.blob.core.windows.net/$AZUREML_DEFAULT_CONTAINER/score\"
  }
}"

Carga y registro del modelo

Cargue los archivos de modelo con una llamada a la API de REST similar:

az storage blob upload-batch -d $AZUREML_DEFAULT_CONTAINER/model -s endpoints/online/model-1/model

Una vez completada la carga, registre el modelo:

curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/models/sklearn/versions/1?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{
    \"properties\": {
        \"modelUri\":\"azureml://subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/workspaces/$WORKSPACE/datastores/$AZUREML_DEFAULT_DATASTORE/paths/model\"
    }
}"

Creación del entorno

La implementación debe ejecutarse en un entorno que tenga las dependencias necesarias. Cree el entorno con una solicitud PUT. Use una imagen de Docker desde Microsoft Container Registry. Puede configurar la imagen de Docker con el comando docker y agregar dependencias de conda con el comando condaFile.

El código siguiente lee el contenido de un entorno de conda (archivo YAML) en una variable de entorno:

ENV_VERSION=$RANDOM
curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/environments/sklearn-env/versions/$ENV_VERSION?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{
    \"properties\":{
        \"condaFile\": \"$CONDA_FILE\",
        \"image\": \"mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:20210727.v1\"
    }
}"

Creación de un punto de conexión

Cree el punto de conexión en línea:

response=$(curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME?api-version=$API_VERSION" \
--header "Content-Type: application/json" \
--header "Authorization: Bearer $TOKEN" \
--data-raw "{
    \"identity\": {
       \"type\": \"systemAssigned\"
    },
    \"properties\": {
        \"authMode\": \"AMLToken\"
    },
    \"location\": \"$LOCATION\"
}")

Creación de una implementación

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

response=$(curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME/deployments/blue?api-version=$API_VERSION" \
--header "Content-Type: application/json" \
--header "Authorization: Bearer $TOKEN" \
--data-raw "{
    \"location\": \"$LOCATION\",
    \"sku\": {
        \"capacity\": 1,
        \"name\": \"Standard_DS2_v2\"
    },
    \"properties\": {
        \"endpointComputeType\": \"Managed\",
        \"scaleSettings\": {
            \"scaleType\": \"Default\"
        },
        \"model\": \"/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/models/sklearn/versions/1\",
        \"codeConfiguration\": {
            \"codeId\": \"/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/codes/score-sklearn/versions/1\",
            \"scoringScript\": \"score.py\"
        },
        \"environmentId\": \"/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/environments/sklearn-env/versions/$ENV_VERSION\"
    }
}")

Invocación del punto de conexión para puntuar datos con el modelo

Necesita el URI de puntuación y el token de acceso para invocar el punto de conexión de implementación.

En primer lugar, obtenga el URI de puntuación:

response=$(curl --location --request GET "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME?api-version=$API_VERSION" \
--header "Content-Type: application/json" \
--header "Authorization: Bearer $TOKEN")

scoringUri=$(echo $response | jq -r '.properties.scoringUri')

A continuación, obtenga el token de acceso del punto de conexión:

response=$(curl -H "Content-Length: 0" --location --request POST "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME/token?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN")
accessToken=$(echo $response | jq -r '.accessToken')

Por último, invoque el punto de conexión mediante la utilidad curl:

curl --location --request POST $scoringUri \
--header "Authorization: Bearer $accessToken" \
--header "Content-Type: application/json" \
--data-raw @endpoints/online/model-1/sample-request.json

Comprobación de los registros de implementación

Compruebe los registros de implementación:

curl --location --request POST "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME/deployments/blue/getLogs?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{ \"tail\": 100 }"

Eliminación de un punto de conexión

Si no va a usar aún más la implementación, elimine los recursos.

Ejecute el siguiente comando, que elimina el punto de conexión y todas las implementaciones subyacentes:

curl --location --request DELETE "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME?api-version=$API_VERSION" \
--header "Content-Type: application/json" \
--header "Authorization: Bearer $TOKEN" || true

Contenido relacionado