Az AutoML beállítása idősorozat-előrejelzési modell betanításához az SDK-val és a parancssori felülettel

ÉRVÉNYES:Azure CLI ml-bővítmény v2 (aktuális)Python SDK azure-ai-ml v2 (aktuális)

Az AutoML szabványos gépi tanulási modelleket és jól ismert idősorozat-modelleket használ az előrejelzések létrehozásához. Ez a megközelítés előzményadatokat tartalmaz a célváltozóról, a felhasználói funkciókról a bemeneti adatokban, valamint automatikusan megtervezett funkciókat. A modellkeresési algoritmusok a lehető legjobb prediktív pontossággal keresnek modellt. További információ: előrejelzési módszertan és modellkeresés.

Ebből a cikkből megtudhatja, hogyan állíthatja be az AutoML-t idősorozat-előrejelzéshez az Azure Machine Learning automatizált ml-jével az Azure Machine Learning Python SDK-ban.

Ehhez a következőket kell tennie:

• Adatok előkészítése a betanításhoz.
• Adott idősorparaméterek konfigurálása előrejelzési feladatban.
• A betanítás, következtetés és modellértékelés vezénylése összetevők és folyamatok használatával.

Az alacsony kódélményért tekintse meg az oktatóanyagot: Igény előrejelzése automatizált gépi tanulással. Ez az erőforrás egy idősorozat-előrejelzési példa, amely automatizált gépi tanulást használ az Azure Machine Learning Studióban.

Előfeltételek

• Egy Azure Machine Learning-munkaterület. Munkaterület létrehozásához lásd: Munkaterület-erőforrások létrehozása.
• AutoML-betanítási feladatok indításának lehetősége. További információ: útmutató az AutoML beállításához.

Betanítási és érvényesítési adatok

Az AutoML-előrejelzés bemeneti adatainak táblázatos formátumú érvényes idősort kell tartalmazniuk. Minden változónak saját megfelelő oszlopot kell tartalmaznia az adattáblában. Az AutoML legalább két oszlopot igényel: egy időoszlopot , amely az időtengelyt és a *céloszlopot jelöli, amely az előrejelzéshez szükséges mennyiség. Más oszlopok is szolgálhatnak előrejelzőként. További információkért tekintse meg , hogyan használja az AutoML az adatokat.

Fontos

Amikor betanított egy modellt a jövőbeli értékek előrejelzésére, győződjön meg arról, hogy a betanításban használt összes funkció használható a kívánt horizontra vonatkozó előrejelzések futtatásakor.

Az aktuális részvényár egyik funkciója például jelentősen növelheti a betanítás pontosságát. Ha azonban hosszú távlattal szeretne előrejelzést végezni, előfordulhat, hogy nem tudja pontosan előrejelezni a jövőbeli idősorpontoknak megfelelő jövőbeli részvényértékeket. A modell pontossága szenvedhet.

Az AutoML-előrejelzési feladatok megkövetelik, hogy a betanítási adatok MLTable-objektumként legyen ábrázolva . Az MLTable megadja az adatforrást és az adatok betöltésének lépéseit. További információ és használati esetek: Táblák használata az Azure Machine Learningben. Tegyük fel például, hogy a betanítási adatok egy helyi könyvtárban lévő CSV-fájlban találhatók, ./train_data/timeseries_train.csv.

Python

Az mltable Python SDK használatával létrehozhat egy MLTable-t, ahogyan az alábbi példában is látható:

import mltable

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

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

Ez a kód létrehoz egy új fájlt ( ./train_data/MLTable), amely tartalmazza a fájlformátumot és a betöltési utasításokat.

A betanítási feladat elindításához definiáljon egy bemeneti adatobjektumot az Azure Machine Learning Python SDK használatával az alábbiak szerint:

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

Új MLTable definiálásához másolja a következő YAML-szöveget egy új fájlba. /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

Kezdje el az AutoML-feladat YAML-konfigurációs fájljának összeállítását az alábbi példában látható betanítási adatokkal:

$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: # cv setting

limits:
    # limit settings

forecasting:
    # forecasting specific settings

training:
    # training settings 

Az útmutató további szakaszaiban részletesebben is hozzáadhatja ezt a konfigurációt. Ebben a példában a hely ./automl-forecasting-job.yml.

Az érvényesítési adatokat hasonló módon adja meg. Hozzon létre egy MLTable-t, és adjon meg egy érvényesítési adatbevitelt. Ha nem ad meg érvényesítési adatokat, az AutoML automatikusan keresztérvényesítési felosztásokat hoz létre a betanítási adatokból a modell kiválasztásához. További információ: előrejelzési modell kiválasztása. A betanítási adatok hosszára vonatkozó követelményekkel kapcsolatos további információkért tekintse meg a betanítási adatok hosszára vonatkozó követelményeket.

További információ arról, hogy az AutoML hogyan alkalmazza a keresztellenőrzést a túlillesztés megakadályozása érdekében.

Számítás a kísérlet futtatásához

Az AutoML az Azure Machine Learning Computet használja, amely egy teljes mértékben felügyelt számítási erőforrás, a betanítási feladat futtatásához. Hozzon létre egy számítási fürtöt .cpu-compute

Python

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

Az alábbi CLI-paranccsal létrehozhat egy új számítást cpu-compute :

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

A feladatdefinícióban hivatkozzon erre a számításra az alábbiak szerint:

$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

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

primary_metric: # primary metric  

target_column_name: # target column name
n_cross_validations: # cv setting

limits:
    # limit settings

forecasting:
    # forecasting specific settings

training:
    # training settings

Kísérlet konfigurálása

Python

Az automl factory függvényekkel konfigurálhatja az előrejelzési feladatokat a Python SDK-ban. Az alábbi példa bemutatja, hogyan hozhat létre előrejelzési feladatot az elsődleges metrika beállításával és a betanítási futtatás korlátainak beállításával:

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

Azure CLI

Az AutoML-feladat általános tulajdonságainak konfigurálása, beleértve a következőket:

• Az elsődleges metrika
• A betanítási adatok céloszlopának neve
• A keresztérvényesítési beállítások
• A feladat erőforráskorlátai

További információkért tekintse meg az előrejelzési feladatot, a betanítási paramétereket és a korlátokat.

$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 and CV
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

Előrejelzési feladatok beállításai

Az előrejelzési feladatok számos, az előrejelzésre jellemző beállítással rendelkeznek. Ezek közül a legalapvetőbb beállítások a betanítási adatok időoszlopának neve és az előrejelzési horizont.

Python

A beállítások konfigurálásához használja az ForecastingJob metódusokat:

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

Azure CLI

Ezek a beállítások a forecasting YAML feladat szakaszában vannak konfigurálva:

$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

Az időoszlop neve kötelező beállítás. Az előrejelzési horizontot általában az előrejelzési forgatókönyvnek megfelelően kell beállítania. Ha az adatok több idősort tartalmaznak, megadhatja az idősor azonosító oszlopainak nevét. Csoportosítva ezek az oszlopok határozzák meg az egyes adatsorokat. Tegyük fel például, hogy olyan adatokkal rendelkezik, amelyek különböző üzletekből és márkákból származó óránkénti értékesítésekből állnak. Az alábbi minta bemutatja, hogyan állíthatja be az idősor-azonosító oszlopokat, feltéve, hogy az adatok tároló és márka nevű oszlopokat tartalmaznak:

Python

# 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"]

Ha nincs megadva, az AutoML megpróbálja automatikusan észlelni az adatok idősor-azonosító oszlopait.

A következő szakaszban további beállítások nem kötelezőek és áttekinthetőek.

Választható előrejelzési feladatok beállításai

Választható konfigurációk érhetők el az előrejelzési feladatokhoz, például a mélytanulás engedélyezéséhez és a célgördítő ablak összesítésének megadásához. A paraméterek teljes listája a referenciadokumentáció dokumentációjában érhető el.

Modell keresési beállításai

