AutoML instellen voor het trainen van een tijdreeksprognosemodel met SDK en CLI

VAN TOEPASSING OP:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

Geautomatiseerde machine learning (AutoML) in Azure Machine Learning maakt gebruik van standaard machine learning-modellen, samen met bekende tijdreeksmodellen om prognoses te maken. Deze benadering bevat historische informatie over de doelvariabele met door de gebruiker verstrekte functies in de invoergegevens en automatisch ontworpen functies. Modelzoekalgoritmen helpen bij het identificeren van modellen met de beste voorspellende nauwkeurigheid. Zie prognosemethodologie en modelverruiming en -selectie voor meer informatie.

In dit artikel wordt beschreven hoe u AutoML instelt voor tijdreeksprognoses met Machine Learning met behulp van de Azure Machine Learning Python SDK](/python/api/overview/azure/ai-ml-readme). Het proces omvat het voorbereiden van gegevens voor het trainen en configureren van tijdreeksparameters in een prognosetaak (klasseverwijzing). Vervolgens traint, deducteert en evalueert u modellen met behulp van onderdelen en pijplijnen.

Zie Zelfstudie: Vraag voorspellen met geautomatiseerde machine learning voor een ervaring met weinig code. Deze resource is een voorbeeld van een tijdreeksprognose waarin AutoML in Azure Machine Learning-studio wordt gebruikt.

Vereisten

• Een Azure Machine Learning-werkruimte. Zie Werkruimtebronnen maken om een werkruimte te maken.
• De mogelijkheid om AutoML-trainingstaken te starten. Zie AutoML-training instellen voor tabelgegevens met de Azure Machine Learning CLI en Python SDK voor meer informatie.

Trainings- en validatiegegevens voorbereiden

Invoergegevens voor AutoML-prognose moeten een geldige tijdreeks in tabelvorm bevatten. Elke variabele moet een eigen overeenkomende kolom in de gegevenstabel hebben. AutoML vereist ten minste twee kolommen: een tijdkolom voor de tijdas en een doelkolom voor de hoeveelheid die moet worden voorspeld. Andere kolommen kunnen fungeren als voorspellers. Zie Hoe AutoML uw gegevens gebruikt voor meer informatie.

Belangrijk

Wanneer u een model traint voor het voorspellen van toekomstige waarden, moet u ervoor zorgen dat alle functies die in de training worden gebruikt, ook kunnen worden gebruikt bij het uitvoeren van voorspellingen voor uw beoogde horizon.

Overweeg een functie voor de huidige aandelenkoers, die de nauwkeurigheid van de training enorm kan verhogen. Als u een voorspelling met een lange horizon maakt, kunt u mogelijk geen nauwkeurige voorspellingen doen over toekomstige aandelenwaarden die overeenkomen met toekomstige tijdreekspunten. Deze benadering kan de nauwkeurigheid van het model verminderen.

Voor AutoML-prognosetaken is vereist dat uw trainingsgegevens worden weergegeven als een MLTable object. Een MLTable object geeft een gegevensbron en stappen op voor het laden van de gegevens. Zie [Werken met tabellen (how-to-mltable.md) voor meer informatie en use cases.

Stel dat uw trainingsgegevens zijn opgenomen in een CSV-bestand in een lokale map, ./train_data/timeseries_train.csv.

Python SDK

U kunt een MLTable object maken met behulp van de Mltable Python SDK , zoals wordt weergegeven in het volgende voorbeeld:

import mltable

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

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

Met deze code maakt u een nieuw bestand, ./train_data/MLTable, dat de bestandsindeling en laadinstructies bevat.

Als u de trainingstaak wilt starten, definieert u als volgt een invoergegevensobject met behulp van de 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"
)

Azure-CLI

U kunt een nieuw MLTable object definiëren door het volgende YAML-fragment te kopiëren naar een nieuw bestand, ./train_data/MLTable:

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

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

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

Begin met het bouwen van de YAML-configuratie voor de AutoML-taak met de trainingsgegevens die zijn opgegeven in het volgende voorbeeld:

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

