Configuración del entrenamiento de AutoML para datos tabulares con la CLI de Azure Machine Learning y el SDK de Python

SE APLICA A:Extensión ML de la CLI de Azure v2 (actual)SDK de Python azure-ai-ml v2 (actual)

En este artículo, aprenderá a configurar un trabajo de entrenamiento de AutoML con el SDK de Python de Azure Machine Learning v2. AutoML selecciona automáticamente un algoritmo y los hiperparámetros, y genera un modelo listo para la implementación. En este artículo, se proporcionan detalles de las distintas opciones que puede usar para configurar experimentos de AutoML.

Si prefiere una experiencia sin código, también puede configurar el entrenamiento de AutoML sin código para datos tabulares con la interfaz de usuario de Estudio.

Requisitos previos

• Suscripción a Azure. Si no tiene una suscripción de Azure, cree una cuenta gratuita antes de empezar. Pruebe la versión gratuita o de pago de Azure Machine Learning.
• Un área de trabajo de Azure Machine Learning. Si no tiene, consulte Creación de recursos para empezar.

Configurar el área de trabajo

Para conectarse a un área de trabajo, debe proporcionar una suscripción, un grupo de recursos y un área de trabajo.

from azure.identity import DefaultAzureCredential
from azure.ai.ml import MLClient

credential = DefaultAzureCredential()
ml_client = None
try:
    ml_client = MLClient.from_config(credential)
except Exception as ex:
    print(ex)
    # Enter details of your Azure Machine Learning workspace
    subscription_id = "<SUBSCRIPTION_ID>"
    resource_group = "<RESOURCE_GROUP>"
    workspace = "<AZUREML_WORKSPACE_NAME>"
    ml_client = MLClient(credential, subscription_id, resource_group, workspace)

az login

az configure --defaults group=<RESOURCE_GROUP> workspace=<AZUREML_WORKSPACE_NAME> location=<LOCATION>

Especificar formato y origen de datos

Para proporcionar datos de entrenamiento en el SDK v2, debe cargarlos en la nube a través de una MLTable.

Requisitos para cargar datos en una tabla MLTable:

• Los datos deben estar en formato tabular.
• El valor que se va a predecir, la columna de destino, debe estar en los datos.

Los datos de entrenamiento deben ser accesibles desde el proceso remoto. AutoML v2 (SDK de Python y CLI/YAML) acepta recursos de datos de MLTable (v2). Aunque para la compatibilidad con versiones anteriores también admite conjuntos de datos tabulares desde la versión 1, un conjunto de datos tabular registrado, a través de las mismas propiedades del conjunto de datos de entrada. Se recomienda usar MLTable, disponible en la versión 2. En este ejemplo, los datos se almacenan en la ruta de acceso local, ./train_data/bank_marketing_train_data.csv.

import mltable

paths = [
    {'file': './train_data/bank_marketing_train_data.csv'}
]

train_table = mltable.from_delimited_files(paths)
train_table.save('./train_data')

$schema: https://azuremlschemas.azureedge.net/latest/MLTable.schema.json

paths:
  - file: ./bank_marketing_train_data.csv
transformations:
  - read_delimited:
        delimiter: ','
        encoding: 'ascii'

Ahora la carpeta ./train_data tiene el archivo de definición de MLTable más el archivo de datos, bank_marketing_train_data.csv.

Para más información sobre MLTable, consulte Trabajar con tablas en Azure Machine Learning.

Datos de entrenamiento, validación y prueba

Puede especificar datos de entrenamiento y conjuntos de datos de validación. Debe proporcionar datos de entrenamiento al parámetro training_data en la función de fábrica del trabajo de AutoML.

Si no especifica explícitamente un parámetro validation_data o n_cross_validation, AutoML aplica técnicas predeterminadas para determinar cómo realizar la validación. Esta determinación depende del número de filas del conjunto de datos asignadas a su parámetro training_data.