Két választható beállítás szabályozza azt a modellteret, ahol az AutoML a legjobb modellt keresi: allowed_training_algorithms és blocked_training_algorithms. Ha a keresési területet egy adott modellosztályokra szeretné korlátozni, használja a allowed_training_algorithms paramétert az alábbi példában leírtak szerint:

Python

# 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

Ebben az esetben az előrejelzési feladat csak exponenciális simítási és rugalmas netes modellosztályokon keres. Ha el szeretne távolítani egy adott modellosztályt a keresési területről, használja az blocked_training_algorithms alábbi mintát:

Python

# 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

A feladat a Prophet kivételével az összes modellosztályon keres. Az előrejelzési modell által elfogadott allowed_training_algorithms blocked_training_algorithmsnevek listájáért lásd a betanítási tulajdonságokat. Alkalmazhatja mindkettőt, de nem, allowed_training_algorithms és blocked_training_algorithms betanítási futtatásra is.

Mély tanulás engedélyezése

Az AutoML egy egyéni mély neurális hálózat (DNN) nevű TCNForecastermodellel rendelkezik. Ez a modell egy temporális konvolúciós hálózat (TCN), amely általános képalkotó feladatmódszereket alkalmaz az idősorok modellezésére. Az egydimenziós "oksági" konvolúciók alkotják a hálózat gerincét, és lehetővé teszik a modell számára, hogy összetett mintákat tanuljon a betanítási előzmények hosszú időtartama alatt. További információ: Bevezetés a TCNForecaster használatába.

A TCNForecaster gyakran nagyobb pontosságot ér el, mint a standard idősoros modellek, ha több ezer vagy több megfigyelés található a betanítási előzményekben. A TCNForecaster modellek betanítása és átsöprése azonban hosszabb időt vesz igénybe a nagyobb kapacitásuk miatt.

Az AutoML-ben a TCNForecaster engedélyezéséhez állítsa be a enable_dnn_training jelölőt a betanítási konfigurációban az alábbiak szerint:

Python

# 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

A TCNForecaster betanítása alapértelmezés szerint egyetlen számítási csomópontra és egyetlen GPU-ra korlátozódik, ha elérhető, modell próbaverziónként. Nagy adatforgatókönyvek esetén javasoljuk, hogy az egyes TCNForecaster-próbaverziókat több magon/GPU-n és csomóponton ossza el. További információkért és kódmintákért lásd az elosztott betanítást.

Ha engedélyezni szeretné a DNN-t az Azure Machine Learning Studióban létrehozott AutoML-kísérlethez, tekintse meg a studio felhasználói felületén található feladattípus-beállításokat.

Feljegyzés

• Ha engedélyezi a DNN-t az SDK-val létrehozott kísérletekhez, a legjobb modellmagyarázatok le lesznek tiltva.
• Az automatizált gépi tanulásban történő előrejelzés DNN-támogatása nem támogatott a Databricksben indított futtatások esetében.
• A DNN-betanítás engedélyezése esetén GPU-számítási típusokat javasoljuk.

Késési és gördülőablak-funkciók

A cél legutóbbi értékei gyakran hatással vannak az előrejelzési modellre. Ennek megfelelően az AutoML időtúllépési és gördülőablak-összesítési funkciókat hozhat létre a modell pontosságának javítása érdekében.

Fontolja meg az energiaigény-előrejelzési forgatókönyvet, amelyben rendelkezésre állnak az időjárási adatok és az előzményigények. A táblázat azokat az eredményül kapott funkciótervezést mutatja be, amelyek akkor fordulnak elő, amikor az ablak-összesítést a legutóbbi három órában alkalmazza a rendszer. A minimális, maximum és összeg oszlopai a megadott beállítások alapján háromórás tolóablakban jönnek létre. A 2017. szeptember 8-án 16:00-tól 2017. szeptember 8-án 13:00 és 15:00 között érvényes maximális, minimális és összegértékek kiszámítása például a 2017. szeptember 8-i keresleti értékek alapján történik. Ez a három órás időszak eltolódik a többi sor adatainak feltöltéséhez. További információkért és példákért tekintse meg az autoML-ben az idősorok előrejelzésének elmaradott funkcióit.

A célhoz tartozó késési és gördülőablak-összesítési funkciókat a gördülőablak méretének és a létrehozni kívánt késési rendelések beállításával engedélyezheti. Az ablak mérete az előző példában három volt. A beállítással feature_lags rendelkező funkciók késését is engedélyezheti. Az alábbi példában ezek a beállítások úgy vannak auto kialakítva, hogy az AutoML automatikusan meghatározza a beállításokat az adatok korrelációs szerkezetének elemzésével:

Python

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

Rövid sorozatok kezelése

Az automatizált gépi tanulás rövid sorozatnak tekint egy idősort, ha nincs elegendő adatpont a modellfejlesztés betanítása és érvényesítési fázisainak elvégzéséhez. További információkért lásd a betanítási adatok hosszára vonatkozó követelményeket.

Az AutoML-nek számos olyan művelete van, amelyet rövid sorozatokhoz is elvégezhet. Ezek a műveletek konfigurálhatók a short_series_handling_config beállítással. Az alapértelmezett érték auto. Az alábbi táblázat a beállításokat ismerteti:

Beállítás	Leírás
auto	A rövid sorozatok kezelésének alapértelmezett értéke. - Ha az összes adatsor rövid, akkor az adatok kitöltése. - Ha nem minden sorozat rövid, ejtse el a rövid sorozatot.
pad	Ha short_series_handling_config = padaz automatizált gépi tanulás véletlenszerű értékeket ad hozzá az egyes talált rövid sorozatokhoz. Az alábbi lista felsorolja az oszloptípusokat és azokat, amelyekhez ki vannak osztva: - Objektumoszlopok naN-ekkel - Numerikus oszlopok 0-val - Logikai/logikai oszlopok hamis értékkel - A céloszlop fehér zajjal van párnázva.
drop	Ha short_series_handling_config = dropaz automatizált gépi tanulás elveti a rövid sorozatot, és nem használható betanításra vagy előrejelzésre. Ezeknek a sorozatoknak az előrejelzései visszatérnek NaN.
None	Egyetlen sorozat sem van kipárnázva vagy elvetve

A következő példában állítsa be a rövid sorozatok kezelését úgy, hogy az összes rövid sorozat a minimális hosszra legyen párnázva:

Python

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

Figyelemfelhívás

A padding hatással lehet az eredményként kapott modell pontosságára, mivel mesterséges adatokat vezet be a betanítási hibák elkerülése érdekében. Ha sok sorozat rövid, akkor a magyarázhatósági eredményekre is hatással lehet.

Gyakorisági és céladat-összesítés

A rendszertelen adatok által okozott hibák elkerülése érdekében használja a gyakorisági és adatösszesítési lehetőségeket. Az adatok szabálytalanok, ha nem követik az idő meghatározott ütemét, például óránként vagy naponta. Az értékesítési pontok adatai jó példa a szabálytalan adatokra. Ezekben az esetekben az AutoML a kívánt gyakorisággal összesítheti az adatokat, majd létrehozhat egy előrejelzési modellt az összesítésekből.

A szabálytalan adatok kezeléséhez be kell állítania a beállításokat és target_aggregate_function a frequency beállításokat. A gyakorisági beállítás bemenetként fogadja el a Pandas DateOffset sztringeket . Az aggregációs függvény támogatott értékei a következők:

Függvény	Leírás
sum	Célértékek összege
mean	A célértékek középértéke vagy átlaga
min	Cél minimális értéke
max	Cél maximális értéke

• A céloszlop értékeit a megadott művelet szerint összesíti a rendszer. sum Általában a legtöbb forgatókönyvhöz megfelelő.
• Összeg, középérték, minimális érték és maximális érték összesítő numerikus prediktoroszlopok az adatokban. Ennek eredményeképpen az automatizált gépi tanulás új oszlopokat hoz létre az aggregációs függvény nevével utótaggal, és alkalmazza a kiválasztott összesítési műveletet.
• A mód összesíti a kategorikus prediktoroszlopok adatait. Ez az ablak legjelesebb kategóriája.
• A minimális érték, a maximális érték és a mód összesíti az adat-előrejelzési oszlopokat.

Az alábbi példa óránként állítja be a gyakoriságot, az aggregációs függvény pedig összegzésre:

Python

# 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

Egyéni keresztérvényesítési beállítások

Az előrejelzési feladatok keresztérvényesítését két testre szabható beállítás szabályozza: a hajtások száma és n_cross_validationsa hajtások közötti időeltolást meghatározó lépésméret. cv_step_size A paraméterek jelentésével kapcsolatos további információkért lásd az előrejelzési modell kiválasztását.

Alapértelmezés szerint az AutoML mindkét beállítást automatikusan beállítja az adatok jellemzői alapján. Előfordulhat, hogy a haladó felhasználók manuálisan szeretnék beállítani őket. Tegyük fel például, hogy napi értékesítési adatokkal rendelkezik, és azt szeretné, hogy az érvényesítési beállítás öt hajtásból álljon, a szomszédos hajtások közötti hétnapos eltolással. Az alábbi kódminta bemutatja, hogyan állíthatja be ezeket az értékeket:

Python

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

Egyéni érés

Az AutoML alapértelmezés szerint a modellek pontosságának növelése érdekében mérnöki funkciókkal bővíti a betanítási adatokat. További információ: automatizált funkciófejlesztés. Az előfeldolgozási lépések némelyike testre szabható az előrejelzési feladat featurizációs konfigurációja alapján.

Az előrejelzés támogatott testreszabásai az alábbi táblázatban találhatók:

Testreszabás	Leírás	Beállítások
Oszlop rendeltetésének frissítése	A megadott oszlop automatikusan észlelt funkciótípusának felülbírálása.	Kategorikus, DateTime, Numerikus
Transzformátorparaméter frissítése	Frissítse a megadott imputer paramétereit.	{"strategy": "constant", "fill_value": <value>}, , {"strategy": "median"}{"strategy": "ffill"}

Tegyük fel például, hogy van egy kiskereskedelmi keresleti forgatókönyve, amelyben az adatok tartalmazzák az árakat, a jelzőt on sale és a terméktípust. Az alábbi minta bemutatja, hogyan állíthat be testre szabott típusokat és imputereket ezekhez a funkciókhoz:

Python

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

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

Ha az Azure Machine Learning Studiót használja a kísérlethez, tekintse meg , hogyan szabhatja testre a featurizációt a studióban.

Előrejelzési feladat elküldése

Miután az összes beállítás konfigurálva van, az előrejelzési feladatot az alábbiak szerint kell futtatnia:

Python

# 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

Azure CLI

A következő PARANCSSOR-parancsban a YAML-feladat konfigurációja az elérési út aktuális munkakönyvtárában található . /automl-forecasting-job.yml. Ha egy másik könyvtárból futtatja a parancsot, ennek megfelelően módosítania kell az elérési utat.

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

A tárolt futtatási azonosítóval adatokat adhat vissza a feladatról. A --web paraméter megnyitja az Azure Machine Learning Studio webes felhasználói felületét, ahol megtekintheti a feladat részleteit:

az ml job show -n $run_id --web

A feladat elküldése után az AutoML kiosztja a számítási erőforrásokat, featurizációs és egyéb előkészítési lépéseket alkalmaz a bemeneti adatokra, és megkezdi az előrejelzési modellek átsöprését. További információ: előrejelzési módszertan és modellkeresés.

Betanítás, következtetés és értékelés vezénylése összetevőkkel és folyamatokkal

Az ml-munkafolyamat valószínűleg nem csupán betanítást igényel. Az azure Machine Learningben a betanítási feladatok mellett az Azure Machine Learningben is vezénylhető további gyakori feladatok az újabb adatok modell-előrejelzéseinek következtetése vagy lekérése, valamint a modell pontosságának kiértékelése egy ismert célértékekkel rendelkező tesztkészleten. A következtetési és kiértékelési feladatok támogatásához az Azure Machine Learning olyan összetevőket biztosít, amelyek önálló kódrészletek, amelyek egy lépést tesznek egy Azure Machine Learning-folyamatban.

Python

Az alábbi példában kérje le az összetevőkódot egy ügyfélregisztrációs adatbázisból:

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

Ezután definiáljon egy gyári függvényt, amely folyamatokat hoz létre a betanítás, a következtetés és a metrikaszámítás vezénylésével. További információ: Kísérlet konfigurálása.

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
    }

A helyi mappákban található adatbevitelek betanítása és tesztelése: ./train_data és ./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',
)

Végül hozza létre a folyamatot, állítsa be az alapértelmezett számítást, és küldje el a feladatot:

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

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 the default compute for the 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

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

jobs:
  # Configure the automl training node of the 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 the inference node to make rolling forecasts on the 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
            forecast_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 the 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}}

Az AutoML-hez MLTable formátumú betanítási adatok szükségesek az AutoML-hez.

Indítsa el a folyamatfuttatást a következő paranccsal. A folyamatkonfiguráció a ./automl-forecasting-pipeline.yml elérési úton található:

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

Az elküldést követően a folyamat autoML-betanítást, gördülő kiértékelési következtetést és metrikaszámítást futtat egymás után. A futtatás monitorozását és vizsgálatát a studio felhasználói felületén végezheti el. A futtatás befejezése után letöltheti a gördülő előrejelzéseket és a kiértékelési metrikákat a helyi munkakönyvtárba:

Python

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

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

A metrikák eredményei ./named-outputs/metrics_results/evaluationResult/metrics.json és az előrejelzések JSON-sorok formátumban ./named-outputs/rolling_fcst_result/inference_output_file formátumban találhatók.

A gördülő értékeléssel kapcsolatos további információkért lásd az előrejelzési modellek következtetését és kiértékelését.

Nagy léptékű előrejelzés: számos modell

Az AutoML számos modellösszetevője lehetővé teszi több millió modell párhuzamos betanítása és kezelése. A számos modellfogalomról további információt a Több modell című témakörben talál.

Számos modell betanítási konfigurációja

A számos modell betanítási összetevője elfogadja az AutoML betanítási beállításainak YAML formátumú konfigurációs fájlját. Az összetevő ezeket a beállításokat alkalmazza az általa indított autoML-példányokra. Ez a YAML-fájl ugyanazzal a specifikációval rendelkezik, mint az előrejelzési feladat , valamint a partition_column_names paraméterek és allow_multi_partitionsa .

Paraméter	Leírás
partition_column_names	Oszlopnevek az adatokban, amelyek csoportosítva határozzák meg az adatpartíciókat. A számos modell betanítási összetevője minden partíción elindít egy független betanítási feladatot.
allow_multi_partitions	Választható jelző, amely lehetővé teszi egy modell betanítását partíciónként, ha minden partíció több egyedi idősort tartalmaz. Az alapértelmezett érték false.

Az alábbi minta egy konfigurációs sablont tartalmaz:

$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

A következő példákban a konfiguráció a ./automl_settings_mm.yml elérési úton lesz tárolva.

Számos modellfolyamat

Ezután definiáljon egy gyári függvényt, amely folyamatokat hoz létre számos modell betanításának, következtetésének és metrikaszámításának vezénylésére. A gyári függvény paramétereit az alábbi táblázatban találja:

Paraméter	Leírás
max_nodes	A betanítási feladatban használandó számítási csomópontok száma
max_concurrency_per_node	Az egyes csomópontokon futtatandó AutoML-folyamatok száma. Ezért számos modellfeladat teljes egyidejűsége a következő max_nodes * max_concurrency_per_node: .
parallel_step_timeout_in_seconds	Számos modell összetevőjének időtúllépése másodpercekben megadott számban.
retrain_failed_models	Jelölő a sikertelen modellek újratanításának engedélyezéséhez. Ez az érték akkor hasznos, ha korábban számos olyan modellt futtatott, amelyek egyes adatpartíciókon sikertelen AutoML-feladatokat eredményeztek. Ha ez a jelző engedélyezve van, számos modell csak a korábban sikertelen partíciók betanítási feladatait indítja el.
forecast_mode	Következtetési mód a modell kiértékeléshez. Az érvényes értékek a következők: recursive és rolling. További információkért lásd az előrejelzési modellek következtetését és kiértékelését.
forecast_step	Lépésméret a gördülő előrejelzéshez. További információkért lásd az előrejelzési modellek következtetését és kiértékelését.

Az alábbi minta egy gyári módszert mutat be számos modell betanítási és modellértékelési folyamat létrehozásához:

Python

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
    }

Hozza létre a folyamatot a gyári függvényen keresztül. A betanítási és tesztelési adatok helyi mappákban találhatók./data/train és ./data/test. Végül állítsa be az alapértelmezett számítást, és küldje el a feladatot az alábbi minta szerint:

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 the default compute for the pipeline steps
settings:
    default_compute: azureml:cpu-compute

# 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
    forecast_step: 1
    retrain_failed_model: False

# pipeline outputs
# output the evaluation metrics and the 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 the inference node to make rolling forecasts on the 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}}
            forecast_step: ${{parent.inputs.forecast_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 the 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}}

A folyamatfeladatot az alábbi paranccsal indíthatja el. A számos modell folyamatkonfigurációja a ./automl-mm-forecasting-pipeline.yml elérési úton található:

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

A feladat befejezése után a kiértékelési metrikák helyileg, az egyetlen betanítási futtatási folyamattal megegyező eljárással tölthetők le.

Részletesebb példaért tekintse meg a több modelljegyzetfüzetet tartalmazó igény-előrejelzést.

Feljegyzés

A számos modell betanítási és következtetési összetevői feltételesen particionálják az adatokat a partition_column_names beállításnak megfelelően, hogy minden partíció a saját fájljában legyen. Ez a folyamat nagyon lassú vagy sikertelen lehet, ha az adatok nagyok. Ebben az esetben javasoljuk az adatok manuális particionálását, mielőtt számos modell betanítását vagy következtetését futtatnánk.

Feljegyzés

Az előfizetésen belül futó számos modell alapértelmezett párhuzamossági korlátja 320. Ha a számítási feladathoz magasabb korlát szükséges, forduljon hozzánk bátran.

Nagy léptékű előrejelzés: hierarchikus idősor

Az AutoML hierarchikus idősorainak (HTS) összetevői lehetővé teszik, hogy nagyszámú modellt taníthasson be hierarchikus struktúrájú adatokra. További információkért lásd a HTS cikkének szakaszát.

HTS-betanítás konfigurálása

A HTS-betanítási összetevő elfogadja az AutoML betanítási beállításainak YAML formátumú konfigurációs fájlját. Az összetevő ezeket a beállításokat alkalmazza az általa indított autoML-példányokra. Ez a YAML-fájl specifikációja megegyezik az előrejelzési feladattal , valamint a hierarchiaadatokhoz kapcsolódó egyéb paraméterekkel:

Paraméter	Leírás
hierarchy_column_names	Az adatok oszlopneveinek listája, amelyek meghatározzák az adatok hierarchikus szerkezetét. A lista oszlopainak sorrendje határozza meg a hierarchiaszinteket. Az összesítés mértéke a listaindexkel együtt csökken. Ez azt jelzi, hogy a lista utolsó oszlopa határozza meg a hierarchia levélszintjének vagy leginkább összesítésének szintjét.
hierarchy_training_level	Az előrejelzési modell betanításához használandó hierarchiaszint.

Az alábbiakban egy mintakonfiguráció látható:

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

A következő példákban a konfiguráció a ./automl_settings_hts.yml elérési úton lesz tárolva.

HTS-folyamat

