Čítať v angličtine

Zdieľať cez

Ladenie hyperparametrov (Ukážka)

  • Článok

Ladenie hyperparametrov je proces hľadania optimálnych hodnôt pre parametre, ktoré model strojového učenia nenaučí počas trénovania, ale nastaví ho používateľ ešte pred začatím procesu trénovania. Tieto parametre sa bežne označujú ako hyperparametre a medzi príklady patrí miera učenia, počet skrytých vrstiev v neurálnej sieti, sila regulácie a veľkosť dávky.

Výkon modelu strojového učenia môže byť vysoko citlivý na výber hyperparametrov a optimálna množina hyperparametrov sa môže výrazne líšiť v závislosti od konkrétneho problému a množiny údajov. Ladenie hyperparametrov je preto kritickým krokom v kanáli strojového učenia, pretože môže mať významný vplyv na presnosť a výkon modelu a zovšeobecnenie.

V službe Fabric môžu dátoví vedci využívať FLAMLzjednodušenú knižnicu jazyka Python na efektívnu automatizáciu strojového učenia a operácií umelej inteligencie na účely svojich požiadaviek na ladenie hyperparametrov. V poznámkových blokoch služby Fabric môžu používatelia zavolať flaml.tune na ladenie ekonomických hyperparametrov.

Dôležité

Táto funkcia je vo verzii Preview.

Ladenie pracovného postupu

Na dokončenie úlohy základného ladenia možno použiť flaml.tune tri základné kroky:

  1. Zadajte cieľ ladenia s ohľadom na hyperparametre.
  2. Zadajte vyhľadávací priestor hyperparametrov.
  3. Zadajte obmedzenia ladenia vrátane obmedzení rozpočtu prostriedkov na vykonanie ladenia, obmedzení konfigurácií alebo obmedzení pre (alebo viaceré) konkrétne metriky.

Ladenie cieľov

Prvým krokom je zadanie vášho cieľa vyladenie. Ak to chcete urobiť, mali by ste najprv zadať svoju postup hodnotenia s ohľadom na hyperparametre vo funkcii evaluation_functiondefinovanej používateľom. Funkcia vyžaduje ako vstup konfiguráciu hyperparametrov. Môže jednoducho vrátiť hodnotu metriky v skalárnom zozname alebo vrátiť slovník párov názvov metriky a hodnôt metriky.

V príklade uvedenom nižšie môžeme definovať funkciu vyhodnotenia s ohľadom na 2 hyperparametre s názvom x a y.

Python 
import time

def evaluate_config(config: dict):
    """evaluate a hyperparameter configuration"""
    score = (config["x"] - 85000) ** 2 - config["x"] / config["y"]


    faked_evaluation_cost = config["x"] / 100000
    time.sleep(faked_evaluation_cost)
    # we can return a single float as a score on the input config:
    # return score
    # or, we can return a dictionary that maps metric name to metric value:
    return {"score": score, "evaluation_cost": faked_evaluation_cost, "constraint_metric": config["x"] * config["y"]}

Hľadať miesto

V ďalšom kroku určíme vyhľadávací priestor hyperparametrov. Vo vyhľadávacej oblasti je potrebné zadať platné hodnoty pre hyperparametre a spôsob vzorkovania týchto hodnôt (napríklad z rovnomerného rozdelenia alebo log-uniformnej distribúcie). V nižšie uvedenom príklade môžeme poskytnúť priestor na vyhľadávanie hyperparametrov x a y. Platné hodnoty pre obe hodnoty sú celé čísla v rozsahu od [1 do 100 000]. Tieto hyperparametre sa odoberajú uniformne v zadaných rozsahoch.

Python 
from flaml import tune

# construct a search space for the hyperparameters x and y.
config_search_space = {
    "x": tune.lograndint(lower=1, upper=100000),
    "y": tune.randint(lower=1, upper=100000)
}

# provide the search space to tune.run
tune.run(..., config=config_search_space, ...)

S protokolom FLAML môžu používatelia prispôsobiť doménu pre konkrétny hyperparameter. Používateľom to umožňuje zadať typ a platný rozsah, z ktorých môžu vzorkovať parametre. Flaml podporuje nasledujúce typy hyperparametrov: float, integer a categorical. Ako príklad nižšie môžete vidieť bežne používané domény:

Python 
config = {
    # Sample a float uniformly between -5.0 and -1.0
    "uniform": tune.uniform(-5, -1),

    # Sample a float uniformly between 3.2 and 5.4,
    # rounding to increments of 0.2
    "quniform": tune.quniform(3.2, 5.4, 0.2),

    # Sample a float uniformly between 0.0001 and 0.01, while
    # sampling in log space
    "loguniform": tune.loguniform(1e-4, 1e-2),

    # Sample a float uniformly between 0.0001 and 0.1, while
    # sampling in log space and rounding to increments of 0.00005
    "qloguniform": tune.qloguniform(1e-4, 1e-1, 5e-5),

    # Sample a random float from a normal distribution with
    # mean=10 and sd=2
    "randn": tune.randn(10, 2),

    # Sample a random float from a normal distribution with
    # mean=10 and sd=2, rounding to increments of 0.2
    "qrandn": tune.qrandn(10, 2, 0.2),

    # Sample a integer uniformly between -9 (inclusive) and 15 (exclusive)
    "randint": tune.randint(-9, 15),

    # Sample a random uniformly between -21 (inclusive) and 12 (inclusive (!))
    # rounding to increments of 3 (includes 12)
    "qrandint": tune.qrandint(-21, 12, 3),

    # Sample a integer uniformly between 1 (inclusive) and 10 (exclusive),
    # while sampling in log space
    "lograndint": tune.lograndint(1, 10),

    # Sample a integer uniformly between 2 (inclusive) and 10 (inclusive (!)),
    # while sampling in log space and rounding to increments of 2
    "qlograndint": tune.qlograndint(2, 10, 2),

    # Sample an option uniformly from the specified choices
    "choice": tune.choice(["a", "b", "c"]),
}

Ďalšie informácie o tom, ako môžete prispôsobiť domény v rámci vyhľadávacieho priestoru, nájdete v dokumentácii flaml o prispôsobení priestorov vyhľadávania.

Obmedzenia ladenia

Posledným krokom je určenie obmedzení úlohy ladenia. Jedným z pozoruhodných vlastností flaml.tune je, že je schopný dokončiť proces ladenia v rámci požadovaného obmedzenia prostriedkov. Ak to chcete urobiť, používateľ môže poskytnúť obmedzenia prostriedkov v súvislosti s časom steny v hodinách (v sekundách) pomocou argumentu time_budget_s alebo z hľadiska počtu skúšobných verzií s použitím argumentu num_samples .

Python 
# Set a resource constraint of 60 seconds wall-clock time for the tuning.
flaml.tune.run(..., time_budget_s=60, ...)

# Set a resource constraint of 100 trials for the tuning.
flaml.tune.run(..., num_samples=100, ...)

# Use at most 60 seconds and at most 100 trials for the tuning.
flaml.tune.run(..., time_budget_s=60, num_samples=100, ...)

Ďalšie informácie o obmedzeniach konfigurácie s prírastkom nájdete v dokumentácii flaml s rozšírenými možnosťami ladenia.

Zhrnutie

Po definovaní našich kritérií ladenia môžeme vykonať skúšobnú verziu ladenia. Na sledovanie výsledkov skúšobnej verzie môžeme využiť automatické označovanie toku strojového učenia na zaznamenávanie metrík a parametrov pre každú z týchto spustení. Tento kód zaznamená celú skúšobnú verziu ladenia hyperparametrov a zvýrazní každú z kombinácií hyperparametrov, ktoré preskúmal flaml.

Python 
import mlflow
mlflow.set_experiment("flaml_tune_experiment")
mlflow.autolog(exclusive=False)

with mlflow.start_run(nested=True, run_name="Child Run: "):
    analysis = tune.run(
        evaluate_config,  # the function to evaluate a config
        config=config_search_space,  # the search space defined
        metric="score",
        mode="min",  # the optimization mode, "min" or "max"
        num_samples=-1,  # the maximal number of configs to try, -1 means infinite
        time_budget_s=10,  # the time budget in seconds
    )

Poznámka

Keď je automatické označovanie toku MLflow povolené, metriky, parametre a modely by sa mali automaticky zaznamenávať ako spustenie toku strojového učenia. To sa však líši podľa rámca. Metriky a parametre pre konkrétne modely sa nemusia zaznamenávať do denníka. Pre modely XGBoost, LightGBM, Spark a SynapseML sa napríklad nebudú zaznamenávať žiadne metriky. Ďalšie informácie o tom, aké metriky a parametre sa zaznamenávajú z jednotlivých rámcov, nájdete v dokumentácii o automatickom značení toku strojového učenia.

Paralelné ladenie so službou Apache Spark

Funkcia flaml.tune podporuje vyladenie Apache Spark aj učeníkov s jedným uzlom. Okrem toho môžete pri ladení študentom s jedným uzlom (napríklad Scikit-Learn) tiež paralelne ladiť tak, aby sa proces ladenia zrýchlil nastavením .use_spark = True V prípade klastrov Spark spustí protokol FLAML predvolene jednu skúšobnú verziu pre každého vykonávateľa. Počet súbežných skúšobných verzií môžete tiež prispôsobiť pomocou argumentu n_concurrent_trials .

Python 

analysis = tune.run(
    evaluate_config,  # the function to evaluate a config
    config=config_search_space,  # the search space defined
    metric="score",
    mode="min",  # the optimization mode, "min" or "max"
    num_samples=-1,  # the maximal number of configs to try, -1 means infinite
    time_budget_s=10,  # the time budget in seconds
    use_spark=True,
)
print(analysis.best_trial.last_result)  # the best trial's result
print(analysis.best_config)  # the best config

Ďalšie informácie o tom, ako paralelne využiť svoje chodníky ladenia, nájdete v dokumentácii flaml pre paralelné úlohy služby Spark.

Vizualizácia výsledkov

Modul flaml.visualization poskytuje pomocné funkcie na vykreslenie procesu optimalizácie pomocou nástroja Plotly. Využitím služby Plotly môžu používatelia interaktívne preskúmať svoje výsledky experimentovania automatizovaného strojového učenia. Ak chcete tieto funkcie vykreslenia použiť, jednoducho zadajte svoj optimalizovaný flaml.AutoML objekt alebo flaml.tune.tune.ExperimentAnalysis objekt ako vstup.

V poznámkovom bloku môžete použiť nasledujúce funkcie:

  • plot_optimization_history: Vykreslte históriu optimalizácie všetkých skúšok v experimente.
  • plot_feature_importance: Vykreslí sa dôležitosť pre každú funkciu v množine údajov.
  • plot_parallel_coordinate: Vykreslí v experimente vzťahy vysokorozmerných parametrov.
  • plot_contour: Vykreslte v experimente vzťah parametra ako znázornenie kontúry.
  • plot_edf: Vykresliť cieľovú hodnotu EDF (funkcia empirickej distribúcie) experimentu.
  • plot_timeline: Vykreslí časovú os experimentu.
  • plot_slice: Vykreslí v štúdii vzťah parametra ako výsek.
  • plot_param_importance: Vykreslí sa dôležitosť hyperparametrov experimentu.

Súvisiaci obsah