Proceso para ejecutar el experimento

Actualmente, los trabajos de AutoML con el SDK de Python v2 (o la CLI v2) solo se admiten en el clúster de proceso remoto o en la instancia de proceso de Azure Machine Learning. Para obtener más información sobre cómo crear proceso con el SDKv2 o CLIv2 de Python, consulte Entrenamiento de modelos con la CLI de Azure Machine Learning, el SDK y la API de REST.

Establecer la configuración de experimento

Puede usar varias opciones para configurar el experimento de AutoML. Estos parámetros de configuración se establecen en el método de tarea. También puede establecer la configuración de entrenamiento de trabajo y los criterios de salida con la configuración de training y limits.

En el ejemplo siguiente se muestran los parámetros necesarios para una tarea de clasificación que especifica la precisión como métrica principal y cinco iteraciones de validación cruzada.

from azure.ai.ml.constants import AssetTypes
from azure.ai.ml import automl, Input

# note that this is a code snippet -- you might have to modify the variable values to run it successfully

# make an Input object for the training data
my_training_data_input = Input(
    type=AssetTypes.MLTABLE, path="./data/training-mltable-folder"
)

# configure the classification job
classification_job = automl.classification(
    compute=my_compute_name,
    experiment_name=my_exp_name,
    training_data=my_training_data_input,
    target_column_name="y",
    primary_metric="accuracy",
    n_cross_validations=5,
    enable_model_explainability=True,
    tags={"my_custom_tag": "My custom value"}
)

# Limits are all optional
classification_job.set_limits(
    timeout_minutes=600, 
    trial_timeout_minutes=20, 
    max_trials=5,
    enable_early_termination=True,
)

# Training properties are optional
classification_job.set_training(
    blocked_training_algorithms=["logistic_regression"], 
    enable_onnx_compatible_models=True
)

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: <my_exp_name>
description: A classification AutoML job
task: classification

training_data:
    path: "./train_data"
    type: mltable

compute: azureml:<my_compute_name>
primary_metric: accuracy  
target_column_name: y
n_cross_validations: 5
enable_model_explainability: True

tags:
    <my_custom_tag>: <My custom value>

limits:
    timeout_minutes: 600 
    trial_timeout_minutes: 20 
    max_trials: 5
    enable_early_termination: True

training:
    blocked_training_algorithms: ["logistic_regression"] 
    enable_onnx_compatible_models: True

Seleccione el tipo de tarea de aprendizaje automático

Antes de poder enviar el trabajo de AutoML, determine el tipo de problema de aprendizaje automático que desea resolver. Este problema determina qué función usa el trabajo y qué algoritmos de modelo aplica.

AutoML admite diferentes tipos de tareas:

• Tareas basadas en datos tabulares

  • clasificación
  • regresión
  • pronóstico

• Tareas de Computer Vision, incluidas

  • Clasificación de imágenes
  • Detección de objetos

• Tareas de procesamiento de lenguaje natural, incluidas

  • Clasificación del texto
  • Reconocimiento de entidades

Para más información, consulte el artículo sobre las tipos de tareas. Para más información sobre cómo configurar trabajos de previsión, consulte Configuración de AutoML para entrenar un modelo de previsión de series temporales.

Algoritmos admitidos

AutoML prueba diferentes modelos y algoritmos durante el proceso de automatización y optimización. Como usuario, no necesita especificar el algoritmo.

El método de tarea determina la lista de algoritmos o modelos que se van a aplicar. Para modificar aún más las iteraciones con los modelos disponibles para incluir o excluir, use los parámetros allowed_training_algorithms o blocked_training_algorithmsen la configuración training del trabajo.

En la siguiente tabla, explore los algoritmos admitidos por tarea de aprendizaje automático.

Con otros algoritmos:

• Algoritmos de varias clases de clasificación de imágenes
• Algoritmos de varias etiquetas de clasificación de imágenes
• Algoritmos de detección de objetos de imagen
• Algoritmos de varias etiquetas de clasificación de texto NLP
• Algoritmos de reconocimiento de entidades con nombre de texto NLP (NER)

Para ver cuadernos de ejemplo de cada tipo de tarea, consulte automl-standalone-jobs.

Métrica principal

El parámetro primary_metric determina la métrica que se va a usar durante el entrenamiento del modelo para la optimización. El tipo de tarea que elija determina las métricas que puede seleccionar.

Elegir una métrica principal para AutoML para optimizar depende de muchos factores. Se recomienda que la consideración principal sea elegir la métrica que mejor represente las necesidades de su empresa. A continuación, considere si la métrica es adecuada para su perfil de conjunto de datos, incluido el tamaño de datos, el intervalo y la distribución de clases. En las secciones siguientes se resumen las métricas principales recomendadas en función del tipo de tarea y el escenario empresarial.

Para obtener información sobre las definiciones específicas de estas métricas, consulte evaluación de los resultados del experimento de AutoML.

Métricas para escenarios de clasificación de varias clases

Estas métricas se aplican a todos los escenarios de clasificación, incluidos datos tabulares, imágenes o computer vision y texto de procesamiento del lenguaje natural (texto NLP).

Las métricas dependientes de umbrales, como accuracy, recall_score_weighted, norm_macro_recall y precision_score_weighted, podrían no optimizarse adecuadamente para los conjuntos de datos que son pequeños, tienen un sesgo de clase muy grande (desequilibrio de clases) o si el valor de métrica esperado está muy cerca de 0,0 o 1,0. En esos casos, AUC_weighted puede ser una mejor opción de métrica principal. Una vez que el aprendizaje automático automatizado se complete, puede elegir el modelo ganador en función de la métrica más adecuada para sus necesidades empresariales.

Métricas para escenarios de clasificación de varias etiquetas

En el caso de la clasificación de texto con varias etiquetas, actualmente "Precisión" es la única métrica principal admitida.

En el caso de la clasificación de imágenes con varias etiquetas, las métricas principales admitidas se definen en la enumeración ClassificationMultilabelPrimaryMetrics.

Métricas para escenarios de reconocimiento de entidades con nombre de texto NLP

Para el texto de Named Entity Recognition (NER) de NLP, actualmente "Precisión" es la única métrica principal admitida.

Métricas para escenarios de regresión

r2_score, normalized_mean_absolute_error y normalized_root_mean_squared_error intentan minimizar los errores de predicción. r2_score y normalized_root_mean_squared_error minimizan los errores cuadráticos medios, mientras normalized_mean_absolute_error minimiza el valor absoluto medio de los errores. El valor absoluto trata los errores en todas las magnitudes por igual y los errores al cuadrado tienen una penalización mucho mayor para los errores con valores absolutos mayores. En función de si los errores mayores se deben penalizar más o no, puede optar por optimizar el error al cuadrado o el error absoluto.

La principal diferencia entre r2_score y normalized_root_mean_squared_error es cómo se normalizan y sus significados. normalized_root_mean_squared_error es la raíz del error cuadrático medio normalizada por intervalo y se puede interpretar como la magnitud media del error para la predicción. r2_score es el error cuadrático medio normalizado por una estimación de varianza de datos. Es la proporción de variación que puede capturar el modelo.

Si el rango, en lugar del valor exacto, es de interés, spearman_correlation puede ser una mejor opción. Mide la correlación de clasificación entre los valores reales y las predicciones.

AutoML no admite actualmente ninguna métrica principal que mida la diferencia relativa entre las predicciones y las observaciones. Las métricas r2_score, normalized_mean_absolute_errory normalized_root_mean_squared_error son medidas de diferencia absoluta. Por ejemplo, si una predicción difiere de una observación en 10 unidades, estas métricas calculan el mismo valor si la observación es de 20 unidades o de 20 000 unidades. En cambio, una diferencia porcentual, que es una medida relativa, proporciona errores del 50 % y del 0,05 %, respectivamente. Para optimizar la diferencia relativa, puede ejecutar AutoML con una métrica principal compatible y, a continuación, seleccionar el modelo con el mejor mean_absolute_percentage_error o root_mean_squared_log_error. Estas métricas no están definidas cuando los valores de observación son cero, por lo que es posible que no siempre sean buenas opciones.

