HyperOpt afmystificeret

Sådan automatiseres modeljustering med HyperOpt

Elsker du at tune modeller? Hvis dit svar er "ja", er dette indlæg ikke til dig.

I denne blog vil vi dække den ekstremt populære automatiserede hyperparameter tuning algoritme kaldet Træbaserede Parzen Estimatorer (TPE). TPE understøttes af open source-pakken, HyperOpt. Ved at udnytte HyperOpt og TPE kan maskinlæringsingeniører hurtigt udvikle højoptimerede modeller uden nogen manuel tuning.

Uden videre skal vi dykke ned!

HyperOpt er en open source python-pakke, der bruger en algoritme kaldet Tree-based Parzen Esimtors (TPE) til at vælge modelhyperparametre, som optimerer en brugerdefineret objektivfunktion. Ved blot at definere den funktionelle form og grænser for hver hyperparameter, søger TPE grundigt, men effektivt gennem komplekse hyperrum for at nå optimum.

TPE er en sekventiel algoritme, der udnytter bayesiansk opdatering og følger nedenstående sekvens.

1. Træn en model med flere sæt tilfældigt udvalgte hyperparametre og returnerer objektive funktionsværdier.
2. Opdel vores observerede objektive funktionsværdier i "gode" og "dårlige" grupper i henhold til en eller anden tærskelgamma (γ).
3. Beregn "lovende"-scoren, hvilket er retfærdigt P(x|god) / P(x|dårlig).
4. Bestem de hyperparametre, der maksimerer lovendehed via blandingsmodeller.
5. Tilpas vores model ved hjælp af hyperparametrene fra trin 4.
6. Gentag trin 2-5 indtil et stopkriterie.

Her er en hurtig kode eksempel.

Ok, det var mange store ord. Lad os sætte farten ned og virkelig forstå, hvad der foregår.

1.1 - Vores mål

Dataforskere har travlt. Vi vil gerne producere rigtig gode modeller, men gør det på en effektiv og ideelt set hands-off måde.

Visse trin i ML-modelleringslivscyklussen er dog meget svære at automatisere. Udforskende dataanalyse (EDA) og feature engineering er for eksempel normalt emnespecifikke og kræver menneskelig intuition. Modeltuning er på den anden side en iterativ proces, hvor computere kan udmærke sig.

Vores mål gennem dette indlæg er at forstå, hvordan man kan udnytte algoritmer til at automatisere modeljusteringsprocessen.

For at hjælpe os med at tænke over det mål, lad os bruge en analogi: vi er pirater, der leder efter begravede skat. Det er også vigtigt at bemærke, at vi er meget effektive pirater, der søger at minimere vores tid på at lede efter den begravede skat. Så hvordan skal vi minimere tidsforbruget på at søge? Svaret er brug et kort!

I figur 1 har vi et fiktivt kort, der viser, hvor vores skat er placeret. Efter masser af klatring og gravning ville det ikke være for svært at nå den skat, fordi vi ved præcis, hvor den er placeret.

Men hvad sker der, når vi ikke har et kort?

Når vi får til opgave at tune en model, får vi desværre ikke et kort. Vores terræn, som svarer til hyperparmeter-søgerummet, er ukendt. Desuden er placeringen af ​​vores skat, som svarer til det optimale sæt af hyperparametre, også ukendt.

Med den opsætning, lad os tale om nogle potentielle måder at udforske dette rum effektivt og finde en skat på!

1.2 — Potentielle løsninger

Den originale metode til modeljustering er "manuel" - ingeniøren vil faktisk manuelt teste mange forskellige konfigurationer og se, hvilken hyperparameterkombination der giver den bedste model. Selvom den er informativ, er denne proces ineffektiv. Der må være en bedre måde...

1.2.1 — Netsøgning (dårligst)

Vores første optimeringsalgoritme er gittersøgning. Gittersøgning tester iterativt alle mulige kombinationer af hyperparametre inden for et brugerspecificeret gitter.

For eksempel, i figur 2, hvor du ser en rød prik, er det, hvor vi omskoler og evaluerer vores model. Denne ramme er ineffektiv, fordi den genbruger dårlige hyperparametre. For eksempel, hvis hyperparameter 2 har ringe indflydelse på vores objektive funktion, vil vi stadig teste alle kombinationer af dens værdier og derved øge det nødvendige antal iterationer med 10x (i dette eksempel).

Men før du går videre, er det vigtigt at bemærke, at gittersøgning stadig er ret populær, fordi den med garanti vil finde et optimum givet et korrekt specificeret gitter. Hvis du beslutter dig for at bruge metoden, sørg for at transformere dit gitter, så det afspejler den funktionelle form af dine hyperparametre. For eksempel, max_depth for en tilfældig skovklassifikator er et heltal — lad det ikke søge over et kontinuerligt rum. Det er også usandsynligt, at det har en ensartet fordeling - hvis du kender den funktionelle form af din hyperparameter, skal du transformere gitteret for at afspejle det.

Sammenfattende gittersøgning er underlagt dimensionalitetens forbandelse og genberegner information mellem evalueringer, men bruges stadig meget.

1.2.2 — Tilfældig søgning (god)

Vores anden algoritme er tilfældig søgning. Tilfældig søgning forsøger tilfældige værdier inden for et brugerspecificeret gitter. I modsætning til gittersøgning er vi ikke henvist til at teste alle mulige kombinationer af hyperparametre, hvilket øger effektiviteten.

Her er en cool kendsgerning: tilfældig søgning vil finde (i gennemsnit) en top 5 % hyperparameterkonfiguration inden for 60 iterationer. Når det er sagt, som med gittersøgning skal du transformere dit søgerum til at afspejle den funktionelle form af hver hyperparam.

Tilfældig søgning er en god baseline for hyperparameteroptimering.

1.2.3 – Bayesiansk optimering (bedre)

Vores tredje kandidat er vores første Sequential Model-Based Optimization (SMBO) algoritme. Den vigtigste konceptuelle forskel fra de tidligere teknikker er vi brug iterativt tidligere kørsler til at bestemme fremtidige udforskningspunkter.

Bayesiansk hyperparameteroptimering ser ud til at udvikle en probabilistisk fordeling af vores hyperparametersøgeområde. Derfra bruger den en opkøbsfunktion, såsom forventet forventet forbedring, til at transformere vores hyperrum til at være mere "søgbart". Endelig bruger den en optimeringsalgoritme, såsom stokastisk gradientnedstigning, til at finde de hyperparametre, der maksimerer vores optagelsesfunktion. Disse hyperparametre bruges til at passe til vores model, og processen gentages indtil konvergens.

Bayesiansk optimering overgår typisk tilfældig søgning, men den har nogle kernebegrænsninger, såsom at kræve numeriske hyperparametre.

1.2.4 — Træbaserede Parzen-estimatorer (bedst)

Lad os endelig tale om stjernen i showet: Tree-Based Parzen Estimators (TPE). TPE er en anden SMBO-algoritme, der typisk overgår grundlæggende bayesiansk optimering, men det vigtigste salgsargument er, at den håndterer komplekse hyperparameterforhold via en træstruktur.

Lad os bruge figur 5 til at forstå dette træstruktur. Her træner vi en Support Vector Machine (SVM) klassifikator. Vi vil teste to kerner: linear , RBF. En linear kernel tager ikke en breddeparameter men RBF gør, så ved at bruge en indlejret ordbog er vi i stand til at kode denne struktur og derved begrænse søgerummet.

TPE understøtter også kategoriske variabler, som traditionel Bayesiansk optimering ikke gør.

Hurtig ansvarsfraskrivelse før du går videre, der er mange andre pakker til justering af hyperparameter. Hver understøtter en række forskellige algoritmer, hvoraf nogle inkluderer tilfældig skov, gaussiske processer og genetiske algoritmer. TPE er en meget populær og generel algoritme, men er ikke nødvendigvis den bedste.

Generelt er TPE en virkelig robust og effektiv hyperparameteroptimeringsløsning.

Nu hvor vi har en generel forståelse af nogle populære hyperparameteroptimeringsalgoritmer, lad os dykke dybt ned i, hvordan TPE fungerer.

For at vende tilbage til vores analogi, er vi pirater, der leder efter begravede skat men har ikke et kort. Vores kaptajn har brug for skatten ASAP, så vi er nødt til at grave på strategiske steder, der har stor sandsynlighed for at have skatte, ved at bruge tidligere udgravninger til at bestemme placeringen af ​​fremtidige udgravninger.

2.1 — Initialisering

For at starte, vi definere begrænsningerne på vores rum. Som nævnt ovenfor har vores hyperparametre ofte en funktionel form, max/min værdier og hierarkisk relation til andre hyperparametre. Ved at bruge vores viden om vores ML-algoritmer og vores data kan vi definere vores søgerum.

Derefter skal vi definere vores objektive funktion, som bruges til at evaluere, hvor "god" vores hyperparameterkombination er. Nogle eksempler inkluderer klassiske ML-tabsfunktioner, såsom RMSE eller AUC.

Store! Nu hvor vi har et afgrænset søgeområde og en måde at måle succes på, er vi klar til at begynde at søge...

2.2 — Iterativ Bayesiansk optimering

Bayesiansk optimering er en sekventiel algoritme, der finder punkter i hyperrummet med stor sandsynlighed for at være "succesfuld" ifølge en objektiv funktion. TPE udnytter bayesiansk optimering, men bruger nogle smarte tricks til at forbedre ydeevnen og håndtere søgeområdets kompleksitet...

2.2.0 — Den konceptuelle opsætning

Det første trick er modellering P(x|y) i stedet for P(y|x)...

Bayesiansk optimering ser typisk ud til at modellere P(y|x), som er sandsynligheden for en objektiv funktionsværdi (y), givet hyperparametre (x). TPE gør det modsatte - det ser ud til at modellere P(x|y), som er sandsynligheden for hyperparametrene (x), givet den objektive funktionsværdi (y).

Kort sagt, TPE forsøger at finde de bedste objektive funktionsværdier og derefter bestemme de tilhørende hyperparametre.

Med den meget vigtige opsætning, lad os komme ind på den faktiske algoritme.

2.2.1 — Opdel vores data i "gode" og "dårlige" grupper

Husk, vores mål er at finde de bedste hyperparameterværdier i henhold til en eller anden objektiv funktion. Så hvordan kan vi udnytte P(x|y) at gøre det?

For det første opdeler TPE vores observerede datapunkter i to grupper: godt, angivet g(x), , dårlig, angivet l(x). Afskæringen mellem godt og dårligt bestemmes af en brugerdefineret parameter gamma (γ), som svarer til den objektive funktionspercentil, der deler vores observationer (y*).

Så med γ = 0.5 er vores objektive funktionsværdi, der deler vores observationer (y*) vil være medianen af ​​vores observerede punkter.

Som vist i figur 7 kan vi formalisere p(x|y) ved hjælp af ovenstående rammer. Og for at rulle med piratanalogien...

Piratperspektiv: ser på de steder, vi allerede har udforsket, viser l(x) steder med meget lidt skatte, og g(x) viser steder med masser af skatte.

2.2.32— Beregn "Promisingness"-score

For det andet definerer TPE, hvordan vi skal evaluere en uobserveret hyperparameterkombination via "lovende"-score.

Figur 8 definerer vores lovende score (P), som kun er et forhold med følgende komponenter...

• tæller: sandsynligheden for at observere et sæt hyperparametre (x), givet den tilsvarende målfunktionsværdi er "godt".
• nævner: sandsynligheden for at observere et sæt hyperparametre (x), givet den tilsvarende målfunktionsværdi er "dårlig".

Jo større "lovende" værdi, jo mere sandsynligt er vores hyperparametre x vil producere en "god" objektiv funktion.

Piratperspektiv: lovende viser, hvor sandsynligt, at en given placering i vores terræn vil have masser af skatte.

Hurtigt til side før du går videre, hvis du er bekendt med Bayesiansk optimering, fungerer denne ligning som en optagelsesfunktion og er proportional med Forventet forbedring (EI).

2.2.3— Opret en sandsynlighedstæthedsestimater

For det tredje søger TPE at evaluere "lovende"-scoren via blandingsmodeller. Ideen med blandingsmodeller er at tage flere sandsynlighedsfordelinger og sætte dem sammen ved hjælp af en lineær kombination - src. Disse kombinerede sandsynlighedsfordelinger bruges derefter til at udvikle sandsynlighedstæthedsestimater.

Generelt er blandingsmodelleringsprocessen...

1. Definer fordelingstypen for vores point. I vores tilfælde, hvis vores variabel er kategorisk, bruger vi en omvægtet kategorisk fordeling, og hvis den er numerisk, bruger vi en gaussisk (dvs. normal) eller ensartet fordeling.
2. Gentag over hvert punkt og indsæt en fordeling på det punkt.
3. Summer massen af ​​alle fordelinger for at få et sandsynlighedstæthedsestimat.

Bemærk, at denne proces køres individuelt for begge sæt l(x) , g(x).

Lad os gennemgå et eksempel i figur 9...

For hver observation (blå prikker på x-aksen) skaber vi en normalfordeling ~N(μ, σ), hvor...

• μ (mu) er middelværdien af ​​vores normalfordeling. Dets værdi er placeringen af ​​vores punkt langs x-aksen.
• σ (sigma) er standardafvigelsen af ​​vores normalfordeling. Dens værdi er afstanden til det nærmeste nabopunkt.

Hvis punkter er tæt på hinanden, vil standardafvigelsen være lille, og derved vil fordelingen være meget høj, og omvendt, hvis punkter er spredt fra hinanden, vil fordelingen være flad (figur 10)...

Piratperspektiv: NA — pirater er ikke gode med blandingsmodeller.

En anden hurtig side, inden du går videre: Hvis du læser litteraturen, vil du bemærke, at TPE bruger "trunkerede" gaussianer, hvilket simpelthen betyder, at gaussianerne er afgrænset af det område, vi angiver i vores hyperparameterkonfiguration i stedet for at strække sig til +/- uendeligt .

2.2.4 — Bestemmelse af det næste punkt at udforske!

Lad os bringe disse stykker sammen. Indtil videre har vi 1) opnået objektive funktionsobservationer, 2) defineret vores "lovende"-formel og 3) skabt et sandsynlighedstæthedsestimat via blandingsmodeller baseret på tidligere værdier. Vi har alle brikkerne til at vurdere et givet punkt!

Vores første skridt er at skabe en gennemsnitlig sandsynlighedsdensitetsfunktion (PDF) for begge g(x) , l(x).

Et eksempel på en proces er vist i figur 11 — den røde linje er vores gennemsnitlige PDF og er simpelthen summen af ​​alle PDF'er divideret med antallet af PDF'er.

Ved at bruge den gennemsnitlige PDF kan vi få sandsynligheden for enhver hyperparameterværdi (x) at være med g(x) or l(x).

Lad os f.eks. sige, at de observerede værdier i figur 11 tilhører det "gode" sæt, g(x). Baseret på vores gennemsnitlige PDF er det usandsynligt, at en hyperparameterværdi på 3.9 eller 0.05 hører til det "gode" sæt. Omvendt ser det ud til, at en hyperparameterværdi på ~1.2 med stor sandsynlighed hører til det "gode" sæt.

Nu er dette kun den ene halvdel af billedet. Vi anvender den samme metode for det "dårlige" sæt, l(x). Da vi søger at maksimere g(x) / l(x), lovende punkter skal placeres hvor g(x) er høj og l(x) er lav.

Ganske cool, ikke?

Med disse sandsynlighedsfordelinger kan vi sample fra vores træstrukturerede hyperparametre og finde det sæt af hyperparametre, der maksimerer "lovende" og derved er værd at udforske.

Piratperspektiv: det næste sted, vi graver, er det sted, der maksimerer (sandsynligheden for at have masser af skatte) / (sandsynligheden for at have en lille skat).

Nu hvor du ved, hvordan det virker, er her nogle praktiske tips til implementering af TPE via open source-pakken, HyperOpt.

3.1 — Struktur af en HyperOpt-app

Generelt er der tre hovedtrin, når man bruger HyperOpt...

1. Definer søgeområdet, som kun er intervallerne og funktionelle former for de hyperparametre, du ønsker at optimere.
2. Definer tilpasningsfunktionen, som kalder din model.fit() funktion på en given tog/test split.
3. Definer den objektive funktion, som er en af ​​de klassiske nøjagtighedsmålinger, såsom RMSE eller AUC.

Desværre kræver disse automatiserede tuning-metoder stadig designinput fra dataforskeren - det er ikke en helt gratis frokost. Men anekdotisk er TPE ret robust over for hyperparameterfejlspecifikation (inden for rimelighedens grænser).

3.2— Tips og tricks

• HyperOpt kan paralleliseres via begge Apache Spark , MongoDB. Hvis du arbejder med flere kerner, hvad enten det er i skyen eller på din lokale maskine, kan dette reducere kørselstiden dramatisk.
• Hvis du paralleliserer tuning-processen via Apache Spark, skal du bruge en SparkTrialsobjekt for single node ML-modeller (sklearn) og en Trails objekt til paralleliserede ML-modeller (MLlib). Koden er nedenfor.
• MLflow er en open source-metode til at spore dine modelkørsler. Det integreres nemt med HyperOpt.
• Indsnævr ikke søgeområdet for tidligt. Nogle kombinationer af hyperparametre kan være overraskende effektive.
• Det kan være vanskeligt at definere søgeområdet, især hvis du ikke kender det funktionel form af dine hyperparametre. Men fra personlig erfaring er TPE ret robust over for fejlspecifikationer af disse funktionelle former.
• At vælge en god objektiv funktion rækker langt. I de fleste tilfælde er fejl ikke skabt lige. Hvis en bestemt type fejl er mere problematisk, skal du sørge for at indbygge den logik i din funktion.

3.3— Et kodeeksempel

Her er noget kode til at køre HyperOpt på en distribueret måde. Det blev tilpasset fra koden i bogen, Machine Learning Engineering i aktion - her er git repo.

Nogle gode funktioner i dette uddrag inkluderer parallelisering via Apache Spark og modellogning via MLflow. Bemærk også, at dette uddrag optimerer en sklearn RandomForestRegressor - du bliver nødt til at ændre modellen og tilpasningsfunktionen, så den passer til dine behov.

Og der har du det - HyperOpt i al sin herlighed!

For at hamre håb om de vigtigste punkter, lad os hurtigt opsummere.

Hyperparameterjustering er en nødvendig del af ML-modellens livscyklus, men er tidskrævende. Sequential Model-Based Optimization (SMBO) algoritmer udmærker sig ved at søge i komplekse hyperrum efter optimum, og de kan anvendes til justering af hyperparameter. Træbaserede Parzen Estimators (TPE) er en meget effektiv SMBO og overgår både Bayesian Optimization og Random Search.

TPE gentager nedenstående trin indtil et stopkriterie:

1. Opdel observerede punkter i "gode" og "dårlige" sæt, ifølge nogle hyperparameter, gamma.
2. Tilpas en blandingsmodel til både det "gode" og "dårlige" sæt for at udvikle et gennemsnitlig sandsynlighedstæthedsestimat.
3. Vælg det punkt, der optimerer "lovende"-scoren, som udnytter trin 2 til at estimere sandsynligheden for at være i "gode" og "dårlige" sæt.

Endelig har vi et rigtig fedt kodestykke, der viser, hvordan man paralleliserer HyperOpt via SparkTrials. Det logger også alle vores iterationer til MLflow.

HyperOpt Demystified Genudgivet fra kilde https://towardsdatascience.com/hyperopt-demystified-3e14006eb6fa?source=rss—-7f60cf5620c9—4 via https://towardsdatascience.com/feed

<!–

->