Ezután definiáljon egy gyári függvényt, amely folyamatokat hoz létre a HTS-betanítás, a következtetés és a metrikaszámítás vezénylésére. A gyári függvény paramétereit az alábbi táblázatban találja:

Paraméter	Leírás
forecast_level	A hierarchia szintje az előrejelzések lekéréséhez a következőhöz:
allocation_method	Az előrejelzések összesítésekor használandó foglalási módszer. Az érvényes értékek a következők: proportions_of_historical_average és average_historical_proportions.
max_nodes	A betanítási feladatban használandó számítási csomópontok száma
max_concurrency_per_node	Az egyes csomópontokon futtatandó AutoML-folyamatok száma. Ezért a HTS-feladatok teljes egyidejűsége .max_nodes * max_concurrency_per_node
parallel_step_timeout_in_seconds	Számos modell összetevőjének időtúllépése másodpercekben megadott számban.
forecast_mode	Következtetési mód a modell kiértékeléshez. Az érvényes értékek a következők: recursive és rolling. További információkért tekintse meg a modellértékelési cikket.
forecast_step	Lépésméret a gördülő előrejelzéshez. További információkért tekintse meg a modellértékelési cikket.

Python

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
    }

Hozza létre a folyamatot a gyári függvény használatával. A betanítási és tesztelési adatok helyi mappákban találhatók./data/train és ./data/test. Végül állítsa be az alapértelmezett számítást, és küldje el a feladatot az alábbi minta szerint:

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 the pipeline steps
settings:
    default_compute: cpu-compute

# 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
    forecast_step: 1
    allocation_method: proportions_of_historical_average
    forecast_level: # forecast level

# pipeline outputs
# output the evaluation metrics and the 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 the inference node to make rolling forecasts on the 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}}
            forecast_step: ${{parent.inputs.forecast_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 the 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}}

A folyamatfeladatot az alábbi paranccsal indíthatja el. A számos modell folyamatkonfigurációja a ./automl-hts-forecasting-pipeline.yml elérési úton található:

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

A feladat befejezése után a kiértékelési metrikák helyileg, az egyetlen betanítási futtatási folyamattal megegyező eljárással tölthetők le.

Részletesebb példaként tekintse meg a hierarchikus idősoros jegyzetfüzettel való igény-előrejelzést.

Feljegyzés

A HTS betanítási és következtetési összetevői feltételesen particionálják az adatokat a hierarchy_column_names beállításnak megfelelően, hogy minden partíció a saját fájljában legyen. Ez a folyamat nagyon lassú vagy sikertelen lehet, ha az adatok nagyok. Ebben az esetben javasoljuk az adatok manuális particionálását a HTS betanítása vagy következtetése előtt.

Feljegyzés

Az előfizetésen belüli hierarchikus idősorok alapértelmezett párhuzamossági korlátja 320. Ha a számítási feladathoz magasabb korlát szükséges, forduljon hozzánk bátran.

Nagy léptékű előrejelzés: elosztott DNN-betanítás

• Az elosztott betanítások előrejelzési feladatokhoz való működéséről az elosztott DNN-betanításban olvashat.
• A kódminták megtekintéséhez tekintse meg az AutoML-t nagy léptékben: elosztott betanítás.

Példajegyzetfüzetek

A speciális előrejelzési konfigurációra vonatkozó részletes kódmintákért tekintse meg az előrejelzési mintajegyzetfüzeteket:

• Igény-előrejelzési folyamat példák
• Mélytanulási modellek
• Ünnepészlelés és jellemzőkre bontás
• Késések és gördülőablak-összesítési funkciók manuális konfigurálása

Kapcsolódó tartalom

• AutoML-modell üzembe helyezése online végponton
• Értelmezhetőség: modellmagyarázatok az automatizált gépi tanulásban (előzetes verzió)
• Az AutoML előrejelzési módszereinek áttekintése
• Nagy léptékű előrejelzés: számos modell és elosztott betanítás
• Milyen modellezési konfigurációt használjak?
• Előrejelzési modellek következtetése és kiértékelése (előzetes verzió)