Utforska avancerade tekniker för hyperparameteroptimering med Amazon SageMaker Automatic Model Tuning | Amazon webbtjänster

Att skapa lösningar för högpresterande maskininlärning (ML) bygger på att utforska och optimera träningsparametrar, även kända som hyperparametrar. Hyperparametrar är de rattar och spakar som vi använder för att justera träningsprocessen, såsom inlärningshastighet, batchstorlek, regleringsstyrka och annat, beroende på den specifika modellen och uppgiften. Att utforska hyperparametrar innebär att systematiskt variera värdena för varje parameter och observera effekten på modellens prestanda. Även om denna process kräver ytterligare ansträngningar, är fördelarna betydande. Hyperparameteroptimering (HPO) kan leda till snabbare träningstider, förbättrad modellnoggrannhet och bättre generalisering till nya data.

Vi fortsätter vår resa från posten Optimera hyperparametrar med Amazon SageMaker Automatic Model Tuning. Vi har tidigare utforskat en enskild jobboptimering, visualiserat resultaten för SageMaker inbyggda algoritm och lärt oss om effekten av särskilda hyperparametervärden. Utöver att använda HPO som en engångsoptimering i slutet av cykeln för modellskapande, kan vi också använda det över flera steg på ett konversationssätt. Varje trimningsjobb hjälper oss att komma närmare ett bra resultat, men dessutom lär vi oss hur känslig modellen är för vissa hyperparametrar och kan använda denna förståelse för att informera nästa trimningsjobb. Vi kan revidera hyperparametrarna och deras värdeintervall baserat på vad vi lärt oss och därför förvandla denna optimeringsinsats till en konversation. Och på samma sätt som vi som ML-utövare samlar på oss kunskap över dessa körningar, Amazon SageMaker Automatic Model Tuning (AMT) med varma starter kan behålla denna kunskap som förvärvats i tidigare trimjobb även för nästa trimjobb.

I det här inlägget kör vi flera HPO-jobb med en anpassad träningsalgoritm och olika HPO-strategier som Bayesiansk optimering och slumpmässig sökning. Vi sätter också varma start i verket och jämför visuellt våra försök för att förfina rymdutforskningen med hyperparameter.

Avancerade koncept av SageMaker AMT

I nästa avsnitt tar vi en närmare titt på vart och ett av följande ämnen och visar hur SageMaker AMT kan hjälpa dig att implementera dem i dina ML-projekt:

• Använd anpassad träningskod och det populära ML-ramverket Scikit-learn i SageMaker Training
• Definiera anpassade utvärderingsmått baserat på loggarna för utvärdering och optimering
• Utför HPO med en lämplig strategi
• Använd varma startar för att förvandla en enda hyperparametersökning till en dialog med vår modell
• Använd avancerade visualiseringstekniker med vårt lösningsbibliotek för att jämföra två HPO-strategier och finjustera jobbresultat

Oavsett om du använder de inbyggda algoritmerna som används i vårt första inlägg eller din egen träningskod, erbjuder SageMaker AMT en sömlös användarupplevelse för att optimera ML-modeller. Den tillhandahåller nyckelfunktioner som gör att du kan fokusera på ML-problemet samtidigt som du automatiskt håller reda på försöken och resultaten. Samtidigt hanterar den automatiskt den underliggande infrastrukturen åt dig.

I det här inlägget går vi bort från en SageMaker inbyggd algoritm och använder anpassad kod. Vi använder en Random Forest från SkLearn. Men vi håller oss till samma ML-uppgift och dataset som i vår första inlägget, som upptäcker handskrivna siffror. Vi täcker innehållet i Jupyter-anteckningsboken 2_advanced_tuning_with_custom_training_and_visualizing.ipynb och inbjuder dig att anropa koden sida vid sida för att läsa vidare.

Låt oss dyka djupare och upptäcka hur vi kan använda anpassad träningskod, distribuera den och köra den, samtidigt som vi utforskar hyperparametersökutrymmet för att optimera våra resultat.

Hur man bygger en ML-modell och utför hyperparameteroptimering

Hur ser en typisk process för att bygga en ML-lösning ut? Även om det finns många möjliga användningsfall och en stor variation av ML-uppgifter där ute, föreslår vi följande mentala modell för ett stegvis tillvägagångssätt:

1. Förstå ditt ML-scenario och välj en algoritm baserat på kraven. Till exempel kanske du vill lösa en bildigenkänningsuppgift med hjälp av en övervakad inlärningsalgoritm. I det här inlägget fortsätter vi att använda scenariot för handskriven bildigenkänning och samma datauppsättning som i vårt första inlägg.
2. Bestäm vilken implementering av algoritmen i SageMaker Training du vill använda. Det finns olika alternativ, inuti SageMaker eller externa. Dessutom måste du definiera vilket underliggande mått som passar bäst för din uppgift och du vill optimera för (såsom noggrannhet, F1-poäng eller ROC). SageMaker stöder fyra alternativ beroende på dina behov och resurser:
   • Använd en förtränad modell via Amazon SageMaker JumpStart, som du kan använda ur lådan eller bara finjustera den.
   • Använd en av de inbyggda algoritmerna för träning och inställning, som XGBoost, som vi gjorde i vårt tidigare inlägg.
   • Träna och trimma en anpassad modell baserad på ett av de stora ramverken som Scikit-learn, TensorFlow eller PyTorch. AWS tillhandahåller ett urval av förgjorda Docker-bilder för detta ändamål. För det här inlägget använder vi det här alternativet, som låter dig experimentera snabbt genom att köra din egen kod ovanpå en förgjord behållarbild.
   • Ta med din egen anpassade Docker-bild om du vill använda ett ramverk eller programvara som inte stöds på annat sätt. Det här alternativet kräver mest ansträngning, men ger också högsta grad av flexibilitet och kontroll.
3. Träna modellen med dina data. Beroende på algoritmimplementeringen från föregående steg kan detta vara så enkelt som att referera till din träningsdata och köra träningsjobbet eller genom att dessutom tillhandahålla anpassad kod för träning. I vårt fall använder vi lite anpassad träningskod i Python baserad på Scikit-learn.
4. Använd hyperparameteroptimering (som en "konversation" med din ML-modell). Efter utbildningen vill du vanligtvis optimera prestandan för din modell genom att hitta den mest lovande kombinationen av värden för din algoritms hyperparametrar.

Beroende på din ML-algoritm och modellstorlek kan det sista steget av hyperparameteroptimering visa sig vara en större utmaning än väntat. Följande frågor är typiska för ML-utövare i detta skede och kanske låter bekanta för dig:

• Vilken typ av hyperparametrar har betydelse för mitt ML-problem?
• Hur kan jag effektivt söka i ett enormt hyperparameterutrymme för att hitta de värdena som ger bäst resultat?
• Hur påverkar kombinationen av vissa hyperparametervärden mitt prestandamått?
• Kostnaderna spelar roll; hur kan jag använda mina resurser på ett effektivt sätt?
• Vilken typ av trimningsexperiment är värda besväret, och hur kan jag jämföra dem?

Det är inte lätt att svara på dessa frågor, men det finns goda nyheter. SageMaker AMT tar det tunga lyftet från dig och låter dig koncentrera dig på att välja rätt HPO-strategi och värdeintervall som du vill utforska. Dessutom underlättar vår visualiseringslösning den iterativa analys- och experimentprocessen för att effektivt hitta välpresterande hyperparametervärden.

I nästa avsnitt bygger vi en sifferigenkänningsmodell från grunden med Scikit-learn och visar alla dessa koncept i praktiken.

Lösningsöversikt

SageMaker erbjuder några mycket praktiska funktioner för att träna, utvärdera och trimma vår modell. Den täcker all funktionalitet i en end-to-end ML-livscykel, så vi behöver inte ens lämna vår Jupyter-dator.

I vårt första inlägg använde vi SageMaker inbyggda algoritm XGBoost. I demonstrationssyfte byter vi denna gång till en Random Forest-klassificerare eftersom vi då kan visa hur du tillhandahåller din egen träningskod. Vi valde att tillhandahålla vårt eget Python-skript och använda Scikit-learn som vårt ramverk. Nu, hur uttrycker vi att vi vill använda ett specifikt ML-ramverk? Som vi kommer att se använder SageMaker en annan AWS-tjänst i bakgrunden för att hämta en förbyggd Docker-containerbild för utbildning—Amazon Elastic Container Registry (Amazon ECR).

Vi täcker följande steg i detalj, inklusive kodavsnitt och diagram för att koppla ihop prickarna. Som nämnts tidigare, om du har chansen, öppna anteckningsboken och kör kodcellerna steg för steg för att skapa artefakterna i din AWS-miljö. Det finns inget bättre sätt för aktivt lärande.

1. Ladda och förbered data först. Vi använder Amazon enkel lagringstjänst (Amazon S3) för att ladda upp en fil som innehåller våra handskrivna siffror.
2. Förbered sedan träningsskriptet och ramberoenden. Vi tillhandahåller den anpassade träningskoden i Python, refererar till några beroende bibliotek och gör en testkörning.
3. För att definiera de anpassade målvärdena låter SageMaker oss definiera ett reguljärt uttryck för att extrahera måtten vi behöver från behållarloggfilerna.
4. Träna modellen med hjälp av ramverket scikit-learn. Genom att referera till en förbyggd containerbild skapar vi ett motsvarande Estimator-objekt och skickar vårt anpassade träningsskript.
5. AMT gör det möjligt för oss att prova olika HPO-strategier. Vi koncentrerar oss på två av dem för det här inlägget: slumpmässig sökning och Bayesiansk sökning.
6. Välj mellan SageMaker HPO-strategier.
7. Visualisera, analysera och jämför inställningsresultat. Vårt visualiseringspaket låter oss upptäcka vilken strategi som presterar bättre och vilka hyperparametervärden som ger bäst prestanda baserat på våra mätvärden.
8. Fortsätt utforskningen av hyperparameterutrymmet och varma start HPO-jobb.

AMT tar hand om att skala och hantera den underliggande beräkningsinfrastrukturen för att köra de olika inställningsjobben på Amazon Elastic Compute Cloud (Amazon EC2) instanser. På så sätt behöver du inte belasta dig själv med att tillhandahålla instanser, hantera eventuella operativsystem- och maskinvaruproblem eller samla loggfiler på egen hand. ML-ramverksbilden hämtas från Amazon ECR och modellartefakterna inklusive inställningsresultat lagras i Amazon S3. Alla loggar och mätvärden samlas in amazoncloudwatch för bekväm åtkomst och ytterligare analys vid behov.

Förutsättningar

Eftersom detta är en fortsättning på en serie rekommenderas, men inte nödvändigtvis, att läsa vårt första inlägg om SageMaker AMT och HPO. Bortsett från det är grundläggande förtrogenhet med ML-koncept och Python-programmering till hjälp. Vi rekommenderar också att följa med varje steg i medföljande anteckningsbok från vårt GitHub-förråd medan du läser det här inlägget. Den bärbara datorn kan köras oberoende av den första, men behöver lite kod från undermappar. Se till att klona hela förvaret i din miljö enligt beskrivningen i README-filen.

Att experimentera med koden och använda de interaktiva visualiseringsalternativen förbättrar din inlärningsupplevelse avsevärt. Så kolla gärna upp det.

Ladda och förbered data

Som ett första steg ser vi till att den nedladdade siffror data vi behöver för utbildning är tillgänglig för SageMaker. Amazon S3 låter oss göra detta på ett säkert och skalbart sätt. Se anteckningsboken för den fullständiga källkoden och anpassa den gärna med dina egna data.

sm_sess = sagemaker.session.Session(boto_session=boto_sess, sagemaker_client=sm)
BUCKET = sm_sess.default_bucket()
PREFIX = 'amt-visualize-demo'
s3_data_url = f's3://{BUCKET}/{PREFIX}/data'
digits = datasets.load_digits()
digits_df = pd.DataFrame(digits.data)
digits_df['y'] = digits.target
digits_df.to_csv('data/digits.csv', index=False)
!aws s3 sync data/ {s3_data_url} —exclude '*' —include 'digits.csv'

Smakämnen digits.csv filen innehåller funktionsdata och etiketter. Varje siffra representeras av pixelvärden i en 8×8-bild, som visas av följande bild för siffran 4.

Förbered utbildningsskriptet och ramberoenden

Nu när data lagras i vår S3-hink kan vi definiera vårt anpassade träningsskript baserat på Scikit lära i Python. SageMaker ger oss möjligheten att helt enkelt referera till Python-filen senare för träning. Alla beroenden som Scikit-learn- eller pandasbiblioteken kan tillhandahållas på två sätt:

• De kan anges uttryckligen i en requirements.txt fil
• De är förinstallerade i den underliggande ML-containerbilden, som antingen tillhandahålls av SageMaker eller specialbyggd

Båda alternativen anses i allmänhet vara standardsätt för beroendehantering, så du kanske redan är bekant med det. SageMaker stöder en mängd olika ML-ramverk i en klar att använda hanterad miljö. Detta inkluderar många av de mest populära datavetenskapliga och ML-ramverken som PyTorch, TensorFlow eller Scikit-learn, som i vårt fall. Vi använder ingen extra requirements.txt fil, men lägg gärna till några bibliotek för att testa den.

Koden för vår implementering innehåller en metod som kallas fit(), som skapar en ny klassificerare för uppgiften för sifferigenkänning och tränar den. Till skillnad från vårt första inlägg där vi använde SageMaker inbyggda XGBoost-algoritm, använder vi nu en RandomForestClassifier tillhandahålls av ML-biblioteket sklearn. Uppmaningen av fit() metod på klassificerarens objekt startar träningsprocessen med en delmängd (80 %) av våra CSV-data:

def fit(train_dir, n_estimators, max_depth, min_samples_leaf, max_features, min_weight_fraction_leaf): digits = pd.read_csv(Path(train_dir)/'digits.csv') Xtrain, Xtest, ytrain, ytest = train_test_split(digits.iloc[:, :-1], digits.iloc[:, -1], test_size=.2) m = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth, min_samples_leaf=min_samples_leaf, max_features=max_features, min_weight_fraction_leaf=min_weight_fraction_leaf) m.fit(Xtrain, ytrain) predicted = m.predict(Xtest) pre, rec, f1, _ = precision_recall_fscore_support(ytest, predicted, pos_label=1, average='weighted') print(f'pre: {pre:5.3f} rec: {rec:5.3f} f1: {f1:5.3}') return m

Se hela manuset i vår Jupyter-anteckningsbok på GitHub.

Försökte du köra skriptet direkt innan du skapade containerresurser för hela utbildningsprocessen? Det här är en bra praxis för att snabbt säkerställa att koden inte har några syntaxfel, kontrollera efter matchande dimensioner för dina datastrukturer och några andra fel tidigt.

Det finns två sätt att köra din kod lokalt. Först kan du köra det direkt i anteckningsboken, vilket också låter dig använda Python Debugger pdb:

# Running the code from within the notebook. It would then be possible to use the Python Debugger, pdb.
from train import fit
fit('data', 100, 10, 1, 'auto', 0.01)

Alternativt kan du köra tågskriptet från kommandoraden på samma sätt som du kanske vill använda det i en container. Detta stöder också inställning av olika parametrar och överskrivning av standardvärdena efter behov, till exempel:

!cd src && python train.py --train ../data/ --model-dir /tmp/ --n-estimators 100

Som utdata kan du se de första resultaten för modellens prestanda baserat på objektiva mätvärden precision, återkallelse och F1-poäng. Till exempel, pre: 0.970 rec: 0.969 f1: 0.969.

Inte illa för en så snabb träning. Men var kom dessa siffror ifrån och vad gör vi med dem?

Definiera anpassade målvärden

Kom ihåg att vårt mål är att fullt ut träna och trimma vår modell baserat på de objektiva mått som vi anser vara relevanta för vår uppgift. Eftersom vi använder ett anpassat träningsskript måste vi definiera dessa mätvärden för SageMaker explicit.

Vårt manus avger mätvärdena precision, återkallelse och F1-poäng under träning helt enkelt genom att använda print fungera:

print(f'pre: {pre:5.3f} rec: {rec:5.3f} f1: {f1:5.3}')

Standardutgången fångas upp av SageMaker och skickas till CloudWatch som en loggström. För att hämta de metriska värdena och arbeta med dem senare i SageMaker AMT, måste vi tillhandahålla lite information om hur man analyserar den utdatan. Vi kan uppnå detta genom att definiera reguljära uttryckssatser (för mer information, se Övervaka och analysera utbildningsjobb med hjälp av Amazon CloudWatch Metrics):

metric_definitions = [ {'Name': 'valid-precision', 'Regex': r'pre:s+(-?[0-9.]+)'}, {'Name': 'valid-recall', 'Regex': r'rec:s+(-?[0-9.]+)'}, {'Name': 'valid-f1', 'Regex': r'f1:s+(-?[0-9.]+)'}] 

Låt oss gå igenom den första metriska definitionen i föregående kod tillsammans. SageMaker kommer att leta efter utdata i loggen som börjar med pre: och följs av ett eller flera blanksteg och sedan ett nummer som vi vill extrahera, varför vi använder den runda parentesen. Varje gång SageMaker hittar ett sådant värde, förvandlar det det till ett CloudWatch-mått med namnet valid-precision.

Träna modellen med hjälp av Scikit-learn-ramverket

Efter att vi skapat vårt träningsskript train.py och instruerar SageMaker om hur man övervakar mätvärdena inom CloudWatch, definierar vi en SageMaker Estimator objekt. Den initierar träningsjobbet och använder den instanstyp vi anger. Men hur kan den här instanstypen skilja sig från den du kör en Amazon SageMaker Studio anteckningsbok på, och varför? SageMaker Studio kör dina tränings- (och slutledningsjobb) på separata beräkningsinstanser än din bärbara dator. Detta gör att du kan fortsätta arbeta i din bärbara dator medan jobben körs i bakgrunden.

Parametern framework_version hänvisar till Scikit-learn-versionen vi använder för vårt träningsjobb. Alternativt kan vi passera image_uri till estimator. Du kan kontrollera om ditt favoritramverk eller ML-bibliotek är tillgängligt som en förbyggd SageMaker Docker-bild och använd den som den är eller med tillägg.

Dessutom kan vi köra SageMaker-utbildningsjobb på EC2 Spot-instanser genom att ställa in use_spot_instances till True. De är lediga kapacitetsinstanser som kan spara upp till 90 % av kostnaderna. Dessa instanser ger flexibilitet när utbildningsjobben körs.

estimator = SKLearn( 'train.py', source_dir='src', role=get_execution_role(), instance_type= 'ml.m5.large', instance_count=1, framework_version='0.23-1', metric_definitions=metric_definitions, # Uncomment the following three lines to use Managed Spot Training # use_spot_instances= True, # max_run= 60 * 60 * 24, # max_wait= 60 * 60 * 24, hyperparameters = {'n-estimators': 100, 'max-depth': 10, 'min-samples-leaf': 1, 'max-features': 'auto', 'min-weight-fraction-leaf': 0.1}
)

Efter att Estimator-objektet har ställts in startar vi utbildningen genom att anropa fit() funktion, tillhandahåller sökvägen till träningsdatauppsättningen på Amazon S3. Vi kan använda samma metod för att tillhandahålla validerings- och testdata. Vi ställer in wait parametern till True så vi kan använda den tränade modellen i de efterföljande kodcellerna.

estimator.fit({'train': s3_data_url}, wait=True)

Definiera hyperparametrar och kör inställningsjobb

Hittills har vi tränat modellen med en uppsättning hyperparametervärden. Men var dessa värden bra? Eller kan vi leta efter bättre? Låt oss använda HyperparameterTuner klass att köra en systematisk sökning över hyperparameterutrymmet. Hur söker vi det här utrymmet med tunern? De nödvändiga parametrarna är namnet på det objektiva måttet och den typ av mål som kommer att styra optimeringen. Optimeringsstrategin är ett annat nyckelargument för tunern eftersom den ytterligare definierar sökutrymmet. Följande är fyra olika strategier att välja mellan:

• Rutnätssökning
• Slumpmässig sökning
• Bayesiansk optimering (standard)
• Hyperband

Vi beskriver dessa strategier ytterligare och utrustar dig med lite vägledning för att välja en senare i det här inlägget.

Innan vi definierar och kör vårt tunerobjekt, låt oss sammanfatta vår förståelse ur ett arkitekturperspektiv. Vi täckte den arkitektoniska översikten av SageMaker AMT i vårt sista inlägg och återge ett utdrag av det här för enkelhetens skull.

Vi kan välja vilka hyperparametrar vi vill ställa in eller lämna statiska. För dynamiska hyperparametrar tillhandahåller vi hyperparameter_ranges som kan användas för att optimera för inställbara hyperparametrar. Eftersom vi använder en Random Forest-klassificerare har vi använt hyperparametrarna från Scikit-learn Random Forest-dokumentation.

Vi begränsar också resurserna med det maximala antalet träningsjobb och parallella träningsjobb som tunern kan använda. Vi kommer att se hur dessa gränser hjälper oss att jämföra resultaten av olika strategier med varandra.

tuner_parameters = { 'estimator': estimator, 'base_tuning_job_name': 'random', 'metric_definitions': metric_definitions, 'objective_metric_name': 'valid-f1', 'objective_type': 'Maximize', 'hyperparameter_ranges': hpt_ranges, 'strategy': 'Random', 'max_jobs': n, # 50 'max_parallel_jobs': k # 2 } 

Liknar skattarens fit funktion startar vi ett trimjobb som kallar tunerns fit:

random_tuner = HyperparameterTuner(**tuner_parameters)
random_tuner.fit({'train': s3_data_url}, wait=False)

Detta är allt vi behöver göra för att låta SageMaker sköta utbildningsjobben (n=50) i bakgrunden, var och en med olika uppsättning hyperparametrar. Vi utforskar resultaten senare i det här inlägget. Men innan dess, låt oss börja ett nytt trimjobb, denna gång med den Bayesianska optimeringsstrategin. Vi kommer att jämföra båda strategierna visuellt efter att de är klara.

tuner_parameters['strategy'] = 'Bayesian'
tuner_parameters['base_tuning_job_name'] = 'bayesian'
bayesian_tuner = HyperparameterTuner(**tuner_parameters)
bayesian_tuner.fit({'train': s3_data_url}, wait=False)

Observera att båda tunerjobben kan köras parallellt eftersom SageMaker orkestrerar de nödvändiga beräkningsinstanserna oberoende av varandra. Det är ganska användbart för utövare som experimenterar med olika tillvägagångssätt samtidigt, som vi gör här.

Välj mellan SageMaker HPO-strategier

När det gäller justering av strategier har du några alternativ med SageMaker AMT: rutnätssökning, slumpmässig sökning, Bayesiansk optimering och Hyperband. Dessa strategier avgör hur de automatiska inställningsalgoritmerna utforskar de specificerade intervallen av hyperparametrar.

Slumpmässig sökning är ganska okomplicerad. Den väljer slumpmässigt kombinationer av värden från de angivna intervallen och kan köras på ett sekventiellt eller parallellt sätt. Det är som att kasta pilar med ögonbindel i hopp om att träffa målet. Vi har börjat med den här strategin, men kommer resultaten att förbättras med en annan?

Bayesiansk optimering tar ett annat tillvägagångssätt än slumpmässig sökning. Den tar hänsyn till historiken för tidigare val och väljer värden som sannolikt kommer att ge de bästa resultaten. Om du vill lära dig av tidigare utforskningar kan du bara uppnå detta genom att köra ett nytt trimningsjobb efter de tidigare. Vettigt, eller hur? På så sätt är Bayesiansk optimering beroende av de tidigare körningarna. Men ser du vilken HPO-strategi som möjliggör högre parallellisering?

Hyperband är en intressant sådan! Den använder en multi-fidelity-strategi, vilket innebär att den dynamiskt allokerar resurser till de mest lovande utbildningsjobben och stoppar de som inte presterar. Därför är Hyperband beräkningseffektivt med resurser och lär sig av tidigare träningsjobb. Efter att ha stoppat de underpresterande konfigurationerna startar en ny konfiguration och dess värden väljs slumpmässigt.

Beroende på dina behov och typen av din modell kan du välja mellan slumpmässig sökning, Bayesiansk optimering eller Hyperband som din inställningsstrategi. Var och en har sin egen strategi och sina fördelar, så det är viktigt att överväga vilken som fungerar bäst för din ML-utforskning. De goda nyheterna för ML-utövare är att du kan välja den bästa HPO-strategin genom att visuellt jämföra effekten av varje försök på det objektiva måttet. I nästa avsnitt ser vi hur man visuellt identifierar effekterna av olika strategier.

Visualisera, analysera och jämför inställningsresultat

När våra trimjobb är klara blir det spännande. Vilka resultat ger de? Vilken typ av uppsving kan du förvänta dig på vårt mått jämfört med din basmodell? Vilka är de bäst presterande hyperparametrarna för vårt användningsfall?

Ett snabbt och enkelt sätt att se HPO-resultaten är genom att besöka SageMaker-konsolen. Under Hyperparameter tuning jobb, kan vi se (per trimningsjobb) kombinationen av hyperparametervärden som har testats och levererat bästa prestanda mätt med vårt objektiva mått (valid-f1).

Är det allt du behöver? Som ML-utövare kanske du inte bara är intresserad av dessa värderingar, utan du vill verkligen lära dig mer om din modells inre funktioner för att utforska dess fulla potential och stärka din intuition med empirisk feedback.

Ett bra visualiseringsverktyg kan i hög grad hjälpa dig att förstå förbättringen av HPO över tid och få empirisk feedback på designbeslut för din ML-modell. Den visar effekten av varje enskild hyperparameter på ditt objektiva mått och ger vägledning för att ytterligare optimera dina inställningsresultat.

Vi använder amtviz anpassat visualiseringspaket för att visualisera och analysera trimningsjobb. Den är enkel att använda och har användbara funktioner. Vi visar dess fördel genom att tolka några individuella diagram och slutligen jämföra slumpmässig sökning sida vid sida med Bayesiansk optimering.

Låt oss först skapa en visualisering för slumpmässig sökning. Vi kan göra detta genom att ringa visualize_tuning_job() från amtviz och skickar vårt första tunerobjekt som ett argument:

from amtviz import visualize_tuning_job
visualize_tuning_job(random_tuner, advanced=True, trials_only=True)

Du kommer att se ett par diagram, men låt oss ta det steg för steg. Det första spridningsdiagrammet från utgången ser ut som följande och ger oss redan några visuella ledtrådar som vi inte skulle känna igen i någon tabell.

Varje prick representerar resultatet av ett individuellt träningsjobb (vårt mål valid-f1 på y-axeln) baserat på dess starttid (x-axel), producerad av en specifik uppsättning hyperparametrar. Därför tittar vi på prestandan för vår modell när den fortskrider under trimningsjobbets varaktighet.

Den prickade linjen framhäver det bästa resultatet hittills och indikerar förbättring över tid. De två bästa träningsjobben fick en F1-poäng på cirka 0.91.

Förutom den prickade linjen som visar de kumulativa framstegen, ser du en trend i diagrammet?

Antagligen inte. Och detta förväntas, eftersom vi tittar på resultaten av den slumpmässiga HPO-strategin. Varje träningsjobb kördes med en annan men slumpmässigt utvald uppsättning hyperparametrar. Om vi ​​fortsatte vårt trimjobb (eller körde ett annat med samma inställning) skulle vi förmodligen se några bättre resultat med tiden, men vi kan inte vara säkra. Slumpmässighet är en knepig sak.

Följande diagram hjälper dig att mäta inverkan av hyperparametrar på den övergripande prestandan. Alla hyperparametrar är visualiserade, men för korthetens skull fokuserar vi på två av dem: n-estimators och max-depth.

Våra två bästa utbildningsjobb använde n-estimators på cirka 20 och 80, och max-depth på cirka 10 respektive 18. De exakta hyperparametervärdena visas via verktygstips för varje punkt (träningsjobb). De är till och med dynamiskt framhävda i alla diagram och ger dig en flerdimensionell vy! Såg du att? Varje hyperparameter plottas mot det objektiva måttet, som ett separat diagram.

Nu, vilken typ av insikter får vi om n-estimators?

Baserat på det vänstra diagrammet verkar det som att mycket låga värdeintervall (under 10) oftare ger dåliga resultat jämfört med högre värden. Därför kan högre värden hjälpa din modell att prestera bättre – intressant.

Däremot korrelationen mellan max-depth hyperparametern till vårt objektiva mått är ganska låg. Vi kan inte tydligt avgöra vilka värdeintervall som ger bättre resultat ur ett allmänt perspektiv.

Sammanfattningsvis kan slumpmässig sökning hjälpa dig att hitta en välpresterande uppsättning hyperparametrar även på relativt kort tid. Dessutom är det inte partisk för en bra lösning utan ger en balanserad bild av sökutrymmet. Ditt resursutnyttjande kanske inte är särskilt effektivt. Den fortsätter att köra träningsjobb med hyperparametrar i värdeintervall som är kända för att ge dåliga resultat.

Låt oss undersöka resultaten av vårt andra trimningsjobb med Bayesiansk optimering. Vi kan använda amtviz att visualisera resultaten på samma sätt som vi gjort hittills för den slumpmässiga söktunern. Eller ännu bättre, vi kan använda funktionen för att jämföra båda inställningsjobben i en enda uppsättning diagram. Ganska praktiskt!

visualize_tuning_job([random_tuner, bayesian_tuner], advanced=True, trials_only=True)

Det finns fler prickar nu eftersom vi visualiserar resultaten av alla träningsjobb för båda, den slumpmässiga sökningen (orange prickar) och den Bayesianska optimeringen (blå prickar). På höger sida kan du se ett densitetsdiagram som visualiserar fördelningen av alla F1-poäng. En majoritet av träningsjobben uppnådde resultat i den övre delen av F1-skalan (över 0.6) – det är bra!

Vad är nyckeln här? Spridningsdiagrammet visar tydligt fördelen med Bayesiansk optimering. Den ger bättre resultat över tid eftersom den kan lära sig av tidigare körningar. Det är därför vi uppnådde betydligt bättre resultat med Bayesian jämfört med slumpmässigt (0.967 mot 0.919) med samma antal träningsjobb.

Det finns ännu mer du kan göra med amtviz. Låt oss borra in.

Om du ger SageMaker AMT instruktionen att köra ett större antal jobb för trimning, kan det bli rörigt att se många försök samtidigt. Det är en av anledningarna till att vi gjorde dessa diagram interaktiva. Du kan klicka och dra på varje scatterplot för hyperparameter för att zooma in på vissa värdeområden och förfina din visuella tolkning av resultaten. Alla andra diagram uppdateras automatiskt. Det är ganska användbart, eller hur? Se nästa diagram som ett exempel och prova det själv i din anteckningsbok!

Som inställningsmaximalist kan du också bestämma dig för att köra ytterligare ett hyperparameterjusteringsjobb ytterligare kan förbättra din modellprestanda. Men den här gången kan ett mer specifikt område av hyperparametervärden utforskas eftersom du redan vet (ungefär) var du kan förvänta dig bättre resultat. Du kan till exempel välja att fokusera på värden mellan 100–200 för n-estimators, som visas i diagrammet. Detta låter AMT fokusera på de mest lovande träningsjobben och ökar din inställningseffektivitet.

För att summera, amtviz ger dig en rik uppsättning visualiseringsfunktioner som låter dig bättre förstå effekten av din modells hyperparametrar på prestanda och möjliggör smartare beslut i dina trimningsaktiviteter.

Fortsätt utforskningen av hyperparameterutrymmet och varma start HPO-jobb

Vi har sett att AMT hjälper oss att utforska hyperparametersökutrymmet effektivt. Men vad händer om vi behöver flera omgångar av trimning för att iterativt förbättra våra resultat? Som nämndes i början vill vi upprätta en optimeringsåterkopplingscykel - vår "konversation" med modellen. Behöver vi börja om från början varje gång?

Låt oss titta på konceptet att köra en varmstart hyperparameter tuning jobb. Den initierar inte nya trimningsjobb från grunden, den återanvänder det som har lärts i de tidigare HPO-körningarna. Detta hjälper oss att bli mer effektiva med vår inställningstid och beräkningsresurser. Vi kan ytterligare iterera ovanpå våra tidigare resultat. För att använda varma starter skapar vi en WarmStartConfig och specificera warm_start_type as IDENTICAL_DATA_AND_ALGORITHM. Det betyder att vi ändrar hyperparametervärdena men vi ändrar inte data eller algoritm. Vi säger åt AMT att överföra förkunskaperna till vårt nya trimjobb.

Genom att hänvisa till våra tidigare Bayesianska optimerings- och slumpmässiga sökningsjobb som parents, vi kan använda dem båda för den varma starten:

warm_start_config = WarmStartConfig(warm_start_type=WarmStartTypes.IDENTICAL_DATA_AND_ALGORITHM, parents=[bayesian_tuner_name, random_tuner_name])
tuner_parameters['warm_start_config'] = warm_start_config

För att se fördelarna med att använda varma starter, se följande diagram. Dessa genereras av amtviz på liknande sätt som vi gjorde tidigare, men den här gången har vi lagt till ytterligare ett trimjobb baserat på en varm start.

I det vänstra diagrammet kan vi observera att nya trimningsjobb mestadels ligger i det övre högra hörnet av prestandametriska grafen (se prickar markerade i orange). Varmstarten har verkligen återanvänt de tidigare resultaten, vilket är anledningen till att dessa datapunkter finns i toppresultaten för F1-poäng. Denna förbättring återspeglas också i densitetsdiagrammet till höger.

Med andra ord väljer AMT automatiskt lovande uppsättningar av hyperparametervärden baserat på dess kunskap från tidigare försök. Detta visas i nästa diagram. Algoritmen skulle till exempel testa ett lågt värde för n-estimators mindre ofta eftersom dessa är kända för att ge dåliga F1-poäng. Vi slösar inga resurser på det, tack vare varma starter.

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 SageMaker 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

Vi har lärt oss hur konsten att bygga ML-lösningar innebär att utforska och optimera hyperparametrar. Att justera dessa rattar och spakar är en krävande men ändå givande process som leder till snabbare träningstider, förbättrad modellnoggrannhet och överlag bättre ML-lösningar. SageMaker AMT-funktionaliteten hjälper oss att köra flera trimningsjobb och starta dem varmt, och tillhandahåller datapunkter för ytterligare granskning, visuell jämförelse och analys.

I det här inlägget tittade vi på HPO-strategier som vi använder med SageMaker AMT. Vi började med slumpmässig sökning, en enkel men presterande strategi där hyperparametrar slumpmässigt samplas från ett sökutrymme. Därefter jämförde vi resultaten med Bayesiansk optimering, som använder probabilistiska modeller för att vägleda sökningen efter optimala hyperparametrar. Efter att vi identifierat en lämplig HPO-strategi och bra hyperparametervärdeintervall genom inledande försök, visade vi hur man använder varma starter för att effektivisera framtida HPO-jobb.

Du kan utforska hyperparametersökutrymmet genom att jämföra kvantitativa resultat. Vi har föreslagit den visuella jämförelsen sida vid sida och tillhandahållit det nödvändiga paketet för interaktiv utforskning. Låt oss veta i kommentarerna hur användbart det var för dig på din resa med hyperparameterinställning!

Om författarna

Ümit Yoldas är en senior lösningsarkitekt med Amazon Web Services. Han arbetar med företagskunder över branscher i Tyskland. Han drivs av att översätta AI-koncept till verkliga lösningar. Utanför jobbet njuter han av tid med familjen, njuter av god mat och utövar träning.

Elina Lesyk är en lösningsarkitekt i München. Hon fokuserar på företagskunder från finansbranschen. På fritiden kan du hitta Elina som bygger applikationer med generativ AI på vissa IT-träffar, driver en ny idé om att åtgärda klimatförändringarna snabbt eller springer i skogen för att förbereda sig för ett halvmaraton med en typisk avvikelse från det planerade schemat.

Mariano Kamp är en Principal Solutions Architect med Amazon Web Services. Han arbetar med banker och försäkringsbolag i Tyskland med maskininlärning. På fritiden tycker Mariano om att vandra med sin fru.

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• Källa: https://aws.amazon.com/blogs/machine-learning/explore-advanced-techniques-for-hyperparameter-optimization-with-amazon-sagemaker-automatic-model-tuning/