Métricas para escenarios de previsión de series temporales

Las recomendaciones son similares a las recomendaciones para escenarios de regresión.

Métricas para escenarios de detección de objetos de imagen

En el caso de la detección de objetos de imagen, las métricas principales admitidas se definen en la enumeración ObjectDetectionPrimaryMetrics.

Métricas para escenarios de segmentación de instancias de imagen

En escenarios de segmentación de instancias de imagen, las métricas principales admitidas se definen en la enumeración InstanceSegmentationPrimaryMetrics.

Caracterización de datos

En cada experimento de AutoML, los datos se transforman automáticamente en números y vectores de números. Los datos también se escalan y se normalizan automáticamente para ayudar a los algoritmos que dependen de características que se encuentran en diferentes escalas. Estas transformaciones de datos se denominan caracterización.

Al configurar trabajos de AutoML, puede habilitar o deshabilitar la configuración de featurization.

En la tabla siguiente se muestra la configuración aceptada para la caracterización.

En el código siguiente, se muestra cómo proporcionar características personalizadas en este caso para un trabajo de regresión.

from azure.ai.ml.automl import ColumnTransformer

transformer_params = {
    "imputer": [
        ColumnTransformer(fields=["CACH"], parameters={"strategy": "most_frequent"}),
        ColumnTransformer(fields=["PRP"], parameters={"strategy": "most_frequent"}),
    ],
}
regression_job.set_featurization(
    mode="custom",
    transformer_params=transformer_params,
    blocked_transformers=["LabelEncoding"],
    column_name_and_types={"CHMIN": "Categorical"},
)

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: <my_exp_name>
description: A classification AutoML job
task: classification

training_data:
    path: "./train_data"
    type: mltable

compute: azureml:<my_compute_name>
primary_metric: accuracy  
target_column_name: y
n_cross_validations: 5
enable_model_explainability: True

featurization:
    mode: custom
    column_name_and_types:
        CHMIN: Categorical
    blocked_transformers: ["label_encoder"]
    transformer_params:
        imputer:
            - fields: ["CACH", "PRP"]
            parameters:
                strategy: most_frequent

limits:
    # limit settings

training:
    # training settings

Exit criteria (Criterios de salida)

Puede definir algunas opciones en la función set_limits() para finalizar el experimento antes de que se complete el trabajo.

Ejecutar experimento

Envíe el experimento para ejecutar y generar un modelo.

Con MLClient creado en los requisitos previos, puede ejecutar el siguiente comando en el área de trabajo.

# Submit the AutoML job
returned_job = ml_client.jobs.create_or_update(
    classification_job
)  # submit the job to the backend

print(f"Created job: {returned_job}")

# Get a URL for the status of the job
returned_job.services["Studio"].endpoint

run_id=$(az ml job create --file automl-classification-job.yml -w <Workspace> -g <Resource Group> --subscription <Subscription>)

az ml job show -n $run_id --web

Varias ejecuciones secundarias en clústeres

Puede realizar ejecuciones secundarias del experimento de AutoML en un clúster que ya está ejecutando otro experimento. El tiempo depende del número de nodos que tiene el clúster y de si esos nodos están disponibles para ejecutar un experimento diferente.

Cada nodo del clúster actúa como una máquina virtual (VM) individual que puede realizar una sola ejecución de entrenamiento. Para AutoML, esto significa una ejecución secundaria. Si todos los nodos están ocupados, AutoML pone en cola un nuevo experimento. Si hay nodos libres disponibles, el nuevo experimento realiza ejecuciones secundarias en paralelo en los nodos o máquinas virtuales disponibles.

Para ayudar a administrar las ejecuciones secundarias y cuándo se pueden ejecutar, se recomienda crear un clúster dedicado por experimento y hacer coincidir el número de max_concurrent_iterations del experimento con el número de nodos del clúster. De esta manera, se usan todos los nodos del clúster al mismo tiempo con el número de ejecuciones e iteraciones secundarias simultáneas que se desee.

Configure max_concurrent_iterations en la configuración de limits. Si no se configura, solo se permite de forma predeterminada una ejecución o iteración secundaria simultánea en cada experimento. En el caso de una instancia de proceso, puede establecer que max_concurrent_trials sea igual que el número de núcleos de la máquina virtual de la instancia de proceso.

Exploración de modelos y métricas

AutoML ofrece opciones para supervisar y evaluar los resultados del entrenamiento.

• Para obtener definiciones y ejemplos de los gráficos de rendimiento y las métricas proporcionadas para cada ejecución, consulte cómo evaluar los resultados del experimento de AutoML.

• Para obtener un resumen de caracterización y comprender qué características se agregaron a un modelo determinado, consulte la transparencia de caracterización.

Desde la interfaz de Azure Machine Learning en la página del modelo, también puede ver los hiperparámetros usados cuando entrene un modelo en particular y también ver y personalizar el código de entrenamiento del modelo interno usado.

Registro e implementación de modelos

Después de probar un modelo y confirmar que desea usarlo en producción, puede registrarlo para su uso posterior.

Uso de AutoML en canalizaciones

Para usar AutoML en los flujos de trabajo de operaciones de aprendizaje automático, puede agregar pasos de trabajo de AutoML a las canalizaciones de Azure Machine Learning. Este enfoque le permite automatizar todo el flujo de trabajo enlazando los scripts de preparación de datos a AutoML. A continuación, registre y valide el mejor modelo resultante.

Este código es una canalización de ejemplo con un componente de clasificación de AutoML y un componente de comando que muestra la salida resultante. El código hace referencia a las entradas (datos de validación y entrenamiento) y a las salidas (mejor modelo) en diferentes pasos.

# Define pipeline
@pipeline(
    description="AutoML Classification Pipeline",
    )
def automl_classification(
    classification_train_data,
    classification_validation_data
):
    # define the automl classification task with automl function
    classification_node = classification(
        training_data=classification_train_data,
        validation_data=classification_validation_data,
        target_column_name="y",
        primary_metric="accuracy",
        # currently need to specify outputs "mlflow_model" explictly to reference it in following nodes 
        outputs={"best_model": Output(type="mlflow_model")},
    )
    # set limits and training
    classification_node.set_limits(max_trials=1)
    classification_node.set_training(
        enable_stack_ensemble=False,
        enable_vote_ensemble=False
    )

    command_func = command(
        inputs=dict(
            automl_output=Input(type="mlflow_model")
        ),
        command="ls ${{inputs.automl_output}}",
        environment="AzureML-sklearn-0.24-ubuntu18.04-py37-cpu:latest"
    )
    show_output = command_func(automl_output=classification_node.outputs.best_model)


pipeline_job = automl_classification(
    classification_train_data=Input(path="./training-mltable-folder/", type="mltable"),
    classification_validation_data=Input(path="./validation-mltable-folder/", type="mltable"),
)

# set pipeline level compute
pipeline_job.settings.default_compute = compute_name

# submit the pipeline job
returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name
)
returned_pipeline_job

# ...
# Note that this is a snippet from the bankmarketing example you can find in our examples repo -> https://github.com/Azure/azureml-examples/tree/main/sdk/python/jobs/pipelines/1h_automl_in_pipeline/automl-classification-bankmarketing-in-pipeline

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

description: AutoML Classification Pipeline
experiment_name: <exp_name>

# set the default compute for the pipeline steps
settings:
    default_compute: azureml:<my_compute>

# pipeline inputs
inputs:
    classification_train_data:
        type: mltable
        path: "./train_data"
    classification_validation_data:
        type: mltable
        path: "./valid_data"

jobs:
    # Configure the automl training node of the pipeline 
    classification_node:
        type: automl
        task: classification
        primary_metric: accuracy
        target_column_name: y
        training_data: ${{parent.inputs.classification_train_data}}
        validation_data: ${{parent.inputs.classification_validation_data}}
        training:
            max_trials: 1
        limits:
            enable_stack_ensemble: False
            enable_vote_ensemble: False
        outputs:
            best_model:
                type: mlflow_model

    show_output:
        type: command
        inputs:
            automl_output: ${{parent.jobs.classification_node.outputs.best_model}}
        environment: "AzureML-sklearn-0.24-ubuntu18.04-py37-cpu:latest"
        command: >-
            ls ${{inputs.automl_output}}
        

> run_id=$(az ml job create --file automl-classification-pipeline.yml -w <Workspace> -g <Resource Group> --subscription <Subscription>)
> az ml job show -n $run_id --web

Uso de AutoML a escala: entrenamiento distribuido

Para escenarios de datos de gran tamaño, AutoML admite el entrenamiento distribuido para un conjunto limitado de modelos:

Los algoritmos de entrenamiento distribuido crean particiones y distribuyen automáticamente los datos entre varios nodos de proceso para el entrenamiento del modelo.

Entrenamiento distribuido para clasificación y regresión

Para usar el entrenamiento distribuido para la clasificación o regresión, establezca las propiedadestraining_mode y max_nodes del objeto de trabajo.

En el ejemplo de código siguiente, se muestra un ejemplo de esta configuración para un trabajo de clasificación:

from azure.ai.ml.constants import TabularTrainingMode

# Set the training mode to distributed
classification_job.set_training(
    allowed_training_algorithms=["LightGBM"],
    training_mode=TabularTrainingMode.DISTRIBUTED
)

# Distribute training across 4 nodes for each trial
classification_job.set_limits(
    max_nodes=4,
    # other limit settings
)

# Set the training mode to distributed
training:
    allowed_training_algorithms: ["LightGBM"]
    training_mode: distributed

# Distribute training across 4 nodes for each trial
limits:
    max_nodes: 4

Entrenamiento distribuido para la previsión

Para obtener información sobre cómo funciona el entrenamiento distribuido para las tareas de previsión, consulte previsión a gran escala. Para usar el entrenamiento distribuido para la previsión, debe establecer las propiedades training_mode, enable_dnn_training,max_nodes y, opcionalmente, max_concurrent_trials del objeto de trabajo.

En el ejemplo de código siguiente, se muestra un ejemplo de esta configuración para un trabajo de previsión:

from azure.ai.ml.constants import TabularTrainingMode

# Set the training mode to distributed
forecasting_job.set_training(
    enable_dnn_training=True,
    allowed_training_algorithms=["TCNForecaster"],
    training_mode=TabularTrainingMode.DISTRIBUTED
)

# Distribute training across 4 nodes
# Train 2 trial models in parallel => 2 nodes per trial
forecasting_job.set_limits(
    max_concurrent_trials=2,
    max_nodes=4,
    # other limit settings
)

# Set the training mode to distributed
training:
    allowed_training_algorithms: ["TCNForecaster"]
    training_mode: distributed

# Distribute training across 4 nodes
# Train 2 trial models in parallel => 2 nodes per trial
limits:
    max_concurrent_trials: 2
    max_nodes: 4

Para obtener ejemplos de código de configuración completo, vea las secciones anteriores sobre configuración y envío de trabajos.

Contenido relacionado

• Obtenga más información sobre cómo y dónde implementar un modelo.
• Más información sobre cómo configurar AutoML para entrenar un modelo de previsión de series temporales.