Voeg meer details toe aan deze configuratie in volgende secties van dit artikel. In dit voorbeeld is de locatie ./automl-forecasting-job.yml.

U geeft validatiegegevens op een vergelijkbare manier op. Maak een MLTable object en geef een invoer voor validatiegegevens op. Als u geen validatiegegevens opgeeft, worden in AutoML automatisch kruisvalidatiesplitsingen gemaakt van uw trainingsgegevens die moeten worden gebruikt voor modelselectie. Voor meer informatie raadpleegt u de volgende bronnen:

• Prognosemodellen selecteren
• Vereisten voor lengte van trainingsgegevens instellen
• Overfitting voorkomen met kruisvalidatie

Rekenkracht maken om een experiment uit te voeren

AutoML maakt gebruik van Azure Machine Learning Compute, een volledig beheerde rekenresource, om de trainingstaak uit te voeren. In het volgende voorbeeld wordt een rekencluster gemaakt met de naam cpu-compute.

Python SDK

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

U kunt een nieuwe berekening maken met cpu-compute de volgende Azure CLI-opdracht:

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

Verwijs als volgt naar de berekening in de taakdefinitie:

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

Experiment configureren

In het volgende voorbeeld ziet u hoe u het experiment configureert.

Python SDK

U gebruikt de AutoML-fabrieksfuncties om prognosetaken in de Python SDK te configureren. In het volgende voorbeeld ziet u hoe u een prognosetaak maakt door de primaire metrische gegevens in te stellen en limieten in te stellen voor de trainingsuitvoering:

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

Azure-CLI

Algemene eigenschappen van de AutoML-taak configureren, waaronder:

• De primaire metrische waarde
• De naam van de doelkolom in de trainingsgegevens
• De instellingen voor kruisvalidatie
• Resourcelimieten voor de taak

Zie het YAML-schema, trainingsparameters en limieten van de opdrachtopdrachtopdracht voorspellen voor meer informatie.

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

Taakinstellingen voor prognose

Prognosetaken hebben veel instellingen die specifiek zijn voor prognoses. De meest elementaire van deze instellingen zijn de naam van de tijdkolom in de trainingsgegevens en de prognosehorizk.

Python SDK

Gebruik de ForecastingJob-methoden om deze instellingen te configureren:

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

Azure-CLI

Deze instellingen worden geconfigureerd in de forecasting sectie van de YAML-configuratie van de taak:

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

De naam van de tijdkolom is een vereiste instelling. Over het algemeen moet u de prognosehorizk instellen op basis van uw voorspellingsscenario. Als uw gegevens meerdere tijdreeksen bevatten, kunt u de namen van de kolommen met tijdreeks-id's opgeven. Wanneer deze kolommen zijn gegroepeerd, definiëren ze de afzonderlijke reeksen. Stel dat u gegevens hebt die bestaan uit uurverkoop uit verschillende winkels en merken. In het volgende voorbeeld ziet u hoe u de tijdreeks-id-kolommen instelt, ervan uitgaande dat de gegevens kolommen met de naam Store en merk bevatten:

Python SDK

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

Azure-CLI

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

AutoML probeert automatisch tijdreeks-id-kolommen in uw gegevens te detecteren als er geen kolommen zijn opgegeven.

Andere instellingen zijn optioneel en gecontroleerd in de volgende sectie.

Optionele instellingen voor prognosetaak

Er zijn optionele configuraties beschikbaar voor het voorspellen van taken, zoals het inschakelen van deep learning en het opgeven van een doelaggregatie van rolling windows. Er is een volledige lijst met parameters beschikbaar in de referentiedocumentatie.

Zoekinstellingen voor modellen

Er zijn twee optionele instellingen waarmee de modelruimte wordt beheerd, waarbij AutoML zoekt naar het beste model: allowed_training_algorithms en blocked_training_algorithms. Als u de zoekruimte wilt beperken tot een bepaalde set modelklassen, gebruikt u de allowed_training_algorithms parameter, zoals wordt weergegeven in het volgende voorbeeld:

Python SDK

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

Azure-CLI

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

In dit scenario zoekt de prognosetaak alleen naar modelklassen Exponentieel smoothing en Elastic Net. Als u een bepaalde set modelklassen uit de zoekruimte wilt verwijderen, gebruikt u de blocked_training_algorithms optie zoals wordt weergegeven in het volgende voorbeeld:

Python SDK

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

Azure-CLI

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

De taak doorzoekt alle modelklassen behalve Prophet. Zie trainingseigenschappen voor een lijst met prognosemodelnamen die worden geaccepteerd in allowed_training_algorithms en.blocked_training_algorithms U kunt een van beide toepassen, maar niet beide allowed_training_algorithms en blocked_training_algorithms op een trainingsuitvoering.

Leren inschakelen voor deep neurale netwerken

AutoML wordt geleverd met een aangepast DNN-model (Deep Neural Network) met de naam TCNForecaster. Dit model is een tijdelijk convolutionele netwerk (TCN), dat algemene imaging-taakmethoden toepast op time-series modellering. Eendimensionale "causale" samenvoegingen vormen de backbone van het netwerk en stellen het model in staat om complexe patronen te leren gedurende lange tijd in de trainingsgeschiedenis. Zie Inleiding tot TCNForecaster voor meer informatie.

De TCNForecaster bereikt vaak een hogere nauwkeurigheid dan standaard tijdreeksmodellen wanneer er duizenden of meer waarnemingen in de trainingsgeschiedenis zijn. Het duurt echter ook langer om TCNForecaster-modellen te trainen en te vegen vanwege hun hogere capaciteit.

U kunt de TCNForecaster in AutoML inschakelen door de enable_dnn_training vlag in de trainingsconfiguratie als volgt in te stellen:

Python SDK

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

Azure-CLI

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

TCNForecaster-training is standaard beperkt tot één rekenknooppunt en één GPU, indien beschikbaar, per modelabonnement. Voor scenario's met grote gegevens wordt aanbevolen om elke TCNForecaster-proefversie over meerdere kernen/GPU's en knooppunten te distribueren. Zie gedistribueerde training voor meer informatie en codevoorbeelden.

Als u DNN wilt inschakelen voor een AutoML-experiment dat is gemaakt in Azure Machine Learning-studio, raadpleegt u de taaktype-instellingen in de gebruikersinterface van studio.

Notitie

• Wanneer u DNN inschakelt voor experimenten die zijn gemaakt met de SDK, worden de beste modeluitlegen uitgeschakeld.
• DNN-ondersteuning voor prognoses in Geautomatiseerde machine learning wordt niet ondersteund voor uitvoeringen die zijn geïnitieerd in Azure Databricks.
• De aanbevolen aanpak is het gebruik van GPU-rekentypen wanneer DNN-training is ingeschakeld.

Functies voor vertragings- en rollend venster

Recente waarden van het doel zijn vaak van invloed op functies in een prognosemodel. AutoML kan daarom functies voor aggregatie van tijd- en rolling vensters maken om de nauwkeurigheid van het model mogelijk te verbeteren.

Overweeg een scenario voor het voorspellen van energievraag waarbij weergegevens en historische vraag beschikbaar zijn. In de tabel ziet u de resulterende functie-engineering die optreedt wanneer vensteraggregatie gedurende de meest recente drie uur wordt toegepast. Kolommen voor minimum, maximum en som worden gegenereerd in een schuifvenster van drie uur op basis van de gedefinieerde instellingen. Voor de waarneming die geldig is op 8 september 2017 4:00 uur, worden de maximum-, minimum- en somwaarden berekend met behulp van de vraagwaarden voor 8 september 2017 1:00 - 3:00 uur. In dit venster van drie uur worden gegevens voor de resterende rijen ingevuld. Zie de vertragingsfuncties voor het voorspellen van tijdreeksen in AutoML voor meer informatie en voorbeelden.

U kunt aggregatiefuncties voor vertragings- en rollingvensters voor het doel inschakelen door de grootte van het rolling-venster en de vertragingsorders in te stellen die u wilt maken. De venstergrootte was drie in het vorige voorbeeld. U kunt ook vertragingen inschakelen voor functies met de feature_lags instelling. In het volgende voorbeeld zijn al deze instellingen zo ingesteld auto dat AutoML automatisch instellingen kan bepalen door de correlatiestructuur van uw gegevens te analyseren:

Python SDK

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

Azure-CLI

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

Verwerking van korte reeksen

AutoML beschouwt een tijdreeks in een korte reeks als er onvoldoende gegevenspunten zijn om de train- en validatiefasen van modelontwikkeling uit te voeren. Zie de vereisten voor lengte van trainingsgegevens voor meer informatie.

AutoML heeft verschillende acties die kunnen worden uitgevoerd voor korte reeksen. Deze acties kunnen worden geconfigureerd met de short_series_handling_config instelling. De standaardwaarde is auto. De volgende tabel beschrijft de instellingen:

Instelling	Beschrijving	Opmerkingen
auto	De standaardwaarde voor het verwerken van korte reeksen.	- Als alle reeksen kort zijn, vult u de gegevens in. - Als niet alle reeksen kort zijn, zet u de korte reeks neer.
pad	Als de short_series_handling_config = pad instelling wordt gebruikt, voegt AutoML willekeurige waarden toe aan elke gevonden korte reeks. AutoML gebruikt de doelkolom met witte ruis.	U kunt de volgende kolomtypen gebruiken met de opgegeven opvulling: - Objectkolommen, pad met NaNs - Numerieke kolommen, pad met 0 (nul) - Booleaanse/logische kolommen, pad met False
drop	Als de short_series_handling_config = drop instelling wordt gebruikt, verwijdert AutoML de korte reeks en wordt deze niet gebruikt voor training of voorspelling.	Voorspellingen voor deze reeks retourneren NaN.
None	Er is geen reeks opgevuld of verwijderd.

In het volgende voorbeeld wordt de verwerking van korte reeksen ingesteld, zodat alle korte reeksen worden opgevuld tot de minimale lengte:

Python SDK

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

Azure-CLI

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

Let op

Opvulling kan van invloed zijn op de nauwkeurigheid van het resulterende model, omdat er kunstmatige gegevens worden geïntroduceerd om trainingsfouten te voorkomen. Als veel van de reeks kort zijn, ziet u mogelijk ook enkele gevolgen in de resultaten van de uitlegbaarheid.

Frequentie en doelgegevensaggregatie

Gebruik de opties voor frequentie en gegevensaggregatie om fouten te voorkomen die worden veroorzaakt door onregelmatige gegevens. Uw gegevens zijn onregelmatig als ze geen vaste frequentie in tijd volgen, zoals elk uur of dagelijks. Point-of-sales-gegevens zijn een goed voorbeeld van onregelmatige gegevens. In deze scenario's kan AutoML uw gegevens aggregeren naar een gewenste frequentie en vervolgens een prognosemodel maken op basis van de aggregaties.

U moet de frequency en target_aggregate_function instellingen instellen om onregelmatige gegevens te verwerken. De frequentie-instelling accepteert Pandas DateOffset-tekenreeksen als invoer. In de volgende tabel ziet u ondersteunde waarden voor de aggregatiefunctie:

Functie	Beschrijving
sum	Som van doelwaarden
mean	Gemiddelde of gemiddelde van doelwaarden
min	Minimumwaarde van een doel
max	Maximumwaarde van een doel

AutoML past aggregatie toe voor de volgende kolommen:

Kolom	Samenvoegingsmethode
Numerieke voorspellers	AutoML gebruikt de sumfuncties , meanen minmax functies. Er worden nieuwe kolommen gegenereerd, waarbij elke kolomnaam een achtervoegsel bevat dat de naam van de aggregatiefunctie identificeert die is toegepast op de kolomwaarden.
Categorische voorspellers	AutoML gebruikt de waarde van de forecast_mode parameter om de gegevens samen te voegen. Het is de meest prominente categorie in het venster. Zie de beschrijvingen van de parameter in de secties Veel modellenpijplijn en HTS-pijplijn voor meer informatie.
Gegevens voorspellen	AutoML gebruikt de minimumdoelwaarde (min), de maximumdoelwaarde (max) en forecast_mode parameterinstellingen om de gegevens samen te voegen.
Doel	AutoML voegt de waarden samen op basis van de opgegeven bewerking. Normaal gesproken is de functie geschikt voor de sum meeste scenario's.

In het volgende voorbeeld wordt de frequentie ingesteld op uur en de aggregatiefunctie om op te sommen:

Python SDK

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

Azure-CLI

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

Aangepaste instellingen voor kruisvalidatie

Er zijn twee aanpasbare instellingen waarmee kruisvalidatie voor prognosetaken wordt gecontroleerd. Pas het aantal vouwen aan met de parameter n_cross_validations en configureer de parameter cv_step_size om de tijdverschil tussen vouwen te definiëren. Zie de selectie van het prognosemodel voor meer informatie.

AutoML stelt standaard beide instellingen automatisch in op basis van de kenmerken van uw gegevens. Geavanceerde gebruikers willen ze mogelijk handmatig instellen. Stel dat u dagelijkse verkoopgegevens hebt en u wilt dat uw validatie-instelling bestaat uit vijf vouwen met een verschuiving van zeven dagen tussen aangrenzende vouwen. In het volgende codevoorbeeld ziet u hoe u deze waarden instelt:

Python SDK

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
)

Azure-CLI

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

Aangepaste featurization

Met AutoML worden standaard trainingsgegevens aangevuld met ontworpen functies om de nauwkeurigheid van de modellen te vergroten. Zie geautomatiseerde functie-engineering voor meer informatie. Sommige van de voorverwerkingsstappen kunnen worden aangepast met behulp van de featurization-configuratie van de prognosetaak.

De volgende tabel bevat de ondersteunde aanpassingen voor prognose:

Aanpassing	Beschrijving	Opties
Update van kolomdoel	Overschrijf het automatisch gedetecteerde functietype voor de opgegeven kolom.	categorical, , dateTimenumeric
Parameterupdate voor transformatieprogramma	Werk de parameters voor de opgegeven imputer bij.	{"strategy": "constant", "fill_value": <value>}, , {"strategy": "median"}{"strategy": "ffill"}

Stel dat u een scenario hebt waarin de gegevens prijzen, een on sale vlag en een producttype bevatten. In het volgende voorbeeld ziet u hoe u aangepaste typen en imputers voor deze functies kunt instellen:

Python SDK

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

Azure-CLI

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

Zie Featurization-instellingen configureren in de studio als u Azure Machine Learning-studio gebruikt voor uw experiment.

Prognosetaak verzenden

Nadat u alle instellingen hebt geconfigureerd, kunt u de prognosetaak uitvoeren. In het volgende voorbeeld ziet u dit proces.

Python SDK

# 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

In de volgende Azure CLI-opdracht bevindt de YAML-taakconfiguratie zich in de huidige werkmap op het pad. /automl-forecasting-job.yml. Als u de opdracht uitvoert vanuit een andere map, moet u het pad dienovereenkomstig wijzigen.

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

U kunt de opgeslagen uitvoerings-id gebruiken om informatie over de taak te retourneren. Met --web de parameter wordt de Azure Machine Learning-studio webgebruikersinterface geopend, waar u details van de taak kunt zien:

az ml job show -n $run_id --web

Nadat u de taak hebt ingediend, richt AutoML rekenresources in, past featurization en andere voorbereidingsstappen toe op de invoergegevens en begint het opruimen van prognosemodellen. Zie de prognosemethodologie in AutoML en Model opruimen en selectie voor prognoses in AutoML voor meer informatie.

Training, deductie en evaluatie organiseren met onderdelen en pijplijnen

Uw machine learning-werkstroom vereist waarschijnlijk meer dan alleen training. Deductie of het ophalen van modelvoorspellingen op nieuwere gegevens en de evaluatie van modelnauwkeurigheid op een testset met bekende doelwaarden zijn andere algemene taken die u in Azure Machine Learning samen met trainingstaken kunt organiseren. Ter ondersteuning van deductie- en evaluatietaken biedt Azure Machine Learning onderdelen, die zelfstandige stukjes code zijn die één stap in een Azure Machine Learning-pijplijn uitvoeren.

Python SDK

Haal in het volgende voorbeeld onderdeelcode op uit een clientregister:

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

Definieer vervolgens een factory-functie waarmee pijplijnen worden gemaakt die training, deductie en metrische berekeningen organiseren. Zie Experiment configureren voor meer informatie.

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
    }

Definieer invoer van train- en testgegevens in lokale mappen ./train_data en ./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',
)

Maak ten slotte de pijplijn, stel de standaard rekenkracht in en verzend de taak:

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

Azure-CLI

$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 vereist trainingsgegevens in MLTable-indeling voor AutoML.

Start de pijplijn die wordt uitgevoerd met behulp van de volgende opdracht. De pijplijnconfiguratie bevindt zich op het pad ./automl-forecasting-pipeline.yml:

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

Nadat u de uitvoeringsaanvraag hebt ingediend, voert de pijplijn AutoML-training, rolling evaluatiedeductie en metrische berekening in volgorde uit. U kunt de uitvoering bewaken en inspecteren in de gebruikersinterface van studio. Wanneer de uitvoering is voltooid, kunt u de rolling prognoses en de metrische evaluatiegegevens downloaden naar de lokale werkmap:

Python SDK

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

Azure-CLI

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

U kunt de uitvoer op de volgende locaties bekijken:

• Metrische gegevens: ./named-outputs/metrics_results/evaluationResult/metrics.json
• Prognoses: ./named-outputs/rolling_fcst_result/inference_output_file (JSON-regelsindeling)

Zie Deductie en evaluatie van prognosemodellen voor meer informatie over rolling evaluatie.

Prognose op schaal: Veel modellen

Met de vele onderdelen van modellen in AutoML kunt u miljoenen modellen parallel trainen en beheren. Zie Veel modellen voor meer informatie over veel modelconcepten.

Trainingsconfiguratie voor veel modellen

Het trainingsonderdeel voor veel modellen accepteert een YAML-indelingsconfiguratiebestand van de AutoML-trainingsinstellingen. Het onderdeel past deze instellingen toe op elk AutoML-exemplaar dat wordt gestart. Het YAML-bestand heeft dezelfde specificatie als de opdrachttaak Voorspellen plus de partition_column_names parameters allow_multi_partitions .

Parameter	Description
partition_column_names	Kolomnamen in de gegevens die, wanneer gegroepeerd, de gegevenspartities definiëren. Het trainingsonderdeel voor veel modellen start een onafhankelijke trainingstaak op elke partitie.
allow_multi_partitions	Een optionele vlag waarmee één model per partitie kan worden getraind wanneer elke partitie meer dan één unieke tijdreeks bevat. De standaardwaarde is false.

In het volgende voorbeeld ziet u een YAML-voorbeeldconfiguratie:

$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

In volgende voorbeelden wordt de configuratie opgeslagen op het pad. /automl_settings_mm.yml'.

Veel modellenpijplijn

Definieer vervolgens een factory-functie die pijplijnen maakt voor het organiseren van veel modellentraining, deductie en metrische berekeningen. In de volgende tabel worden de parameters voor deze factory-functie beschreven:

Parameter	Description
max_nodes	Het aantal rekenknooppunten dat moet worden gebruikt in de trainingstaak.
max_concurrency_per_node	Het aantal AutoML-processen dat op elk knooppunt moet worden uitgevoerd. Daarom is max_nodes * max_concurrency_per_nodede totale gelijktijdigheid van een groot aantal modellen taken.
parallel_step_timeout_in_seconds	Veel time-outs voor modellenonderdelen die zijn opgegeven in het aantal seconden.
retrain_failed_models	Vlag om opnieuw trainen in te schakelen voor mislukte modellen. Deze waarde is handig als u veel modellen hebt uitgevoerd die hebben geresulteerd in mislukte AutoML-taken op sommige gegevenspartities. Wanneer u deze vlag inschakelt, starten veel modellen alleen trainingstaken voor eerder mislukte partities.
forecast_mode	Deductiemodus voor modelevaluatie. Geldige waarden zijn recursive (standaard) en rolling. Zie Deductie en evaluatie van prognosemodellen en de verwijzing naar de klasse ManyModelsInferenceParameters voor meer informatie.
step	Stapgrootte voor rolling prognose (standaard is 1). Zie Deductie en evaluatie van prognosemodellen en de verwijzing naar de klasse ManyModelsInferenceParameters voor meer informatie.

