Configuración de AutoML para entrenar un modelo de previsión de series temporales con 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 series temporales 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](/python/api/overview/azure/ai-ml-readme). El proceso incluye la preparación de datos para el entrenamiento y la configuración de parámetros de series temporales en un trabajo de previsión (referencia de clase). Después, se entrenan, realizan inferencias y evalúan modelos mediante componentes y canalizaciones.
Para obtener una experiencia con poco código, consulte Tutorial: Previsión de la demanda con aprendizaje automático automatizado. Este recurso es un ejemplo de previsión de series temporales que usa AutoML en Estudio de Azure Machine Learning.
Requisitos previos
- Un área de trabajo de Azure Machine Learning. Para crear un área de trabajo, consulte Creación de recursos del área de trabajo.
- La capacidad de iniciar trabajos de entrenamiento de AutoML. Para obtener más información, consulte Configuración del entrenamiento de AutoML para datos tabulares con la CLI de Azure Machine Learning y el SDK de Python.
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 Uso de los datos por parte de ML automatizado.
Importante
Al entrenar un modelo para la previsión de valores futuros, asegúrese de que se puedan usar todas las características usadas en el entrenamiento al ejecutar predicciones para el horizonte previsto.
Considere una característica para el precio actual de acciones de la bolsa, lo que puede aumentar enormemente la precisión del entrenamiento. Si piensa en la previsión con un horizonte largo, es posible que no pueda predecir con precisión los valores futuros de las acciones que correspondan a puntos de series temporales 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 de MLTable especifica un origen de datos y pasos para cargar los datos. Para obtener más información y casos de uso, consulte [Trabajar con tablas(how-to-mltable.md)].
Para el siguiente ejemplo, supongamos que los datos de entrenamiento se encuentran en un archivo CSV en un directorio local, ./train_data/timeseries_train.csv.
Puede crear un objeto de MLTable mediante el mltable del SDK de Python tal como se muestra en el ejemplo siguiente:
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 como se indica a continuación:
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 datos de validación de forma similar. Cree un objeto de 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:
- Selección de modelos de previsión
- Establecer requisitos de longitud de datos de entrenamiento
- Evitar el sobreajuste con la validación cruzada
Creación de un proceso para ejecutar el experimento
AutoML usa 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-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()Configuración del experimento
En el ejemplo siguiente, se 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 hora 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 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 almacenar y marca:
# 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 revisan 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 con desplazamiento de objetivo. La lista completa de parámetros se encuentra disponible en la documentación de referencia.
Configuración de búsqueda de modelos
Existen dos opciones de configuración que controlan el espacio del modelo en el que 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 parámetro allowed_training_algorithms como se muestra en el ejemplo siguiente:
# 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 Exponential Smoothing y Elastic Net. Para quitar un conjunto determinado de clases de modelo del espacio de búsqueda, use blocked_training_algorithms como se muestra en el ejemplo siguiente:
# 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. Puede aplicar tanto allowed_training_algorithms como 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 o 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 largas duraciones en el historial de entrenamiento. Para obtener más información, consulte Introduction a TCNForecaster.
TCNForecaster suele lograr una mayor precisión que los modelos de series temporales estándar cuando hay miles de observaciones o más en el historial de entrenamiento. Sin embargo, también se tarda más tiempo en entrenar y hacer el barrido de los modelos de TCNForecaster debido a su mayor capacidad.
Para habilitar TCNForecaster en AutoML, establezca la marca enable_dnn_training en la configuración de entrenamiento de la siguiente manera:
# 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 Estudio de Azure Machine Learning, consulte los procedimientos en la interfaz de usuario de Estudio para la configuración del tipo de tarea.
Nota:
- Al habilitar DNN para los experimentos creados con el SDK, las mejores explicaciones del modelo se deshabilitan.
- La compatibilidad con DNN para la previsión en el aprendizaje automático automatizado no es compatible con 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 ventana graduales y de retraso
Los valores recientes del destino suelen ser características impactantes en un modelo de previsión. En consecuencia, AutoML puede crear características de agregación de ventana graduales y de retraso 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 de mínimo, máximo, y suma se generan en una ventana deslizante de tres horas en función de la configuración definida. Por ejemplo, para la observación válida del 8 de septiembre de 2017 4:00 a. m., los valores máximo, mínimo y suma se calculan con los valores de la demanda del 8 de septiembre de 2017, de la 1:00 a. m. a las 3:00 a. m. 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 Características de retardo para predecir series temporales en AutoML.
Puede habilitar las características de agregación de ventanas lag y graduales para el destino estableciendo el tamaño de la ventana gradual y los pedidos de retardo que desea crear. El tamaño de la ventana era tres en el ejemplo anterior. También puede habilitar los retrasos para las características con la configuración 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
AutoML 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. Estas acciones se pueden configurar con short_series_handling_config. 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 breves, se rellenan los datos. - Si no todas las series son breves, se anulan las series breves. |
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 NaN - 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 control de series cortas para que todas las series cortas se rellenen con la longitud mínima:
forecasting_job.set_forecast_settings(
..., # Other settings
short_series_handling_config='pad'
)
Precaución
El relleno puede afectar a la precisión del modelo resultante, ya que introduce datos artificiales para evitar errores de entrenamiento. Si muchas de las series son cortas, es posible que también vea algún impacto en los resultados de la 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 sum, mean, min y max. Genera nuevas columnas, donde 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 muchos 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 con 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 de características automatizadas. Algunos de los pasos de preprocesamiento se pueden personalizar mediante la configuración de la 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 Estudio de Azure Machine Learning para el experimento, consulte Configuración de las opciones de caracterización en Estudio.
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 siguiente ejemplo, 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 la 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 con 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 piezas de código autónomas que realizan un paso en una canalización de Azure Machine Learning.
En el ejemplo siguiente, recupere 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 orquestan 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 graduales 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 gradual, consulte Inferencia y evaluación de modelos de previsión.
Previsión a escala: muchos modelos
Los componentes de muchos modelos de AutoML permiten entrenar y administrar millones de modelos en paralelo. Para obtener más información sobre muchos conceptos de modelos, consulte Muchos modelos.
Configuración del entrenamiento de muchos modelos
El componente de entrenamiento de muchos modelos 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 inicia. El archivo YAML tiene la misma especificación que el trabajo del comando de previsión, 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 muchos 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. |
En el ejemplo siguiente, se proporciona 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 de acceso, ./automl_settings_mm.yml".
Canalización de muchos modelos
A continuación, defina una función de fábrica que cree 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. Por lo tanto, la simultaneidad total de los trabajos de muchos modelos es max_nodes * max_concurrency_per_node. |
parallel_step_timeout_in_seconds |
Muchos modelos de tiempo de expiración de componentes especificados 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 muchas ejecuciones de modelos anteriores que provocaron errores en los trabajos de AutoML en algunas particiones de datos. Cuando habilita esta marca, muchos modelos solo inician 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 tamaño 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 muchas canalizaciones de entrenamiento y evaluación de modelos:
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()
# 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 a través de la función fábrica. Los datos de entrenamiento y prueba se encuentran en las carpetas locales ./data/train y ./data/test, respectivamente. 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 mismo procedimiento que en la canalización de ejecución de entrenamiento única.
Para ver un ejemplo más detallado, consulte también la previsión de la demanda con cuadernos de muchos modelos.
Consideraciones de entrenamiento para una ejecución de muchos modelos
Los componentes del entrenamiento de muchos modelos y la inferencia crean condicionalmente particiones de los datos según la configuración partition_column_names para que cada partición esté en su propio archivo. Este proceso puede ser muy lento o producir errores cuando los datos son muy grandes. La recomendación es particionar los datos manualmente antes de ejecutar el entrenamiento o inferencia de muchos modelos.
Nota:
El límite de paralelismo predeterminado para muchos modelos que se ejecutan dentro de una suscripción se establece en 320. Si la carga de trabajo requiere un límite mayor, puede ponerse en contacto con el soporte técnico de Microsoft.
Previsión a escala: serie temporal jerárquica
Los componentes de la serie temporal jerárquica (HTS) de AutoML permiten entrenar un gran número de modelos en datos con 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 inicia. Este archivo YAML tiene la misma especificación que el Trabajo del comando de previsión, además de 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 la mayoría desagregados, de la jerarquía. |
hierarchy_training_level |
Nivel de jerarquía que se va a usar para el entrenamiento del modelo de previsión. |
En el ejemplo siguiente, se proporciona 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 de acceso, ./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 la que se van a recuperar las previsiones. |
allocation_method |
Método de asignación que se va a usar cuando se desagreguen las previsiones. Los valores válidos son proportions_of_historical_average y average_historical_proportions. |
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. Por lo tanto, la simultaneidad total de un trabajo HTS es max_nodes * max_concurrency_per_node. |
parallel_step_timeout_in_seconds |
Muchos modelos de tiempo de expiración de componentes especificados en número de 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 modelos de previsión y la referencia de la clase HTSInferenceParameters. |
step |
Tamaño del paso para la previsión gradual (el tamaño predeterminado es 1). Para obtener más información, consulte Inferencia y evaluación de modelos de previsión y la referencia de la clase HTSInferenceParameters. |
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()
# 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 mediante la función factory. Los datos de entrenamiento y prueba se encuentran en las carpetas locales ./data/train y ./data/test, respectivamente. 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, las métricas de evaluación se pueden descargar localmente mediante el mismo procedimiento que en la canalización de ejecución de entrenamiento única.
Para obtener un ejemplo más detallado, consulte la previsión de la demanda con el cuaderno jerárquico de series temporales.
Consideraciones de entrenamiento para una ejecución de HTS
Los componentes e inferencia del entrenamiento HTS crean condicionalmente particiones de los datos según la configuración hierarchy_column_names para que cada partición esté en su propio archivo. Este proceso puede ser muy lento o producir errores cuando los datos son muy grandes. El enfoque recomendado es particionar 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 dentro de una suscripción está establecido en 320. Si la carga de trabajo requiere un límite mayor, puede ponerse en contacto con el 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).
Para escenarios con requisitos de datos de gran tamaño, 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 Uso de 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:
- Creación de canalización de previsión de demanda (HTS y muchos modelos)
- Entrenamiento del modelo TCNForecaster (DNN) en el conjunto de datos de GitHub
- Previsión con detección de días festivos y caracterización (conjunto de datos de uso compartido de bicicletas)
- Configuración manual de retrasos y agregaciones de ventanas graduales