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)

Ebből a cikkből megtudhatja, hogyan állíthatja be az AutoML-t idősorozat-előrejelzéshez az Azure Machine Tanulás automatizált gépi tanulással az Azure Machine Tanulás 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 a következő oktatóanyagot: Igény előrejelzése automatizált gépi tanulással egy idősoros előrejelzési példához automatizált gépi tanulással az Azure Machine Tanulás studióban.

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. Megközelítésünk a célváltozó előzményadatait, a bemeneti adatok felhasználó által biztosított funkcióit és az automatikusan megtervezett funkciókat tartalmazza. A modellkeresési algoritmusok ezután a legjobb prediktív pontosságú modell megtalálásán dolgoznak. További részletekért tekintse meg az előrejelzési módszertanról és a modellkeresésről szóló cikkeinket.

Előfeltételek

Ebben a cikkben a következőt kell megadnia:

• Egy Azure Machine Learning-munkaterület. A 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. A részletekért kövesse az AutoML beállításához szükséges útmutatót.

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

Az AutoML-előrejelzés bemeneti adatainak táblázatos formátumú érvényes idősorokat kell tartalmazniuk. Minden változónak saját megfelelő oszlopot kell tartalmaznia az adattáblában. Az AutoML-hez legalább két oszlopra van szükség: egy időoszlopra , 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 részletekért tekintse meg , hogyan használja az AutoML az adatokat.

Fontos

A jövőbeli értékek előrejelzésére szolgáló modell betanításakor 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ú horizonttal 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, és a modell pontossága is 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ókért és használati esetekért tekintse meg az MLTable útmutatóját. Tegyük fel egyszerű példaként, hogy a betanítási adatok egy CSV-fájlban találhatók egy helyi könyvtárban. ./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/MLTableamely tartalmazza a fájlformátumot és a betöltési utasításokat.

Most definiál egy bemeneti adatobjektumot, amely egy betanítási feladat elindításához szükséges az Azure Machine Tanulás 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

Most megkezdheti 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ó későbbi szakaszaiban részletesebben is bemutatjuk ezt a konfigurációt, feltéve, hogy a YAML-szöveg az elérési úton van tárolva. ./automl-forecasting-job.yml

Az érvényesítési adatokat hasonló módon adhatja meg egy MLTable létrehozásával és egy érvényesítési adatbevitel megadásával. 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 részletekért tekintse meg az előrejelzési modell kiválasztásáról szóló cikkünket. Az előrejelzési modell sikeres betanításához szükséges betanítási adatok hosszának követelményeit is megtekintheti.

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 Tanulás 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. A következő példában létrejön egy számítási fürt neve 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

Ezután a feladatdefinícióban a következőképpen hivatkozhat erre a számításra:

$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

Most már konfiguráljuk az AutoML-feladat általános tulajdonságait, például az elsődleges metrikát, a betanítási adatok céloszlopának nevét, a keresztérvényesítési beállításokat és a feladat erőforráskorlátait. További információkért és a paraméterek teljes listájáért tekintse meg az előrejelzési feladatot, a betanítási paramétereket és a korlátok referenciadokumentumait.

$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

Feladatbeállítások előrejelzése

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, és általában az előrejelzési forgatókönyvnek megfelelően kell beállítania az előrejelzési horizontot. 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 különböző üzletekből és márkákból származó óránkénti értékesítésekből álló adatokkal rendelkezik. Az alábbi minta bemutatja, hogyan állíthatja be az idősor-azonosító oszlopokat, feltéve, hogy az adatok "store" és "brand" 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"]

Az AutoML megpróbálja automatikusan észlelni az adatsor-azonosító oszlopait, ha nincs megadva.

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 az előrejelzési 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 a modellterületet, 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 a blocked_training_algorithms, mint az alábbi példában:

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ályban keres. Az előrejelzési modellek elfogadott neveinek listáját a betanítási tulajdonságok referenciadokumentációjában allowed_training_algorithmsblocked_training_algorithmstalálja. Vagy mindkettőt, de mindkettőt nem, allowed_training_algorithms és blocked_training_algorithms alkalmazható egy betanítási futtatásra.

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 vagy TCN, amely általános képalkotó feladatmódszereket alkalmaz az idősorok modellezésére. Nevezetesen 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 részletekért tekintse meg a TCNForecaster cikkünket.

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 tekintse meg az elosztott betanítási cikk szakaszát.

Ha engedélyezni szeretné a DNN-t egy, az Azure Machine Tanulás 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.
• A Databricksben indított futtatások esetében nem támogatott az automatikus gépi Tanulás előrejelzésének DNN-támogatása.
• A GPU-számítási típusok akkor ajánlottak, ha engedélyezve van a DNN-betanítás

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 részletekért és példákért tekintse meg a késés funkcióról szóló cikket.

A célhoz a késési és a gördülőablak-összesítési funkciókat úgy engedélyezheti, hogy beállítja a gördülő ablak méretét, amely az előző példában három volt, valamint a létrehozni kívánt késési rendeléseket. A beállítással feature_lags rendelkező funkciók késését is engedélyezheti. Az alábbi példában ezeket a beállításokat auto úgy állítottuk be, 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. A hosszkövetelményekkel kapcsolatos további részletekért tekintse meg 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 az "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 = pad, akkor az 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 = drop, akkor az automatizált gépi tanulás elveti a rövid sorozatot, és nem használható betanításra vagy előrejelzésre. A sorozat előrejelzései a NaN-t fogják visszaadni.
None	Egyetlen sorozat sem van kipárnázva vagy elvetve

A következő példában úgy állítjuk be a rövid sorozatok kezelését, 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

Figyelmeztetés

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

Gyakoriság > 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. Az összeg általában a legtöbb forgatókönyvhöz megfelelő.
• Az adatok numerikus előrejelzési oszlopait összeg, középérték, minimális érték és maximális érték összesíti. 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.
• Kategorikus prediktoroszlopok esetén az adatok összesítése mód szerint történik, amely az ablak legjelesebb kategóriája.
• A dátumelőzítő oszlopok a minimális érték, a maximális érték és a mód szerint vannak összesítve.

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 tekintse meg 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, de a haladó felhasználók manuálisan is beállíthatják ő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. A következő kódminta bemutatja, hogyan állíthatja be ezeket:

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ókért tekintse meg az automatizált szolgáltatásfejlesztést . 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	Felülbírálja a megadott oszlop automatikusan észlelt szolgáltatástípusát.	"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, az "értékesítésre" jelzőt és egy 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 Tanulás 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

Az összes beállítás konfigurálása után az alábbi módon indíthatja el az előrejelzési feladatot:

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 parancssori felület következő parancsában feltételezzük, hogy a YAML-konfiguráció a jelenlegi munkakönyvtárban van az elérési úton. ./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 Tanulás studio webes felhasználói felületét, ahol részletezheti a feladat részleteit:

az ml job show -n $run_id --web

A feladat elküldése után az AutoML számítási erőforrásokat fog kiépíteni, featurizálási és egyéb előkészítési lépéseket alkalmaz a bemeneti adatokra, majd megkezdi az előrejelzési modellek átsöprését. További részletekért tekintse meg az előrejelzési módszertanról és a modellkeresésről szóló cikkeinket.

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

Fontos

Ez a funkció jelenleg nyilvános előzetes verzióban érhető el. Ez az előzetes verzió szolgáltatásszintű szerződés nélkül érhető el, és éles számítási feladatokhoz nem javasoljuk. Előfordulhat, hogy néhány funkció nem támogatott, vagy korlátozott képességekkel rendelkezik.

További információ: Kiegészítő használati feltételek a Microsoft Azure előzetes verziójú termékeihez.

Az ml-munkafolyamat valószínűleg nem csupán betanítást igényel. Az azureML-ben a betanítási feladatok mellett az azureML-ben is vezénylést végezhet, vagy lekérte az újabb adatokra vonatkozó modell-előrejelzéseket, és kiértékelheti a modell pontosságát egy ismert célértékekkel rendelkező tesztkészleten. A következtetési és kiértékelési feladatok támogatásához az AzureML olyan összetevőket biztosít, amelyek önálló kódrészletek, amelyek egyetlen lépést tesznek egy AzureML-folyamatban.

Python

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

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 meghatározunk 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. A betanítási beállításokról további információt a betanítási konfigurációs szakaszban talál.

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
    }

Most definiáljuk az adatbemenetek betanítása és tesztelése, feltéve, hogy azok helyi mappákban találhatók, ./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 létrehozzuk a folyamatot, beállítjuk az alapértelmezett számítást, és elküldjük 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}}

Vegye figyelembe, hogy az AutoML-hez mlTable formátumú betanítási adatokra van szükség az AutoML-hez.

Most az alábbi paranccsal indíthatja el a folyamatfuttatást, feltéve, hogy a folyamatkonfiguráció az elérési úton ./automl-forecasting-pipeline.ymlvan:

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 a gördülő előrejelzések és a kiértékelési metrikák letölthetők 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

Ezután megtalálhatja a metrikák eredményeit ./named-outputs/metrics_results/evaluationResult/metrics.json és az előrejelzéseket JSON-sorok formátumban a következőben ./named-outputs/rolling_fcst_result/inference_output_file: .

A gördülő értékeléssel kapcsolatos további részletekért tekintse meg az előrejelzési modell kiértékelési cikkét.

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

Fontos

Ez a funkció jelenleg nyilvános előzetes verzióban érhető el. Ez az előzetes verzió szolgáltatásszintű szerződés nélkül érhető el, és éles számítási feladatokhoz nem javasoljuk. Előfordulhat, hogy néhány funkció nem támogatott, vagy korlátozott képességekkel rendelkezik.

További információ: Kiegészítő használati feltételek a Microsoft Azure előzetes verziójú termékeihez.

Az AutoML számos modellösszetevője lehetővé teszi több millió modell párhuzamos betanítása és kezelése. A modellekkel kapcsolatos fogalmakkal kapcsolatos további információkért tekintse meg a számos modellről szóló cikket.

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 specifikációja megegyezik az előrejelzési feladat specifikációval, valamint további paraméterekkel partition_column_names és allow_multi_partitions.

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 Hamis.

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 feltételezzük, hogy a konfiguráció az elérési úton van tárolva. ./automl_settings_mm.yml

Számos modellfolyamat

Ezután meghatározunk 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 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 "recursive" "rolling". További információé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óért tekintse meg a modellértékelési cikket .

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
    }

Most a folyamatot a gyári függvényen keresztül hozzuk létre, feltéve, hogy a betanítási és tesztelési adatok helyi mappákban vannak, ./data/train illetve ./data/test. Végül beállítjuk az alapértelmezett számítást, és elküldjük 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 a következő paranccsal indíthatja el, feltéve, hogy a számos modell folyamatkonfigurációja az elérési úton ./automl-mm-forecasting-pipeline.ymlvan:

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.

A részletesebb példaért tekintse meg az igény-előrejelzést számos modelljegyzetfüzettel .

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.

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

Fontos

Ez a funkció jelenleg nyilvános előzetes verzióban érhető el. Ez az előzetes verzió szolgáltatásszintű szerződés nélkül érhető el, és éles számítási feladatokhoz nem javasoljuk. Előfordulhat, hogy néhány funkció nem támogatott, vagy korlátozott képességekkel rendelkezik.

További információ: Kiegészítő használati feltételek a Microsoft Azure előzetes verziójú termékeihez.

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ó további 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élszintét (a legtöbb összesítést).
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 feltételezzük, hogy a konfiguráció az elérési úton van tárolva. ./automl_settings_hts.yml

HTS-folyamat

Ezután meghatározunk 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 "recursive" "rolling". További információé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óé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
    }

Most a folyamatot a gyári függvényen keresztül hozzuk létre, feltéve, hogy a betanítási és tesztelési adatok helyi mappákban vannak, ./data/train illetve ./data/test. Végül beállítjuk az alapértelmezett számítást, és elküldjük 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 a következő paranccsal indíthatja el, feltéve, hogy a számos modell folyamatkonfigurációja az elérési úton ./automl-hts-forecasting-pipeline.ymlvan:

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.

Az igény-előrejelzést hierarchikus idősoros jegyzetfüzettel is megtekintheti részletesebb példaként.

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.

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

• Ha szeretné megtudni, hogyan működik az elosztott betanítás az előrejelzési feladatokhoz, tekintse meg a nagy léptékű előrejelzési cikkünket.
• A kódmintákat a táblázatos adatokról szóló cikk szakaszában találja.

Példajegyzetfüzetek

Tekintse meg az előrejelzési mintanotebookokat, amelyekben részletes kódpéldákat találhat az előrejelzési konfigurációkra, például a következőkre:

• 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

Következő lépések

• További információ az AutoML-modellek online végponton való üzembe helyezéséről.
• Tudnivalók az értelmezhetőségről : modellmagyarázatok az automatizált gépi tanulásban (előzetes verzió).
• Ismerje meg, hogyan építi ki az AutoML az előrejelzési modelleket.
• Ismerje meg a nagy léptékű előrejelzést.
• Ismerje meg, hogyan konfigurálhatja az AutoML-t különböző előrejelzési forgatókönyvekhez.
• Megismerheti az előrejelzési modellek következtetését és kiértékelését.