SE APLICA A:
Extensión ml de la CLI de Azure v2 (actual)
SDK de Python azure-ai-ml v2 (actual)
Azure Machine Learning ofrece múltiples formas de enviar trabajos de entrenamiento de ML. En este artículo, aprenderá a enviar trabajos mediante los métodos siguientes:
- Extensión de la CLI de Azure para aprendizaje automático: la extensión
ml, también denominada CLI v2.
- SDK de Python v2 para Azure Machine Learning.
- API de REST: la API en la que se basan la CLI y el SDK.
Requisitos previos
Para usar el SDK, instale el SDK de Azure Machine Learning v2 para Python.
Para usar la información de la API de REST, necesita los siguientes elementos:
Una entidad de servicio en el área de trabajo. Utilice la autenticación de entidad de servicio para las solicitudes administrativas de REST.
Un token de autenticación de entidad de servicio. Siga los pasos descritos en Recuperación de un token de autenticación de entidad de servicio para obtener este token.
La utilidad curl. El programa curl está disponible en el subsistema de Windows para Linux o en cualquier distribución de UNIX.
Sugerencia
En PowerShell, curl es un alias para Invoke-WebRequest. El comando curl -d "key=val" -X POST uri se convierte en Invoke-WebRequest -Body "key=val" -Method POST -Uri uri.
Aunque es posible llamar a la API REST desde PowerShell, los ejemplos de este artículo suponen que usa Bash.
La utilidad jq para procesar JSON. Use esta utilidad para extraer valores de los documentos JSON que devuelve la API REST.
Clone el repositorio de ejemplos
Los fragmentos de código de este artículo se basan en ejemplos del repositorio de GitHub de ejemplos de Azure Machine Learning. Para clonar el repositorio en su entorno de desarrollo, utilice el siguiente comando:
git clone --depth 1 https://github.com/Azure/azureml-examples
Sugerencia
Use --depth 1 para clonar solo la confirmación más reciente en el repositorio, lo que reduce el tiempo para completar la operación.
Trabajo de ejemplo
Los ejemplos de este artículo utilizan el conjunto de datos de la flor del iris para entrenar un modelo MLFlow.
Entrenamiento en la nube
Al entrenar en la nube, debe conectarse al área de trabajo de Azure Machine Learning y seleccionar un recurso de proceso para ejecutar el trabajo de entrenamiento.
1. Conexión al área de trabajo
Sugerencia
Use las pestañas siguientes para seleccionar el método que desea usar para entrenar un modelo. Al seleccionar una pestaña, se cambia automáticamente todas las pestañas de este artículo a la misma pestaña. Puede seleccionar otra pestaña en cualquier momento.
Para conectarse al área de trabajo, necesita parámetros de identificador: una suscripción, un grupo de recursos y un nombre de área de trabajo. Use estos detalles en el elemento MLClient del espacio de nombres azure.ai.ml para tener disponible un control para el área de trabajo de Azure Machine Learning correspondiente. Para autenticarse, use la autenticación predeterminada de Azure. Para obtener más información sobre cómo configurar las credenciales y conectarse a un área de trabajo, consulte este ejemplo.
#import required libraries
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential
#Enter details of your Azure Machine Learning workspace
subscription_id = '<SUBSCRIPTION_ID>'
resource_group = '<RESOURCE_GROUP>'
workspace = '<AZUREML_WORKSPACE_NAME>'
#connect to the workspace
ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
Al usar la CLI de Azure, necesita parámetros de identificador: una suscripción, un grupo de recursos y un nombre de área de trabajo. Aunque puede especificar estos parámetros para cada comando, también puede establecer los valores predeterminados que usan todos los comandos. Use los siguientes comandos para establecer valores predeterminados. Reemplace <subscription ID>, <Azure Machine Learning workspace name> y <resource group> por los valores de la configuración:
az account set --subscription <subscription ID>
az configure --defaults workspace=<Azure Machine Learning workspace name> group=<resource group>
En los ejemplos de la API de REST de este artículo se usan marcadores de posición $SUBSCRIPTION_ID, $RESOURCE_GROUP, $LOCATION, y $WORKSPACE. Reemplace los marcadores de posición con sus propios valores de la siguiente manera:
-
$SUBSCRIPTION_ID: ID de su suscripción de Azure.
-
$RESOURCE_GROUP: el grupo de recursos de Azure que contiene su área de trabajo.
-
$LOCATION: la región de Azure donde se encuentra el área de trabajo.
-
$WORKSPACE: el nombre del área de trabajo de Azure Machine Learning.
-
$COMPUTE_NAME: el nombre de su clúster de proceso de Azure Machine Learning.
Las REST administrativa solicita un token de autenticación de entidad de servicio. Puede recuperar un token con el siguiente comando. El token se almacena en la variable de entorno $TOKEN:
TOKEN=$(az account get-access-token --query accessToken -o tsv)
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 versión de la API como una variable para dar cabida a versiones futuras:
API_VERSION="2022-05-01"
Al entrenar mediante la API REST, debe cargar los datos y los scripts de entrenamiento en una cuenta de almacenamiento a la que pueda acceder el área de trabajo. En el ejemplo siguiente se obtiene la información de almacenamiento del área de trabajo y se guarda en variables para que pueda usarla más adelante:
# 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')
2. Creación de un recurso de proceso para el entrenamiento
Un clúster de proceso de Azure Machine Learning es un recurso de proceso totalmente administrado que puede usar para ejecutar el trabajo de entrenamiento. En los ejemplos siguientes, creará un clúster de proceso denominado cpu-cluster.
from azure.ai.ml.entities import AmlCompute
# specify aml compute name.
cpu_compute_target = "cpu-cluster"
try:
ml_client.compute.get(cpu_compute_target)
except Exception:
print("Creating a new cpu compute target...")
compute = AmlCompute(
name=cpu_compute_target, size="STANDARD_D2_V2", min_instances=0, max_instances=4
)
ml_client.compute.begin_create_or_update(compute).result()
az ml compute create -n cpu-cluster --type amlcompute --min-instances 0 --max-instances 4
curl -X PUT \
"https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/computes/$COMPUTE_NAME?api-version=$API_VERSION" \
-H "Authorization:Bearer $TOKEN" \
-H "Content-Type: application/json" \
-d '{
"location": "'$LOCATION'",
"properties": {
"computeType": "AmlCompute",
"properties": {
"vmSize": "Standard_D2_V2",
"vmPriority": "Dedicated",
"scaleSettings": {
"maxNodeCount": 4,
"minNodeCount": 0,
"nodeIdleTimeBeforeScaleDown": "PT30M"
}
}
}
}'
Sugerencia
Aunque la operación devuelve una respuesta después de unos segundos, esta respuesta solo indica que se acepta la solicitud de creación. La creación del clúster puede tardar varios minutos en finalizar.
3. Envío del trabajo de entrenamiento
Para ejecutar este script, use un command que ejecute el script de Python main.py que se encuentra en ./sdk/python/jobs/single-step/lightgbm/iris/src/. Tú envías el comando como un job a Azure Machine Learning.
from azure.ai.ml import command, Input
# define the command
command_job = command(
code="./src",
command="python main.py --iris-csv ${{inputs.iris_csv}} --learning-rate ${{inputs.learning_rate}} --boosting ${{inputs.boosting}}",
environment="AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu@latest",
inputs={
"iris_csv": Input(
type="uri_file",
path="https://azuremlexamples.blob.core.windows.net/datasets/iris.csv",
),
"learning_rate": 0.9,
"boosting": "gbdt",
},
compute="cpu-cluster",
)
# submit the command
returned_job = ml_client.jobs.create_or_update(command_job)
# get a URL for the status of the job
returned_job.studio_url
En los ejemplos previos, configuraste:
-
code : ruta de acceso donde se encuentra el código para ejecutar el comando.
-
command : comando que debe ejecutarse.
-
environment: el entorno necesario para ejecutar el script de entrenamiento. En este ejemplo, use un entorno mantenido o listo proporcionado por Azure Machine Learning denominado AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu. Use la versión más reciente de este entorno mediante la @latest directiva . También puede usar entornos personalizados especificando una imagen de Docker base y especificando un yaml de conda sobre él.
-
inputs: diccionario de entradas mediante pares de nombre y valor para el comando. La clave es un nombre para la entrada dentro del contexto del trabajo y el valor es el valor de entrada. Referencia las entradas de command mediante la expresión ${{inputs.<input_name>}}. Para usar archivos o carpetas como entradas, use la Input clase . Para más información, consulte SDK and CLI v2 expressions (Expresiones de SDK y CLI v2).
Para más información, consulte la documentación de referencia.
Al enviar el trabajo, el servicio devuelve una dirección URL al estado del trabajo en Azure Machine Learning Studio. Use la interfaz de usuario de Studio para ver el progreso del trabajo. También puede usar returned_job.status para comprobar el estado actual del trabajo.
El az ml job create comando de este ejemplo requiere un archivo de definición de trabajo YAML. El archivo usado en este ejemplo contiene el siguiente contenido:
$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
code: src
command: >-
python main.py
--iris-csv ${{inputs.iris_csv}}
inputs:
iris_csv:
type: uri_file
path: https://azuremlexamples.blob.core.windows.net/datasets/iris.csv
environment: azureml:AzureML-lightgbm-3.3@latest
compute: azureml:cpu-cluster
display_name: lightgbm-iris-example
experiment_name: lightgbm-iris-example
description: Train a LightGBM model on the Iris dataset.
En el YAML anterior, ha configurado lo siguiente:
-
code : ruta de acceso donde se encuentra el código para ejecutar el comando.
-
command : comando que debe ejecutarse.
-
inputs: diccionario de entradas mediante pares de nombre y valor para el comando. La clave es un nombre para la entrada dentro del contexto del trabajo y el valor es el valor de entrada. Se puede apuntar a las entradas en command mediante la expresión ${{inputs.<input_name>}}. Para más información, consulte SDK and CLI v2 expressions (Expresiones de SDK y CLI v2).
-
environment: el entorno necesario para ejecutar el script de entrenamiento. En este ejemplo, use un entorno mantenido o listo proporcionado por Azure Machine Learning denominado AzureML-lightgbm-3.3. Use la versión más reciente de este entorno mediante la @latest directiva . También puede usar entornos personalizados especificando una imagen de Docker base y especificando un yaml de conda sobre él.
Para enviar el trabajo, utilice el siguiente comando. El identificador de ejecución (nombre) del trabajo de entrenamiento se almacena en la variable $run_id:
run_id=$(az ml job create -f jobs/single-step/lightgbm/iris/job.yml --query name -o tsv)
Use el identificador de ejecución almacenado para devolver información sobre el trabajo. El parámetro --web abre la interfaz de usuario web de Azure Machine Learning Studio, donde puede profundizar en los detalles del trabajo:
az ml job show -n $run_id --web
Al enviar un trabajo, debe cargar los scripts de entrenamiento y los datos en una ubicación de almacenamiento en la nube a la que pueda acceder el área de trabajo de Azure Machine Learning.
Use el siguiente comando de la CLI de Azure para cargar el script de entrenamiento. El comando especifica el directorio que contiene los archivos necesarios para el entrenamiento, no un archivo individual. Si quiere usar REST para cargar los datos en su lugar, consulte la referencia put Blob :
az storage blob upload-batch -d $AZUREML_DEFAULT_CONTAINER/testjob -s cli/jobs/single-step/lightgbm/iris/src/ --account-name $AZURE_STORAGE_ACCOUNT
Cree una referencia con versiones a los datos de entrenamiento. En este ejemplo, los datos ya están en la nube y se encuentran en https://azuremlexamples.blob.core.windows.net/datasets/iris.csv. Para obtener más información sobre cómo hacer referencia a datos, consulte Datos en Azure Machine Learning:
DATA_VERSION=$RANDOM
curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/data/iris-data/versions/$DATA_VERSION?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{
\"properties\": {
\"description\": \"Iris dataset\",
\"dataType\": \"uri_file\",
\"dataUri\": \"https://azuremlexamples.blob.core.windows.net/datasets/iris.csv\"
}
}"
Registre una referencia con versiones al script de entrenamiento para su uso con un trabajo. En este ejemplo, la ubicación del script es la cuenta de almacenamiento predeterminada y el contenedor que ha cargado en el paso 1. Se devuelve el identificador del código de entrenamiento con versiones y se almacena en la variable $TRAIN_CODE:
TRAIN_CODE=$(curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/codes/train-lightgbm/versions/1?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{
\"properties\": {
\"description\": \"Train code\",
\"codeUri\": \"https://$AZURE_STORAGE_ACCOUNT.blob.core.windows.net/$AZUREML_DEFAULT_CONTAINER/testjob\"
}
}" | jq -r '.id')
Cree el entorno que usa el clúster para ejecutar el script de entrenamiento. En este ejemplo, use un entorno mantenido o listo proporcionado por Azure Machine Learning denominado AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu. El siguiente comando recupera una lista de las versiones de entorno, con la versión más reciente en la parte superior de la colección.
jq se usa para recuperar el identificador de la versión más reciente ([0]), que a continuación se almacena en la $ENVIRONMENT variable .
ENVIRONMENT=$(curl --location --request GET "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/environments/AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu?api-version=$API_VERSION" --header "Authorization: Bearer $TOKEN" | jq -r .id)
Por último, envíe el trabajo. El siguiente ejemplo muestra cómo enviar el trabajo, referenciar el ID del código de entrenamiento, el ID del entorno, la URL de los datos de entrada y el ID del clúster de proceso. La ubicación de salida del trabajo se almacena en la $JOB_OUTPUT variable :
Sugerencia
El nombre del trabajo debe ser único. En este ejemplo, uuidgen se usa para generar un valor único para el nombre.
run_id=$(uuidgen)
curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/jobs/$run_id?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{
\"properties\": {
\"jobType\": \"Command\",
\"codeId\": \"$TRAIN_CODE\",
\"command\": \"python main.py --iris-csv \$AZURE_ML_INPUT_iris\",
\"environmentId\": \"$ENVIRONMENT\",
\"inputs\": {
\"iris\": {
\"jobInputType\": \"uri_file\",
\"uri\": \"https://azuremlexamples.blob.core.windows.net/datasets/iris.csv\"
}
},
\"experimentName\": \"lightgbm-iris\",
\"computeId\": \"/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/computes/$COMPUTE_NAME\"
}
}"
Registro del modelo entrenado
En los ejemplos siguientes se muestra cómo registrar un modelo en el área de trabajo de Azure Machine Learning.
Sugerencia
El trabajo de entrenamiento devuelve la propiedad name. Use este nombre como parte de la ruta de acceso al modelo.
from azure.ai.ml.entities import Model
from azure.ai.ml.constants import AssetTypes
run_model = Model(
path="azureml://jobs/{}/outputs/artifacts/paths/model/".format(returned_job.name),
name="run-model-example",
description="Model created from run.",
type=AssetTypes.MLFLOW_MODEL
)
ml_client.models.create_or_update(run_model)
Sugerencia
Use el nombre almacenado en la $run_id variable como parte de la ruta de acceso al modelo.
az ml model create -n sklearn-iris-example -v 1 -p runs:/$run_id/model --type mlflow_model
Sugerencia
Use el nombre almacenado en la $run_id variable como parte de la ruta de acceso al 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\": {
\"modelType\": \"mlflow_model\",
\"modelUri\":\"runs:/$run_id/model\"
}
}"
Pasos siguientes
Ahora que tiene un modelo entrenado, aprenda a implementarlo mediante un punto de conexión en línea.
Para obtener más ejemplos, consulte el repositorio de GitHub de ejemplos de Azure Machine Learning.
Para más información sobre los comandos de la CLI de Azure, las clases del SDK de Python o las API de REST que se usan en este artículo, consulte la siguiente documentación de referencia: