Optimer hyperparametre med Amazon SageMaker Automatic Model Tuning

Maskinlæringsmodeller (ML) tager verden med storm. Deres præstation er afhængig af at bruge de rigtige træningsdata og vælge den rigtige model og algoritme. Men det slutter ikke her. Typisk udsætter algoritmer nogle designbeslutninger til ML-praktikeren, så de kan vedtage til deres specifikke data og opgave. Disse udskudte designbeslutninger manifesterer sig som hyperparametre.

Hvad betyder det navn? Resultatet af ML-træning, modellen, kan i høj grad ses som en samling af parametre, der læres under træningen. Derfor kaldes de parametre, der bruges til at konfigurere ML-træningsprocessen, hyperparametre – parametre, der beskriver oprettelsen af ​​parametre. I hvert fald er de af meget praktisk nytte, såsom antallet af epoker, der skal trænes, indlæringshastigheden, den maksimale dybde af et beslutningstræ, og så videre. Og vi er meget opmærksomme på dem, fordi de har stor indflydelse på din models ultimative ydeevne.

Ligesom at dreje på en knap på en radiomodtager for at finde den rigtige frekvens, bør hver hyperparameter indstilles omhyggeligt for at optimere ydeevnen. At søge i hyperparameterrummet efter de optimale værdier kaldes justering af hyperparameter or hyperparameter optimering (HPO), og bør resultere i en model, der giver præcise forudsigelser.

I dette indlæg opsætter og kører vi vores første HPO-job ved hjælp af Amazon SageMaker Automatisk Model Tuning (AMT). Vi lærer om de tilgængelige metoder til at udforske resultaterne og skaber nogle indsigtsfulde visualiseringer af vores HPO-forsøg og udforskningen af ​​hyperparameterrummet!

Amazon SageMaker Automatisk Model Tuning

Som ML-praktiserende bruger SageMaker AMT, kan du fokusere på følgende:

• Udbyde et træningsjob
• Definition af den rigtige objektive metrik, der matcher din opgave
• Omfang af hyperparametersøgerummet

SageMaker AMT tager sig af resten, og du behøver ikke tænke på infrastrukturen, orkestrere træningsjob og forbedre hyperparametervalg.

Lad os starte med at bruge SageMaker AMT til vores første simple HPO-job, til at træne og tune en XGBoost-algoritme. Vi ønsker, at din AMT-rejse skal være praktisk og praktisk, så vi har delt eksemplet i det følgende GitHub repository. Dette indlæg dækker 1_tuning_of_builtin_xgboost.ipynb notesbog.

I et kommende indlæg vil vi udvide idéen om blot at finde de bedste hyperparametre og inkludere at lære om søgeområdet og til hvilke hyperparameterområder en model er følsom. Vi viser også, hvordan man kan omdanne en one-shot tuning-aktivitet til en flertrinssamtale med ML-praktikeren for at lære sammen. Stay tuned (pun intended)!

Forudsætninger

Dette indlæg er for alle, der er interesseret i at lære om HPO og kræver ikke forudgående viden om emnet. Grundlæggende kendskab til ML-koncepter og Python-programmering er dog nyttig. For den bedste læringsoplevelse anbefaler vi stærkt at følge med kører hvert trin i notesbogen sideløbende med at læse dette indlæg. Og i slutningen af ​​notesbogen får du også prøvet en interaktiv visualisering, der gør tuning-resultaterne levende.

Løsningsoversigt

Vi vil bygge en ende-til-ende-opsætning til at køre vores første HPO-job ved hjælp af SageMaker AMT. Når vores tuning-job er afsluttet, ser vi på nogle af de tilgængelige metoder til at udforske resultaterne, både via AWS Management Console og programmatisk via AWS SDK'er og API'er.

For det første gør vi os bekendt med miljøet og SageMaker Training ved at køre et selvstændigt træningsjob, uden nogen tuning for nu. Vi bruger XGBoost-algoritmen, en af ​​mange algoritmer, der leveres som en SageMaker indbygget algoritme (intet træningsscript påkrævet!).

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