In het volgende voorbeeld ziet u een fabrieksmethode voor het bouwen van veel modellentrainings- en modelevaluatiepijplijnen:

Python SDK

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
    }

Bouw de pijplijn met de fabrieksfunctie. De trainings- en testgegevens bevinden zich respectievelijk in de lokale mappen ./data/train en ./data/test. Stel ten slotte de standaard rekenkracht in en verzend de taak, zoals wordt weergegeven in het volgende voorbeeld:

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)

Azure-CLI

$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}}

U start de pijplijntaak met de volgende opdracht. De configuratie van de pijplijn voor veel modellen bevindt zich op het pad ./automl-mm-forecasting-pipeline.yml:

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

Nadat de taak is voltooid, kunt u de metrische evaluatiegegevens lokaal downloaden met behulp van dezelfde procedure als in de pijplijn voor één trainingsuitvoering.

Zie de vraagprognoses met een groot aantal modellen voor een gedetailleerder voorbeeld.

Trainingsoverwegingen voor een groot aantal modellen worden uitgevoerd

De vele modellen trainen en deductieonderdelen partitioneren uw gegevens voorwaardelijk op basis van de partition_column_names instelling, zodat elke partitie zich in een eigen bestand bevindt. Dit proces kan erg traag zijn of mislukken wanneer gegevens erg groot zijn. U wordt aangeraden uw gegevens handmatig te partitioneren voordat u veel modellen traint of deductie uitvoert.

Notitie

De standaardlimiet voor parallelle uitvoering voor een groot aantal modellen binnen een abonnement is ingesteld op 320. Als uw workload een hogere limiet vereist, kunt u contact opnemen met Microsoft Ondersteuning.

Prognose op schaal: Hiërarchische tijdreeks

Met de hiërarchische tijdreeksonderdelen (HTS) in AutoML kunt u een groot aantal modellen trainen op gegevens met hiërarchische structuur. Zie Hiërarchische tijdreeksprognoses voor meer informatie.

HTS-trainingsconfiguratie

Het HTS-trainingsonderdeel accepteert een YAML-indelingsconfiguratiebestand van de AutoML-trainingsinstellingen. Het onderdeel past deze instellingen toe op elk AutoML-exemplaar dat wordt gestart. Dit YAML-bestand heeft dezelfde specificatie als de opdrachttaak Voorspellen en andere parameters met betrekking tot de hiërarchiegegevens:

Parameter	Description
hierarchy_column_names	Een lijst met kolomnamen in de gegevens die de hiërarchische structuur van de gegevens definiëren. De volgorde van de kolommen in deze lijst bepaalt de hiërarchieniveaus. De mate van aggregatie neemt af met de lijstindex. Dat wil gezegd, de laatste kolom in de lijst definieert het blad, of het meest geaggregeerde niveau van de hiërarchie.
hierarchy_training_level	Het hiërarchieniveau dat moet worden gebruikt voor het trainen van prognosemodellen.

In het volgende voorbeeld ziet u een YAML-voorbeeldconfiguratie:

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

In volgende voorbeelden wordt de configuratie opgeslagen op het pad, ./automl_settings_hts.yml.

HTS-pijplijn

Definieer vervolgens een factory-functie die pijplijnen maakt voor indeling van HTS-training, deductie en metrische berekeningen. In de volgende tabel worden de parameters voor deze factory-functie beschreven:

Parameter	Description
forecast_level	Het niveau van de hiërarchie waarvoor prognoses moeten worden opgehaald.
allocation_method	Toewijzingsmethode die moet worden gebruikt wanneer prognoses worden uitgesplitst. Geldige waarden zijn proportions_of_historical_average en average_historical_proportions.
max_nodes	Het aantal rekenknooppunten dat moet worden gebruikt in de trainingstaak.
max_concurrency_per_node	Het aantal AutoML-processen dat op elk knooppunt moet worden uitgevoerd. Daarom is max_nodes * max_concurrency_per_nodede totale gelijktijdigheid van een HTS-taak .
parallel_step_timeout_in_seconds	Veel time-outs voor modellenonderdelen die zijn opgegeven in het aantal seconden.
forecast_mode	Deductiemodus voor modelevaluatie. Geldige waarden zijn recursive en rolling. Zie Deductie en evaluatie van prognosemodellen en de verwijzing naar de klasse HTSInferenceParameters voor meer informatie.
step	Stapgrootte voor rolling prognose (standaard is 1). Zie Deductie en evaluatie van prognosemodellen en de verwijzing naar de klasse HTSInferenceParameters voor meer informatie.

Python SDK

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
    }

Bouw de pijplijn met behulp van de fabrieksfunctie. De trainings- en testgegevens bevinden zich respectievelijk in de lokale mappen ./data/train en ./data/test. Stel ten slotte de standaard rekenkracht in en verzend de taak, zoals wordt weergegeven in het volgende voorbeeld:

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)

Azure-CLI

$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}}

U start de pijplijntaak met de volgende opdracht. De configuratie van de pijplijn voor veel modellen bevindt zich op het pad ./automl-hts-forecasting-pipeline.yml:

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

Nadat de taak is voltooid, kunnen de metrische evaluatiegegevens lokaal worden gedownload met behulp van dezelfde procedure als in de pijplijn voor één trainingsuitvoering.

Zie de vraagprognoses met een hiërarchisch tijdreeksnotitieblok voor een gedetailleerder voorbeeld.

Trainingsoverwegingen voor een HTS-uitvoering

De HTS-trainings- en deductieonderdelen partitioneren uw gegevens voorwaardelijk volgens de hierarchy_column_names instelling, zodat elke partitie zich in een eigen bestand bevindt. Dit proces kan erg traag zijn of mislukken wanneer gegevens erg groot zijn. De aanbevolen methode is om uw gegevens handmatig te partitioneren voordat u HTS-training of -deductie uitvoert.

Notitie

De standaardlimiet voor parallelle uitvoering voor een HTS-uitvoering binnen een abonnement is ingesteld op 320. Als uw workload een hogere limiet vereist, kunt u contact opnemen met Microsoft Ondersteuning.

Prognose op schaal: Gedistribueerde DNN-training

Zoals eerder in dit artikel is beschreven, kunt u leren voor deep neurale netwerken (DNN) inschakelen. Zie Distributed Neural Network Training (preview) voor meer informatie over hoe gedistribueerde training voor DNN-prognosetaken werkt.

Voor scenario's met grote gegevensvereisten is gedistribueerde training met AutoML beschikbaar voor een beperkte set modellen. Meer informatie en codevoorbeelden vindt u op schaal in AutoML: Gedistribueerde training.

Voorbeeldnotebooks verkennen

Gedetailleerde codevoorbeelden die geavanceerde prognoseconfiguraties demonstreren, zijn beschikbaar in de GitHub-opslagplaats voor Voorbeeldnotebooks voor AutoML-prognoses. Hier volgen enkele voorbeelden van notebooks:

• Pijplijn voor vraagprognoses maken (HTS- en Veel-modellen)
• TCNForecaster-model (DNN) trainen op GitHub-gegevensset
• Prognose met vakantiedetectie en -featurization (gegevensset voor fietsshares)
• Vertraging en aggregatie van rolling window handmatig configureren

Gerelateerde inhoud

• Een AutoML-model implementeren op een online-eindpunt
• Uitleg van AutoML-modellen ophalen met de Python SDK
• Een modelconfiguratie kiezen