Compartir a través de

Configuración de AutoML para entrenar un modelo de previsión de series temporales mediante el SDK y la CLI

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

El aprendizaje automático automatizado (AutoML) en Azure Machine Learning usa modelos de aprendizaje automático estándar junto con modelos de serie temporal conocidos para crear previsiones. Este enfoque incorpora información histórica acerca de la variable de destino con las características proporcionadas por el usuario en los datos de entrada y las características diseñadas automáticamente. Los algoritmos de búsqueda de modelos ayudan a identificar modelos con la mejor precisión predictiva. Para obtener más información, consulte metodología de previsión y barrido y selección de modelos.

En este artículo se describe cómo configurar AutoML para la previsión de series temporales con Machine Learning mediante el SDK de Python de Azure Machine Learning y la CLI de Azure. El proceso incluye la preparación de datos para el entrenamiento y la configuración de parámetros de serie temporal en un trabajo de previsión (referencia de clase). A continuación, se entrenan, infieren y evalúan los modelos mediante componentes y canalizaciones.

Para una experiencia con poco código, consulte Tutorial: Previsión de la demanda con aprendizaje automático automatizado. En este artículo se proporciona un ejemplo de previsión de series temporales que usa AutoML en Azure Machine Learning Studio.

Requisitos previos

Preparación de los datos de entrenamiento y validación

Los datos de entrada para la previsión de AutoML deben contener una serie temporal válida en formato tabular. Cada variable debe tener su propia columna correspondiente en la tabla de datos. AutoML requiere al menos dos columnas: una columna de tiempo para representar el eje de tiempo y una columna de destino para la cantidad de la previsión. Otras columnas pueden servir como predictores. Para obtener más información, consulte Cómo utiliza los datos AutoML.

Importante

Al entrenar un modelo para predecir valores futuros, asegúrese de que todas las características usadas en el entrenamiento también se pueden usar al ejecutar predicciones para el horizonte previsto.

Considere una función para el precio actual del stock, que puede aumentar la precisión del entrenamiento. Si prevé con un horizonte largo, es posible que no pueda predecir con precisión los valores futuros de existencias que corresponden a puntos de serie temporal futuros. Este enfoque puede reducir la precisión del modelo.

Los trabajos de previsión de AutoML requieren que los datos de entrenamiento se representen como un objeto MLTable. Un objeto MLTable especifica un origen de datos y los pasos para cargar los datos. Para obtener más información y casos de uso, consulte Trabajar con tablas.

En el ejemplo siguiente, supongamos que los datos de entrenamiento se encuentran en un archivo CSV en un directorio local: ./train_data/timeseries_train.csv.

Puede crear un MLTable objeto mediante el miembro del SDK de Python mltable:

import mltable

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

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

Este código crea un nuevo archivo, ./train_data/MLTable, que contiene el formato de archivo y las instrucciones de carga.

Para iniciar el trabajo de entrenamiento, defina un objeto de datos de entrada mediante el SDK de Python:

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

# Training MLTable defined locally, with local data to be uploaded.
my_training_data_input = Input(
    type=AssetTypes.MLTABLE, path="./train_data"
)

Especifique los datos de validación de forma similar. Cree un objeto MLTable y especifique una entrada de datos de validación. Como alternativa, si no proporciona datos de validación, AutoML crea automáticamente divisiones de validación cruzada de los datos de entrenamiento que se usarán para la selección del modelo. Para obtener más información, consulte los siguientes recursos:

Configurar recursos de computación para ejecutar el experimento

AutoML usa el proceso de Azure Machine Learning, que es un recurso de proceso totalmente administrado, para ejecutar el trabajo de entrenamiento.

En el ejemplo siguiente, se crea 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()

Configuración del experimento

El ejemplo siguiente muestra cómo configurar el experimento.

Las funciones de fábrica de AutoML se usan para configurar trabajos de previsión en el SDK de Python. En el ejemplo siguiente se muestra cómo crear un trabajo de previsión estableciendo la métrica principal y estableciendo límites en la ejecución del entrenamiento:

from azure.ai.ml import automl

# Set forecasting variables.
# As needed, modify the variable values to run the snippet successfully.
forecasting_job = automl.forecasting(
    compute="cpu-compute",
    experiment_name="sdk-v2-automl-forecasting-job",
    training_data=my_training_data_input,
    target_column_name=target_column_name,
    primary_metric="normalized_root_mean_squared_error",
    n_cross_validations="auto",
)

# Set optional limits.
forecasting_job.set_limits(
    timeout_minutes=120,
    trial_timeout_minutes=30,
    max_concurrent_trials=4,
)

Configuración del trabajo de previsión

Las tareas de previsión tienen muchas configuraciones específicas de la previsión. Los valores más básicos de esta configuración son el nombre de la columna de tiempo en los datos de entrenamiento y el horizonte de previsión.

