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.
Prerrequisitos
Para usar la información de la API de REST, necesita los siguientes elementos:
Una entidad de servicio en el área de trabajo. Las solicitudes administrativas de REST usan la autenticación de entidad de servicio.
Un token de autenticación de entidad de servicio. Para recuperar este token, siga los pasos que se describen en la sección Recuperación de un token de autenticación de entidad de servicio.
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 de Invoke-WebRequest
y 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 de REST desde PowerShell, los ejemplos de este artículo suponen que usa Bash.
La utilidad jq para procesar JSON. Esta utilidad se usa para extraer valores de los documentos JSON que se devuelven de las llamadas 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 solamente la confirmación más reciente en el repositorio, lo cual 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 que se usará 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 cambiarán 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. Usará estos detalles en MLClient
del espacio d nombres azure.ai.ml
para obtener un identificador para el área de trabajo de Azure Machine Learning necesaria. Para autenticarse, use la autenticación predeterminada de Azure. Consulte este ejemplo para más información sobre cómo configurar las credenciales y conectarse a un área de trabajo.
#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)
Cuando se utiliza la CLI de Azure, se necesitan parámetros de identificación: 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 se usarán para 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
: el identificador de la suscripción a 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 de REST, los datos y los scripts de entrenamiento deben cargarse 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 poder 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 se puede usar para ejecutar el trabajo de entrenamiento. En los ejemplos siguientes, se crea un clúster de proceso denominado cpu-compute
.
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
Mientras se devuelve una respuesta después de unos segundos, esto solo indica que se ha aceptado 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, usará un command
que ejecute el script de Python main.py ubicado en ./sdk/python/jobs/single-step/lightgbm/iris/src/. El comando se ejecutará mediante su envío como 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 anteriores, se configuró:
-
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, se usa un entorno mantenido o listo proporcionado por Azure Machine Learning denominado AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu
. Usamos la versión más reciente de este entorno mediante la directiva @latest
. 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. Se puede hacer referencia a las entradas en command
mediante la expresión ${{inputs.<input_name>}}
. Para usar archivos o carpetas como entradas, puede usar la clase Input
. 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, se 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 comando az ml job create
usado en este ejemplo requiere un archivo de definición de trabajo YAML. El contenido del archivo usado en este ejemplo son:
$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.
Anteriormente, configuró 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 hacer referencia 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, se usa un entorno mantenido o listo proporcionado por Azure Machine Learning denominado AzureML-lightgbm-3.3
. Usamos la versión más reciente de este entorno mediante la directiva @latest
. 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)
Puede usar 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
Como parte del envío de trabajos, los scripts de entrenamiento y los datos deben cargarse 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, en su lugar, quiere usar REST para cargar los datos, consulte la referencia Blob put:
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 usará el clúster para ejecutar el script de entrenamiento. En este ejemplo, se usa 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 luego se almacena en la variable $ENVIRONMENT
.
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 almacenará en la variable $JOB_OUTPUT
:
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
La propiedad name
devuelta por el trabajo de entrenamiento se usa 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
El nombre (almacenado en la variable $run_id
) se usa 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
El nombre (almacenado en la variable $run_id
) se usa 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: