Optimera hyperparametrar med Amazon SageMaker Automatic Model Tuning

Maskininlärningsmodeller (ML) tar världen med storm. Deras prestanda är beroende av att använda rätt träningsdata och att välja rätt modell och algoritm. Men det slutar inte här. Vanligtvis skjuter algoritmer upp vissa designbeslut till ML-utövaren att anta för deras specifika data och uppgift. Dessa uppskjutna designbeslut visar sig som hyperparametrar.

Vad betyder det namnet? Resultatet av ML-träning, modellen, kan till stor del ses som en samling parametrar som lärs in under träningen. Därför kallas parametrarna som används för att konfigurera ML-träningsprocessen hyperparametrar – parametrar som beskriver skapandet av parametrar. De är i alla fall till mycket praktisk användning, som antalet epoker att träna, inlärningshastigheten, maxdjupet för ett beslutsträd och så vidare. Och vi lägger stor vikt vid dem eftersom de har stor inverkan på din modells ultimata prestanda.

Precis som att vrida på en ratt på en radiomottagare för att hitta rätt frekvens, bör varje hyperparameter justeras noggrant för att optimera prestandan. Att söka i hyperparameterutrymmet efter de optimala värdena kallas hyperparameterinställning or hyperparameteroptimering (HPO), och bör resultera i en modell som ger korrekta förutsägelser.

I det här inlägget ställer vi in ​​och kör vårt första HPO-jobb med hjälp av Amazon SageMaker Automatisk modellinställning (AMT). Vi lär oss om tillgängliga metoder för att utforska resultaten och skapar några insiktsfulla visualiseringar av våra HPO-försök och utforskningen av hyperparameterutrymmet!

Amazon SageMaker Automatisk modellinställning

Som ML-utövare använder SageMaker AMT, kan du fokusera på följande:

• Tillhandahålla ett träningsjobb
• Definiera rätt objektiva mått som matchar din uppgift
• Omfattning av hyperparametersökutrymmet

SageMaker AMT tar hand om resten, och du behöver inte tänka på infrastrukturen, orkestrera träningsjobb och förbättra valet av hyperparameter.

Låt oss börja med att använda SageMaker AMT för vårt första enkla HPO-jobb, för att träna och ställa in en XGBoost-algoritm. Vi vill att din AMT-resa ska vara praktisk och praktisk, så vi har delat med oss ​​av exemplet nedan GitHub repository. Det här inlägget täcker 1_tuning_of_builtin_xgboost.ipynb anteckningsbok.

I ett kommande inlägg kommer vi att utvidga idén om att bara hitta de bästa hyperparametrarna och inkludera lärande om sökutrymmet och för vilka hyperparameterintervall en modell är känslig. Vi kommer också att visa hur man förvandlar en trimningsaktivitet i ett steg till en konversation i flera steg med ML-utövaren, för att lära sig tillsammans. Håll utkik (pun intended)!

Förutsättningar

Det här inlägget är för alla som är intresserade av att lära sig om HPO och kräver inga förkunskaper om ämnet. Grundläggande förtrogenhet med ML-koncept och Python-programmering är dock till hjälp. För den bästa inlärningsupplevelsen rekommenderar vi starkt att följa med köra varje steg i anteckningsboken parallellt med att läsa detta inlägg. Och i slutet av anteckningsboken får du också prova en interaktiv visualisering som gör trimningsresultaten levande.

Lösningsöversikt

Vi kommer att bygga en end-to-end-installation för att köra vårt första HPO-jobb med SageMaker AMT. När vårt trimjobb är klart tittar vi på några av de tillgängliga metoderna för att utforska resultaten, både via AWS Management Console och programmatiskt via AWS SDK:er och API:er.

Först bekantar vi oss med miljön och SageMaker Training genom att köra ett fristående träningsjobb, utan någon justering just nu. Vi använder XGBoost-algoritmen, en av många algoritmer som tillhandahålls som en SageMaker inbyggd algoritm (inget träningsskript krävs!).

Vi ser hur SageMaker Training fungerar på följande sätt:

• Startar och stoppar en instans
• Tillhandahåller den nödvändiga behållaren
• Kopierar tränings- och valideringsdata till instansen
• Driver utbildningen
• Samlar in mätvärden och loggar
• Samlar och lagrar den tränade modellen

Sedan flyttar vi till AMT och kör ett HPO-jobb:

• Vi ställer upp och lanserar vårt trimjobb med AMT
• Vi dyker ner i de metoder som finns tillgängliga för att extrahera detaljerade prestationsmått och metadata för varje träningsjobb, vilket gör att vi kan lära oss mer om de optimala värdena i vårt hyperparameterutrymme
• Vi visar dig hur du kan se resultaten av försöken
• Vi förser dig med verktyg för att visualisera data i en serie diagram som avslöjar värdefulla insikter i vårt hyperparameterutrymme

Träna en SageMaker inbyggd XGBoost-algoritm

Allt börjar med att träna en modell. Genom att göra det får vi en känsla av hur SageMaker Training fungerar.

Vi vill dra fördel av hastigheten och användarvänligheten som SageMaker erbjuder inbyggda algoritmer. Allt vi behöver är några steg för att komma igång med träningen:

1. Förbered och ladda data – Vi laddar ner och förbereder vår datauppsättning som indata för XGBoost och laddar upp den till vår Amazon enkel lagringstjänst (Amazon S3) hink.
2. Välj vår inbyggda algoritms bild-URI – SageMaker använder denna URI för att hämta vår träningsbehållare, som i vårt fall innehåller ett färdigt XGBoost-träningsskript. Flera algoritmversioner stöds.
3. Definiera hyperparametrarna – SageMaker tillhandahåller ett gränssnitt för att definiera hyperparametrar för vår inbyggda algoritm. Det här är samma hyperparametrar som används av öppen källkodsversionen.
4. Konstruera estimatorn – Vi definierar träningsparametrarna som instanstyp och antal instanser.
5. Anropa fit()-funktionen – Vi börjar vårt träningsjobb.

Följande diagram visar hur dessa steg fungerar tillsammans.

Ange uppgifterna

För att köra ML-utbildning behöver vi tillhandahålla data. Vi tillhandahåller vår utbildnings- och valideringsdata till SageMaker via Amazon S3.

I vårt exempel använder vi för enkelhets skull SageMakers standardhink för att lagra våra data. Men anpassa gärna följande värden efter dina önskemål:

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

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

I anteckningsboken använder vi en offentlig datauppsättning och lagrar data lokalt i data katalog. Vi laddar sedan upp vår utbildnings- och valideringsdata till Amazon S3. Senare definierar vi också pekare till dessa platser för att skicka dem till 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 det här inlägget koncentrerar vi oss på att introducera HPO. Som illustration använder vi en specifik datauppsättning och uppgift, så att vi kan få mätningar av objektiva mått som vi sedan använder för att optimera urvalet av hyperparametrar. Men för det övergripande inlägget spelar varken data eller uppgiften roll. För att ge dig en komplett bild, låt oss kort beskriva vad vi gör: vi tränar en XGBoost-modell som ska klassificera handskrivna siffror från
Optisk igenkänning av handskrivna siffror Dataset [1] via Scikit-learn. XGBoost är en utmärkt algoritm för strukturerad data och kan till och med appliceras på Digits-datauppsättningen. Värdena är 8×8 bilder, som i följande exempel visar en
0 a
5 och en
4.

Välj XGBoost-bild-URI

Efter att ha valt vår inbyggda algoritm (XGBoost) måste vi hämta bild-URI och skicka denna till SageMaker för att laddas in i vår träningsinstans. För detta steg granskar vi tillgängliga versioner. Här har vi bestämt oss för att använda version 1.5.1, som erbjuder den senaste versionen av algoritmen. Beroende på uppgiften kan ML-utövare skriva sitt eget träningsmanus som till exempel inkluderar dataförberedande steg. Men detta är inte nödvändigt i vårt fall.

Om du vill skriva ditt eget träningsmanus, håll utkik, vi har dig täckt i vårt nästa inlägg! Vi visar dig hur du kör SageMaker Training-jobb med dina egna anpassade träningsskript.

För närvarande behöver vi rätt bild-URI genom att ange algoritmen, AWS-regionen och versionsnumret:

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

Det är allt. Nu har vi en referens till XGBoost-algoritmen.

Definiera hyperparametrarna

Nu definierar vi våra hyperparametrar. Dessa värden konfigurerar hur vår modell kommer att tränas och påverkar så småningom hur modellen presterar mot det objektiva mått som vi mäter mot, till exempel noggrannhet i vårt fall. Observera att inget om följande kodblock är specifikt för SageMaker. Vi använder faktiskt öppen källkodsversion av XGBoost, precis tillhandahållen av och optimerad för SageMaker.

Även om var och en av dessa hyperparametrar är konfigurerbara och justerbara, är det objektiva måttet multi:softmax bestäms av vår datauppsättning och vilken typ av problem vi löser. I vårt fall innehåller datauppsättningen siffror flera etiketter (en observation av en handskriven siffra kan vara 0 or 1,2,3,4,5,6,7,8,9), vilket betyder att det är ett klassificeringsproblem i flera 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
}

För mer information om de andra hyperparametrarna, se XGBoost Hyperparametrar.

Konstruera estimatorn

Vi konfigurerar träningen på ett estimatorobjekt, vilket är ett högnivågränssnitt för SageMaker Training.

Därefter definierar vi antalet instanser att träna på, instanstypen (CPU-baserad eller GPU-baserad) och storleken på den bifogade 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 nu den infrastrukturkonfiguration som vi behöver för att komma igång. SageMaker Training tar hand om resten.

Anropa fit()-funktionen

Kommer du ihåg data vi laddade upp till Amazon S3 tidigare? Nu skapar vi referenser till 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')

Ett samtal till fit() lanserar vår utbildning. Vi skickar in referenserna till träningsdata vi just skapat för att peka SageMaker Training till vår tränings- och valideringsdata:

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

Observera att för att köra HPO senare behöver vi faktiskt inte ringa fit() här. Vi behöver bara estimatorobjektet senare för HPO och kan bara hoppa till att skapa vårt HPO-jobb. Men eftersom vi vill lära oss om SageMaker Training och se hur man kör ett enda träningsjobb, kallar vi det här och granskar resultatet.

Efter att träningen har börjat börjar vi se utdata under cellerna, som visas i följande skärmdump. Utgången är tillgänglig i amazoncloudwatch såväl som i denna anteckningsbok.

Den svarta texten är loggutdata från SageMaker själv, som visar stegen som är involverade i träningsorkestrering, som att starta instansen och ladda träningsbilden. Den blå texten matas ut direkt från själva träningsinstansen. Vi kan observera processen med att ladda och analysera träningsdata och visuellt se träningsframstegen och förbättringen av det objektiva måttet direkt från träningsskriptet som körs på instansen.

Observera också att i slutet av utskriftsjobbet visas träningslängden i sekunder och fakturerbara sekunder.

Slutligen ser vi att SageMaker laddar upp vår träningsmodell till S3-utgångsvägen definierad på estimatorobjektet. Modellen är redo att användas för slutledning.

I ett framtida inlägg kommer vi att skapa vår egen utbildningsbehållare och definiera våra träningsmått att skicka ut. Du kommer att se hur SageMaker är agnostiker av vilken behållare du passerar den för träning. Detta är väldigt praktiskt när du vill komma igång snabbt med en inbyggd algoritm, men sedan senare bestämmer dig för att skicka ditt eget anpassade träningsskript!

Inspektera nuvarande och tidigare utbildningsjobb

Hittills har vi arbetat från vår anteckningsbok med vår kod och skickat in utbildningsjobb till SageMaker. Låt oss byta perspektiv och lämna anteckningsboken ett ögonblick för att kolla in hur det här ser ut på SageMaker-konsolen.

SageMaker för ett historiskt register över utbildningsjobb som den körde, deras konfigurationer som hyperparametrar, algoritmer, datainmatning, den fakturerbara tiden och resultaten. I listan i föregående skärmdump ser du de senaste träningsjobben filtrerade för XGBoost. Det markerade träningsjobbet är jobbet vi just tränade i anteckningsboken, vars utdata du såg tidigare. Låt oss dyka in i detta individuella träningsjobb för att få mer information.

Följande skärmdump visar konsolvyn av vårt träningsjobb.

Vi kan granska informationen vi fick som cellutdata till vår fit() funktion i det individuella träningsjobbet inom SageMaker-konsolen, tillsammans med de parametrar och metadata vi definierade i vår estimator.

Kom ihåg loggutgången från träningsinstansen vi såg tidigare. Vi kan komma åt loggarna för vårt träningsjobb här också, genom att rulla till Övervaka avsnitt och välja Visa loggar.

Detta visar oss instansloggarna inuti CloudWatch.

Kom också ihåg hyperparametrarna vi angav i vår anteckningsbok för träningsjobbet. Vi ser dem här i samma UI på träningsjobbet också.

Faktum är att detaljerna och metadata som vi angav tidigare för vårt träningsjobb och estimator finns på den här sidan på SageMaker-konsolen. Vi har ett användbart register över inställningarna som används för utbildningen, till exempel vilken utbildningsbehållare som användes och var utbildnings- och valideringsdatauppsättningarna finns.

Du kanske frågar just nu, varför är detta relevant för hyperparameteroptimering? Det beror på att du kan söka, inspektera och dyka djupare in i de HPO-försök som vi är intresserade av. Kanske de som ger bäst resultat, eller de som visar intressant beteende. Vi överlåter till dig vad du definierar som "intressant". Det ger oss ett gemensamt gränssnitt för att inspektera våra utbildningsjobb, och du kan använda det med SageMaker Search.

Även om SageMaker AMT orkestrerar HPO-jobben, lanseras alla HPO-prövningarna som individuella SageMaker Training-jobb och kan nås som sådana.

Med träningen täckt, låt oss börja trimma!

Träna och trimma en SageMaker inbyggd XGBoost-algoritm

För att finjustera vår XGBoost-modell kommer vi att återanvända våra befintliga hyperparametrar och definiera värdeintervall som vi vill utforska för dem. Se detta som att utvidga gränserna för utforskning inom vårt sökutrymme för hyperparameter. Vårt trimjobb kommer att prova från sökutrymmet och köra utbildningsjobb för nya kombinationer av värden. Följande kod visar hur man anger hyperparameterintervallen som SageMaker AMT ska sampla från:

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ådena för en enskild hyperparameter specificeras av deras typ, till exempel ContinuousParameter. För mer information och tips om hur du väljer dessa parameterintervall, se Trimma en XGBoost-modell.

Vi har inte kört några experiment än, så vi vet inte intervallen för bra värden för våra hyperparametrar. Därför börjar vi med en utbildad gissning, med hjälp av vår kunskap om algoritmer och vår dokumentation av hyperparametrarna för de inbyggda algoritmerna. Detta definierar en startpunkt för att definiera sökutrymmet.

Sedan kör vi en trimningsjobbsampling från hyperparametrar i de definierade intervallen. Som ett resultat kan vi se vilka hyperparameterintervall som ger bra resultat. Med denna kunskap kan vi förfina sökutrymmets gränser genom att begränsa eller bredda vilka hyperparameterintervall som ska användas. Vi visar hur man lär sig av försöken i nästa och sista avsnitt, där vi undersöker och visualiserar resultaten.

I vårt nästa inlägg fortsätter vi vår resa och dyker djupare. Dessutom kommer vi att lära oss att det finns flera strategier som vi kan använda för att utforska vårt sökutrymme. Vi kommer att köra efterföljande HPO-jobb för att hitta ännu fler prestandavärden för våra hyperparametrar, samtidigt som vi jämför dessa olika strategier. Vi kommer också att se hur man får en varm start med SageMaker AMT för att använda kunskapen från tidigare utforskade sökutrymmen i vår utforskning bortom dessa initiala gränser.

För det här inlägget fokuserar vi på hur man analyserar och visualiserar resultaten av ett enda HPO-jobb med hjälp av den Bayesianska sökstrategin, vilket sannolikt kommer att vara en bra utgångspunkt.

Om du följer med i den länkade anteckningsboken, notera att vi klarar samma estimator som vi använde för vårt enda, inbyggda XGBoost-träningsjobb. Detta estimatorobjekt fungerar som en mall för nya utbildningsjobb som AMT skapar. AMT kommer sedan att variera hyperparametrarna inom de intervall vi definierat.

Genom att specificera att vi vill maximera vårt objektiva mått, validation:accuracy, säger vi till SageMaker AMT att leta efter dessa mätvärden i träningsinstansloggarna och välja hyperparametervärden som den tror kommer att maximera noggrannhetsmåttet på våra valideringsdata. Vi valde en lämplig objektivt mått för XGBoost från vår dokumentation.

Dessutom kan vi dra fördel av parallellisering med max_parallel_jobs. Detta kan vara ett kraftfullt verktyg, särskilt för strategier vars försök väljs ut oberoende, utan att ta hänsyn till (lära sig av) resultaten av tidigare försök. Vi kommer att utforska dessa andra strategier och parametrar ytterligare i vårt nästa inlägg. För det här inlägget använder vi Bayesian, vilket är en utmärkt standardstrategi.

Vi definierar också max_jobs för att definiera hur många försök som ska köras totalt. Avvik gärna från vårt exempel och använd ett mindre antal för att spara pengar.

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å samma sätt som när vi lanserade ett enda utbildningsjobb tidigare i inlägget. Men den här gången på tunerobjektet, inte estimatorobjektet. Detta sätter igång trimningsjobbet, och i sin tur börjar AMT träningsjobb.

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öljande diagram utökar vår tidigare arkitektur genom att inkludera HPO med SageMaker AMT.

Vi ser att vårt HPO-jobb har skickats in. Beroende på antalet försök, definierat av n_jobs och nivån av parallellisering kan detta ta lite tid. För vårt exempel kan det ta upp till 30 minuter för 50 försök med bara en parallelliseringsnivå på 3.

tuning job submitted: bayesian-221102-2053.

När det här inställningsjobbet är klart, låt oss utforska informationen som är tillgänglig för oss på SageMaker-konsolen.

Undersök AMT-jobb på konsolen

Låt oss hitta vårt trimjobb på SageMaker-konsolen genom att välja Utbildning i navigeringsfönstret och sedan Hyperparameter tuning jobb. Detta ger oss en lista över våra AMT-jobb, som visas i följande skärmdump. Här lokaliserar vi vår bayesian-221102-2053 trimningsjobbet och upptäck att det nu är klart.

Låt oss ta en närmare titt på resultatet av detta HPO-jobb.

Vi har utforskat att extrahera resultaten programmatiskt i anteckningsbok. Först via SageMaker Python SDK, som är ett Python-bibliotek med öppen källkod på högre nivå, som tillhandahåller ett dedikerat API till SageMaker. Sedan igenom Boto3, som ger oss API:er på lägre nivå till SageMaker och andra AWS-tjänster.

Med SageMaker Python SDK kan vi få resultaten av vårt HPO-jobb:

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

Detta gjorde det möjligt för oss att analysera resultaten av var och en av våra försök i en Pandas DataFrame, som visas i följande skärmdump.

Låt oss nu byta perspektiv igen och se hur resultaten ser ut på SageMaker-konsolen. Sedan ska vi titta på våra anpassade visualiseringar.

På samma sida, att välja vår bayesian-221102-2053 trimjobb ger oss en lista över tester som kördes för vårt trimjobb. Varje HPO-försök här är ett SageMaker-utbildningsjobb. Minns tidigare när vi tränade vår enda XGBoost-modell och undersökte träningsjobbet i SageMaker-konsolen. Vi kan göra samma sak för våra försök här.

När vi undersöker våra rättegångar ser vi det bayesian-221102-2053-048-b59ec7b4 skapade den bäst presterande modellen, med en valideringsnoggrannhet på cirka 89.815 %. Låt oss utforska vilka hyperparametrar som ledde till denna prestanda genom att välja Bästa träningsjobbet fliken.

Vi kan se en detaljerad bild av de bästa utvärderade hyperparametrarna.

Vi kan omedelbart se vilka hyperparametervärden som ledde till denna överlägsna prestanda. Däremot vill vi veta mer. Kan du gissa vad? Vi ser det alpha antar ett ungefärligt värde av 0.052456 och på samma sätt, eta är inställd på 0.433495. Detta säger oss att dessa värden fungerade bra, men det säger oss lite om själva hyperparameterutrymmet. Till exempel kan vi undra om 0.433495 för eta var det högsta värdet som testades, eller om det finns utrymme för tillväxt och modellförbättringar genom att välja högre värden.

För det måste vi zooma ut och ta en mycket bredare vy för att se hur andra värden för våra hyperparametrar presterade. Ett sätt att titta på mycket data på en gång är att plotta våra hyperparametervärden från våra HPO-försök på ett diagram. På så sätt ser vi hur dessa värden presterade relativt. I nästa avsnitt hämtar vi denna data från SageMaker och visualiserar den.

Visualisera våra prövningar

SageMaker SDK förser oss med data för vår utforskning, och anteckningsböckerna ger dig en titt på det. Men det finns många sätt att använda och visualisera det. I det här inlägget delar vi ett prov med hjälp av Altair statistiskt visualiseringsbibliotek, som vi använder för att skapa en mer visuell översikt över våra försök. Dessa finns i amtviz paket, som vi tillhandahåller som en del av provet:

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

Kraften i dessa visualiseringar blir omedelbart uppenbar när vi ritar våra försöks valideringsnoggrannhet (y-axel) över tid (x-axel). Följande diagram till vänster visar valideringsnoggrannheten över tid. Vi kan tydligt se att modellens prestanda förbättras när vi kör fler tester över tiden. Detta är ett direkt och förväntat resultat av att driva HPO med en Bayesiansk strategi. I vårt nästa inlägg ser vi hur detta jämförs med andra strategier och observerar att detta inte behöver vara fallet för alla strategier.

Efter att ha granskat de övergripande framstegen över tiden, låt oss nu titta på vårt hyperparameterutrymme.

Följande diagram visar valideringsnoggrannhet på y-axeln, med varje diagram som visas max_depth, alpha, etaoch min_child_weight på x-axeln, respektive. Vi har ritat in hela vårt HPO-jobb i varje diagram. Varje punkt är ett enda försök, och varje diagram innehåller alla 50 försök, men separerade för varje hyperparameter. Detta innebär att vår bästa testversion, #48, representeras av exakt en blå prick i vart och ett av dessa diagram (som vi har markerat för dig i följande figur). Vi kan visuellt jämföra dess prestanda inom ramen för alla andra 49 försök. Så låt oss titta närmare.

Fascinerande! Vi ser omedelbart vilka regioner av våra definierade intervall i vårt hyperparameterutrymme som är mest presterande! Tänker tillbaka på vår eta värde, är det tydligt nu att samplingsvärden närmare 0 gav sämre prestanda, medan att flytta närmare vår gräns, 0.5, ger bättre resultat. Det omvända verkar vara sant alphaoch max_depth verkar ha en mer begränsad uppsättning föredragna värden. Tittar på max_depth, kan du också se hur användningen av en Bayesiansk strategi instruerar SageMaker AMT att prova oftare värden som den lärt sig fungerade bra tidigare.

Tittar på vår eta värde, kanske vi undrar om det är värt att utforska mer till höger, kanske bortom 0.45? Fortsätter det att följa efter till lägre noggrannhet, eller behöver vi mer data här? Denna undran är en del av syftet med att driva vårt första HPO-jobb. Det ger oss insikter i vilka områden av hyperparameterutrymmet vi bör utforska ytterligare.

Om du är angelägen om att veta mer och är lika exalterad som vi är av den här introduktionen till ämnet, håll utkik efter vårt nästa inlägg, där vi kommer att prata mer om de olika HPO-strategierna, jämföra dem med varandra och träna med vårt eget Python-skript.

Städa upp

För att undvika oönskade kostnader när du är klar med att experimentera med HPO måste du ta bort alla filer i din S3-bucket med prefixet amt-visualize-demo och även stänga av Studio-resurser.

Kör följande kod i din anteckningsbok för att ta bort alla S3-filer från det här inlägget.

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

Om du vill behålla datamängderna eller modellartefakterna kan du ändra prefixet i koden till amt-visualize-demo/data att bara radera data eller amt-visualize-demo/output för att bara ta bort modellartefakterna.

Slutsats

I det här inlägget tränade och trimmade vi en modell med den inbyggda SageMaker-versionen av XGBoost-algoritmen. Genom att använda HPO med SageMaker AMT lärde vi oss om hyperparametrarna som fungerar bra för just den här algoritmen och datamängden.

Vi såg flera sätt att granska resultaten av vårt hyperparameterjusteringsjobb. Vi började med att extrahera hyperparametrarna för den bästa testversionen, och vi lärde oss också hur vi kan få en djupare förståelse för hur våra tester hade framskridit över tiden och vilka hyperparametervärden som har effekt.

Med SageMaker-konsolen såg vi också hur man kan dyka djupare in i individuella träningslopp och granska deras loggar.

Vi zoomade sedan ut för att se alla våra försök tillsammans och granska deras prestanda i förhållande till andra försök och hyperparametrar.

Vi lärde oss att baserat på observationerna från varje försök kunde vi navigera i hyperparameterutrymmet för att se att små förändringar av våra hyperparametervärden kan ha en enorm inverkan på vår modellprestanda. Med SageMaker AMT kan vi köra hyperparameteroptimering för att hitta bra hyperparametervärden effektivt och maximera modellens prestanda.

I framtiden kommer vi att undersöka olika HPO-strategier som erbjuds av SageMaker AMT och hur man använder vår egen anpassade träningskod. Låt oss veta i kommentarerna om du har en fråga eller vill föreslå ett område som vi bör täcka i kommande inlägg.

Tills dess önskar vi dig och dina modeller lycka till med lärande och trimning!

Referensprojekt

citat:

[1] Dua, D. och 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 författarna

Andrew Ellul är en lösningsarkitekt med Amazon Web Services. Han arbetar med små och medelstora företag i Tyskland. Utanför jobbet tycker Andrew om att utforska naturen till fots eller på cykel.

Elina Lesyk är en lösningsarkitekt i München. Hennes fokus ligger på företagskunder från finansbranschen. På fritiden gillar Elina att lära sig gitarrteori på spanska för att korslära och springa.

Mariano Kamp är en Principal Solutions Architect med Amazon Web Services. Han arbetar med finansiella tjänster i Tyskland med maskininlärning. På fritiden tycker Mariano om att vandra med sin fru.