Use los métodos ForecastingJob para configurar estas opciones:

# Forecasting-specific configuration.
forecasting_job.set_forecast_settings(
    time_column_name=time_column_name,
    forecast_horizon=24
)

El nombre de la columna de tiempo es una configuración necesaria. Por lo general, debe establecer el horizonte de previsión según el escenario de predicción. Si los datos contienen varias series temporales, puede especificar los nombres de las columnas de identificador de serie temporal. Cuando estas columnas se agrupan, definen la serie individual. Por ejemplo, supongamos que tiene datos que constan de las ventas por hora de diferentes tiendas y marcas. En el ejemplo siguiente se muestra cómo establecer las columnas de identificador de serie temporal, suponiendo que los datos contengan columnas denominadas store y brand:

# Forecasting-specific configuration.
# Add time series IDs for store and brand.
forecasting_job.set_forecast_settings(
    ...,  # Other settings.
    time_series_id_column_names=['store', 'brand']
)

AutoML intenta detectar automáticamente columnas de identificador de serie temporal en los datos si no se especifica ninguna.

Otras opciones de configuración son opcionales y se describen en la sección siguiente.

Configuración opcional del trabajo de previsión

Hay configuraciones opcionales disponibles para las tareas de previsión, como la habilitación del aprendizaje profundo y la especificación de una agregación de ventana móvil de destino. La lista completa de parámetros se encuentra disponible en la documentación de referencia.

Configuración de búsqueda de modelos

Hay dos ajustes opcionales que controlan el espacio del modelo donde AutoML busca el mejor modelo: allowed_training_algorithms y blocked_training_algorithms. Para restringir el espacio de búsqueda a un conjunto determinado de clases de modelo, use el allowed_training_algorithms parámetro , como se muestra aquí:

# Only search ExponentialSmoothing and ElasticNet models.
forecasting_job.set_training(
    allowed_training_algorithms=["ExponentialSmoothing", "ElasticNet"]
)

En este escenario, el trabajo de previsión busca solo en las clases de modelo de suavizado exponencial y red elástica. Para quitar un conjunto determinado de clases de modelo del espacio de búsqueda, use blocked_training_algorithms, como se muestra aquí:

# Search over all model classes except Prophet.
forecasting_job.set_training(
    blocked_training_algorithms=["Prophet"]
)

El trabajo busca en todas las clases de modelo excepto Prophet. Para obtener una lista de los nombres de modelo de previsión que se aceptan en allowed_training_algorithms y blocked_training_algorithms, consulte propiedades de entrenamiento. Puedes aplicar cualquiera de los dos, pero no ambos, allowed_training_algorithms y blocked_training_algorithms a una ejecución de entrenamiento.

Habilitación del aprendizaje para redes neuronales profundas

AutoML se incluye con un modelo de red neuronal profunda (DNN) personalizado denominado TCNForecaster. Este modelo es una red convolucional temporal (TCN), que aplica métodos comunes de tareas de creación de imágenes al modelado de series temporales. Las convoluciones unidimensionales "causales" forman la red troncal de la red y permiten al modelo aprender patrones complejos durante duraciones prolongadas en el historial de entrenamiento. Para obtener más información, consulte Introducción a TCNForecaster.

Diagrama que muestra los componentes principales del modelo TCNForecaster de AutoML.

TCNForecaster suele lograr una mayor precisión que los modelos de serie temporal estándar cuando hay miles o más observaciones en el historial de entrenamiento. Sin embargo, también se tarda más tiempo en entrenar y evaluar modelos TCNForecaster debido a su mayor capacidad de procesamiento.

Puede habilitar TCNForecaster en AutoML estableciendo la enable_dnn_training marca en la configuración de entrenamiento, como se indica a continuación:

# Include TCNForecaster models in the model search.
forecasting_job.set_training(
    enable_dnn_training=True
)

De manera predeterminada, el entrenamiento TCNForecaster se limita a un único nodo de proceso y una única GPU, si está disponible, por prueba de modelo. En escenarios de datos de gran tamaño, la recomendación es distribuir cada prueba de TCNForecaster a través de varios núcleos, GPU y nodos. Para obtener más información y ejemplos de código, consulte entrenamiento distribuido.

Para habilitar DNN para un experimento de AutoML creado en Azure Machine Learning Studio, consulte el artículo Configuración del tipo de tarea en la interfaz de usuario de Studio.

Nota:

  • Al habilitar DNN para los experimentos creados con el SDK, las mejores explicaciones del modelo se deshabilitan.
  • El soporte para DNN en la previsión del aprendizaje automático automatizado no está disponible para las ejecuciones iniciadas en Azure Databricks.
  • El enfoque recomendado es usar tipos de proceso de GPU cuando se habilita el entrenamiento de DNN.

Características de los retrasos y las ventanas móviles

Los valores recientes del destino suelen ser características impactantes en un modelo de previsión. En consecuencia, AutoML puede crear funciones de agregación de ventanas móviles y retrasos en el tiempo para mejorar potencialmente la precisión del modelo.

Considere un escenario de previsión de la demanda energética en el que están disponibles los datos meteorológicos y la demanda histórica. En la tabla se muestra la ingeniería de características resultante que se produce cuando se aplica la agregación de ventanas en las tres horas más recientes. Las columnas para los valores mínimo, máximo y suma se generan en una ventana deslizante de tres horas según la configuración definida. Por ejemplo, para la observación válida el 8 de septiembre de 2017, 4:00 a. m., los valores máximo, mínimo y suma se calculan mediante los valores de demanda para el 8 de septiembre de 2017, 1:00 - 3:00 AM. Esta ventana tiene tres turnos de horas juntos para rellenar los datos de las filas restantes. Para obtener más información y ejemplos, consulte Funciones de retraso para predecir series temporales en AutoML.

Tabla con datos que muestran la ventana móvil de destino. Los valores de la columna Demanda están resaltados.

Puede activar las funciones de agregación de ventanas móviles y retrasos para el destino estableciendo el tamaño de la ventana móvil y las órdenes de retraso que desea crear. El tamaño de la ventana es tres en el ejemplo anterior. También puede habilitar los retrasos para las funciones usando la configuración de feature_lags. En el ejemplo siguiente, todas estas opciones de configuración se establecen en auto para indicar a AutoML que determine automáticamente la configuración mediante el análisis de la estructura de correlación de los datos:

forecasting_job.set_forecast_settings(
    ...,  # Other settings.
    target_lags='auto', 
    target_rolling_window_size='auto',
    feature_lags='auto'
)

Control de series breves

El ML automatizado considera una serie temporal como serie breve si no hay suficientes puntos de datos para llevar a cabo las fases de entrenamiento y validación del desarrollo del modelo. Para obtener más información, consulte requisitos de longitud de datos de entrenamiento.

AutoML tiene varias acciones que puede realizar para series cortas. Puede configurar estas acciones mediante la short_series_handling_config configuración . El valor predeterminado es auto. En la siguiente tabla se describen las configuraciones:

Configuración Descripción Notas
auto Valor predeterminado para el control de series cortas. - Si todas las series son cortas, se rellenan los datos.
- Si no todas las series son cortas, se anulan las series cortas.
pad Si se usa la configuración short_series_handling_config = pad, AutoML agrega valores aleatorios a cada serie corta encontrada. AutoML rellena la columna de destino con ruido blanco. Puede usar los siguientes tipos de columna con el relleno especificado:
- Columnas de objeto, relleno con NaNs.
- Columnas numéricas, relleno con 0 (cero).
- Columnas booleanas o lógicas, relleno con False.
drop Si se usa la configuración short_series_handling_config = drop, AutoML quita la serie corta y no se usa para el entrenamiento ni la predicción. Las predicciones de estas series devuelven NaN.
None No se rellena ni anula ninguna serie.

En el ejemplo siguiente se establece el manejo de series cortas para que todas ellas se rellenen a la longitud mínima.

forecasting_job.set_forecast_settings(
    ...,  # Other settings.
    short_series_handling_config='pad'
)

Precaución

El relleno puede afectar la precisión del modelo resultante porque introduce datos artificiales para evitar fallos en el entrenamiento. Si muchas de las series son cortas, puede que también vea algún impacto en los resultados de la capacidad de explicación.

Frecuencia y agregación de datos de destino

Use las opciones de agregación de datos y frecuencia para evitar errores causados por datos irregulares. Los datos son irregulares si no siguen una cadencia establecida en el tiempo, como cada hora o diariamente. Los datos de punto de venta son un buen ejemplo de datos irregulares. En estos casos, AutoML puede agregar los datos a una frecuencia deseada y, a continuación, crear un modelo de previsión a partir de los agregados.

Debe establecer la configuración frequency y target_aggregate_function para controlar datos irregulares. La configuración de frecuencia acepta Cadenas DateOffset de Pandas como entrada. En la tabla siguiente se muestran los valores admitidos para la función de agregación:

Función Descripción
sum  La suma de los valores de destino
mean  La media o promedio de los valores de destino
min El valor mínimo de un destino
max El valor máximo de un destino

AutoML aplica la agregación para las columnas siguientes:

Columna Método de agregación
Predictores numéricos AutoML usa las funciones de sum, mean, min y max. Genera nuevas columnas. Cada nombre de columna incluye un sufijo que identifica el nombre de la función de agregación aplicada a los valores de columna.
Predictores categóricos AutoML usa el valor del parámetro forecast_mode para agregar los datos. Es la categoría más destacada de la ventana. Para obtener más información, consulte las descripciones del parámetro en las secciones Canalización de varios modelos y Canalización de HTS .
Predictores de datos AutoML usa el valor de destino mínimo (min), el valor de destino máximo (max) y la configuración del parámetro forecast_mode para agregar los datos.
Destino AutoML agrega los valores según la operación especificada. Normalmente, la función sum es adecuada para la mayoría de los escenarios.

En el ejemplo siguiente se establece la frecuencia en cada hora y la función de agregación en suma:

# Aggregate the data to hourly frequency.
forecasting_job.set_forecast_settings(
    ...,  # Other settings.
    frequency='H',
    target_aggregate_function='sum'
)

Configuración personalizada de validación cruzada

Hay dos configuraciones personalizables que controlan la validación cruzada para los trabajos de previsión. Personalice el número de plegamientos mediante el parámetro n_cross_validations y configure el parámetro cv_step_size para definir el desplazamiento de tiempo entre plegamientos. Para obtener más información, consulte selección del modelo de previsión.

De manera predeterminada, AutoML establece ambas opciones automáticamente en función de las características de los datos. Es posible que los usuarios avanzados quieran establecerlos manualmente. Por ejemplo, supongamos que tiene datos de ventas diarios y desea que la configuración de validación conste de cinco plegamientos con un desplazamiento de siete días entre plegados adyacentes. En el ejemplo de código siguiente se muestra cómo establecer estos valores:

from azure.ai.ml import automl

# Create a job with five CV folds.
forecasting_job = automl.forecasting(
    ...,  # Other training parameters.
    n_cross_validations=5,
)

# Set the step size between folds to seven days.
forecasting_job.set_forecast_settings(
    ...,  # Other settings.
    cv_step_size=7
)

Caracterización personalizada

De forma predeterminada, AutoML aumenta los datos de entrenamiento con características diseñadas para aumentar la precisión de los modelos. Para obtener más información, consulte Ingeniería automatizada de características. Puede personalizar algunos de los pasos de preprocesamiento mediante la configuración de caracterización del trabajo de previsión.

En la tabla siguiente se enumeran las personalizaciones admitidas para la previsión:

Personalización Descripción Opciones
Actualización del propósito de la columna Invalida el tipo de característica detectado automáticamente para la columna especificada. categorical, , dateTime, numeric
Actualización de parámetros del transformador Actualice los parámetros del equipo de imputer especificado. {"strategy": "constant", "fill_value": <value>}, , {"strategy": "median"}, {"strategy": "ffill"}

Por ejemplo, supongamos que tiene un escenario de demanda comercial en el que los datos incluyen precios, una marca de on sale y un tipo de producto. En el ejemplo siguiente se muestra cómo puede establecer tipos personalizados e imputadores para estas características:

from azure.ai.ml.automl import ColumnTransformer

# Customize imputation methods for price and is_on_sale features.
# Median value imputation for price, constant value of zero for is_on_sale.
transformer_params = {
    "imputer": [
        ColumnTransformer(fields=["price"], parameters={"strategy": "median"}),
        ColumnTransformer(fields=["is_on_sale"], parameters={"strategy": "constant", "fill_value": 0}),
    ],
}

# Set the featurization.
# Ensure product_type feature is interpreted as categorical.
forecasting_job.set_featurization(
    mode="custom",
    transformer_params=transformer_params,
    column_name_and_types={"product_type": "Categorical"},
)

Si usa Azure Machine Learning Studio para el experimento, consulte Configuración de las opciones de caracterización en Studio.

Envío del trabajo de previsión

Después de configurar todas las opciones, todo está listo para ejecutar el trabajo de previsión. En el ejemplo siguiente se muestra este proceso.

# Submit the AutoML job.
returned_job = ml_client.jobs.create_or_update(
    forecasting_job
)

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

# Get a URL for the job in the studio UI.
returned_job.services["Studio"].endpoint

Una vez que envíe el trabajo, AutoML aprovisiona recursos de proceso, aplica caracterización y otros pasos de preparación a los datos de entrada y comienza a realizar un barrido sobre los modelos de previsión. Para obtener más información, consulte Metodología de previsión en AutoML y Barrido y selección de modelos para la previsión en AutoML.

Orquestación del entrenamiento, la inferencia y la evaluación mediante componentes y canalizaciones

Es probable que el flujo de trabajo de aprendizaje automático requiera más que solo el entrenamiento. La inferencia o la recuperación de predicciones del modelo en datos más recientes y la evaluación de la precisión del modelo en un conjunto de pruebas con valores de destino conocidos son otras tareas comunes que puede organizar en Azure Machine Learning junto con trabajos de entrenamiento. Para admitir tareas de inferencia y evaluación, Azure Machine Learning proporciona componentes, que son partes de código autónomas que realizan un paso en una canalización de Azure Machine Learning.

En el ejemplo siguiente se recupera el código de componente de un registro de cliente:

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

# Get credential to access azureml registry.
try:
    credential = DefaultAzureCredential()
    # Check if token can be obtained successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential fails.
    credential = InteractiveBrowserCredential()

# Create client to access assets in azureml-preview registry.
ml_client_registry = MLClient(
    credential=credential,
    registry_name="azureml-preview"
)

# Create client to access assets in azureml registry.
ml_client_metrics_registry = MLClient(
    credential=credential,
    registry_name="azureml"
)

# Get inference component from registry.
inference_component = ml_client_registry.components.get(
    name="automl_forecasting_inference",
    label="latest"
)

# Get component to compute evaluation metrics from registry.
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

A continuación, defina una función de fábrica que cree canalizaciones que orquesten el entrenamiento, la inferencia y el cálculo de métricas. Para obtener más información, consulte Configuración del experimento.

from azure.ai.ml import automl
from azure.ai.ml.constants import AssetTypes
from azure.ai.ml.dsl import pipeline

@pipeline(description="AutoML Forecasting Pipeline")
def forecasting_train_and_evaluate_factory(
    train_data_input,
    test_data_input,
    target_column_name,
    time_column_name,
    forecast_horizon,
    primary_metric='normalized_root_mean_squared_error',
    cv_folds='auto'
):
    # Configure training node of pipeline.
    training_node = automl.forecasting(
        training_data=train_data_input,
        target_column_name=target_column_name,
        primary_metric=primary_metric,
        n_cross_validations=cv_folds,
        outputs={"best_model": Output(type=AssetTypes.MLFLOW_MODEL)},
    )

    training_node.set_forecasting_settings(
        time_column_name=time_column_name,
        forecast_horizon=max_horizon,
        frequency=frequency,
        # Other settings.
        ... 
    )
    
    training_node.set_training(
        # Training parameters.
        ...
    )
    
    training_node.set_limits(
        # Limit settings.
        ...
    )

    # Configure inference node to make rolling forecasts on test set.
    inference_node = inference_component(
        test_data=test_data_input,
        model_path=training_node.outputs.best_model,
        target_column_name=target_column_name,
        forecast_mode='rolling',
        step=1
    )

    # Configure metrics calculation node.
    compute_metrics_node = compute_metrics_component(
        task="tabular-forecasting",
        ground_truth=inference_node.outputs.inference_output_file,
        prediction=inference_node.outputs.inference_output_file,
        evaluation_config=inference_node.outputs.evaluation_config_output_file
    )

    # Return dictionary with evaluation metrics and raw test set forecasts.
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result,
        "rolling_fcst_result": inference_node.outputs.inference_output_file
    }

Defina las entradas de datos de entrenamiento y prueba contenidas en carpetas locales ./train_data y ./test_data.

my_train_data_input = Input(
    type=AssetTypes.MLTABLE,
    path="./train_data"
)

my_test_data_input = Input(
    type=AssetTypes.URI_FOLDER,
    path='./test_data',
)

Por último, construya la canalización, establezca su proceso predeterminado y envíe el trabajo:

pipeline_job = forecasting_train_and_evaluate_factory(
    my_train_data_input,
    my_test_data_input,
    target_column_name,
    time_column_name,
    forecast_horizon
)

# Set pipeline-level compute.
pipeline_job.settings.default_compute = compute_name

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

Después de enviar la solicitud de ejecución, la canalización ejecuta el entrenamiento de AutoML, la inferencia de evaluación gradual y el cálculo de métricas en secuencia. Puede supervisar e inspeccionar la ejecución en la interfaz de usuario de Studio. Cuando se complete la ejecución, puede descargar las previsiones móviles y las métricas de evaluación en el directorio de trabajo local:

# Download metrics JSON.
ml_client.jobs.download(returned_pipeline_job.name, download_path=".", output_name='metrics_result')

# Download rolling forecasts.
ml_client.jobs.download(returned_pipeline_job.name, download_path=".", output_name='rolling_fcst_result')

Puede revisar la salida en las siguientes ubicaciones:

  • Métricas: ./named-outputs/metrics_results/evaluationResult/metrics.json
  • Previsiones: ./named-outputs/rolling_fcst_result/inference_output_file (formato de líneas JSON)

Para obtener más información sobre la evaluación móvil, consulte Inferencia y evaluación de modelos de previsión.

Previsión a escala: muchos modelos

Los componentes de varios modelos de AutoML permiten entrenar y administrar millones de modelos en paralelo. Para obtener más información, consulte Muchos modelos.

Configuración de entrenamiento de varios modelos

El componente de entrenamiento para múltiples modelos acepta un archivo de configuración en formato YAML para la configuración de entrenamiento de AutoML. El componente aplica esta configuración a cada instancia de AutoML que se inicia. El archivo YAML tiene la misma especificación que el trabajo de comando Forecasting, además de los parámetros partition_column_names y allow_multi_partitions.

Parámetro Descripción
partition_column_names Nombres de columna en los datos que, cuando se agrupan, definen las particiones de datos. El componente de entrenamiento de varios modelos inicia un trabajo de entrenamiento independiente en cada partición.
allow_multi_partitions Marca opcional que permite entrenar un modelo por partición cuando cada partición contiene más de una serie temporal única. El valor predeterminado es false.

Esta es una configuración de YAML de ejemplo:

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

description: A time-series forecasting job config
compute: azureml:<cluster-name>
task: forecasting
primary_metric: normalized_root_mean_squared_error
target_column_name: sales
n_cross_validations: 3

forecasting:
  time_column_name: date
  time_series_id_column_names: ["state", "store"]
  forecast_horizon: 28

training:
  blocked_training_algorithms: ["ExtremeRandomTrees"]

limits:
  timeout_minutes: 15
  max_trials: 10
  max_concurrent_trials: 4
  max_cores_per_trial: -1
  trial_timeout_minutes: 15
  enable_early_termination: true
  
partition_column_names: ["state", "store"]
allow_multi_partitions: false

En ejemplos posteriores, la configuración se almacena en la ruta ./automl_settings_mm.yml.

Canalización de varios modelos

A continuación, definirá una función de fábrica que crea canalizaciones para la orquestación de muchos modelos de entrenamiento, inferencia y cálculo de métricas. En la tabla siguiente se describen los parámetros de esta función de fábrica:

Parámetro Descripción
max_nodes Número de nodos de proceso que se van a usar en el trabajo de entrenamiento.
max_concurrency_per_node Número de procesos de AutoML que se ejecutarán en cada nodo. La simultaneidad total de un trabajo de muchos modelos es max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Tiempo de espera de los componentes de muchos modelos, especificado en número de segundos.
retrain_failed_models Marca para habilitar el reentrenamiento de los modelos con errores. Este valor es útil si ha realizado ejecuciones anteriores de varios modelos que provocaron errores en los trabajos de AutoML en algunas particiones de datos. Al habilitar esta marca, muchos modelos solo ejecutan trabajos de entrenamiento para particiones con errores anteriores.
forecast_mode Modo de inferencia para la evaluación del modelo. Los valores válidos son recursive (predeterminado) y rolling. Para obtener más información, consulte Inferencia y evaluación de los modelos de previsión y la referencia de Clase ManyModelsInferenceParameters.
step Tamaño del paso para la previsión gradual. El valor predeterminado es 1. Para obtener más información, consulte Inferencia y evaluación de los modelos de previsión y la referencia de Clase ManyModelsInferenceParameters.

En el ejemplo siguiente se muestra un método de fábrica para construir canalizaciones de entrenamiento y evaluación de modelos de varios modelos:

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

# Get credential to access azureml registry.
try:
    credential = DefaultAzureCredential()
    # Check whether token can be obtained.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential if DefaultAzureCredential fails.
    credential = InteractiveBrowserCredential()

# Get many-models training component.
mm_train_component = ml_client_registry.components.get(
    name='automl_many_models_training',
    version='latest'
)

# Get many-models inference component.
mm_inference_component = ml_client_registry.components.get(
    name='automl_many_models_inference',
    version='latest'
)

# Get component to compute evaluation metrics.
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

@pipeline(description="AutoML Many Models Forecasting Pipeline")
def many_models_train_evaluate_factory(
    train_data_input,
    test_data_input,
    automl_config_input,
    compute_name,
    max_concurrency_per_node=4,
    parallel_step_timeout_in_seconds=3700,
    max_nodes=4,
    retrain_failed_model=False,
    forecast_mode="rolling",
    forecast_step=1
):
    mm_train_node = mm_train_component(
        raw_data=train_data_input,
        automl_config=automl_config_input,
        max_nodes=max_nodes,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        retrain_failed_model=retrain_failed_model,
        compute_name=compute_name
    )

    mm_inference_node = mm_inference_component(
        raw_data=test_data_input,
        max_nodes=max_nodes,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        optional_train_metadata=mm_train_node.outputs.run_output,
        forecast_mode=forecast_mode,
        step=forecast_step,
        compute_name=compute_name
    )

    compute_metrics_node = compute_metrics_component(
        task="tabular-forecasting",
        prediction=mm_inference_node.outputs.evaluation_data,
        ground_truth=mm_inference_node.outputs.evaluation_data,
        evaluation_config=mm_inference_node.outputs.evaluation_configs
    )

    # Return metrics results from rolling evaluation.
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result
    }

Construya la canalización con la función de fábrica. Los datos de entrenamiento y prueba se encuentran en las carpetas locales ./data/train y ./data/test. Por último, establezca el proceso predeterminado y envíe el trabajo como se muestra en el ejemplo siguiente:

pipeline_job = many_models_train_evaluate_factory(
    train_data_input=Input(
        type="uri_folder",
        path="./data/train"
    ),
    test_data_input=Input(
        type="uri_folder",
        path="./data/test"
    ),
    automl_config=Input(
        type="uri_file",
        path="./automl_settings_mm.yml"
    ),
    compute_name="<cluster name>"
)
pipeline_job.settings.default_compute = "<cluster name>"

returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name,
)
ml_client.jobs.stream(returned_pipeline_job.name)

Una vez finalizado el trabajo, puede descargar las métricas de evaluación localmente mediante el procedimiento de la canalización de ejecución de entrenamiento única.

Para obtener un ejemplo más detallado, consulte el cuaderno Previsión de demanda mediante muchos modelos.

Consideraciones de entrenamiento para una ejecución con muchos modelos

  • Los componentes de entrenamiento e inferencia multimodelo condicionan la partición de los datos según la configuración partition_column_names. Este proceso da como resultado que cada partición se encuentre en su propio archivo. El proceso puede ser lento o producir errores cuando tiene muchos datos. Se recomienda crear particiones de los datos manualmente antes de ejecutar el entrenamiento o la inferencia de varios modelos.

  • Durante el entrenamiento de varios modelos, los modelos se registran automáticamente en el área de trabajo, por lo que no se requiere el registro manual de modelos. Los modelos se denominan en función de la partición en la que se entrenaron y estos nombres no son personalizables. Las etiquetas tampoco son personalizables. Estas propiedades se usan para detectar automáticamente modelos durante la inferencia.

  • La implementación de modelos individuales no es escalable, pero puede usar PipelineComponentBatchDeployment para facilitar el proceso de implementación. Para obtener un ejemplo, consulte el cuaderno Previsión de la demanda mediante muchos modelos.

  • Durante la inferencia, los modelos adecuados (la versión más reciente) se seleccionan automáticamente en función de la partición enviada en los datos de inferencia. De forma predeterminada, cuando se usa training_experiment_name, se utiliza el modelo más reciente, pero puede invalidar este comportamiento para seleccionar modelos de una ejecución de entrenamiento determinada proporcionando también train_run_id.

Nota:

El límite de paralelismo predeterminado para una ejecución de varios modelos en una suscripción es 320. Si la carga de trabajo requiere un límite mayor, puede ponerse en contacto con soporte técnico de Microsoft.

Previsión a escala: serie temporal jerárquica

Los componentes jerárquicos de series temporales (HTS) de AutoML permiten entrenar un gran número de modelos en datos que se encuentra en una estructura jerárquica. Para obtener más información, consulte Previsión de series temporales jerárquicas.

Configuración del entrenamiento de HTS

El componente de entrenamiento de HTS acepta un archivo de configuración en formato YAML de la configuración de entrenamiento de AutoML. El componente aplica esta configuración a cada instancia de AutoML que se ejecuta. Este archivo YAML tiene la misma especificación que el trabajo de comando Forecasting, pero incluye otros parámetros relacionados con la información de jerarquía:

Parámetro Descripción
hierarchy_column_names Lista de nombres de columna en los datos que definen la estructura jerárquica de los datos. El orden de las columnas de esta lista determina los niveles de jerarquía. El grado de agregación disminuye con el índice de lista. Es decir, la última columna de la lista define el nivel de hoja, o más desagregado, de la jerarquía.
hierarchy_training_level Nivel de jerarquía que se va a usar para el entrenamiento del modelo de previsión.

Esta es una configuración de YAML de ejemplo:

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

description: A time-series forecasting job config
compute: azureml:cluster-name
task: forecasting
primary_metric: normalized_root_mean_squared_error
log_verbosity: info
target_column_name: sales
n_cross_validations: 3

forecasting:
  time_column_name: "date"
  time_series_id_column_names: ["state", "store", "SKU"]
  forecast_horizon: 28

training:
  blocked_training_algorithms: ["ExtremeRandomTrees"]

limits:
  timeout_minutes: 15
  max_trials: 10
  max_concurrent_trials: 4
  max_cores_per_trial: -1
  trial_timeout_minutes: 15
  enable_early_termination: true
  
hierarchy_column_names: ["state", "store", "SKU"]
hierarchy_training_level: "store"

En ejemplos posteriores, la configuración se almacena en la ruta ./automl_settings_hts.yml.

Canalización de HTS

A continuación, defina una función de fábrica que cree canalizaciones para la orquestación del entrenamiento, la inferencia y el cálculo de métricas de HTS. En la tabla siguiente se describen los parámetros de esta función de fábrica:

Parámetro Descripción
forecast_level Nivel de la jerarquía para el que se van a recuperar las previsiones.
allocation_method Método de asignación que se va a usar cuando se desagregan las previsiones. Los valores válidos son proportions_of_historical_average y average_historical_proportions.
max_nodes Número de nodos de cómputo a utilizar en el trabajo de entrenamiento.
max_concurrency_per_node Número de procesos de AutoML que se van a ejecutar en cada nodo. La simultaneidad total de un trabajo de HTS es max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Tiempo de espera del componente de muchos modelos, especificado en segundos.
forecast_mode Modo de inferencia para la evaluación del modelo. Los valores válidos son recursive y rolling. Para obtener más información, consulte Inferencia y evaluación de los modelos de previsión y la referencia de Clase HTSInferenceParameters.
step Tamaño del paso para la previsión móvil. El valor predeterminado es 1. Para obtener más información, consulte Inferencia y evaluación de los modelos de previsión y la referencia de Clase HTSInferenceParameters. 
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

# Get credential to access azureml registry.
try:
    credential = DefaultAzureCredential()
    # Check whether token can be obtained.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential if DefaultAzureCredential fails.
    credential = InteractiveBrowserCredential()

# Get HTS training component.
hts_train_component = ml_client_registry.components.get(
    name='automl_hts_training',
    version='latest'
)

# Get HTS inference component.
hts_inference_component = ml_client_registry.components.get(
    name='automl_hts_inference',
    version='latest'
)

# Get component to compute evaluation metrics.
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

@pipeline(description="AutoML HTS Forecasting Pipeline")
def hts_train_evaluate_factory(
    train_data_input,
    test_data_input,
    automl_config_input,
    max_concurrency_per_node=4,
    parallel_step_timeout_in_seconds=3700,
    max_nodes=4,
    forecast_mode="rolling",
    forecast_step=1,
    forecast_level="SKU",
    allocation_method='proportions_of_historical_average'
):
    hts_train = hts_train_component(
        raw_data=train_data_input,
        automl_config=automl_config_input,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        max_nodes=max_nodes
    )
    hts_inference = hts_inference_component(
        raw_data=test_data_input,
        max_nodes=max_nodes,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        optional_train_metadata=hts_train.outputs.run_output,
        forecast_level=forecast_level,
        allocation_method=allocation_method,
        forecast_mode=forecast_mode,
        step=forecast_step
    )
    compute_metrics_node = compute_metrics_component(
        task="tabular-forecasting",
        prediction=hts_inference.outputs.evaluation_data,
        ground_truth=hts_inference.outputs.evaluation_data,
        evaluation_config=hts_inference.outputs.evaluation_configs
    )

    # Return metrics results from rolling evaluation.
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result
    }

Construya la canalización con la función de fábrica. Los datos de entrenamiento y prueba se encuentran en las carpetas locales ./data/train y ./data/test. Por último, establezca el proceso predeterminado y envíe el trabajo como se muestra en el ejemplo siguiente:

pipeline_job = hts_train_evaluate_factory(
    train_data_input=Input(
        type="uri_folder",
        path="./data/train"
    ),
    test_data_input=Input(
        type="uri_folder",
        path="./data/test"
    ),
    automl_config=Input(
        type="uri_file",
        path="./automl_settings_hts.yml"
    )
)
pipeline_job.settings.default_compute = "cluster-name"

returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name,
)
ml_client.jobs.stream(returned_pipeline_job.name)

Una vez finalizado el trabajo, puede descargar las métricas de evaluación localmente mediante el procedimiento de la canalización de ejecución de entrenamiento única.

Para obtener un ejemplo más detallado, consulte el cuaderno Previsión de la demanda mediante HTS.

Consideraciones de entrenamiento para una ejecución de HTS

Los componentes de entrenamiento e inferencia de HTS particionan condicionalmente los datos de acuerdo con la hierarchy_column_names configuración para que cada partición esté en su propio archivo. Este proceso puede ser lento o producir errores cuando tiene muchos datos. Se recomienda crear particiones de los datos manualmente antes de ejecutar el entrenamiento o la inferencia de HTS.

Nota:

El límite de paralelismo predeterminado para una ejecución de HTS en una suscripción es 320. Si la carga de trabajo requiere un límite mayor, puede ponerse en contacto con soporte técnico de Microsoft.

Previsión a escala: entrenamiento de DNN distribuido

Como se ha descrito anteriormente en este artículo, puede habilitar el aprendizaje para redes neuronales profundas (DNN). Para obtener información sobre cómo funciona el entrenamiento distribuido para las tareas de previsión de DNN, consulte Entrenamiento de red neuronal profunda distribuida (versión preliminar).

En escenarios que requieren grandes cantidades de datos, el entrenamiento distribuido con AutoML está disponible para un conjunto limitado de modelos. Puede encontrar más información y ejemplos de código en AutoML a escala: entrenamiento distribuido.

Exploración de cuadernos de ejemplo

Los ejemplos de código detallados, que muestran configuraciones avanzadas de previsión, están disponibles en el repositorio de GitHub Cuadernos de ejemplo de previsión de AutoML. Estos son algunos de los cuadernos de ejemplo:

Contenido relacionado

  • Last updated on