• Starter og stopper en instans
• Forsyner den nødvendige beholder
• Kopierer trænings- og valideringsdataene til instansen
• Afvikler træningen
• Indsamler metrics og logfiler
• Samler og opbevarer den trænede model

Så flytter vi til AMT og kører et HPO-job:

• Vi opretter og lancerer vores tuningjob med AMT
• Vi dykker ned i de tilgængelige metoder til at udtrække detaljerede præstationsmålinger og metadata for hvert træningsjob, hvilket gør os i stand til at lære mere om de optimale værdier i vores hyperparameterrum
• Vi viser dig, hvordan du kan se resultaterne af forsøgene
• Vi giver dig værktøjer til at visualisere data i en række diagrammer, der afslører værdifuld indsigt i vores hyperparameterrum

Træn en SageMaker indbygget XGBoost-algoritme

Det hele starter med at træne en model. På den måde får vi en fornemmelse af, hvordan SageMaker Training fungerer.

Vi ønsker at drage fordel af den hastighed og brugervenlighed, som SageMaker tilbyder indbyggede algoritmer. Alt, hvad vi behøver, er et par trin for at komme i gang med træning:

1. Forbered og indlæs dataene – Vi downloader og forbereder vores datasæt som input til XGBoost og uploader det til vores Amazon Simple Storage Service (Amazon S3) spand.
2. Vælg vores indbyggede algoritmes billed-URI – SageMaker bruger denne URI til at hente vores træningscontainer, som i vores tilfælde indeholder et klar til brug XGBoost træningsscript. Flere algoritmeversioner understøttes.
3. Definer hyperparametrene – SageMaker giver en grænseflade til at definere hyperparametre for vores indbyggede algoritme. Dette er de samme hyperparametre, som bruges af open source-versionen.
4. Konstruer estimatoren – Vi definerer træningsparametrene såsom instanstype og antal instanser.
5. Kald fit()-funktionen – Vi starter vores træningsjob.

Følgende diagram viser, hvordan disse trin fungerer sammen.

Giv dataene

For at køre ML-træning skal vi levere data. Vi leverer vores trænings- og valideringsdata til SageMaker via Amazon S3.

I vores eksempel bruger vi for nemheds skyld SageMaker-standardbøtten til at gemme vores data. Men du er velkommen til at tilpasse følgende værdier til dine præferencer:

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

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

I notesbogen bruger vi et offentligt datasæt og gemmer dataene lokalt i data vejviser. Vi uploader derefter vores trænings- og valideringsdata til Amazon S3. Senere definerer vi også pointere til disse steder for at videregive 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 indlæg koncentrerer vi os om at introducere HPO. Til illustration bruger vi et bestemt datasæt og opgave, så vi kan opnå målinger af objektive metrikker, som vi så bruger til at optimere udvælgelsen af ​​hyperparametre. For det overordnede indlæg betyder hverken data eller opgave dog noget. For at præsentere dig for et komplet billede, lad os kort beskrive, hvad vi gør: vi træner en XGBoost-model, der skal klassificere håndskrevne cifre fra
Optisk genkendelse af datasæt med håndskrevne cifre [1] via Scikit-learn. XGBoost er en fremragende algoritme til strukturerede data og kan endda anvendes på Digits-datasættet. Værdierne er 8×8 billeder, som i det følgende eksempel viser en
0 a
5 og en
4.

Vælg XGBoost-billed-URI

Efter at have valgt vores indbyggede algoritme (XGBoost), skal vi hente billed-URI'en og videregive denne til SageMaker for at indlæse på vores træningsinstans. Til dette trin gennemgår vi tilgængelige versioner. Her har vi besluttet at bruge version 1.5.1, som tilbyder den nyeste version af algoritmen. Afhængigt af opgaven kan ML-udøvere skrive deres eget træningsscript, der for eksempel inkluderer dataforberedelsestrin. Men det er ikke nødvendigt i vores tilfælde.

Hvis du vil skrive dit eget træningsmanuskript, så følg med, vi har dig dækket i vores næste indlæg! Vi viser dig, hvordan du kører SageMaker Training jobs med dine egne tilpassede træningsscripts.

Indtil videre har vi brug for den korrekte billed-URI ved at angive algoritmen, AWS-regionen og versionsnummeret:

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

Det er det. Nu har vi en reference til XGBoost-algoritmen.

Definer hyperparametrene

Nu definerer vi vores hyperparametre. Disse værdier konfigurerer, hvordan vores model vil blive trænet, og påvirker i sidste ende, hvordan modellen klarer sig i forhold til den objektive metrik, vi måler mod, såsom nøjagtighed i vores tilfælde. Bemærk, at intet ved den følgende kodeblok er specifikt for SageMaker. Vi bruger faktisk open source version af XGBoost, netop leveret af og optimeret til SageMaker.

Selvom hver af disse hyperparametre er konfigurerbare og justerbare, er den objektive metrik multi:softmax bestemmes af vores datasæt og den type problem, vi løser. I vores tilfælde indeholder Digits-datasættet flere etiketter (en observation af et håndskrevet ciffer kunne være 0 or 1,2,3,4,5,6,7,8,9), hvilket betyder, at det er et klassifikationsproblem med 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 mere information om de andre hyperparametre, se XGBoost Hyperparametre.

Konstruer estimatoren

Vi konfigurerer træningen på et estimatorobjekt, som er en grænseflade på højt niveau til SageMaker Training.

Dernæst definerer vi antallet af forekomster, der skal trænes på, forekomsttypen (CPU-baseret eller GPU-baseret) og størrelsen af ​​det vedhæftede lager:

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 nu den infrastrukturkonfiguration, vi skal bruge for at komme i gang. SageMaker Training tager sig af resten.

Kald fit()-funktionen

Kan du huske de data, vi uploadede til Amazon S3 tidligere? Nu opretter vi referencer 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')

Et opkald til fit() lancerer vores træning. Vi videregiver referencerne til de træningsdata, vi lige har oprettet for at pege SageMaker Training til vores trænings- og valideringsdata:

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

Bemærk, at for at køre HPO senere, behøver vi faktisk ikke at ringe fit() her. Vi har bare brug for estimatorobjektet senere til HPO, og kunne bare springe til at skabe vores HPO-job. Men fordi vi gerne vil lære om SageMaker Training og se, hvordan man kører et enkelt træningsjob, kalder vi det her og gennemgår outputtet.

Efter træningen starter, begynder vi at se output under cellerne, som vist på det følgende skærmbillede. Udgangen er tilgængelig i amazoncloudwatch samt i denne notesbog.

Den sorte tekst er log-output fra selve SageMaker, der viser de trin, der er involveret i træningsorkestrering, såsom at starte instansen og indlæse træningsbilledet. Den blå tekst udskrives direkte fra selve træningsinstansen. Vi kan observere processen med at indlæse og parse træningsdataene og visuelt se træningsfremskridtet og forbedringen i den objektive metrisk direkte fra træningsscriptet, der kører på instansen.

Bemærk også, at i slutningen af ​​outputjobbet vises træningsvarigheden i sekunder og fakturerbare sekunder.

Til sidst ser vi, at SageMaker uploader vores træningsmodel til S3-outputstien, der er defineret på estimatorobjektet. Modellen er klar til at blive implementeret til slutning.

I et fremtidigt indlæg opretter vi vores egen træningscontainer og definerer vores træningsmålinger, der skal udsendes. Du vil se, hvordan SageMaker er agnostisk over for, hvilken beholder du giver den til træning. Dette er meget praktisk, når du vil komme hurtigt i gang med en indbygget algoritme, men så senere beslutter dig for at videregive dit eget tilpassede træningsscript!

Undersøg nuværende og tidligere uddannelsesjob

Indtil videre har vi arbejdet ud fra vores notesbog med vores kode og indsendt træningsjob til SageMaker. Lad os skifte perspektiv og forlade notesbogen et øjeblik for at se, hvordan det ser ud på SageMaker-konsollen.

SageMaker gemmer en historisk registrering af træningsjob, den kørte, deres konfigurationer såsom hyperparametre, algoritmer, datainput, den fakturerbare tid og resultaterne. På listen i det foregående skærmbillede ser du de seneste træningsjob, der er filtreret efter XGBoost. Det fremhævede træningsjob er det job, vi lige har trænet i notesbogen, hvis output du så tidligere. Lad os dykke ned i dette individuelle træningsjob for at få mere information.

Følgende skærmbillede viser konsolvisningen af ​​vores træningsjob.

Vi kan gennemgå de oplysninger, vi modtog som celleoutput til vores fit() funktion i det individuelle træningsjob i SageMaker-konsollen, sammen med de parametre og metadata, vi definerede i vores estimator.

Husk log-outputtet fra den træningsinstans, vi så tidligere. Vi kan også her få adgang til logfilerne for vores træningsjob ved at rulle til Overvåg afsnit og valg Se logfiler.

Dette viser os instansloggene inde i CloudWatch.

Husk også de hyperparametre, vi har angivet i vores notesbog for træningsjobbet. Vi ser dem også her i den samme brugergrænseflade af træningsjobbet.

Faktisk kan de detaljer og metadata, vi specificerede tidligere for vores træningsjob og estimator, findes på denne side på SageMaker-konsollen. Vi har en nyttig registrering af de indstillinger, der blev brugt til træningen, såsom hvilken træningsbeholder der blev brugt, og placeringen af ​​trænings- og valideringsdatasættene.

Du spørger måske på dette tidspunkt, hvorfor netop dette er relevant for hyperparameteroptimering? Det er fordi du kan søge, inspicere og dykke dybere ned i de HPO-forsøg, som vi er interesserede i. Måske dem med de bedste resultater, eller dem, der viser interessant adfærd. Vi overlader det til dig, hvad du definerer som "interessant". Det giver os en fælles grænseflade til at inspicere vores træningsjob, og du kan bruge den med SageMaker Search.

Selvom SageMaker AMT orkestrerer HPO-jobbene, lanceres HPO-prøverne alle som individuelle SageMaker Training-job og kan tilgås som sådan.

Med træning dækket, lad os få tuning!

Træn og tune en SageMaker indbygget XGBoost-algoritme

For at tune vores XGBoost-model vil vi genbruge vores eksisterende hyperparametre og definere rækker af værdier, vi vil udforske for dem. Tænk på dette som at udvide grænserne for udforskning inden for vores hyperparametersøgeområde. Vores tuning-job vil prøve fra søgeområdet og køre træningsjob for nye kombinationer af værdier. Følgende kode viser, hvordan man angiver de hyperparameterområder, som SageMaker AMT skal sample 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åderne for en individuel hyperparameter er specificeret efter deres type, f.eks Kontinuerlig Parameter. For mere information og tips om valg af disse parameterområder, se Tune en XGBoost-model.

Vi har ikke kørt nogen eksperimenter endnu, så vi kender ikke intervallerne for gode værdier for vores hyperparametre. Derfor starter vi med et kvalificeret gæt, ved at bruge vores viden om algoritmer og vores dokumentation af hyperparametrene for de indbyggede algoritmer. Dette definerer et udgangspunkt for at definere søgerummet.

Derefter kører vi en tuning-job-sampling fra hyperparametre i de definerede områder. Som et resultat kan vi se, hvilke hyperparameterområder, der giver gode resultater. Med denne viden kan vi forfine søgerummets grænser ved at indsnævre eller udvide hvilke hyperparameterområder, der skal bruges. Vi demonstrerer, hvordan man lærer af forsøgene i næste og sidste afsnit, hvor vi undersøger og visualiserer resultaterne.

I vores næste indlæg fortsætter vi vores rejse og dykker dybere. Derudover vil vi lære, at der er flere strategier, som vi kan bruge til at udforske vores søgeområde. Vi kører efterfølgende HPO-job for at finde endnu mere effektive værdier for vores hyperparametre, mens vi sammenligner disse forskellige strategier. Vi vil også se, hvordan man får en varm start med SageMaker AMT for at bruge viden opnået fra tidligere udforskede søgerum i vores udforskning ud over disse oprindelige grænser.

Til dette indlæg fokuserer vi på, hvordan man analyserer og visualiserer resultaterne af et enkelt HPO-job ved hjælp af den Bayesianske søgestrategi, som sandsynligvis vil være et godt udgangspunkt.

Hvis du følger med i den tilknyttede notesbog, bemærk, at vi består den samme estimator, som vi brugte til vores enkelte, indbyggede XGBoost-træningsjob. Dette estimatorobjekt fungerer som en skabelon for nye træningsjob, som AMT opretter. AMT vil derefter variere hyperparametrene inden for de områder, vi definerede.

Ved at specificere, at vi ønsker at maksimere vores objektive metric, validation:accuracy, fortæller vi SageMaker AMT om at lede efter disse metrics i træningsinstansloggene og vælge hyperparameterværdier, som den mener vil maksimere nøjagtighedsmetrikken på vores valideringsdata. Vi valgte en passende objektiv metrik for XGBoost fra vores dokumentation.

Derudover kan vi drage fordel af parallelisering med max_parallel_jobs. Dette kan være et stærkt værktøj, især for strategier, hvis forsøg er udvalgt uafhængigt, uden at tage hensyn til (lære af) resultaterne af tidligere forsøg. Vi vil udforske disse andre strategier og parametre yderligere i vores næste indlæg. Til dette indlæg bruger vi Bayesian, som er en fremragende standardstrategi.

Vi definerer også max_jobs for at definere, hvor mange forsøg der skal køres i alt. Du er velkommen til at afvige fra vores eksempel og bruge et mindre antal for at spare penge.

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 igen fit(), på samme måde som da vi lancerede et enkelt træningsjob tidligere i indlægget. Men denne gang på tunerobjektet, ikke estimatorobjektet. Dette starter tuning-jobbet, og til gengæld starter AMT træningsjob.

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 udvider vores tidligere arkitektur ved at inkludere HPO med SageMaker AMT.

Vi ser, at vores HPO-job er blevet indsendt. Afhængigt af antallet af forsøg, defineret af n_jobs og niveauet af parallelisering, kan dette tage noget tid. For vores eksempel kan det tage op til 30 minutter for 50 forsøg med kun et paralleliseringsniveau på 3.

tuning job submitted: bayesian-221102-2053.

Når dette tuningjob er afsluttet, lad os udforske de oplysninger, der er tilgængelige for os på SageMaker-konsollen.

Undersøg AMT-opgaver på konsollen

Lad os finde vores tuning-job på SageMaker-konsollen ved at vælge Kurser i navigationsruden og derefter Hyperparameter tuning job. Dette giver os en liste over vores AMT-job, som vist på det følgende skærmbillede. Her finder vi vores bayesian-221102-2053 tuning job og opdage, at det nu er færdigt.

Lad os se nærmere på resultaterne af dette HPO-job.

Vi har undersøgt at udtrække resultaterne programmatisk i notesbog. Først via SageMaker Python SDK, som er et højere niveau open source Python-bibliotek, der leverer en dedikeret API til SageMaker. Så igennem Boto3, som giver os API'er på lavere niveau til SageMaker og andre AWS-tjenester.

Ved at bruge SageMaker Python SDK kan vi opnå resultaterne af vores HPO-job:

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

Dette gjorde det muligt for os at analysere resultaterne af hver af vores forsøg i en Pandas DataFrame, som det ses på det følgende skærmbillede.

Lad os nu skifte perspektiv igen og se, hvordan resultaterne ser ud på SageMaker-konsollen. Derefter vil vi se på vores tilpassede visualiseringer.

På samme side, at vælge vores bayesian-221102-2053 tuning job giver os en liste over forsøg, der blev kørt til vores tuning job. Hvert HPO-forsøg her er et SageMaker-uddannelsesjob. Husk tidligere, da vi trænede vores single XGBoost-model og undersøgte træningsjobbet i SageMaker-konsollen. Vi kan gøre det samme for vores forsøg her.

Når vi undersøger vores forsøg, ser vi det bayesian-221102-2053-048-b59ec7b4 skabte den bedst ydende model med en valideringsnøjagtighed på cirka 89.815 %. Lad os undersøge, hvilke hyperparametre der førte til denne ydeevne ved at vælge Bedste træningsjob fane.

Vi kan se en detaljeret visning af de bedste evaluerede hyperparametre.

Vi kan med det samme se, hvilke hyperparameterværdier der førte til denne overlegne ydeevne. Vi vil dog gerne vide mere. Kan du gætte hvad? Det ser vi alpha antager en omtrentlig værdi på 0.052456 og ligeledes, eta er sat til 0.433495. Dette fortæller os, at disse værdier fungerede godt, men det fortæller os lidt om selve hyperparameterrummet. For eksempel kan vi spekulere på, om 0.433495 for eta var den højeste værdi testet, eller om der er plads til vækst og modelforbedring ved at vælge højere værdier.

Til det skal vi zoome ud og se et meget bredere billede for at se, hvordan andre værdier for vores hyperparametre klarede sig. En måde at se på en masse data på én gang er at plotte vores hyperparameterværdier fra vores HPO-forsøg på et diagram. På den måde ser vi, hvordan disse værdier fungerede relativt. I næste afsnit trækker vi disse data fra SageMaker og visualiserer dem.

Visualiser vores prøvelser

SageMaker SDK giver os dataene til vores udforskning, og notesbøgerne giver dig et indblik i det. Men der er mange måder at bruge og visualisere det på. I dette indlæg deler vi en prøve ved hjælp af Altair statistisk visualiseringsbibliotek, som vi bruger til at skabe et mere visuelt overblik over vores forsøg. Disse findes i amtviz pakke, som vi leverer som en del af prøven:

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

Styrken i disse visualiseringer bliver straks tydelig, når vi plotter vores forsøgs valideringsnøjagtighed (y-akse) over tid (x-akse). Følgende diagram til venstre viser valideringsnøjagtighed over tid. Vi kan tydeligt se, at modellens ydeevne forbedres, efterhånden som vi kører flere forsøg over tid. Dette er et direkte og forventet resultat af at drive HPO med en Bayesiansk strategi. I vores næste indlæg ser vi, hvordan dette kan sammenlignes med andre strategier og observerer, at dette ikke behøver at være tilfældet for alle strategier.

Efter at have gennemgået de overordnede fremskridt over tid, lad os nu se på vores hyperparameterrum.

Følgende diagrammer viser valideringsnøjagtighed på y-aksen, hvor hvert diagram vises max_depth, alpha, etaog min_child_weight på henholdsvis x-aksen. Vi har plottet hele vores HPO-job ind i hvert diagram. Hvert punkt er et enkelt forsøg, og hvert diagram indeholder alle 50 forsøg, men adskilt for hver hyperparameter. Dette betyder, at vores bedste præstationsprøve, #48, er repræsenteret med nøjagtig én blå prik i hvert af disse diagrammer (som vi har fremhævet for dig i den følgende figur). Vi kan visuelt sammenligne dens ydeevne inden for rammerne af alle andre 49 forsøg. Så lad os se nærmere.

Spændende! Vi ser med det samme, hvilke områder af vores definerede områder i vores hyperparameterrum der er mest effektive! Tænker tilbage på vores eta værdi, er det klart nu, at stikprøveværdier tættere på 0 gav dårligere ydeevne, hvorimod at flytte tættere på vores grænse, 0.5, giver bedre resultater. Det omvendte ser ud til at være tilfældet alphaog max_depth ser ud til at have et mere begrænset sæt foretrukne værdier. Ser på max_depth, kan du også se, hvordan brugen af ​​en Bayesiansk strategi instruerer SageMaker AMT til at prøve oftere værdier, den lærte, fungerede godt tidligere.

Kigger på vores eta værdi, kan vi spekulere på, om det er værd at udforske mere til højre, måske ud over 0.45? Fortsætter det med at spore af til lavere nøjagtighed, eller har vi brug for flere data her? Denne undren er en del af formålet med at køre vores første HPO-job. Det giver os indsigt i, hvilke områder af hyperparameterrummet vi bør udforske yderligere.

Hvis du er ivrig efter at vide mere og er lige så begejstret som vi er af denne introduktion til emnet, så følg med i vores næste indlæg, hvor vi vil tale mere om de forskellige HPO-strategier, sammenligne dem med hinanden og øve træning med vores eget Python-script.

Ryd op

For at undgå at pådrage sig uønskede omkostninger, når du er færdig med at eksperimentere med HPO, skal du fjerne alle filer i din S3-bøtte med præfikset amt-visualize-demo og også lukke Studio-ressourcer.

Kør følgende kode i din notesbog for at fjerne alle S3-filer fra dette indlæg.

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

Hvis du ønsker at beholde datasættene eller modelartefakterne, kan du ændre præfikset i koden til amt-visualize-demo/data kun at slette data eller amt-visualize-demo/output for kun at slette modelartefakter.

Konklusion

I dette indlæg trænede og tunede vi en model ved hjælp af SageMaker indbyggede version af XGBoost-algoritmen. Ved at bruge HPO med SageMaker AMT lærte vi om de hyperparametre, der fungerer godt for denne særlige algoritme og datasæt.

Vi så flere måder at gennemgå resultaterne af vores hyperparameterjusteringsjob på. Startende med at udtrække hyperparametrene for det bedste forsøg, lærte vi også, hvordan man opnår en dybere forståelse af, hvordan vores forsøg var skredet frem over tid, og hvilke hyperparameterværdier, der har indflydelse.

Ved at bruge SageMaker-konsollen så vi også, hvordan man kan dykke dybere ned i individuelle træningsløb og gennemgå deres logfiler.

Vi zoomede derefter ud for at se alle vores forsøg sammen og gennemgå deres ydeevne i forhold til andre forsøg og hyperparametre.

Vi lærte, at baseret på observationerne fra hvert forsøg var vi i stand til at navigere i hyperparameterrummet for at se, at små ændringer i vores hyperparameterværdier kan have en enorm indflydelse på vores modelydelse. Med SageMaker AMT kan vi køre hyperparameteroptimering for at finde gode hyperparameterværdier effektivt og maksimere modellens ydeevne.

I fremtiden vil vi se nærmere på forskellige HPO-strategier, der tilbydes af SageMaker AMT, og hvordan man bruger vores egen tilpassede træningskode. Fortæl os i kommentarerne, hvis du har et spørgsmål eller vil foreslå et område, som vi bør dække i kommende indlæg.

Indtil da ønsker vi dig og dine modeller god læring og tuning!

Referencer

citater:

[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 arbejder med små og mellemstore virksomheder i Tyskland. Uden for arbejdet nyder Andrew at udforske naturen til fods eller på cykel.

Elina Lesyk er en Solutions Architect beliggende i München. Hendes fokus er på virksomhedskunder fra Financial Services Industry. I sin fritid kan Elina godt lide at lære guitarteori på spansk for at krydse lære og løbe en tur.

Mariano Kamp er en Principal Solutions Architect med Amazon Web Services. Han arbejder med finansielle servicekunder i Tyskland om maskinlæring. I sin fritid nyder Mariano at vandre med sin kone.