Optimaliser hyperparametre med Amazon SageMaker Automatic Model Tuning

Maskinlæringsmodeller (ML) tar verden med storm. Ytelsen deres er avhengig av å bruke de riktige treningsdataene og velge riktig modell og algoritme. Men det slutter ikke her. Vanligvis utsetter algoritmer noen designbeslutninger til ML-utøveren for å ta i bruk for deres spesifikke data og oppgave. Disse utsatte designbeslutningene manifesterer seg som hyperparametere.

Hva betyr det navnet? Resultatet av ML-trening, modellen, kan i stor grad sees på som en samling parametere som læres under trening. Derfor kalles parameterne som brukes til å konfigurere ML-treningsprosessen hyperparametere – parametere som beskriver opprettelsen av parametere. I alle fall er de av veldig praktisk nytte, for eksempel antall epoker å trene, læringshastigheten, maksimal dybde til et beslutningstre, og så videre. Og vi legger stor vekt på dem fordi de har stor innvirkning på den ultimate ytelsen til modellen din.

Akkurat som å vri på en knott på en radiomottaker for å finne riktig frekvens, bør hver hyperparameter justeres nøye for å optimalisere ytelsen. Å søke i hyperparameterrommet etter de optimale verdiene kalles hyperparameterinnstilling or optimalisering av hyperparameter (HPO), og bør resultere i en modell som gir nøyaktige spådommer.

I dette innlegget setter vi opp og kjører vår første HPO-jobb ved hjelp av Amazon SageMaker Automatisk modellinnstilling (AMT). Vi lærer om tilgjengelige metoder for å utforske resultatene, og skaper noen innsiktsfulle visualiseringer av våre HPO-forsøk og utforskningen av hyperparameterrommet!

Amazon SageMaker Automatisk modellinnstilling

Som ML-utøver ved hjelp av SageMaker AMT, kan du fokusere på følgende:

• Gi en treningsjobb
• Definere riktig målberegning som samsvarer med oppgaven din
• Omfang av hyperparametersøkeområdet

SageMaker AMT tar seg av resten, og du trenger ikke tenke på infrastrukturen, orkestrere treningsjobber og forbedre hyperparametervalg.

La oss starte med å bruke SageMaker AMT for vår første enkle HPO-jobb, for å trene og justere en XGBoost-algoritme. Vi ønsker at din AMT-reise skal være praktisk og praktisk, så vi har delt eksempelet nedenfor GitHub repository. Dette innlegget dekker 1_tuning_of_builtin_xgboost.ipynb notisbok.

I et kommende innlegg vil vi utvide forestillingen om å bare finne de beste hyperparametrene og inkludere å lære om søkeområdet og hvilke hyperparameterområder en modell er sensitiv. Vi vil også vise hvordan du kan gjøre en engangsinnstillingsaktivitet til en flertrinnssamtale med ML-utøveren, for å lære sammen. Følg med (pun intended)!

Forutsetninger

Dette innlegget er for alle som er interessert i å lære om HPO og krever ikke forkunnskaper om emnet. Grunnleggende kjennskap til ML-konsepter og Python-programmering er imidlertid nyttig. For den beste læringsopplevelsen anbefaler vi på det sterkeste å følge med kjører hvert trinn i notatboken parallelt med å lese dette innlegget. Og på slutten av notatboken får du også prøve ut en interaktiv visualisering som gjør tuning-resultatene levende.

Løsningsoversikt

Vi skal bygge et ende-til-ende-oppsett for å kjøre vår første HPO-jobb ved å bruke SageMaker AMT. Når tuningjobben vår er fullført, ser vi på noen av metodene som er tilgjengelige for å utforske resultatene, både via AWS-administrasjonskonsoll og programmatisk via AWS SDK-er og API-er.

Først gjør vi oss kjent med miljøet og SageMaker Training ved å kjøre en frittstående treningsjobb, uten noen tuning foreløpig. Vi bruker XGBoost-algoritmen, en av mange algoritmer som leveres som en SageMaker innebygd algoritme (ingen opplæringsskript kreves!).

Vi ser hvordan SageMaker Training fungerer på følgende måter:

• Starter og stopper en forekomst
• Forsyner nødvendig container
• Kopierer opplærings- og valideringsdataene til forekomsten
• Driver treningen
• Samler inn beregninger og logger
• Samler og lagrer den trente modellen

Deretter flytter vi til AMT og kjører en HPO-jobb:

• Vi setter opp og lanserer tuningjobben vår med AMT
• Vi dykker ned i metodene som er tilgjengelige for å trekke ut detaljerte ytelsesmålinger og metadata for hver treningsjobb, noe som gjør oss i stand til å lære mer om de optimale verdiene i hyperparameterområdet vårt
• Vi viser deg hvordan du kan se resultatene av forsøkene
• Vi gir deg verktøy for å visualisere data i en serie diagrammer som avslører verdifull innsikt i hyperparameterområdet vårt

Tren en SageMaker innebygd XGBoost-algoritme

Det hele starter med å trene en modell. Ved å gjøre det får vi en følelse av hvordan SageMaker Training fungerer.

Vi ønsker å dra nytte av hastigheten og brukervennligheten som tilbys av SageMaker innebygde algoritmer. Alt vi trenger er noen få trinn for å komme i gang med trening:

1. Forbered og last inn dataene – Vi laster ned og klargjør datasettet vårt som input for XGBoost og laster det opp til vårt Amazon enkel lagringstjeneste (Amazon S3) bøtte.
2. Velg vår innebygde algoritmes bilde-URI – SageMaker bruker denne URIen til å hente treningsbeholderen vår, som i vårt tilfelle inneholder et klar-til-gå XGBoost-treningsskript. Flere algoritmeversjoner støttes.
3. Definer hyperparametrene – SageMaker gir et grensesnitt for å definere hyperparametere for vår innebygde algoritme. Dette er de samme hyperparametrene som brukes av åpen kildekode-versjonen.
4. Konstruer estimatoren – Vi definerer treningsparametere som instanstype og antall instanser.
5. Kall funksjonen fit(). – Vi starter treningsjobben.

Følgende diagram viser hvordan disse trinnene fungerer sammen.

Oppgi dataene

For å drive ML-trening må vi levere data. Vi gir våre opplærings- og valideringsdata til SageMaker via Amazon S3.

I vårt eksempel bruker vi for enkelhets skyld SageMaker standard bøtte for å lagre dataene våre. Men du kan gjerne tilpasse følgende verdier til dine preferanser:

sm_sess = sagemaker.session.Session([..])

BUCKET = sm_sess.default_bucket()
PREFIX = 'amt-visualize-demo'
output_path = f's3://{BUCKET}/{PREFIX}/output'

I notatboken bruker vi et offentlig datasett og lagrer dataene lokalt i data katalog. Vi laster deretter opp opplærings- og valideringsdataene våre til Amazon S3. Senere definerer vi også pekere til disse stedene for å sende dem til SageMaker Training.

# acquire and prepare the data (not shown here)
# store the data locally
[..]
train_data.to_csv('data/train.csv', index=False, header=False)
valid_data.to_csv('data/valid.csv', index=False, header=False)
[..]
# upload the local files to S3
boto_sess.resource('s3').Bucket(BUCKET).Object(os.path.join(PREFIX, 'data/train/train.csv')).upload_file('data/train.csv')
boto_sess.resource('s3').Bucket(BUCKET).Object(os.path.join(PREFIX, 'data/valid/valid.csv')).upload_file('data/valid.csv')

I dette innlegget konsentrerer vi oss om å introdusere HPO. Til illustrasjon bruker vi et spesifikt datasett og oppgave, slik at vi kan få målinger av objektive metrikker som vi deretter bruker for å optimalisere utvalget av hyperparametre. For det overordnede innlegget betyr imidlertid verken dataene eller oppgaven. For å gi deg et fullstendig bilde, la oss kort beskrive hva vi gjør: vi trener en XGBoost-modell som skal klassifisere håndskrevne sifre fra
Optisk gjenkjenning av datasett med håndskrevne sifre [1] via Scikit-learn. XGBoost er en utmerket algoritme for strukturerte data og kan til og med brukes på Digits-datasettet. Verdiene er 8×8 bilder, som i følgende eksempel som viser en
0 a
5 og en
4.

Velg XGBoost-bilde-URI

Etter å ha valgt vår innebygde algoritme (XGBoost), må vi hente bilde-URI og sende denne til SageMaker for å laste inn i treningsinstansen vår. For dette trinnet vurderer vi tilgjengelige versjoner. Her har vi bestemt oss for å bruke versjon 1.5.1, som tilbyr den nyeste versjonen av algoritmen. Avhengig av oppgaven kan ML-utøvere skrive sitt eget treningsskript som for eksempel inkluderer dataforberedelsestrinn. Men dette er ikke nødvendig i vårt tilfelle.

Hvis du vil skrive ditt eget treningsmanus, så følg med, vi har dekket deg i vårt neste innlegg! Vi viser deg hvordan du kjører SageMaker Training-jobber med dine egne tilpassede opplæringsskript.

For nå trenger vi riktig bilde-URI ved å spesifisere algoritmen, AWS-regionen og versjonsnummeret:

xgboost_container = sagemaker.image_uris.retrieve('xgboost', region, '1.5-1')

Det er det. Nå har vi en referanse til XGBoost-algoritmen.

Definer hyperparametrene

Nå definerer vi hyperparametrene våre. Disse verdiene konfigurerer hvordan modellen vår skal trenes opp, og påvirker til slutt hvordan modellen presterer mot den objektive metrikken vi måler mot, for eksempel nøyaktighet i vårt tilfelle. Merk at ingenting om den følgende kodeblokken er spesifikt for SageMaker. Vi bruker faktisk åpen kildekode-versjon av XGBoost, nettopp levert av og optimalisert for SageMaker.

Selv om hver av disse hyperparametrene er konfigurerbare og justerbare, er den objektive metrikken multi:softmax bestemmes av datasettet vårt og typen problem vi løser for. I vårt tilfelle inneholder Digits-datasettet flere etiketter (en observasjon av et håndskrevet siffer kan være 0 or 1,2,3,4,5,6,7,8,9), som betyr at det er et klassifiseringsproblem i flere klasser.

hyperparameters = {
    'num_class': 10,
    'max_depth': 5,
    'eta':0.2,
    'alpha': 0.2,
    'objective':'multi:softmax',
    'eval_metric':'accuracy',
    'num_round':200,
    'early_stopping_rounds': 5
}

For mer informasjon om de andre hyperparametrene, se XGBoost hyperparametere.

Konstruer estimatoren

Vi konfigurerer opplæringen på et estimatorobjekt, som er et høynivågrensesnitt for SageMaker Training.

Deretter definerer vi antall forekomster som skal trenes på, forekomsttypen (CPU-basert eller GPU-basert), og størrelsen på den vedlagte lagringen:

estimator = sagemaker.estimator.Estimator(
    image_uri=xgboost_container, 
    hyperparameters=hyperparameters,
    role=role,
    instance_count=1, 
    instance_type='ml.m5.large', 
    volume_size=5, # 5 GB 
    output_path=output_path
)

Vi har nå infrastrukturkonfigurasjonen vi trenger for å komme i gang. SageMaker Training tar seg av resten.

Kall funksjonen fit().

Husker du dataene vi lastet opp til Amazon S3 tidligere? Nå lager vi referanser til det:

s3_input_train = TrainingInput(s3_data=f's3://{BUCKET}/{PREFIX}/data/train', content_type='csv')
s3_input_valid = TrainingInput(s3_data=f's3://{BUCKET}/{PREFIX}/data/valid', content_type='csv')

En samtale til fit() lanserer opplæringen vår. Vi sender inn referansene til treningsdataene vi nettopp opprettet for å peke SageMaker Training til trenings- og valideringsdataene våre:

estimator.fit({'train': s3_input_train, 'validation': s3_input_valid})

Merk at for å kjøre HPO senere, trenger vi faktisk ikke å ringe fit() her. Vi trenger bare estimatorobjektet senere for HPO, og kan bare hoppe til å lage HPO-jobben vår. Men fordi vi ønsker å lære om SageMaker Training og se hvordan vi kjører en enkelt treningsjobb, kaller vi det her og gjennomgår resultatet.

Etter at treningen starter, begynner vi å se utdataene under cellene, som vist i følgende skjermbilde. Utgangen er tilgjengelig i Amazon CloudWatch så vel som i denne notatboken.

Den svarte teksten er loggutgang fra selve SageMaker, og viser trinnene som er involvert i treningsorkestrering, for eksempel å starte instansen og laste inn treningsbildet. Den blå teksten skrives ut direkte fra selve treningsforekomsten. Vi kan observere prosessen med å laste og analysere treningsdataene, og visuelt se treningsfremgangen og forbedringen i den objektive metrikken direkte fra treningsskriptet som kjører på instansen.

Merk også at på slutten av utgangsjobben vises opplæringsvarigheten i sekunder og fakturerbare sekunder.

Til slutt ser vi at SageMaker laster opp treningsmodellen vår til S3-utgangsbanen som er definert på estimatorobjektet. Modellen er klar til å bli distribuert for slutning.

I et fremtidig innlegg vil vi lage vår egen treningsbeholder og definere treningsberegningene våre som skal sendes ut. Du vil se hvordan SageMaker er agnostisk for hvilken beholder du passerer den for trening. Dette er veldig nyttig når du vil komme raskt i gang med en innebygd algoritme, men senere bestemmer deg for å sende ditt eget tilpassede treningsskript!

Inspiser nåværende og tidligere opplæringsjobber

Så langt har vi jobbet fra notatboken vår med koden vår og sendt inn opplæringsjobber til SageMaker. La oss bytte perspektiv og la den bærbare PC-en et øyeblikk for å sjekke ut hvordan dette ser ut på SageMaker-konsollen.

SageMaker fører en historisk oversikt over treningsjobber den kjørte, deres konfigurasjoner som hyperparametre, algoritmer, datainndata, fakturerbar tid og resultatene. I listen i det foregående skjermbildet ser du de siste treningsjobbene filtrert for XGBoost. Den uthevede treningsjobben er jobben vi nettopp trente i notatboken, hvis utgang du så tidligere. La oss dykke ned i denne individuelle treningsjobben for å få mer informasjon.

Følgende skjermbilde viser konsollvisningen av treningsjobben vår.

Vi kan se gjennom informasjonen vi mottok som celleutgang til vår fit() funksjon i den individuelle treningsjobben i SageMaker-konsollen, sammen med parameterne og metadataene vi definerte i vår estimator.

Husk loggutgangen fra treningsforekomsten vi så tidligere. Vi kan få tilgang til loggene for treningsjobben vår her også, ved å bla til Overvåke seksjon og valg Se logger.

Dette viser oss forekomstloggene inne i CloudWatch.

Husk også hyperparametrene vi spesifiserte i notatboken for treningsjobben. Vi ser dem her i samme brukergrensesnitt til treningsjobben også.

Faktisk kan detaljene og metadataene vi spesifiserte tidligere for vår treningsjobb og estimator finnes på denne siden på SageMaker-konsollen. Vi har en nyttig oversikt over innstillingene som ble brukt for opplæringen, for eksempel hvilken treningsbeholder som ble brukt og plasseringen av opplærings- og valideringsdatasettene.

Du spør kanskje på dette tidspunktet, hvorfor akkurat dette er relevant for hyperparameteroptimalisering? Det er fordi du kan søke, inspisere og dykke dypere inn i de HPO-forsøkene vi er interessert i. Kanskje de med de beste resultatene, eller de som viser interessant oppførsel. Vi overlater til deg det du definerer som "interessant". Det gir oss et felles grensesnitt for å inspisere treningsjobbene våre, og du kan bruke det med SageMaker Search.

Selv om SageMaker AMT orkestrerer HPO-jobbene, lanseres alle HPO-prøvene som individuelle SageMaker Training-jobber og kan nås som sådan.

Med trening dekket, la oss få tuning!

Tren og still inn en SageMaker innebygd XGBoost-algoritme

For å finjustere XGBoost-modellen vår, skal vi gjenbruke våre eksisterende hyperparametre og definere verdiområder vi ønsker å utforske for dem. Tenk på dette som å utvide grensene for utforskning innenfor vårt hyperparametersøkerom. Vår tuning-jobb vil prøve fra søkeområdet og kjøre treningsjobber for nye kombinasjoner av verdier. Følgende kode viser hvordan du spesifiserer hyperparameterområdene som SageMaker AMT skal prøve fra:

from sagemaker.tuner import IntegerParameter, ContinuousParameter, HyperparameterTuner

hpt_ranges = {
    'alpha': ContinuousParameter(0.01, .5),
    'eta': ContinuousParameter(0.1, .5),
    'min_child_weight': ContinuousParameter(0., 2.),
    'max_depth': IntegerParameter(1, 10)
}

Områdene for en individuell hyperparameter er spesifisert etter deres type, som Kontinuerlig parameter. For mer informasjon og tips om valg av disse parameterområdene, se Still inn en XGBoost-modell.

Vi har ikke kjørt noen eksperimenter ennå, så vi vet ikke rekkevidden av gode verdier for hyperparametrene våre. Derfor starter vi med en utdannet gjetning, ved å bruke vår kunnskap om algoritmer og vår dokumentasjon av hyperparametrene for de innebygde algoritmene. Dette definerer et utgangspunkt for å definere søkeområdet.

Deretter kjører vi en innstillingsjobbsampling fra hyperparametere i de definerte områdene. Som et resultat kan vi se hvilke hyperparameterområder som gir gode resultater. Med denne kunnskapen kan vi avgrense søkeområdets grenser ved å begrense eller utvide hvilke hyperparameterområder som skal brukes. Vi viser hvordan man kan lære av forsøkene i neste og siste del, hvor vi undersøker og visualiserer resultatene.

I vårt neste innlegg fortsetter vi reisen og dykker dypere. I tillegg vil vi lære at det er flere strategier vi kan bruke for å utforske søkeområdet vårt. Vi kjører påfølgende HPO-jobber for å finne enda flere ytelsesverdier for hyperparametrene våre, mens vi sammenligner disse forskjellige strategiene. Vi vil også se hvordan du får en varm start med SageMaker AMT for å bruke kunnskapen vi har fått fra tidligere utforskede søkerom i vår utforskning utover de opprinnelige grensene.

For dette innlegget fokuserer vi på hvordan du analyserer og visualiserer resultatene av en enkelt HPO-jobb ved å bruke den Bayesianske søkestrategien, som sannsynligvis vil være et godt utgangspunkt.

Hvis du følger med i den tilknyttede notatboken, legg merke til at vi passerer den samme estimatoren som vi brukte for vår enkle, innebygde XGBoost-treningsjobb. Dette estimatorobjektet fungerer som en mal for nye opplæringsjobber som AMT oppretter. AMT vil da variere hyperparametrene innenfor områdene vi definerte.

Ved å spesifisere at vi ønsker å maksimere vår objektive beregning, validation:accuracy, ber vi SageMaker AMT om å se etter disse beregningene i treningsforekomstloggene og velge hyperparameterverdier som den tror vil maksimere nøyaktighetsberegningen på valideringsdataene våre. Vi valgte en passende objektiv beregning for XGBoost fra vår dokumentasjon.

I tillegg kan vi dra nytte av parallellisering med max_parallel_jobs. Dette kan være et kraftig verktøy, spesielt for strategier hvis forsøk velges uavhengig, uten å vurdere (lære av) resultatene fra tidligere forsøk. Vi vil utforske disse andre strategiene og parameterne videre i vårt neste innlegg. For dette innlegget bruker vi Bayesian, som er en utmerket standardstrategi.

Vi definerer også max_jobs for å definere hvor mange forsøk som skal kjøres totalt. Avvik gjerne fra vårt eksempel og bruk et mindre antall for å spare penger.

n_jobs = 50
n_parallel_jobs = 3

tuner_parameters = {
    'estimator': estimator, # The same estimator object we defined above
    'base_tuning_job_name': 'bayesian',
    'objective_metric_name': 'validation:accuracy',
    'objective_type': 'Maximize',
    'hyperparameter_ranges': hpt_ranges,
    'strategy': 'Bayesian',
    'max_jobs': n_jobs,
    'max_parallel_jobs': n_parallel_jobs
}

Vi ringer nok en gang fit(), på samme måte som da vi lanserte en enkelt treningsjobb tidligere i innlegget. Men denne gangen på tunerobjektet, ikke estimatorobjektet. Dette setter i gang tuningjobben, og i sin tur starter AMT treningsjobber.

tuner = HyperparameterTuner(**tuner_parameters)
tuner.fit({'train': s3_input_train, 'validation': s3_input_valid}, wait=False)
tuner_name = tuner.describe()['HyperParameterTuningJobName']
print(f'tuning job submitted: {tuner_name}.')

Følgende diagram utvider vår tidligere arkitektur ved å inkludere HPO med SageMaker AMT.

Vi ser at HPO-jobben vår er sendt inn. Avhengig av antall forsøk, definert av n_jobs og nivået av parallellisering, kan dette ta litt tid. For vårt eksempel kan det ta opptil 30 minutter for 50 forsøk med bare et parallelliseringsnivå på 3.

tuning job submitted: bayesian-221102-2053.

Når denne innstillingsjobben er fullført, la oss utforske informasjonen som er tilgjengelig for oss på SageMaker-konsollen.

Undersøk AMT-jobber på konsollen

La oss finne tuningjobben vår på SageMaker-konsollen ved å velge Kurs i navigasjonsruten og deretter Hyperparameter tuning jobber. Dette gir oss en liste over våre AMT-jobber, som vist i følgende skjermbilde. Her finner vi vår bayesian-221102-2053 innstillingsjobben og se at den nå er fullført.

La oss se nærmere på resultatene av denne HPO-jobben.

Vi har utforsket å trekke ut resultatene programmatisk i bærbare. Først via SageMaker Python SDK, som er et høyere nivå åpen kildekode Python-bibliotek, som gir en dedikert API til SageMaker. Så gjennom Boto3, som gir oss API-er på lavere nivå til SageMaker og andre AWS-tjenester.

Ved å bruke SageMaker Python SDK kan vi få resultatene av HPO-jobben vår:

sagemaker.HyperparameterTuningJobAnalytics(tuner_name).dataframe()[:10]

Dette tillot oss å analysere resultatene av hver av våre forsøk i en Pandas DataFrame, som vist i følgende skjermbilde.

La oss nå bytte perspektiv igjen og se hvordan resultatene ser ut på SageMaker-konsollen. Deretter skal vi se på våre tilpassede visualiseringer.

På samme side velger du vår bayesian-221102-2053 tuning jobb gir oss en liste over prøver som ble kjørt for tuning jobben vår. Hver HPO-prøve her er en SageMaker Training-jobb. Husker tidligere da vi trente vår single XGBoost-modell og undersøkte treningsjobben i SageMaker-konsollen. Vi kan gjøre det samme for prøvelsene våre her.

Når vi undersøker prøvelsene våre, ser vi det bayesian-221102-2053-048-b59ec7b4 skapte modellen med best ytelse, med en valideringsnøyaktighet på omtrent 89.815 %. La oss utforske hvilke hyperparametre som førte til denne ytelsen ved å velge Beste treningsjobb fanen.

Vi kan se en detaljert oversikt over de beste hyperparametrene som er evaluert.

Vi kan umiddelbart se hvilke hyperparameterverdier som førte til denne overlegne ytelsen. Vi ønsker imidlertid å vite mer. Kan du gjette hva? Det ser vi alpha får en omtrentlig verdi på 0.052456, og på samme måte, eta er satt til 0.433495. Dette forteller oss at disse verdiene fungerte bra, men det forteller oss lite om selve hyperparameterrommet. For eksempel kan vi lure på om 0.433495 for eta var den høyeste verdien som ble testet, eller om det er rom for vekst og modellforbedring ved å velge høyere verdier.

For det må vi zoome ut og ta et mye bredere syn for å se hvordan andre verdier for hyperparametrene våre presterte. En måte å se på mye data på en gang er å plotte hyperparameterverdiene våre fra HPO-forsøkene våre på et diagram. På den måten ser vi hvordan disse verdiene presterte relativt. I neste seksjon henter vi disse dataene fra SageMaker og visualiserer dem.

Visualiser prøvelsene våre

SageMaker SDK gir oss dataene for utforskningen vår, og notatbøkene gir deg et innblikk i det. Men det er mange måter å utnytte og visualisere det på. I dette innlegget deler vi et eksempel ved å bruke Altair statistisk visualiseringsbibliotek, som vi bruker til å produsere en mer visuell oversikt over forsøkene våre. Disse finnes i amtviz pakken, som vi leverer som en del av prøven:

from amtviz import visualize_tuning_job
visualize_tuning_job(tuner, trials_only=True)

Kraften til disse visualiseringene blir umiddelbart tydelig når du plotter våre forsøks valideringsnøyaktighet (y-aksen) over tid (x-aksen). Følgende diagram til venstre viser valideringsnøyaktighet over tid. Vi kan tydelig se at modellens ytelse forbedres etter hvert som vi kjører flere forsøk over tid. Dette er et direkte og forventet resultat av å drive HPO med en Bayesiansk strategi. I vårt neste innlegg ser vi hvordan dette sammenlignes med andre strategier og observerer at dette ikke trenger å være tilfelle for alle strategier.

Etter å ha gjennomgått den generelle fremgangen over tid, la oss nå se på hyperparameterrommet vårt.

Følgende diagrammer viser valideringsnøyaktighet på y-aksen, med hvert diagram som vises max_depth, alpha, etaog min_child_weight på x-aksen, henholdsvis. Vi har plottet hele HPO-jobben vår i hvert diagram. Hvert punkt er en enkelt prøveversjon, og hvert diagram inneholder alle 50 forsøk, men atskilt for hver hyperparameter. Dette betyr at prøveversjonen vår med best ytelse, #48, er representert med nøyaktig én blå prikk i hvert av disse diagrammene (som vi har fremhevet for deg i følgende figur). Vi kan visuelt sammenligne ytelsen innenfor konteksten av alle andre 49 forsøk. Så la oss se nærmere.

Fascinerende! Vi ser umiddelbart hvilke områder av våre definerte områder i hyperparameterrommet vårt som er mest effektive! Tenker tilbake på vår eta verdi, er det klart nå at samplingsverdier nærmere 0 ga dårligere ytelse, mens å flytte nærmere grensen vår, 0.5, gir bedre resultater. Det motsatte ser ut til å være sant for alphaog max_depth ser ut til å ha et mer begrenset sett med foretrukne verdier. Ser på max_depth, kan du også se hvordan bruk av en Bayesiansk strategi instruerer SageMaker AMT til å prøve oftere verdier den lærte fungerte bra tidligere.

Ser på vår eta verdi, kan vi lure på om det er verdt å utforske mer til høyre, kanskje utover 0.45? Fortsetter det å spore av til lavere nøyaktighet, eller trenger vi mer data her? Denne undringen er en del av hensikten med å drive vår første HPO-jobb. Det gir oss innsikt i hvilke områder av hyperparameterrommet vi bør utforske videre.

Hvis du er interessert i å vite mer, og er like spent som vi er etter denne introduksjonen til emnet, så følg med på vårt neste innlegg, hvor vi snakker mer om de forskjellige HPO-strategiene, sammenligner dem med hverandre, og øv på trening med vårt eget Python-skript.

Rydd opp

For å unngå å pådra deg uønskede kostnader når du er ferdig med å eksperimentere med HPO, må du fjerne alle filene i S3-bøtten din med prefikset amt-visualize-demo og også slå av Studio-ressurser.

Kjør følgende kode i notatboken for å fjerne alle S3-filer fra dette innlegget.

!aws s3 rm s3://{BUCKET}/amt-visualize-demo --recursive

Hvis du ønsker å beholde datasettene eller modellartefaktene, kan du endre prefikset i koden til amt-visualize-demo/data å bare slette dataene eller amt-visualize-demo/output å bare slette modellartefakter.

konklusjonen

I dette innlegget har vi trent og tunet en modell ved hjelp av SageMaker innebygde versjon av XGBoost-algoritmen. Ved å bruke HPO med SageMaker AMT, lærte vi om hyperparametrene som fungerer godt for denne spesielle algoritmen og datasettet.

Vi så flere måter å vurdere resultatene av vår hyperparameterinnstillingsjobb på. Vi startet med å trekke ut hyperparametrene til den beste prøven, og vi lærte også hvordan vi kan få en dypere forståelse av hvordan forsøkene våre har utviklet seg over tid og hvilke hyperparameterverdier som har effekt.

Ved å bruke SageMaker-konsollen så vi også hvordan vi kan dykke dypere inn i individuelle treningsløp og gjennomgå loggene deres.

Vi zoomet deretter ut for å se alle forsøkene våre sammen, og vurdere ytelsen deres i forhold til andre forsøk og hyperparametre.

Vi lærte at basert på observasjonene fra hvert forsøk, var vi i stand til å navigere i hyperparameterrommet for å se at små endringer i hyperparameterverdiene våre kan ha stor innvirkning på modellytelsen vår. Med SageMaker AMT kan vi kjøre hyperparameteroptimalisering for å finne gode hyperparameterverdier effektivt og maksimere modellytelsen.

I fremtiden vil vi se nærmere på ulike HPO-strategier som tilbys av SageMaker AMT og hvordan du bruker vår egen tilpassede opplæringskode. Gi oss beskjed i kommentarfeltet hvis du har et spørsmål eller ønsker å foreslå et område som vi bør dekke i kommende innlegg.

Inntil da ønsker vi deg og modellene dine god læring og tuning!

Referanser

sitater:

[1] Dua, D. og Graff, C. (2019). UCI Machine Learning Repository [http://archive.ics.uci.edu/ml]. Irvine, CA: University of California, School of Information and Computer Science.

Om forfatterne

Andrew Ellul er en løsningsarkitekt med Amazon Web Services. Han jobber med små og mellomstore bedrifter i Tyskland. Utenom jobben liker Andrew å utforske naturen til fots eller på sykkel.

Elina Lesyk er en løsningsarkitekt lokalisert i München. Hennes fokus er på bedriftskunder fra finansnæringen. På fritiden liker Elina å lære gitarteori på spansk for å krysslære og gå på løpetur.

Mariano Kamp er en hovedløsningsarkitekt med Amazon Web Services. Han jobber med finanskunder i Tyskland om maskinlæring. På fritiden liker Mariano å gå tur med kona.