Delen via

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

  • Artikel

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

AutoML maakt gebruik van standaard machine learning-modellen, samen met bekende tijdreeksmodellen om prognoses te maken. Deze benadering bevat historische informatie over de doelvariabele, door de gebruiker verstrekte functies in de invoergegevens en automatisch ontworpen functies. Modelzoekalgoritmen werken om een model te vinden met de beste voorspellende nauwkeurigheid. Zie prognosemethodologie en modelzoekopdrachten voor meer informatie.

In dit artikel leert u hoe u AutoML instelt voor tijdreeksprognoses met geautomatiseerde ML van Azure Machine Learning in de Azure Machine Learning Python SDK.

Dit doet u als volgt:

  • Gegevens voorbereiden voor training.
  • Configureer specifieke tijdreeksparameters in een prognosetaak.
  • Training, deductie en modelevaluatie organiseren met behulp van onderdelen en pijplijnen.

Zie Zelfstudie: Vraag voorspellen met geautomatiseerde machine learning voor een lage code-ervaring. Deze resource is een voorbeeld van een tijdreeksprognose dat gebruikmaakt van geautomatiseerde ML in de Azure Machine Learning-studio.

Vereisten

Trainings- en validatiegegevens

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 die de tijdsas en de *doelkolom vertegenwoordigt. Dit is de hoeveelheid die moet worden voorspeld. Andere kolommen kunnen fungeren als voorspellers. Zie voor meer informatie hoe AutoML uw gegevens gebruikt.

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, kunnen worden gebruikt bij het uitvoeren van voorspellingen voor uw beoogde horizon.

Een functie voor de huidige aandelenkoers kan bijvoorbeeld de nauwkeurigheid van de training enorm verhogen. Als u echter van plan bent om te voorspellen met een lange horizon, kunt u mogelijk niet nauwkeurig toekomstige aandelenwaarden voorspellen die overeenkomen met toekomstige tijdreekspunten. Modelnauwkeurigheid kan lijden.

Voor AutoML-prognosetaken is vereist dat uw trainingsgegevens worden weergegeven als een MLTable-object . Een MLTable bevat een gegevensbron en stappen voor het laden van de gegevens. Zie Werken met tabellen in Azure Machine Learning voor meer informatie en gebruiksvoorbeelden. Stel dat uw trainingsgegevens zijn opgenomen in een CSV-bestand in een lokale map. /train_data/timeseries_train.csv.

U kunt een MLTable maken met behulp van de Mltable Python SDK , zoals 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 Azure Machine Learning 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"
)

U geeft validatiegegevens op een vergelijkbare manier op. Maak een MLTable en geef een validatiegegevensinvoer op. Als u geen validatiegegevens opgeeft, worden in AutoML automatisch kruisvalidatiesplitsingen gemaakt van uw trainingsgegevens die moeten worden gebruikt voor modelselectie. Zie de selectie van het prognosemodel voor meer informatie. Zie de vereisten voor de lengte van trainingsgegevens voor meer informatie over de hoeveelheid trainingsgegevens die u nodig hebt.

Meer informatie over hoe AutoML kruisvalidatie toepast om te voorkomen dat overpassen wordt toegepast.

Compute en uitvoering van het experiment instellen

AutoML maakt gebruik van Azure Machine Learning Compute, een volledig beheerde rekenresource, om de trainingstaak uit te voeren. Maak een rekencluster met de naam cpu-compute.

from azure.ai.ml.entities import AmlCompute

# specify aml compute name.
cpu_compute_target = "cpu-cluster"

try:
    ml_client.compute.get(cpu_compute_target)
except Exception:
    print("Creating a new cpu compute target...")
    compute = AmlCompute(
        name=cpu_compute_target, size="STANDARD_D2_V2", min_instances=0, max_instances=4
    )
    ml_client.compute.begin_create_or_update(compute).result()

Experiment configureren

U gebruikt de automl-factoryfuncties om prognoses te configureren in de Python SDK. 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

# note that the below is a code snippet -- you might have to modify the variable values to run it 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",
)

# Limits are all optional
forecasting_job.set_limits(
    timeout_minutes=120,
    trial_timeout_minutes=30,
    max_concurrent_trials=4,
)

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.

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
)

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, definieert u de afzonderlijke reeksen. Stel dat u gegevens hebt die bestaan uit uurverkopen 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:

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

AutoML 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 referentiedocumentatiedocumentatie .

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 in het volgende voorbeeld:

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

In dit geval zoekt de prognosetaak alleen naar exponentieel smoothing- en elastic net-modelklassen. Als u een bepaalde set modelklassen uit de zoekruimte wilt verwijderen, gebruikt u de blocked_training_algorithms functie zoals in het volgende voorbeeld:

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

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.

Deep Learning inschakelen

AutoML wordt geleverd met een aangepast DNN-model (Deep Neural Network) genaamd TCNForecaster. Dit model is een tijdelijk convolutionele netwerk (TCN), dat algemene imaging-taakmethoden toepast op tijdreeksmodellering. 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.

Diagram met de belangrijkste onderdelen van TCNForecaster van AutoML.

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:

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

TCNForecaster-training is standaard beperkt tot één rekenknooppunt en één GPU, indien beschikbaar, per modelabonnement. Voor scenario's met grote gegevens raden we u aan 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 de 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 in Databricks zijn geïnitieerd.
  • We raden GPU-rekentypen aan 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 bijvoorbeeld 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 gemarkeerde functies voor het voorspellen van tijdreeksen in AutoML voor meer informatie en voorbeelden.

Schermopname van het rolling doelvenster met de waarden voor Vraag gemarkeerd.

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 auto al deze instellingen zodanig dat AutoML automatisch instellingen bepaalt door de correlatiestructuur van uw gegevens te analyseren:

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

Verwerking van korte reeksen

Geautomatiseerde ML 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
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 short_series_handling_config = padgeautomatiseerde ML willekeurige waarden toevoegt aan elke gevonden korte reeks. Hieronder ziet u de kolomtypen en waarmee ze zijn opgevuld:
- Objectkolommen met NaN's
- Numerieke kolommen met 0
- Booleaanse/logische kolommen met Onwaar
- De doelkolom wordt opgevuld met witte ruis.
drop Als short_series_handling_config = dropgeautomatiseerde ML de korte reeks laat vallen en deze niet wordt gebruikt voor training of voorspelling. Voorspellingen voor deze reeks retourneren NaN.
None Er is geen reeks opgevuld of verwijderd

Stel in het volgende voorbeeld de verwerking van korte reeksen in, zodat alle korte reeksen worden opgevuld tot de minimale lengte:

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

Let op

Opvulling kan van invloed zijn op de nauwkeurigheid van het resulterende model, omdat u kunstmatige gegevens introduceert 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 gevallen kan AutoML uw gegevens aggregeren naar een gewenste frequentie en vervolgens een prognosemodel bouwen 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. Ondersteunde waarden voor de aggregatiefunctie zijn:

Functie Beschrijving
sum  Som van doelwaarden
mean  Gemiddelde of gemiddelde van doelwaarden
min Minimumwaarde van een doel
max Maximumwaarde van een doel
  • De doelkolomwaarden worden geaggregeerd volgens de opgegeven bewerking. sum Normaal gesproken is dit geschikt voor de meeste scenario's.
  • Som, gemiddelde, minimumwaarde en maximumwaarde aggregeren numerieke predictorkolommen in uw gegevens. Als gevolg hiervan genereert geautomatiseerde ML nieuwe kolommen met de naam van de aggregatiefunctie en past de geselecteerde statistische bewerking toe.
  • In de modus worden de gegevens voor categorische predictorkolommen samengevoegd. Het is de meest prominente categorie in het venster.
  • Minimumwaarde, maximumwaarde en modus aggregeren de gegevens voorspellende kolommen.

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

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

Aangepaste instellingen voor kruisvalidatie

Er zijn twee aanpasbare instellingen waarmee kruisvalidatie voor prognosetaken wordt beheerd: het aantal vouwen, n_cross_validationsen de stapgrootte die de tijdsverschil tussen vouwen definieert, cv_step_size. Zie de selectie van het prognosemodel voor meer informatie over de betekenis van deze parameters.

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:

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
)

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.

Ondersteunde aanpassingen voor prognoses staan in de volgende tabel:

Aanpassing Beschrijving Opties
Update van kolomdoel Overschrijf het automatisch gedetecteerde functietype voor de opgegeven kolom. Categorisch, Datum/tijd, Numeriek
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:

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 that product_type feature is interpreted as categorical
forecasting_job.set_featurization(
    mode="custom",
    transformer_params=transformer_params,
    column_name_and_types={"product_type": "Categorical"},
)

Als u de Azure Machine Learning-studio voor uw experiment gebruikt, raadpleegt u hoe u featurization kunt aanpassen in de studio.

Een prognosetaak verzenden

Nadat alle instellingen zijn geconfigureerd, voert u de prognosetaak als volgt uit:

# 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 AML studio user interface
returned_job.services["Studio"].endpoint

Nadat de taak is verzonden, richt AutoML rekenresources in, past featurization en andere voorbereidingsstappen toe op de invoergegevens en begint het opruimen van voorspellingsmodellen. Zie prognosemethodologie en modelzoekopdrachten voor meer informatie.

Training, deductie en evaluatie organiseren met onderdelen en pijplijnen

Uw ML-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.

Haal in het volgende voorbeeld onderdeelcode op uit een clientregister:

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

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

# Create a client for accessing assets in the AzureML preview registry
ml_client_registry = MLClient(
    credential=credential,
    registry_name="azureml-preview"
)

# Create a client for accessing assets in the AzureML preview registry
ml_client_metrics_registry = MLClient(
    credential=credential,
    registry_name="azureml"
)

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

# Get a component for computing evaluation metrics from the 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 the training node of the 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 the inference node to make rolling forecasts on the 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',
        forecast_step=1
    )

    # Configure the 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 a dictionary with the evaluation metrics and the 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 the pipeline job
returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name
)
returned_pipeline_job

Zodra de pijplijn is verzonden, 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:

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

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

U vindt de resultaten van metrische gegevens in ./named-outputs/metrics_results/evaluationResult/metrics.json en de prognoses, in de indeling JSON-regels, in ./named-outputs/rolling_fcst_result/inference_output_file.

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. Dit YAML-bestand heeft dezelfde specificatie als de prognosetaak plus parameters partition_column_names en 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.

Het volgende voorbeeld bevat een configuratiesjabloon:

$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. De parameters van deze fabrieksfunctie worden beschreven in de volgende tabel:

Parameter Description
max_nodes 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 in het aantal seconden zijn opgegeven.
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 deze vlag is ingeschakeld, starten veel modellen alleen trainingstaken voor eerder mislukte partities.
forecast_mode Deductiemodus voor modelevaluatie. Geldige waarden zijn recursive en rolling. Zie Deductie en evaluatie van prognosemodellen voor meer informatie.
forecast_step Stapgrootte voor rolling prognose. Zie Deductie en evaluatie van prognosemodellen voor meer informatie.

In het volgende voorbeeld ziet u een fabrieksmethode voor het bouwen van veel modellen voor het trainen en evalueren van modellen:

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

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

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

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

# Get a component for computing 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,
        forecast_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 the metrics results from the rolling evaluation
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result
    }

Bouw de pijplijn via de fabrieksfunctie. De trainings- en testgegevens bevinden zich respectievelijk in lokale mappen ./data/train en ./data/test. Stel ten slotte de standaard rekenkracht in en verzend de taak zoals 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)

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 vraagprognose met veel modellennotitieblok voor een gedetailleerder voorbeeld voor een gedetailleerder voorbeeld voor een gedetailleerder voorbeeld.

Notitie

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. In dit geval raden we u aan 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, aarzel dan niet om contact met ons op te nemen.

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 de sectie HTS-artikel 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 prognosetaak plus andere parameters die betrekking hebben op 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.

Hieronder ziet u een 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. De parameters van deze fabrieksfunctie worden beschreven in de volgende tabel:

Parameter Description
forecast_level Het niveau van de hiërarchie voor het ophalen van prognoses voor
allocation_method Toewijzingsmethode die moet worden gebruikt wanneer prognoses worden uitgesplitst. Geldige waarden zijn proportions_of_historical_average en average_historical_proportions.
max_nodes 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 in het aantal seconden zijn opgegeven.
forecast_mode Deductiemodus voor modelevaluatie. Geldige waarden zijn recursive en rolling. Zie het artikel over modelevaluatie voor meer informatie.
forecast_step Stapgrootte voor rolling prognose. Zie het artikel over modelevaluatie voor meer informatie. 
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

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

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

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

# Get a component for computing 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,
        forecast_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 the metrics results from the 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 lokale mappen ./data/train en ./data/test. Stel ten slotte de standaard rekenkracht in en verzend de taak zoals 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)

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.

Notitie

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. In dit geval raden we u aan uw gegevens handmatig te partitioneren voordat u HTS-training of -deductie uitvoert.

Notitie

De standaardlimiet voor parallelle uitvoering voor een hiërarchische tijdreeks binnen een abonnement is ingesteld op 320. Als uw workload een hogere limiet vereist, aarzel dan niet om contact met ons op te nemen.

Prognose op schaal: gedistribueerde DNN-training

Voorbeeldnotebooks

Zie de voorbeeldnotebooks voor prognoses voor gedetailleerde codevoorbeelden van geavanceerde configuratie van prognoses:

Gerelateerde inhoud