设置 AutoML，通过 SDK 和 CLI 训练时序预测模型

项目
11/11/2024

适用范围：Azure CLI ml 扩展 v2（最新版）Python SDK azure-ai-ml v2（最新版）

Azure 机器学习中的自动化机器学习 (AutoML) 使用标准机器学习模型以及知名的时序模型来创建预测。这种方法结合了有关目标变量的历史信息，以及输入数据中用户提供的特征和自动设计的特征。模型搜索算法可帮助识别预测准确度最佳的模型。有关详细信息，请参阅预测方法和模型扫描和选择。

本文介绍如何设置 AutoML，以使用 Azure 机器学习 Python SDK](https://learn.microsoft.com/python/api/overview/azure/ai-ml-readme)，利用机器学习进行时序预测。该过程包括在预测作业（类参考）中准备用于训练的数据和配置时序参数。然后，使用组件和管道对模型进行训练、推理和评估。

如需低代码体验，请参阅教程：使用自动化机器学习预测需求。此资源是一个时序预测示例，它使用 Azure 机器学习工作室中的 AutoML。

先决条件

Azure 机器学习工作区。若要创建工作区，请参阅创建工作区资源。
启动 AutoML 训练作业的功能。有关详细信息，请参阅使用 Azure 机器学习 CLI 和 Python SDK 为表格数据设置 AutoML 训练。

准备训练和验证数据

用于 AutoML 预测的输入数据必须包含表格格式的有效时序。每个变量在数据表中必须具有其自己的对应列。 AutoML 至少需要两列：表示时间轴的“时间”列和表示要预测的数量的“目标”列。其他列可用作预测器。有关详细信息，请参阅 AutoML 如何使用数据。

重要

训练模型来预测未来的值时，请确保训练中使用的所有特征也都可在针对预期时间范围运行预测时使用。

考虑当前股票价格的特征，它可能大幅提高训练的准确度。如果使用较长的时间范围进行预测，则可能无法准确预测与未来的时序点相对应的未来股价值。这种方法可能会降低模型准确度。

AutoML 预测作业要求将训练数据表示为 MLTable 对象。 MLTable 对象指定了数据源和加载数据的步骤。有关详细信息和用例，请参阅[使用表(how-to-mltable.md)。

对于以下示例，假设训练数据包含在本地目录中的 CSV 文件 (./train_data/timeseries_train.csv) 内。

Python SDK
Azure CLI

可以使用 mltable Python SDK 创建 MLTable 对象，如以下示例所示：

import mltable

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

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

此代码会创建一个新文件 ./train_data/MLTable，其中包含文件格式和加载说明。

要启动训练作业，请使用 Python SDK 定义输入数据对象，如下所示：

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"
)

可通过将以下 YAML 代码片段复制到新文件 ./train_data/MLTable 来定义新的 MLTable 对象：

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

type: mltable
paths:
    - file: ./timeseries_train.csv

transformations:
    - read_delimited:
        delimiter: ','
        encoding: ascii

开始为 AutoML 作业生成 YAML 配置，并指定训练数据，如以下示例所示：

$schema: https://azuremlsdk2.blob.core.chinacloudapi.cn/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

# Training data MLTable for the AutoML job
training_data:
    path: "./train_data"
    type: mltable

validation_data:
    # Optional validation data

compute: # Compute for training job
primary_metric: # Primary metric  

target_column_name: # Target column name
n_cross_validations: # Cross validation setting

limits:
    # Limit settings

forecasting:
    # Forecasting specific settings

training:
    # Training settings

在本文的后续部分中向此配置添加更多详细信息。在此示例中，该位置为 ./automl-forecasting-job.yml。

以类似的方式指定验证数据。创建 MLTable 对象并指定验证数据输入。或者，如果未提供验证数据，AutoML 将自动根据训练数据创建交叉验证拆分，以用于模型选择。有关更多信息，请参阅以下资源：

创建计算以运行试验

AutoML 使用 Azure 机器学习计算（完全托管的计算资源）来运行训练作业。以下示例创建了一个名为 cpu-compute 的计算群集。

Python SDK
Azure CLI

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()

可使用以下 Azure CLI 命令创建名为 cpu-compute 的新计算：

az ml compute create -n cpu-compute --type amlcompute --min-instances 0 --max-instances 4

在作业定义中引用该计算，如下所示：

$schema: https://azuremlsdk2.blob.core.chinacloudapi.cn/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

# Set training data MLTable for the AutoML job
training_data:
    path: "./train_data"
    type: mltable

# Set compute for the training job to use 
compute: azureml:cpu-compute

primary_metric: # Primary metric  

target_column_name: # Target column name
n_cross_validations: # Cross validation setting

limits:
    # Limit settings

forecasting:
    # Forecasting specific settings

training:
    # Training settings

配置试验

以下示例演示如何配置试验。

Python SDK
Azure CLI

使用 AutoML 工厂函数在 Python SDK 中配置预测作业。以下示例演示如何通过设置主要指标和对训练运行设置限制来创建预测作业：

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,
)

配置 AutoML 作业的常规属性，包括：

主要指标
训练数据中的目标列的名称
交叉验证设置
作业的资源限制

有关详细信息，请参阅预测命令作业 YAML 架构、训练参数以及限制。

$schema: https://azuremlsdk2.blob.core.chinacloudapi.cn/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

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

compute: azureml:cpu-compute

# Settings for primary metric, target/label column name, cross validation
primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

# Settings for training job limits on time, concurrency, and others
limits:
    timeout_minutes: 120
    trial_timeout_minutes: 30
    max_concurrent_trials: 4

forecasting:
    # Forecasting specific settings

training:
    # Training settings

预测作业设置

预测任务具有许多特定于预测的设置。在这些设置中，最基本的是训练数据中时间列的名称以及预测范围。

Python SDK
Azure CLI

使用 ForecastingJob 方法配置以下设置：

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

这些设置在作业 YAML 配置的 forecasting 部分中进行配置：

$schema: https://azuremlsdk2.blob.core.chinacloudapi.cn/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

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

compute: azureml:cpu-compute

primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

limits:
    timeout_minutes: 120
    trial_timeout_minutes: 30
    max_concurrent_trials: 4

# Forecasting specific settings
# Set the horizon to 24 for this example, the horizon generally depends on the business scenario
forecasting:
    time_column_name: <time_column_name>
    forecast_horizon: 24

training:
    # Training settings

时间列名称是必需设置。通常应根据预测方案设置预测范围。如果数据包含多个时序，则可以指定时序 ID 列的名称。对这些列分组时，这些列就会定义单个序列。例如，假设数据包含不同商店和品牌的每小时销售额。以下示例演示了如何设置时序 ID 列（假设数据包含名为“商店”和“品牌”的列）：

Python SDK
Azure CLI

# 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']
)

# Forecasting specific settings
# Add time series IDs for store and brand
forecasting:
    # Other settings
    time_series_id_column_names: ["store", "brand"]

如果未指定时序 ID 列，AutoML 会尝试自动检测数据中的时序 ID 列。

其他设置是可选的，下一部分将进行介绍。

可选的预测作业设置

可选配置可用于预测任务，例如，启用深度学习和指定目标滚动窗口聚合。有关完整的参数列表，可查看参考文档。

模型搜索设置

通过两个可选设置（allowed_training_algorithms 和 blocked_training_algorithms）可以控制 AutoML 搜索最佳模型的模型空间。要将搜索空间限制为一组给定的模型类，请使用 allowed_training_algorithms 参数，如以下示例所示：

Python SDK
Azure CLI

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

$schema: https://azuremlsdk2.blob.core.chinacloudapi.cn/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

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

compute: azureml:cpu-compute

primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

limits:
    timeout_minutes: 120
    trial_timeout_minutes: 30
    max_concurrent_trials: 4

forecasting:
    time_column_name: <time_column_name>
    forecast_horizon: 24

# Training settings
# Only search ExponentialSmoothing and ElasticNet models
training:
    allowed_training_algorithms: ["ExponentialSmoothing", "ElasticNet"]
    # Other training settings

在这种情况下，预测作业仅搜索指数平滑和弹性网络模型类。要从搜索空间中移除一组给定的模型类，请使用 blocked_training_algorithms，如以下示例所示：

Python SDK
Azure CLI

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

# Training settings
# Search over all model classes except Prophet
training:
    blocked_training_algorithms: ["Prophet"]
    # other training settings

作业将搜索除 Prophet 之外的所有模型类。有关 allowed_training_algorithms 和 blocked_training_algorithms 中接受的预测模型名的列表，请查看训练属性。可以将 allowed_training_algorithms 或 blocked_training_algorithms 应用到训练运行，但不能同时将这两者应用到训练运行。

启用深度神经网络学习

AutoML 随附了一个名为 TCNForecaster 的自定义深度神经网络 (DNN) 模型。此模型是一个时间卷积网络 (TCN)，可用于将常见的图像处理任务方法应用于时序建模。一维“因果”卷积构成了网络的主干，使模型能够在训练历史的长时间内学习复杂的模式。有关详细信息，请参阅 TCNForecaster 简介。

当训练历史记录中存在数千个或更多个观测时，与标准时序模型相比，TCNForecaster 通常可获得更高的准确度。但由于其容量较高，训练和扫描 TCNForecaster 模型需要的时间也会较长。

可通过在训练配置中设置 enable_dnn_training 标志，在 AutoML 中启用 TCNForecaster，如下所示：

Python SDK
Azure CLI

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

# Training settings
# Include TCNForecaster models in the model search
training:
    enable_dnn_training: true
    # Other training settings

默认情况下，TCNForecaster 训练的限制是，对于每个模型试用，有一个计算节点和一个 GPU（如果可用）。对于大型数据方案，建议将每个 TCNForecaster 试用版分发到多个核心/GPU 和节点。有关详细信息和代码示例，请参阅分布式训练。

要为在 Azure 机器学习工作室中创建的 AutoML 试验启用 DNN，请参阅工作室 UI 操作指南中的任务类型设置。

注意

为使用 SDK 创建的试验启用 DNN 时，系统会禁用最佳模型说明。
DNN 支持在自动化机器学习中预测，但不支持在 Azure Databricks 中启动的运行。
建议的方法是在启用 DNN 训练后使用 GPU 计算类型。

滞后和滚动窗口特征

目标的最近值通常是预测模型中具有影响力的特征。因此，AutoML 可创建时间滞后和滚动窗口聚合特征，从而可能提高模型准确度。

考虑一个提供了天气数据和历史需求的能源需求预测方案。该表显示了最近三小时内应用窗口聚合后产生的特征工程。最小值、最大值以及总和的列是根据定义的设置在三小时的滑动窗口上生成的。例如，对于 2017 年 9 月 8 日凌晨 4:00 有效的观测，使用 2017 年 9 月 8 日凌晨 1:00 至 3:00 的需求值计算最大值、最小值和总和值。这个三小时的窗口将移位以填充其余行的数据。有关详细信息和示例，请参阅 AutoML 中时序预测的滞后特征。

可通过设置滚动窗口大小和要创建的滞后顺序，为目标启用滞后和滚动窗口聚合特征。上一示例中的窗口大小为 3。还可使用 feature_lags 设置为特征启用滞后。在以下示例中，所有这些设置都设置为 auto，以指示 AutoML 通过分析数据的关联结构自动确定设置：

Python SDK
Azure CLI

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

# Forecasting specific settings
# Auto configure lags and rolling window features
forecasting:
    target_lags: auto
    target_rolling_window_size: auto
    feature_lags: auto
    # Other settings

短时序处理

如果数据点不足，无法执行模型开发的训练和验证阶段，AutoML 会将一个时序视为短时序。有关详细信息，请参阅训练数据长度要求。

AutoML 可对短时序执行多个操作。通过 short_series_handling_config 设置可以配置这些操作。默认值为 auto。下表描述了这些设置：

设置	说明	备注
`auto`	短时序处理的默认值。	- 如果所有时序都是短时序，则填充数据。 - 如果并非所有时序都是短时序，则删除短时序。
`pad`	如果使用 `short_series_handling_config = pad` 设置，则 AutoML 会为找到的每个短时序添加随机值。 AutoML 使用白噪声填充目标列。	可以使用以下带有指定填充的列类型： - 对象列，使用 `NaN` 填充 - 数值列，用 0（零）填充 - 布尔/逻辑列，使用 `False` 填充
`drop`	如果使用 `short_series_handling_config = drop` 设置，则 AutoML 会删除短时序，并且该短时序不会用于训练或预测。	对这些时序的预测会返回 `NaN`。
`None`	不会填充或删除任何时序。

以下示例中设置了短时序处理，以便将所有短时序填充到最小长度：

Python SDK
Azure CLI

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

# Forecasting specific settings
# Auto configure lags and rolling window features
forecasting:
    short_series_handling_config: pad
    # Other settings

注意

填充可能会影响生成的模型的准确度，因为这引入了人工数据来避免训练失败。如果许多时序都是短时序，你可能还会在可解释性结果中看到一些影响。

频率和目标数据聚合

使用频率和数据聚合选项避免不规则数据导致的故障。如果数据不遵循设定的时间节奏（例如每小时或每天），则数据是不规则的。销售点数据是一个很好的不规则数据示例。在这些情况下，AutoML 可以按所需的频率聚合数据，然后根据聚合生成预测模型。

需要设置 frequency 和 target_aggregate_function 设置来处理不规则的数据。频率设置接受 Pandas DateOffset 字符串作为输入。下表显示聚合函数支持的值：

函数	说明
`sum`	求目标值的总和
`mean`	目标值的平均值
`min`	求目标的最小值
`max`	求目标的最大值

AutoML 对以下列应用聚合：

列	聚合方法
数值预测器	AutoML 使用 `sum`、`mean`、`min` 和 `max` 函数。它会生成新列，其中每个列名都包含一个后缀，用于标识应用于列值的聚合函数的名称。
分类预测器	AutoML 使用 `forecast_mode` 参数的值来聚合数据。它是窗口中最突出的类别。有关详细信息，请参阅多模型管道和 HTS 管道部分中参数的说明。
数据预测器	AutoML 使用最小目标值 (`min`)、最大目标值 (`max`) 和 `forecast_mode` 参数设置来聚合数据。
目标	AutoML 根据指定的操作聚合值。通常，`sum` 函数适用于大多数方案。

以下示例将频率设置为每小时，并将聚合函数设置为 summation：

Python SDK
Azure CLI

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

# Forecasting specific settings
# Auto configure lags and rolling window features
forecasting:
    frequency: H
    target_aggregate_function: sum
    # Other settings

自定义交叉验证设置

可以使用两个可自定义的设置来控制预测作业的交叉验证。使用 n_cross_validations 参数自定义折叠数，并配置 cv_step_size 参数以定义折叠之间的时间偏移。有关详细信息，请参阅预测模型选择。

默认情况下，AutoML 会根据数据的特征自动设置这两个设置。高级用户可能想要手动设置它们。例如，假设你有每日销售数据，并且希望验证设置包含五个折叠，而相邻折叠之间的偏移量为 7 天。下面的代码示例演示了如何设置这些值：

Python SDK
Azure CLI

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
)

$schema: https://azuremlsdk2.blob.core.chinacloudapi.cn/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

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

compute: azureml:cpu-compute

primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

# Use five CV folds
n_cross_validations: 5

# Set the step size between folds to seven days
forecasting:
    cv_step_size: 7
    # Other settings

limits:
    # Limit settings

training:
    # Training settings

自定义特征化

默认情况下，AutoML 使用工程特征扩充训练数据，以提高模型的准确度。有关详细信息，请参阅自动化特征工程。可使用预测作业的特征化配置来自定义某些预处理步骤。

下表列出了支持的预测自定义项：

自定义	说明	选项
列用途更新	重写指定列的自动检测到的特征类型。	`categorical`，`dateTime`，`numeric`
转换器参数更新	更新指定的 imputer 的参数。	`{"strategy": "constant", "fill_value": <value>}`，`{"strategy": "median"}`，`{"strategy": "ffill"}`

例如，假设你有一个零售需求场景，其中数据包括价格、on sale 标志和产品类型。以下示例演示了如何为这些功能设置自定义类型和 imputer：

Python SDK
Azure CLI

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"},
)

$schema: https://azuremlsdk2.blob.core.chinacloudapi.cn/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

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

compute: azureml:cpu-compute

primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

# Customize imputation methods for price and is_on_sale features
# Median value imputation for price, constant value of zero for is_on_sale
featurization:
    mode: custom
    column_name_and_types:
        product_type: Categorical
    transformer_params:
        imputer:
            - fields: ["price"]
            parameters:
                strategy: median
            - fields: ["is_on_sale"]
            parameters:
                strategy: constant
                fill_value: 0

forecasting:
    # Forecasting specific settings

limits:
    # Limit settings

training:
    # Training settings

如果使用 Azure 机器学习工作室进行试验，请参阅在工作室中配置特征化设置。

提交预测作业

配置所有设置后，即可运行预测作业。下面的示例对此过程进行了演示。

Python SDK
Azure CLI

# 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

在以下 Azure CLI 命令中，作业 YAML 配置位于当前工作目录中，路径为 ./automl-forecasting-job.yml。如果从其他目录运行命令，需要相应地更改路径。

run_id=$(az ml job create --file automl-forecasting-job.yml)

你可以使用存储的运行 ID 返回有关作业的信息。 --web 参数打开 Azure 机器学习工作室 Web UI，你可在该 UI 中查看作业的详细信息：

az ml job show -n $run_id --web

提交作业后，AutoML 会预配计算资源，对输入数据应用特征化和其他准备步骤，然后开始扫描预测模型。有关详细信息，请参阅 AutoML 中的预测方法和 AutoML 中的模型扫描和预测选择。

使用组件和管道协调训练、推理和评估

机器学习工作流需要的可能不仅仅是训练。可在 Azure 机器学习中与训练作业一起协调的其他常见任务包括推理或检索对较新数据的模型预测，以及基于具有已知目标值的测试集评估模型准确度。为了支持推理和评估任务，Azure 机器学习提供了组件，这些组件是独立的代码片段，用于在 Azure 机器学习管道中执行一个步骤。

Python SDK
Azure CLI

在以下示例中，从客户端注册表中检索组件代码：

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.chinacloudapi.cn/.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"
)

接下来，定义一个工厂函数，以便创建用于协调训练、推理和指标计算的管道。有关详细信息，请参阅配置试验。

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
    }

定义本地文件夹 ./train_data 和 ./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',
)

最后，构造管道，设置其默认计算并提交作业：

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

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

description: AutoML Forecasting Pipeline
experiment_name: cli-v2-automl-forecasting-pipeline

# Set default compute for pipeline steps
settings:
    default_compute: cpu-compute

# Pipeline inputs
inputs:
    train_data_input:
        type: mltable
        path: "./train_data"
    test_data_input:
        type: uri_folder
        path: "./test_data"
    target_column_name: <target column name>
    time_column_name: <time column name>
    forecast_horizon: <forecast horizon>
    primary_metric: normalized_root_mean_squared_error
    cv_folds: auto

# Set pipeline outputs
# Output the evaluation metrics and raw test set rolling forecasts
outputs: 
    metrics_result:
        type: uri_file
        mode: upload
    rolling_fcst_result:
        type: uri_file
        mode: upload

jobs:
  # Configure automl training node of pipeline 
    training_node:
        type: automl
        task: forecasting
        primary_metric: ${{parent.inputs.primary_metric}}
        target_column_name: ${{parent.inputs.target_column_name}}
        training_data: ${{parent.inputs.train_data_input}}
        n_cross_validations: ${{parent.inputs.cv_folds}}
        training:
            # Training settings
        forecasting:
            time_column_name: ${{parent.inputs.time_column_name}}
            forecast_horizon: ${{parent.inputs.forecast_horizon}}
            # Other forecasting specific settings
        limits:
            # Limit settings
        outputs:
            best_model:
                type: mlflow_model

    # Configure inference node to make rolling forecasts on test set
    inference_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_forecasting_inference
        inputs:
            target_column_name: ${{parent.inputs.target_column_name}}
            forecast_mode: rolling
            step: 1
            test_data: ${{parent.inputs.test_data_input}}
            model_path: ${{parent.jobs.training_node.outputs.best_model}}
        outputs:
            inference_output_file: ${{parent.outputs.rolling_fcst_result}}
            evaluation_config_output_file:
                type: uri_file

    # Configure metrics calculation node
    compute_metrics:
        type: command
        component: azureml://registries/azureml/compute_metrics
        inputs:
            task: "tabular-forecasting"
            ground_truth: ${{parent.jobs.inference_node.outputs.inference_output_file}}
            prediction: ${{parent.jobs.inference_node.outputs.inference_output_file}}
            evaluation_config: ${{parent.jobs.inference_node.outputs.evaluation_config_output_file}}
        outputs:
            evaluation_result: ${{parent.outputs.metrics_result}}

AutoML 需要 MLTable 格式的训练数据来进行 AutoML。

使用以下命令启动管道运行。管道配置位于路径 ./automl-forecasting-pipeline.yml 中：

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

提交运行请求后，管道将按顺序运行 AutoML 训练、滚动评估推理和指标计算。可以在工作室 UI 中监视和检查运行。运行完成后，可将滚动预测和评估指标下载到本地工作目录：

Python SDK
Azure CLI

# 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')

az ml job download --name $run_id --download-path . --output-name metrics_result
az ml job download --name $run_id --download-path . --output-name rolling_fcst_result

可以在以下位置查看输出：

指标：./named-outputs/metrics_results/evaluationResult/metrics.json
预测：./named-outputs/rolling_fcst_result/inference_output_file（JSON 行格式）

有关滚动评估的详细信息，请参阅预测模型的推理和评估。

大规模预测：多模型

AutoML 中的许多模型组件使你能够并行训练和管理数百万个模型。有关多模型概念的详细信息，请参阅多模型。

多模型训练配置

多模型训练组件接受 AutoML 训练设置的 YAML 格式配置文件。该组件将这些设置应用于它启动的每个 AutoML 实例。 YAML 文件具有与预测命令作业相同的规范，还具有 partition_column_names 和 allow_multi_partitions 参数。

参数	说明
`partition_column_names`	数据中的列名，分组后定义数据分区。多模型训练组件在每个分区上启动独立的训练作业。
`allow_multi_partitions`	一个可选标志，允许在每个分区包含多个唯一时序时为每个分区训练一个模型。默认值为 `false`。

以下示例提供示例 YAML 配置：

$schema: https://azuremlsdk2.blob.core.chinacloudapi.cn/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

在后续示例中，该配置存储在路径 ./automl_settings_mm.yml` 中。

多模型管道

接下来，定义一个工厂函数，以便创建用于协调多模型训练、推理和指标计算的管道。下表描述了此工厂函数的参数：

参数	说明
`max_nodes`	要在训练作业中使用的计算节点数。
`max_concurrency_per_node`	要在每个节点上运行的 AutoML 进程数。因此，多模型作业的总并发性为 `max_nodes * max_concurrency_per_node`。
`parallel_step_timeout_in_seconds`	以秒数指定的多模型组件超时。
`retrain_failed_models`	用于为失败的模型启用重新训练的标志。如果之前执行的多模型运行导致了 AutoML 作业在某些数据分区上失败，则此值很有用。启用此标志后，多模型运行仅针对之前失败的分区启动训练作业。
`forecast_mode`	模型评估的推理模式。有效值为 `recursive`（默认值）和 `rolling`。有关详细信息，请参阅预测模型的推理和评估和 ManyModelsInferenceParameters 类参考。
`step`	滚动预测的步长（默认为 1）。有关详细信息，请参阅预测模型的推理和评估和 ManyModelsInferenceParameters 类参考。

以下示例演示了用于构造多模型训练和模型评估管道的工厂方法：

Python SDK
Azure CLI

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.chinacloudapi.cn/.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
    }

通过工厂函数构造管道。训练和测试数据分别位于本地文件夹 ./data/train 和 ./data/test 中。最后，设置默认计算并提交作业，如以下示例所示：

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)

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

description: AutoML Many Models Forecasting Pipeline
experiment_name: cli-v2-automl-mm-forecasting-pipeline

# Set default compute for pipeline steps
settings:
    default_compute: azureml:cpu-compute

# Set pipeline inputs
inputs:
    train_data_input:
        type: uri_folder
        path: "./train_data"
        mode: direct
    test_data_input:
        type: uri_folder
        path: "./test_data"
    automl_config_input:
        type: uri_file
        path: "./automl_settings_mm.yml"
    max_nodes: 4
    max_concurrency_per_node: 4
    parallel_step_timeout_in_seconds: 3700
    forecast_mode: rolling
    step: 1
    retrain_failed_model: False

# Set pipeline outputs
# Output the evaluation metrics and raw test set rolling forecasts
outputs: 
    metrics_result:
        type: uri_file
        mode: upload

jobs:
    # Configure AutoML many models training component
    mm_train_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_many_models_training
        inputs:
            raw_data: ${{parent.inputs.train_data_input}}
            automl_config: ${{parent.inputs.automl_config_input}}
            max_nodes: ${{parent.inputs.max_nodes}}
            max_concurrency_per_node: ${{parent.inputs.max_concurrency_per_node}}
            parallel_step_timeout_in_seconds: ${{parent.inputs.parallel_step_timeout_in_seconds}}
            retrain_failed_model: ${{parent.inputs.retrain_failed_model}}
        outputs:
            run_output:
                type: uri_folder

    # Configure inference node to make rolling forecasts on test set
    mm_inference_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_many_models_inference
        inputs:
            raw_data: ${{parent.inputs.test_data_input}}
            max_concurrency_per_node: ${{parent.inputs.max_concurrency_per_node}}
            parallel_step_timeout_in_seconds: ${{parent.inputs.parallel_step_timeout_in_seconds}}
            forecast_mode: ${{parent.inputs.forecast_mode}}
            step: ${{parent.inputs.step}}
            max_nodes: ${{parent.inputs.max_nodes}}
            optional_train_metadata: ${{parent.jobs.mm_train_node.outputs.run_output}}
        outputs:
            run_output:
                type: uri_folder
            evaluation_configs:
                type: uri_file
            evaluation_data:
                type: uri_file

    # Configure metrics calculation node
    compute_metrics:
        type: command
        component: azureml://registries/azureml/components/compute_metrics
        inputs:
            task: "tabular-forecasting"
            ground_truth: ${{parent.jobs.mm_inference_node.outputs.evaluation_data}}
            prediction: ${{parent.jobs.mm_inference_node.outputs.evaluation_data}}
            evaluation_config: ${{parent.jobs.mm_inference_node.outputs.evaluation_configs}}
        outputs:
            evaluation_result: ${{parent.outputs.metrics_result}}

使用以下命令启动管道作业。多模型管道配置位于路径 ./automl-mm-forecasting-pipeline.yml 中：

az ml job create --file automl-mm-forecasting-pipeline.yml -w <Workspace> -g <Resource Group> --subscription <Subscription>

作业完成后，可按照与在单个训练运行管道中相同的过程，在本地下载评估指标。

有关更详细的示例，请参阅“使用多模型预测需求”笔记本。

多模型运行的训练注意事项

多模型训练和推理组件根据 partition_column_names 设置有条件地对数据进行分区，以便每个分区都在其自己的文件中。当数据非常大时，此过程可能会非常缓慢或者会失败。建议在运行多模型训练或推理之前，手动对数据进行分区。

注意

订阅中运行的许多模型的默认并行度限制将设置为 320。如果工作负载需要更高的限制，可以联系 Microsoft 支持部门。

大规模预测：分层时序

AutoML 中的分层时序 (HTS) 组件使你能够基于具有分层结构的数据训练大量模型。有关详细信息，请参阅分层时序预测。

HTS 训练配置

HTS 训练组件接受 AutoML 训练设置的 YAML 格式配置文件。该组件将这些设置应用于它启动的每个 AutoML 实例。此 YAML 文件具有与预测命令作业相同的规范，还具有其他与层次结构信息相关的参数：

参数	说明
`hierarchy_column_names`	数据中的列名列表，这些列名定义了数据的分层结构。此列表中的列的顺序决定了层次结构级别。聚合程度随着列表索引的增加而降低。也就是说，列表中的最后一列定义层次结构中的叶级（或聚合度最低的级别）。
`hierarchy_training_level`	用于预测模型训练的层次结构级别。

以下示例提供示例 YAML 配置：

$schema: https://azuremlsdk2.blob.core.chinacloudapi.cn/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"

在后续示例中，该配置存储在路径 ./automl_settings_hts.yml 中。

HTS 管道

接下来，定义一个工厂函数，以便创建用于协调 HTS 训练、推理和指标计算的管道。下表描述了此工厂函数的参数：

参数	说明
`forecast_level`	要检索其预测的层次结构的级别。
`allocation_method`	分解预测时要使用的分配方法。有效值为 `proportions_of_historical_average` 和 `average_historical_proportions`。
`max_nodes`	要在训练作业中使用的计算节点数。
`max_concurrency_per_node`	要在每个节点上运行的 AutoML 进程数。因此，HTS 作业的总并发性为 `max_nodes * max_concurrency_per_node`。
`parallel_step_timeout_in_seconds`	以秒数指定的多模型组件超时。
`forecast_mode`	模型评估的推理模式。有效值为 `recursive` 和 `rolling`。有关详细信息，请参阅预测模型的推理和评估和 HTSInferenceParameters 类参考。
`step`	滚动预测的步长（默认为 1）。有关详细信息，请参阅预测模型的推理和评估和 HTSInferenceParameters 类参考。

Python SDK
Azure CLI

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.chinacloudapi.cn/.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
    }

使用工厂函数来构造管道。训练和测试数据分别位于本地文件夹 ./data/train 和 ./data/test 中。最后，设置默认计算并提交作业，如以下示例所示：

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)

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

description: AutoML Many Models Forecasting Pipeline
experiment_name: cli-v2-automl-mm-forecasting-pipeline

# Set the default compute for pipeline steps
settings:
    default_compute: cpu-compute

# Set pipeline inputs
inputs:
    train_data_input:
        type: uri_folder
        path: "./train_data"
        mode: direct
    test_data_input:
        type: uri_folder
        path: "./test_data"
    automl_config_input:
        type: uri_file
        path: "./automl_settings_hts.yml"
    max_concurrency_per_node: 4
    parallel_step_timeout_in_seconds: 3700
    max_nodes: 4
    forecast_mode: rolling
    step: 1
    allocation_method: proportions_of_historical_average
    forecast_level: # forecast level

# Set pipeline outputs
# Output evaluation metrics and raw test set rolling forecasts
outputs: 
    metrics_result:
        type: uri_file
        mode: upload

jobs:
    # Configure AutoML many models training component
    hts_train_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_hts_training
        inputs:
            raw_data: ${{parent.inputs.train_data_input}}
            automl_config: ${{parent.inputs.automl_config_input}}
            max_nodes: ${{parent.inputs.max_nodes}}
            max_concurrency_per_node: ${{parent.inputs.max_concurrency_per_node}}
            parallel_step_timeout_in_seconds: ${{parent.inputs.parallel_step_timeout_in_seconds}}
        outputs:
            run_output:
                type: uri_folder


    # Configure inference node to make rolling forecasts on test set
    hts_inference_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_hts_inference
        inputs:
            raw_data: ${{parent.inputs.test_data_input}}
            max_concurrency_per_node: ${{parent.inputs.max_concurrency_per_node}}
            parallel_step_timeout_in_seconds: ${{parent.inputs.parallel_step_timeout_in_seconds}}
            forecast_mode: ${{parent.inputs.forecast_mode}}
            step: ${{parent.inputs.step}}
            max_nodes: ${{parent.inputs.max_nodes}}
            optional_train_metadata: ${{parent.jobs.hts_train_node.outputs.run_output}}
            forecast_level: ${{parent.inputs.forecast_level}}
            allocation_method: ${{parent.inputs.allocation_method}}
        outputs:
            run_output:
                type: uri_folder
            evaluation_configs:
                type: uri_file
            evaluation_data:
                type: uri_file

    # Configure metrics calculation node
    compute_metrics:
        type: command
        component: azureml://registries/azureml/components/compute_metrics
        inputs:
            task: "tabular-forecasting"
            ground_truth: ${{parent.jobs.hts_inference_node.outputs.evaluation_data}}
            prediction: ${{parent.jobs.hts_inference_node.outputs.evaluation_data}}
            evaluation_config: ${{parent.jobs.hts_inference_node.outputs.evaluation_configs}}
        outputs:
            evaluation_result: ${{parent.outputs.metrics_result}}

使用以下命令启动管道作业。多模型管道配置位于路径 ./automl-hts-forecasting-pipeline.yml 中：

az ml job create --file automl-hts-forecasting-pipeline.yml -w <Workspace> -g <Resource Group> --subscription <Subscription>