Konfigurera AutoML för att träna en prognosmodell för tidsserier med Python

GÄLLER FÖR: Python SDK azure-ai-ml v2 (aktuell)

• v1
• v2 (aktuell version)

I den här artikeln får du lära dig hur du konfigurerar AutoML-träning för prognosmodeller för tidsserier med Automatiserad ML i Azure Machine Learning Python SDK.

Det gör du på följande sätt:

• Förbereda data för träning.
• Konfigurera specifika tidsserieparametrar i ett prognostiseringsjobb.
• Hämta förutsägelser från tränade tidsseriemodeller.

En låg kodupplevelse finns i Självstudie: Prognostisera efterfrågan med automatiserad maskininlärning för ett exempel på tidsserieprognoser med automatiserad ML i Azure Machine Learning-studio.

AutoML använder standardmaskininlärningsmodeller tillsammans med välkända tidsseriemodeller för att skapa prognoser. Vår metod innehåller flera sammanhangsberoende variabler och deras relation till varandra under träningen. Eftersom flera faktorer kan påverka en prognos överensstämmer den här metoden väl med verkliga prognosscenarier. När du till exempel skapar prognoser för försäljning kan interaktioner mellan historiska trender, växelkurser och priser gemensamt driva försäljningsresultatet. Mer information finns i vår artikel om prognostiseringsmetodik.

Förutsättningar

För den här artikeln behöver du:

• En Azure Machine Learning-arbetsyta. Information om hur du skapar arbetsytan finns i Skapa arbetsyteresurser.

• Möjligheten att starta AutoML-träningsjobb. Följ instruktionerna för att konfigurera AutoML för mer information.

Tränings- och valideringsdata

Indata för AutoML-prognostisering måste innehålla giltiga tidsserier i tabellformat. Varje variabel måste ha en egen motsvarande kolumn i datatabellen. AutoML kräver minst två kolumner: en tidskolumn som representerar tidsaxeln och målkolumnen som är den kvantitet som ska prognostiseras. Andra kolumner kan fungera som prediktorer. Mer information finns i hur AutoML använder dina data.

Viktigt

När du tränar en modell för prognostisering av framtida värden ska du se till att alla funktioner som används i träningen kan användas när du kör förutsägelser för din avsedda horisont.

Till exempel kan en funktion för aktuell aktiekurs kraftigt öka träningsprecisionen. Men om du tänker göra prognoser med en lång horisont kanske du inte kan förutsäga framtida aktievärden som motsvarar framtida tidsseriepunkter och modellprecisionen kan bli lidande.

AutoML-prognosjobb kräver att dina träningsdata representeras som ett MLTable-objekt . En MLTable anger en datakälla och steg för att läsa in data. Mer information och användningsfall finns i instruktionsguiden för MLTable. Som ett enkelt exempel antar vi att dina träningsdata finns i en CSV-fil i en lokal katalog, ./train_data/timeseries_train.csv. Du kan definiera en ny MLTable genom att kopiera följande YAML-kod till en ny fil: ./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

Nu kan du definiera ett indataobjekt som krävs för att starta ett träningsjobb med hjälp av Azure Machine Learning Python SDK enligt följande:

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

Du kan ange valideringsdata på ett liknande sätt genom att skapa en MLTable och ett indataobjekt. Om du inte anger valideringsdata skapar AutoML automatiskt korsvalideringsdelningar från dina träningsdata som ska användas för modellval. Mer information finns i vår artikel om val av prognosmodell . Se även kraven för träningsdatalängd för information om hur mycket träningsdata du behöver för att kunna träna en prognosmodell.

Läs mer om hur AutoML tillämpar korsvalidering för att förhindra överanpassning.

Beräkning för att köra experiment

AutoML använder Azure Machine Learning Compute, som är en fullständigt hanterad beräkningsresurs, för att köra träningsjobbet. I följande exempel skapas ett beräkningskluster med namnet cpu-compute :

from azure.ai.ml.entities import AmlCompute

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

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

Konfigurera experiment

Det finns flera alternativ som du kan använda för att konfigurera autoML-prognosexperimentet. Dessa konfigurationsparametrar anges i aktivitetsmetoden automl.forecasting(). Du kan också ange inställningar för jobbträning och avslutsvillkor med funktionerna set_training() respektive set_limits().

I följande exempel visas hur du skapar ett prognostiseringsjobb med normaliserat rotvärdesfel i kvadrat som primärt mått och automatiskt konfigurerade korsvalideringsdelegeringar:

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=compute_name,
    experiment_name=exp_name,
    training_data=my_training_data_input,
    target_column_name=target_column_name,
    primary_metric="NormalizedRootMeanSquaredError",
    n_cross_validations="auto",
)

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

Konfigurationsinställningar

Prognostiseringsaktiviteter har många inställningar som är specifika för prognostisering. Använd metoden set_forecast_settings() för ett prognostiseringsjobb för att ange prognosparametrar. I följande exempel anger vi namnet på tidskolumnen i träningsdata och anger prognoshorisonten:

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

Tidskolumnnamnet är en obligatorisk inställning och du bör vanligtvis ange prognoshorisonten enligt ditt förutsägelsescenario. Om dina data innehåller flera tidsserier kan du ange namnen på kolumnerna för tidsserie-ID. När dessa kolumner grupperas definierar de enskilda serierna. Anta till exempel att du har data som består av timförsäljning från olika butiker och varumärken. Följande exempel visar hur du anger kolumnerna för tidsserie-ID,förutsatt att data innehåller kolumner med namnen "store" och "brand":

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

AutoML försöker automatiskt identifiera tidsserie-ID-kolumner i dina data om inga anges.

Andra inställningar är valfria och granskas i avsnittet valfria inställningar .

Valfria inställningar

Valfria konfigurationer är tillgängliga för prognostiseringsuppgifter, till exempel att aktivera djupinlärning och ange en målsammanställning för rullande fönster. En fullständig lista över parametrar finns i forecast_settings API-dokumentet.

Inställningar för modellsökning

Det finns två valfria inställningar som styr modellutrymmet där AutoML söker efter den bästa modellen och allowed_training_algorithmsblocked_training_algorithms. Om du vill begränsa sökutrymmet till en viss uppsättning modellklasser använder du allowed_training_algorithms som i följande exempel:

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

I det här fallet söker prognosjobbet bara över modellklasserna Exponential Smoothing och Elastic Net. Om du vill ta bort en viss uppsättning modellklasser från sökområdet använder du blocked_training_algorithms som i följande exempel:

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

Nu söker jobbet igenom alla modellklasser utom Prophet. En lista över prognosmodellnamn som accepteras i och blocked_training_algorithmsfinns i allowed_training_algorithmsprognosmodeller som stöds och regressionsmodeller som stöds.

Aktivera djupinlärning

AutoML levereras med en anpassad DNN-modell (Deep Neural Network) med namnet TCNForecaster. Den här modellen är ett temporalt convolutional-nätverk, eller TCN, som använder vanliga avbildningsaktivitetsmetoder för tidsseriemodellering. Det vill säga att endimensionella "kausala" faltningar utgör nätverkets ryggrad och gör det möjligt för modellen att lära sig komplexa mönster under långa varaktigheter i träningshistoriken. Mer information finns i vår TCNForecaster-artikel.

TCNForecaster uppnår ofta högre noggrannhet än standardmodeller för tidsserier när det finns tusentals eller fler observationer i träningshistoriken. Men det tar också längre tid att träna och sopa över TCNForecaster-modeller på grund av deras högre kapacitet.

Du kan aktivera TCNForecaster i AutoML genom att ange enable_dnn_training flaggan i metoden set_training() enligt följande:

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

Information om hur du aktiverar DNN för ett AutoML-experiment som skapats i Azure Machine Learning-studio finns i inställningarna för aktivitetstyp i studiogränssnittet.

Anteckning

• När du aktiverar DNN för experiment som skapats med SDK inaktiveras de bästa modellförklaringarna .
• DNN-stöd för prognostisering i Automatiserad maskininlärning stöds inte för körningar som initieras i Databricks.
• GPU-beräkningstyper rekommenderas när DNN-träning är aktiverad

Målsammansättning av rullande fönster

De senaste värdena för målet är ofta effektfulla funktioner i en prognosmodell. Med löpande fönsteraggregeringar kan du lägga till rullande aggregeringar av datavärden som funktioner. Att generera och använda dessa funktioner som extra kontextuella data hjälper till med träningsmodellens precision.

Tänk dig ett scenario för prognostisering av energibehov där väderdata och historisk efterfrågan är tillgängliga. Tabellen visar resulterande funktionsframställning som inträffar när fönsteraggregering tillämpas under de senaste tre timmarna. Kolumner för minimum, maximum och sum genereras i ett skjutfönster på tre timmar baserat på de definierade inställningarna. För observationen som är giltig den 8 september 2017 04:00 beräknas till exempel värdena för max, minimum och summa med hjälp av efterfrågevärdena för 8 september 2017 01:00–03:00. Det här fönstret med tre timmar flyttas för att fylla i data för de återstående raderna.

Du kan aktivera sammansättningsfunktioner för rullande fönster och ange fönsterstorleken via metoden set_forecast_settings(). I följande exempel anger vi fönsterstorleken till "auto" så att AutoML automatiskt fastställer ett bra värde för dina data:

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

Hantering av korta serier

Automatiserad ML betraktar en tidsserie som en kort serie om det inte finns tillräckligt med datapunkter för att genomföra tränings- och valideringsfaserna för modellutveckling. Mer information om längdkrav finns i krav på träningsdatalängd .

AutoML har flera åtgärder som kan utföras för korta serier. Dessa åtgärder kan konfigureras med inställningen short_series_handling_config . Standardvärdet är "auto". I följande tabell beskrivs inställningarna:

Inställningen	Beskrivning
auto	Standardvärdet för hantering av korta serier. - Om alla serier är korta fyller du ut data. - Om inte alla serier är korta släpper du den korta serien.
pad	Om short_series_handling_config = padlägger automatiserad ML till slumpmässiga värden i varje kortserie som hittas. Följande listar kolumntyperna och vad de är vadderade med: - Objektkolumner med NaNs – Numeriska kolumner med 0 – Booleska/logiska kolumner med falskt – Målkolumnen är utfyllnad med slumpmässiga värden med medelvärdet noll och standardavvikelsen 1.
drop	Om short_series_handling_config = drop, tar automatiserad ML bort den korta serien och den kommer inte att användas för träning eller förutsägelse. Förutsägelser för dessa serier returnerar NaN:s.
None	Ingen serie är vadderad eller tappad

I följande exempel anger vi kortseriehanteringen så att alla korta serier är vadderade till minsta längd:

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

Varning

Utfyllnad kan påverka precisionen för den resulterande modellen, eftersom vi introducerar artificiella data bara för att komma förbi träningen utan fel. Om många av serierna är korta kan du också se en viss inverkan på förklarbarhetsresultaten

Frekvensmåldataaggregering &

Använd alternativen för frekvens och dataaggregering för att undvika fel som orsakas av oregelbundna data. Dina data är oregelbundna om de inte följer en angiven takt i tiden, t.ex. varje timme eller varje dag. Point-of-sales-data är ett bra exempel på oregelbundna data. I dessa fall kan AutoML aggregera dina data till önskad frekvens och sedan skapa en prognosmodell från aggregeringarna.

Du måste ange frequency inställningarna och target_aggregate_function för att hantera oregelbundna data. Frekvensinställningen accepterar Pandas DateOffset-strängar som indata. Värden som stöds för aggregeringsfunktionen är:

Funktion	Beskrivning
sum	Summan av målvärden
mean	Medelvärde eller medelvärde för målvärden
min	Minimivärde för ett mål
max	Maximalt värde för ett mål

• Målkolumnvärdena aggregeras enligt den angivna åtgärden. Vanligtvis är summan lämplig för de flesta scenarier.
• Numeriska förutsägelsekolumner i dina data aggregeras med summa, medelvärde, minimivärde och högsta värde. Därför genererar automatiserad ML nya kolumner suffix med namnet på sammansättningsfunktionen och tillämpar den valda mängdåtgärden.
• För kategoriska förutsägelsekolumner aggregeras data efter läge, den mest framträdande kategorin i fönstret.
• Kolumner för datum förutsägare aggregeras efter minsta värde, högsta värde och läge.

I följande exempel anges frekvensen till varje timme och sammansättningsfunktionen till sammanfattning:

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

Anpassade inställningar för korsvalidering

Det finns två anpassningsbara inställningar som styr korsvalidering för prognostiseringsjobb: antalet vikningar, n_cross_validations, och stegstorleken som definierar tidsförskjutningen mellan vikter, cv_step_size. Se val av prognosmodell för mer information om innebörden av dessa parametrar. Som standard ställer AutoML in båda inställningarna automatiskt baserat på dina datas egenskaper, men avancerade användare kanske vill ange dem manuellt. Anta till exempel att du har dagliga försäljningsdata och att du vill att valideringskonfigurationen ska bestå av fem vikter med en sjudagarsförskjutning mellan intilliggande veck. Följande kodexempel visar hur du anger dessa:

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
)

Anpassad funktionalisering

Som standard utökar AutoML träningsdata med konstruerade funktioner för att öka modellernas noggrannhet. Mer information finns i automatiserad funktionsframställning . Vissa av förbearbetningsstegen kan anpassas med hjälp set_featurization() av metoden för prognostiseringsjobbet.

Anpassningar som stöds för prognostisering är:

Anpassning	Beskrivning	Alternativ
Uppdatering av kolumnsyfte	Åsidosätt den automatiskt identifierade funktionstypen för den angivna kolumnen.	"Kategorisk", "DateTime", "Numerisk"
Uppdatering av transformerarparameter	Uppdatera parametrarna för angiven imputer.	{"strategy": "constant", "fill_value": <value>}, {"strategy": "median"}, {"strategy": "ffill"}

Anta till exempel att du har ett scenario för detaljhandelsefterfrågan där data innehåller funktioner som pris, en "till salu"-flagga och en produkttyp. Följande exempel visar hur du kan ange anpassade typer och imputer för dessa funktioner:

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

Om du använder Azure Machine Learning-studio för experimentet kan du läsa om hur du anpassar funktionalisering i studio.

Kör experimentet

När alla inställningar har konfigurerats kan du starta prognosjobbet mlcient via följande:

# 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 status of the job
returned_job.services["Studio"].endpoint

Prognostisering med en tränad modell

När du har använt AutoML för att träna och välja en bästa modell är nästa steg att utvärdera modellen. Om den uppfyller dina krav kan du använda den för att generera prognoser i framtiden. Det här avsnittet visar hur du skriver Python-skript för utvärdering och förutsägelse. Ett exempel på hur du distribuerar en tränad modell med ett slutsatsdragningsskript finns i vår exempelanteckningsbok.

Utvärdera modellens noggrannhet med en rullande prognos

Innan du placerar en modell i produktion bör du utvärdera dess noggrannhet på en testuppsättning som hålls från träningsdata. En metod för bästa praxis är en löpande utvärdering som för den tränade prognosmakaren framåt i tiden över testuppsättningen, med medelvärde för felmått över flera förutsägelsefönster. Helst är testuppsättningen för utvärderingen lång i förhållande till modellens prognoshorisont. Uppskattningar av prognostiseringsfel kan annars vara statistiskt bullriga och därför mindre tillförlitliga.

Anta till exempel att du tränar en modell på den dagliga försäljningen för att förutsäga efterfrågan upp till två veckor (14 dagar) in i framtiden. Om det finns tillräckligt med historiska data kan du reservera de sista månaderna till och med ett år med data för testuppsättningen. Den löpande utvärderingen börjar med att generera en prognos på 14 dagar i förväg för testuppsättningens två första veckor. Sedan avanceras prognosmakaren med ett antal dagar in i testuppsättningen och du genererar ytterligare en prognos på 14 dagar i förväg från den nya positionen. Processen fortsätter tills du kommer till slutet av testuppsättningen.

Om du vill göra en löpande utvärdering anropar rolling_forecast du metoden för fitted_modeloch beräknar sedan önskade mått för resultatet. Ett löpande utvärderingsslutsatsskript visas i följande kodexempel:

"""
This is the script that is executed on the compute instance. It relies
on the model.pkl file which is uploaded along with this script to the
compute instance.
"""

import os
import pandas as pd

from sklearn.externals import joblib


def init():
    global target_column_name
    global fitted_model

    target_column_name = os.environ["TARGET_COLUMN_NAME"]
    # AZUREML_MODEL_DIR is an environment variable created during deployment
    # It is the path to the model folder (./azureml-models)
    # Please provide your model's folder name if there's one
    model_path = os.path.join(os.environ["AZUREML_MODEL_DIR"], "model.pkl")
    try:
        fitted_model = joblib.load(model_path)
    except Exception:
        print("Loading pickle failed. Trying torch.load()")

        import torch
        model_path = os.path.join(os.environ["AZUREML_MODEL_DIR"], "model.pt") 
        device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
        fitted_model = torch.load(model_path, map_location=device)


def run(mini_batch):
    print(f"run method start: {__file__}, run({mini_batch})")
    resultList = []
    for test in mini_batch:
        if not test.endswith(".csv"):
            continue
        X_test = pd.read_csv(test, parse_dates=[fitted_model.time_column_name])
        y_test = X_test.pop(target_column_name).values

        # Make a rolling forecast, advancing the forecast origin by 1 period on each iteration through the test set
        X_rf = fitted_model.rolling_forecast(
            X_test, y_test, step=1, ignore_data_errors=True
        )

        resultList.append(X_rf)

    return pd.concat(resultList, sort=False, ignore_index=True)

I det här exemplet är stegstorleken för den rullande prognosen inställd på en, vilket innebär att prognosmakaren är avancerad en period, eller en dag i vårt exempel på efterfrågeförutsägelse, vid varje iteration. Det totala antalet prognoser som returneras av rolling_forecast beror på längden på testuppsättningen och den här stegstorleken. Mer information och exempel finns i dokumentationen rolling_forecast() och notebook-filen Forecasting away from training data (Prognostisering bort från träningsdata).

Förutsägelse in i framtiden

forecast_quantiles() genererar prognoser för angivna kvanter av förutsägelsefördelningen. Den här metoden ger därmed ett sätt att få en poängprognos med en kon av osäkerhet runt den. Läs mer i notebook-filen Prognostisering bort från träningsdata.

I följande exempel ersätter du först alla värden i y_pred med NaN. Prognosens ursprung ligger i slutet av träningsdata i det här fallet. Men om du bara ersatte den andra halvan av y_pred med NaNskulle funktionen lämna de numeriska värdena i den första halvan oförändrade, men prognostisera NaN värdena i den andra halvan. Funktionen returnerar både de prognostiserade värdena och de justerade funktionerna.

Du kan också använda parametern forecast_destinationforecast_quantiles() i funktionen för att göra prognoser för värden fram till ett angivet datum.

label_query = test_labels.copy().astype(np.float)
label_query.fill(np.nan)
label_fcst, data_trans = fitted_model.forecast_quantiles(
    test_dataset, label_query, forecast_destination=pd.Timestamp(2019, 1, 8)
)

Inga quantiles anges här, så endast punktprognosen genereras. Du kanske vill förstå förutsägelserna i en specifik kvantil av fördelningen. Till exempel när prognosen används för att kontrollera inventering som livsmedelsartiklar eller virtuella datorer för en molntjänst. I sådana fall är kontrollpunkten vanligtvis något i stil med "vi vill att artikeln ska finnas i lager och inte ta slut 99 % av tiden". Följande exempel visar hur du anger prognoskvanter, till exempel 50:e eller 95:e percentilen:

# Get forecasts for the 5th, 50th, and 90th percentiles 
fitted_model.quantiles = [0.05, 0.5, 0.9]
fitted_model.forecast_quantiles(
    test_dataset, label_query, forecast_destination=pd.Timestamp(2019, 1, 8)
)

Du kan beräkna modellmått som RMSE (Root Mean Squared Error) eller MAPE (Mean Absolute Percentage Error) för att beräkna modellens prestanda. Ett exempel finns i avsnittet Utvärdera i notebook-filen för cykelresursefterfrågan .

När den övergripande modellprecisionen har fastställts är det mest realistiska nästa steg att använda modellen för att göra prognoser för okända framtida värden.

Ange en datauppsättning i samma format som testuppsättningen test_dataset , men med framtida datetimes, och den resulterande förutsägelseuppsättningen är de prognostiserade värdena för varje tidsseriesteg. Anta att de sista posterna i datauppsättningen var för den 31 december 2018. Skapa en tidsseriepost för varje butik som börjar den 1 januari 2019 för att skapa en prognos för efterfrågan.

day_datetime,store,week_of_year
01/01/2019,A,1
01/01/2019,A,1

Upprepa de steg som krävs för att läsa in framtida data till en dataram och kör best_run.forecast_quantiles(test_dataset) sedan för att förutsäga framtida värden.

Anteckning

Förutsägelser i exemplet stöds inte för prognostisering med automatiserad ML när target_lags och/eller target_rolling_window_size är aktiverade.

Prognostisering i stor skala

GÄLLER FÖR:Python SDK azureml v1

Viktigt

Många modeller och hierarkiska tidsserier stöds för närvarande endast i Azure Machine Learning v1. Stöd för Azure Machine Learning v2 kommer.

Det finns scenarier där en enskild maskininlärningsmodell är otillräcklig och flera maskininlärningsmodeller behövs. Du kan till exempel förutsäga försäljningen för varje enskild butik för ett varumärke eller skräddarsy en upplevelse för enskilda användare. Att skapa en modell för varje instans kan leda till bättre resultat på många maskininlärningsproblem.

Gruppering är ett begrepp i tidsserieprognoser som gör att tidsserier kan kombineras för att träna en enskild modell per grupp. Den här metoden kan vara särskilt användbar om du har tidsserier som kräver utjämning, fyllning eller entiteter i gruppen som kan dra nytta av historik eller trender från andra entiteter. Många modeller och prognoser för hierarkiska tidsserier är lösningar som drivs av automatiserad maskininlärning för dessa storskaliga prognosscenarier.

Många modeller

Med azure machine learning-lösningen med många modeller med automatiserad maskininlärning kan användarna träna och hantera miljontals modeller parallellt. Lösningsacceleratorn Många modeller använder Azure Machine Learning-pipelines för att träna modellen. Mer specifikt används ett Pipeline-objekt och ParalleRunStep och kräver specifika konfigurationsparametrar som anges via ParallelRunConfig.

I följande diagram visas arbetsflödet för lösningen med många modeller.

Följande kod visar de nyckelparametrar som användare behöver för att konfigurera sina många modeller som körs. I notebook-filen Många modeller – Automatiserad ML finns ett exempel på prognostisering för många modeller

from azureml.train.automl.runtime._many_models.many_models_parameters import ManyModelsTrainParameters

partition_column_names = ['Store', 'Brand']
automl_settings = {"task" : 'forecasting',
                   "primary_metric" : 'normalized_root_mean_squared_error',
                   "iteration_timeout_minutes" : 10, #This needs to be changed based on the dataset. Explore how long training is taking before setting this value 
                   "iterations" : 15,
                   "experiment_timeout_hours" : 1,
                   "label_column_name" : 'Quantity',
                   "n_cross_validations" : "auto", # Could be customized as an integer
                   "cv_step_size" : "auto", # Could be customized as an integer
                   "time_column_name": 'WeekStarting',
                   "max_horizon" : 6,
                   "track_child_runs": False,
                   "pipeline_fetch_max_batch_size": 15,}

mm_paramters = ManyModelsTrainParameters(automl_settings=automl_settings, partition_column_names=partition_column_names)

Prognostisering av hierarkisk tidsserie

I de flesta program behöver kunderna förstå sina prognoser på makro- och mikronivå i verksamheten. oavsett om det handlar om att förutsäga försäljningen av produkter på olika geografiska platser eller förstå den förväntade efterfrågan på arbetskraft för olika organisationer på ett företag. Det är viktigt att du kan träna en maskininlärningsmodell att göra intelligenta prognoser för hierarkidata.

En hierarkisk tidsserie är en struktur där serien har kapslade attribut. Geografiska attribut eller produktkatalogattribut är naturliga exempel. I följande exempel visas data med unika attribut som utgör en hierarki. Vår hierarki definieras av: produkttypen, till exempel hörlurar eller surfplattor, produktkategorin som delar upp produkttyper i tillbehör och enheter och den region som produkterna säljs i.

För att ytterligare visualisera detta innehåller lövnivåerna i hierarkin alla tidsserier med unika kombinationer av attributvärden. Varje högre nivå i hierarkin tar hänsyn till en mindre dimension för att definiera tidsserien och aggregerar varje uppsättning underordnade noder från den lägre nivån till en överordnad nod.

Den hierarkiska tidsserielösningen bygger på lösningen många modeller och delar en liknande konfigurationskonfiguration.

Följande kod visar nyckelparametrarna för att konfigurera dina hierarkiska tidsserieprognoskörningar. Se notebook-filen Hierarkisk tidsserie – Automatiserad ML för ett exempel från slutpunkt till slutpunkt.

from azureml.train.automl.runtime._hts.hts_parameters import HTSTrainParameters

model_explainability = True

engineered_explanations = False # Define your hierarchy. Adjust the settings below based on your dataset.
hierarchy = ["state", "store_id", "product_category", "SKU"]
training_level = "SKU"# Set your forecast parameters. Adjust the settings below based on your dataset.
time_column_name = "date"
label_column_name = "quantity"
forecast_horizon = 7


automl_settings = {"task" : "forecasting",
                   "primary_metric" : "normalized_root_mean_squared_error",
                   "label_column_name": label_column_name,
                   "time_column_name": time_column_name,
                   "forecast_horizon": forecast_horizon,
                   "hierarchy_column_names": hierarchy,
                   "hierarchy_training_level": training_level,
                   "track_child_runs": False,
                   "pipeline_fetch_max_batch_size": 15,
                   "model_explainability": model_explainability,# The following settings are specific to this sample and should be adjusted according to your own needs.
                   "iteration_timeout_minutes" : 10,
                   "iterations" : 10,
                   "n_cross_validations" : "auto", # Could be customized as an integer
                   "cv_step_size" : "auto", # Could be customized as an integer
                   }

hts_parameters = HTSTrainParameters(
    automl_settings=automl_settings,
    hierarchy_column_names=hierarchy,
    training_level=training_level,
    enable_engineered_explanations=engineered_explanations
)

Exempelnotebook-filer

Notebook-filerna med prognosexempel innehåller detaljerade kodexempel för avancerad konfiguration av prognostisering, inklusive:

• djupinlärningsmodeller
• funktionalisering och identifiering av helgdagar
• manuell konfiguration för fördröjningar och funktioner för löpande fönsteraggregering

Nästa steg

• Läs mer om hur du distribuerar en AutoML-modell till en onlineslutpunkt.
• Lär dig mer om tolkningsbarhet: modellförklaringar i automatiserad maskininlärning (förhandsversion).
• Lär dig mer om hur AutoML skapar prognosmodeller.
• Lär dig hur du konfigurerar AutoML för olika prognostiseringsscenarier.