Hyperparameterjustering (forhåndsvisning)
Hyperparameterjustering er prosessen med å finne de optimale verdiene for parameterne som ikke læres av maskinlæringsmodellen under opplæring, men heller angitt av brukeren før opplæringsprosessen begynner. Disse parameterne kalles ofte hyperparametere, og eksempler inkluderer læringsfrekvensen, antall skjulte lag i et nevrale nettverk, regulariseringsstyrken og batchstørrelsen.
Ytelsen til en maskinlæringsmodell kan være svært følsom for valg av hyperparametere, og det optimale settet med hyperparametere kan variere sterkt avhengig av det spesifikke problemet og datasettet. Hyperparameterjustering er derfor et kritisk trinn i maskinlæringssamlebåndet, da det kan ha en betydelig innvirkning på modellens nøyaktighet og generaliseringsytelse.
I Fabric kan dataforskere dra nytte FLAMLav et lett Python-bibliotek for effektiv automatisering av maskinlæring og AI-operasjoner, for deres hyperparameterjusteringskrav. I Fabric-notatblokker kan brukere kreve flaml.tune økonomisk hyperparameterjustering.
Viktig
Denne funksjonen er i forhåndsvisning.
Justeringsarbeidsflyt
Det finnes tre viktige trinn å bruke flaml.tune til å fullføre en grunnleggende justeringsoppgave:
- Angi justeringsmålet med hensyn til hyperparameterne.
- Angi et søkeområde for hyperparameterne.
- Angi justeringsbetingelser, inkludert begrensninger på ressursbudsjettet for å utføre justering, begrensninger på konfigurasjonene, eller/og begrensninger på en (eller flere) bestemte metrikkverdier.
Justeringsmål
Det første trinnet er å angi justeringsmålet. Hvis du vil gjøre dette, må du først angi evalueringsprosedyren med hensyn til hyperparameterne i en brukerdefinert funksjon evaluation_function. Funksjonen krever en hyperparameterkonfigurasjon som inndata. Den kan ganske enkelt returnere en metrisk verdi i en skalar eller returnere en ordliste med metrisk navn og metriske verdipar.
I eksemplet nedenfor kan vi definere en evalueringsfunksjon med hensyn til to hyperparametere med navn x og y.
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"]}
Søkeområde
Deretter angir vi søkeområdet for hyperparametere. I søkeområdet må du angi gyldige verdier for hyperparameterne og hvordan disse verdiene er samplet (for eksempel fra en enhetlig fordeling eller en log-uniform fordeling). I eksemplet nedenfor kan vi gi søkeområdet for hyperparameterne x og y. De gyldige verdiene for begge er heltall fra [1, 100 000]. Disse hyperparameterne er samplet jevnt i de angitte områdene.
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, ...)
Med FLAML kan brukere tilpasse domenet for en bestemt hyperparameter. Dette gjør det mulig for brukere å angi en type og et gyldig område som eksempelparametere fra. FLAML støtter følgende hyperparametertyper: flyt, heltall og kategorisk. Du kan se dette eksemplet nedenfor for vanlige domener:
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"]),
}
Hvis du vil lære mer om hvordan du kan tilpasse domener i søkeområdet, kan du gå til FLAML-dokumentasjonen om tilpassing av søkeområder.
Justeringsbetingelser
Det siste trinnet er å angi begrensninger for justeringsoppgaven. En bemerkelsesverdig egenskap flaml.tune er at den er i stand til å fullføre justeringsprosessen innenfor en nødvendig ressursbetingelse. Hvis du vil gjøre dette, kan en bruker angi ressursbegrensninger når det gjelder veggklokketid (i sekunder) ved hjelp time_budget_s av argumentet eller når det gjelder antall forsøk som bruker num_samples argumentet.
# 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, ...)
Hvis du vil ha mer informasjon om konfigurasjonsbetingelser for tillegg, kan du gå til FLAML-dokumentasjonen for avanserte justeringsalternativer.
Sette den sammen
Når vi har definert justeringskriteriene våre, kan vi utføre prøveversjonen av justeringen. Hvis du vil spore resultatene av prøveversjonen, kan vi dra nytte av MLFlow-autologging for å registrere måledata og parametere for hver av disse kjøringene. Denne koden fanger opp hele prøveversjonen av hyperparameterjustering, og uthever hver av hyperparameterkombinasjonene som ble utforsket av FLAML.
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
)
Merk
Når autologging av MLflow er aktivert, bør måledata, parametere og modeller logges automatisk når MLFlow kjører. Dette varierer imidlertid etter rammeverket. Måledata og parametere for bestemte modeller loggføres kanskje ikke. Det logges for eksempel ingen måledata for XGBoost-, LightGBM-, Spark- og SynapseML-modeller. Du kan lære mer om hvilke måledata og parametere som hentes fra hvert rammeverk ved hjelp av MLFlow-dokumentasjonen for automatisk tillogging.
Parallell justering med Apache Spark
Funksjonaliteten flaml.tune støtter justering av både Apache Spark og single-node-elever. I tillegg, når du justerer elever med enkeltnode (f.eks. Scikit-Learn-elever), kan du også parallelisere justeringen for å øke hastigheten på justeringsprosessen ved å angi use_spark = True. For Spark-klynger starter FLAML som standard én prøveversjon per eksekutor. Du kan også tilpasse antall samtidige forsøk ved hjelp n_concurrent_trials av argumentet.
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
Hvis du vil lære mer om hvordan du parallelliserer justeringssporene, kan du gå til FLAML-dokumentasjonen for parallelle Spark-jobber.
Visualiser resultater
Modulen flaml.visualization inneholder verktøyfunksjoner for å plotte optimaliseringsprosessen ved hjelp av Plotly. Ved å utnytte Plotly kan brukerne interaktivt utforske resultatene fra AutoML-eksperimentet. Hvis du vil bruke disse plottfunksjonene, kan du ganske enkelt angi optimaliserte flaml.AutoML funksjoner eller flaml.tune.tune.ExperimentAnalysis objekter som inndata.
Du kan bruke følgende funksjoner i notatblokken:
plot_optimization_history: Plotteoptimaliseringshistorikk for alle forsøk i eksperimentet.plot_feature_importance: Plotte viktighet for hver funksjon i datasettet.plot_parallel_coordinate: Tegn inn de høydimensjonale parameterrelasjonene i eksperimentet.plot_contour: Tegn inn parameterrelasjonen som konturplott i eksperimentet.plot_edf: Tegn inn målverdien EDF (empirisk fordelingsfunksjon) for eksperimentet.plot_timeline: Plotte tidslinjen for eksperimentet.plot_slice: Tegn inn parameterrelasjonen som slice plot i en studie.plot_param_importance: Plot hyperparameter betydningen av eksperimentet.