Optimaliseer hyperparameters met Amazon SageMaker Automatic Model Tuning

Machine learning (ML)-modellen veroveren de wereld stormenderhand. Hun prestaties zijn afhankelijk van het gebruik van de juiste trainingsgegevens en het kiezen van het juiste model en algoritme. Maar hier houdt het niet op. Doorgaans stellen algoritmen sommige ontwerpbeslissingen uit aan de ML-beoefenaar om deze over te nemen voor hun specifieke gegevens en taak. Deze uitgestelde ontwerpbeslissingen manifesteren zich als hyperparameters.

Wat betekent die naam? Het resultaat van ML-training, het model, kan grotendeels worden gezien als een verzameling parameters die tijdens de training worden geleerd. Daarom worden de parameters die worden gebruikt om het ML-trainingsproces te configureren hyperparameters genoemd: parameters die het maken van parameters beschrijven. In ieder geval zijn ze van zeer praktisch nut, zoals het aantal te trainen tijdperken, het leertempo, de maximale diepte van een beslissingsboom, enzovoort. En we besteden er veel aandacht aan omdat ze een grote impact hebben op de uiteindelijke prestaties van uw model.

Net als het draaien aan een knop op een radio-ontvanger om de juiste frequentie te vinden, moet elke hyperparameter zorgvuldig worden afgesteld om de prestaties te optimaliseren. Het zoeken in de hyperparameterruimte naar de optimale waarden wordt genoemd afstemming van hyperparameters or hyperparameter optimalisatie (HPO), en moet resulteren in een model dat nauwkeurige voorspellingen geeft.

In dit bericht hebben we onze eerste HPO-taak opgezet en uitgevoerd met behulp van Amazon SageMaker automatische modelafstemming (AMT). We leren over de methoden die beschikbaar zijn om de resultaten te verkennen en creëren een aantal inzichtelijke visualisaties van onze HPO-onderzoeken en de verkenning van de hyperparameterruimte!

Amazon SageMaker automatische modelafstemming

Als een ML-beoefenaar die gebruikt SageMaker AMT, kunt u zich richten op het volgende:

• Het geven van een opleidingsbaan
• Het definiëren van de juiste objectieve maatstaf die past bij uw taak
• Scoring van de hyperparameter-zoekruimte

SageMaker AMT zorgt voor de rest, en u hoeft niet na te denken over de infrastructuur, het orkestreren van trainingstaken en het verbeteren van hyperparameterselectie.

Laten we beginnen met het gebruik van SageMaker AMT voor onze eerste eenvoudige HPO-taak, om een ​​XGBoost-algoritme te trainen en af ​​te stemmen. We willen dat uw AMT-reis praktijkgericht en praktisch is, daarom hebben we het voorbeeld hieronder gedeeld GitHub-repository. Dit bericht heeft betrekking op de 1_tuning_of_builtin_xgboost.ipynb notebook.

In een volgend bericht zullen we het idee van alleen het vinden van de beste hyperparameters uitbreiden en leren over de zoekruimte en voor welke hyperparameterbereiken een model gevoelig is. We laten ook zien hoe je een eenmalige afstemmingsactiviteit kunt omzetten in een meerstapsgesprek met de ML-beoefenaar, om samen te leren. Blijf op de hoogte (bedoelde woordspeling)!

Voorwaarden

Dit bericht is bedoeld voor iedereen die meer wil weten over HPO en geen voorkennis van het onderwerp vereist. Basiskennis van ML-concepten en Python-programmering is echter nuttig. Voor de beste leerervaring raden we je ten zeerste aan om mee te volgen elke stap in het notitieblok uitvoeren tegelijk met het lezen van dit bericht. En aan het einde van de notebook kunt u ook een interactieve visualisatie uitproberen die de afstemmingsresultaten tot leven brengt.

Overzicht oplossingen

We gaan een end-to-end setup bouwen om onze eerste HPO-taak uit te voeren met behulp van SageMaker AMT. Wanneer onze afstemmingstaak is voltooid, kijken we naar enkele van de beschikbare methoden om de resultaten te verkennen, beide via de AWS-beheerconsole en programmatisch via de AWS SDK's en API's.

Eerst maken we ons vertrouwd met de omgeving en SageMaker Training door een zelfstandige trainingstaak uit te voeren, voorlopig zonder enige afstemming. We gebruiken het XGBoost-algoritme, een van de vele algoritmen die als SageMaker ingebouwd algoritme (geen trainingsscript vereist!).

We zien hoe SageMaker Training op de volgende manieren werkt:

• Start en stopt een instantie
• Bevoorraadt de nodige container
• Kopieert de trainings- en validatiegegevens naar de instantie
• Verzorgt de opleiding
• Verzamelt statistieken en logboeken
• Verzamelt en slaat het getrainde model op

Daarna verhuizen we naar AMT en voeren we een HPO-taak uit:

• We hebben onze afstemmingstaak opgezet en gelanceerd met AMT
• We duiken in de beschikbare methoden om gedetailleerde prestatiestatistieken en metadata voor elke trainingstaak te extraheren, waardoor we meer te weten kunnen komen over de optimale waarden in onze hyperparameterruimte
• We laten u zien hoe u de resultaten van de onderzoeken kunt bekijken
• We bieden u hulpmiddelen om gegevens te visualiseren in een reeks grafieken die waardevolle inzichten in onze hyperparameterruimte onthullen

Train een in SageMaker ingebouwd XGBoost-algoritme

Het begint allemaal met het trainen van een model. Door dit te doen, krijgen we een idee van hoe SageMaker Training werkt.

We willen profiteren van de snelheid en het gebruiksgemak van de SageMaker ingebouwde algoritmen. Alles wat we nodig hebben zijn een paar stappen om te beginnen met trainen:

1. Bereid de gegevens voor en laad ze – We downloaden en bereiden onze dataset voor als invoer voor XGBoost en uploaden deze naar onze Amazon eenvoudige opslagservice (Amazon S3) emmer.
2. Selecteer de afbeeldings-URI van ons ingebouwde algoritme – SageMaker gebruikt deze URI om onze trainingscontainer op te halen, die in ons geval een kant-en-klaar XGBoost-trainingsscript bevat. Er worden verschillende algoritmeversies ondersteund.
3. Definieer de hyperparameters – SageMaker biedt een interface om de hyperparameters voor ons ingebouwde algoritme. Dit zijn dezelfde hyperparameters die worden gebruikt door de open-sourceversie.
4. Construeer de schatter – We definiëren de trainingsparameters zoals instantietype en aantal instanties.
5. Roep de functie fit() aan – We beginnen onze trainingsbaan.

Het volgende diagram laat zien hoe deze stappen samenwerken.

Geef de gegevens door

Om ML-training uit te voeren, moeten we gegevens verstrekken. We verstrekken onze trainings- en validatiegegevens aan SageMaker via Amazon S3.

In ons voorbeeld gebruiken we voor de eenvoud de standaardbucket van SageMaker om onze gegevens op te slaan. Maar voel je vrij om de volgende waarden naar eigen voorkeur aan te passen:

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

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

In de notebook gebruiken we een openbare dataset en slaan we de gegevens lokaal op in de data map. Vervolgens uploaden we onze trainings- en validatiegegevens naar Amazon S3. Later definiëren we ook verwijzingen naar deze locaties om ze door te geven aan 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')

In deze post concentreren we ons op de introductie van HPO. Ter illustratie gebruiken we een specifieke dataset en taak, zodat we metingen van objectieve metrieken kunnen verkrijgen die we vervolgens gebruiken om de selectie van hyperparameters te optimaliseren. Voor de algemene functie zijn noch de gegevens, noch de taak van belang. Om u een compleet beeld te geven, beschrijven we kort wat we doen: we trainen een XGBoost-model dat handgeschreven cijfers uit de
Optische herkenning van gegevensset met handgeschreven cijfers [1] via Scikit-leer. XGBoost is een uitstekend algoritme voor gestructureerde data en kan zelfs worden toegepast op de Digits-dataset. De waarden zijn 8×8 afbeeldingen, zoals in het volgende voorbeeld met a
0 a
5 en
4.

Selecteer de XGBoost-afbeeldings-URI

Nadat we ons ingebouwde algoritme (XGBoost) hebben gekozen, moeten we de afbeeldings-URI ophalen en deze doorgeven aan SageMaker om in onze trainingsinstantie te laden. Voor deze stap bekijken we de beschikbare versies. Hier hebben we besloten om versie 1.5.1 te gebruiken, die de nieuwste versie van het algoritme biedt. Afhankelijk van de taak kunnen ML-beoefenaars hun eigen trainingsscript schrijven dat bijvoorbeeld stappen voor gegevensvoorbereiding bevat. Maar dat is in ons geval niet nodig.

Als je je eigen trainingsscript wilt schrijven, houd ons dan in de gaten, we helpen je in ons volgende bericht! We laten u zien hoe u SageMaker-trainingstaken kunt uitvoeren met uw eigen aangepaste trainingsscripts.

Voor nu hebben we de juiste afbeeldings-URI nodig door het algoritme, de AWS-regio en het versienummer op te geven:

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

Dat is het. Nu hebben we een verwijzing naar het XGBoost-algoritme.

Definieer de hyperparameters

Nu definiëren we onze hyperparameters. Deze waarden configureren hoe ons model wordt getraind en beïnvloeden uiteindelijk hoe het model presteert ten opzichte van de objectieve statistiek waarmee we meten, zoals nauwkeurigheid in ons geval. Merk op dat niets over het volgende codeblok specifiek is voor SageMaker. We gebruiken eigenlijk de open-source versie van XGBoost, zojuist geleverd door en geoptimaliseerd voor SageMaker.

Hoewel elk van deze hyperparameters configureerbaar en aanpasbaar is, is de objectieve metriek multi:softmax wordt bepaald door onze dataset en het type probleem waarvoor we een oplossing zoeken. In ons geval bevat de dataset Cijfers meerdere labels (een observatie van een handgeschreven cijfer kan 0 or 1,2,3,4,5,6,7,8,9), wat betekent dat het een classificatieprobleem met meerdere klassen is.

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
}

Raadpleeg voor meer informatie over de andere hyperparameters XGBoost-hyperparameters.

Construeer de schatter

We configureren de training op een schatterobject, een interface op hoog niveau voor SageMaker Training.

Vervolgens definiëren we het aantal instanties waarop moet worden getraind, het instantietype (CPU-gebaseerd of GPU-gebaseerd) en de grootte van de gekoppelde opslag:

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
)

We hebben nu de infrastructuurconfiguratie die we nodig hebben om aan de slag te gaan. SageMaker Training zorgt voor de rest.

Roep de functie fit() aan

Weet je nog de gegevens die we eerder naar Amazon S3 hebben geüpload? Nu maken we er verwijzingen naar:

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')

Een oproep naar fit() start onze opleiding. We geven de verwijzingen door naar de trainingsgegevens die we zojuist hebben gemaakt om SageMaker Training naar onze trainings- en validatiegegevens te verwijzen:

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

Merk op dat om HPO later uit te voeren, we eigenlijk niet hoeven te bellen fit() hier. We hebben later alleen het schatterobject nodig voor HPO en kunnen gewoon doorgaan met het maken van onze HPO-taak. Maar omdat we meer willen weten over SageMaker Training en willen zien hoe we een enkele trainingstaak kunnen uitvoeren, noemen we het hier en bekijken we de uitvoer.

Nadat de training is gestart, beginnen we de uitvoer onder de cellen te zien, zoals weergegeven in de volgende schermafbeelding. De uitvoer is beschikbaar in Amazon Cloud Watch en in dit notitieboekje.

De zwarte tekst is logboekuitvoer van SageMaker zelf, die de stappen laat zien die betrokken zijn bij trainingsorkestratie, zoals het starten van de instantie en het laden van de trainingsafbeelding. De blauwe tekst wordt rechtstreeks vanuit de trainingsinstantie zelf uitgevoerd. We kunnen het proces van het laden en parseren van de trainingsgegevens observeren en de voortgang van de training en de verbetering van de objectieve meetgegevens visueel zien, rechtstreeks vanuit het trainingsscript dat op de instantie wordt uitgevoerd.

Merk ook op dat aan het einde van de uitvoertaak de trainingsduur in seconden en factureerbare seconden worden weergegeven.

Ten slotte zien we dat SageMaker ons trainingsmodel uploadt naar het S3-uitvoerpad dat is gedefinieerd op het schatterobject. Het model is klaar om te worden ingezet voor inferentie.

In een toekomstige post zullen we onze eigen trainingscontainer maken en onze trainingsstatistieken definiëren om uit te zenden. U zult zien hoe SageMaker agnostisch is van welke container u het doorgeeft voor training. Dit is erg handig voor als je snel aan de slag wilt met een ingebouwd algoritme, maar later besluit om je eigen aangepaste trainingsscript door te geven!

Inspecteer huidige en eerdere trainingsbanen

Tot nu toe hebben we vanuit ons notitieboekje met onze code gewerkt en trainingsopdrachten ingediend bij SageMaker. Laten we van perspectief wisselen en de notebook even laten staan ​​om te kijken hoe dit eruit ziet op de SageMaker-console.

SageMaker houdt een historisch overzicht bij van de uitgevoerde trainingstaken, hun configuraties zoals hyperparameters, algoritmen, gegevensinvoer, de factureerbare tijd en de resultaten. In de lijst in de voorgaande schermafbeelding ziet u de meest recente trainingstaken die zijn gefilterd voor XGBoost. De gemarkeerde trainingstaak is de taak die we zojuist hebben getraind in het notitieboek, waarvan u de uitvoer eerder hebt gezien. Laten we in deze individuele trainingsbaan duiken om meer informatie te krijgen.

De volgende schermafbeelding toont de consoleweergave van onze trainingstaak.

We kunnen de informatie die we hebben ontvangen bekijken als celuitvoer naar onze fit() functie in de individuele trainingstaak binnen de SageMaker-console, samen met de parameters en metadata die we in onze schatter hebben gedefinieerd.

Roep de logboekuitvoer op van de trainingsinstantie die we eerder hebben gezien. We hebben hier ook toegang tot de logboeken van onze trainingstaak door naar de monitor sectie en kiezen Logboeken bekijken.

Dit toont ons de instantielogboeken in CloudWatch.

Onthoud ook de hyperparameters die we in ons notitieboek hebben opgegeven voor de trainingstaak. We zien ze hier ook in dezelfde gebruikersinterface van de trainingstaak.

De details en metadata die we eerder hebben opgegeven voor onze trainingstaak en schatter, zijn zelfs te vinden op deze pagina op de SageMaker-console. We hebben een handig overzicht van de instellingen die voor de training zijn gebruikt, zoals welke trainingscontainer is gebruikt en de locaties van de trainings- en validatiedatasets.

U vraagt ​​zich nu misschien af ​​waarom dit precies relevant is voor optimalisatie van hyperparameters? Het is omdat je kunt zoeken, inspecteren en dieper kunt duiken in die HPO-onderzoeken waarin we geïnteresseerd zijn. Misschien degenen met de beste resultaten, of degenen die interessant gedrag vertonen. Wat jij definieert als 'interessant' laten we aan jou over. Het geeft ons een gemeenschappelijke interface voor het inspecteren van onze trainingsopdrachten, en u kunt het gebruiken met SageMaker Search.

Hoewel SageMaker AMT de HPO-taken orkestreert, worden de HPO-proeven allemaal gelanceerd als individuele SageMaker-trainingstaken en zijn ze als zodanig toegankelijk.

Met training gedekt, laten we afstemmen!

Train en tune een in SageMaker ingebouwd XGBoost-algoritme

Om ons XGBoost-model af te stemmen, gaan we onze bestaande hyperparameters hergebruiken en waardenbereiken definiëren die we voor hen willen verkennen. Zie dit als het uitbreiden van de grenzen van verkenning binnen onze hyperparameter-zoekruimte. Onze afstemmingstaak neemt monsters uit de zoekruimte en voert trainingstaken uit voor nieuwe combinaties van waarden. De volgende code laat zien hoe u de hyperparameterbereiken specificeert waaruit SageMaker AMT moet samplen:

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)
}

De bereiken voor een individuele hyperparameter worden gespecificeerd door hun type, zoals ContinueParameter. Raadpleeg voor meer informatie en tips over het kiezen van deze parameterbereiken Een XGBoost-model afstemmen.

We hebben nog geen experimenten uitgevoerd, dus we kennen het bereik van goede waarden voor onze hyperparameters niet. Daarom beginnen we met een weloverwogen gok, gebruikmakend van onze kennis van algoritmen en onze documentatie van de hyperparameters voor de ingebouwde algoritmen. Dit definieert een startpunt om de zoekruimte te definiëren.

Vervolgens voeren we een afstemtaakbemonstering uit van hyperparameters in de gedefinieerde bereiken. Hierdoor kunnen we zien welke hyperparameterbereiken goede resultaten opleveren. Met deze kennis kunnen we de grenzen van de zoekruimte verfijnen door de te gebruiken hyperparameterbereiken te verkleinen of te verbreden. In het volgende en laatste deel laten we zien hoe we van de proeven kunnen leren, waar we de resultaten onderzoeken en visualiseren.

In onze volgende post zetten we onze reis voort en duiken we dieper. Bovendien zullen we leren dat er verschillende strategieën zijn die we kunnen gebruiken om onze zoekruimte te verkennen. We zullen volgende HPO-taken uitvoeren om nog meer performante waarden voor onze hyperparameters te vinden, terwijl we deze verschillende strategieën vergelijken. We zullen ook zien hoe we een warme start kunnen maken met SageMaker AMT om de kennis die is opgedaan met eerder verkende zoekruimten te gebruiken bij onze verkenning buiten die aanvankelijke grenzen.

Voor deze post richten we ons op het analyseren en visualiseren van de resultaten van een enkele HPO-taak met behulp van de Bayesiaanse zoekstrategie, wat waarschijnlijk een goed startpunt is.

Als je meegaat in het gekoppelde notitieboekje, houd er dan rekening mee dat we dezelfde schatter doorgeven die we gebruikten voor onze enkele, ingebouwde XGBoost-trainingstaak. Dit Estimator-object fungeert als sjabloon voor nieuwe trainingstaken die AMT maakt. AMT zal dan de hyperparameters variëren binnen de bereiken die we hebben gedefinieerd.

Door te specificeren dat we onze objectieve maatstaf willen maximaliseren, validation:accuracy, vertellen we SageMaker AMT om naar deze statistieken te zoeken in de trainingsinstantielogboeken en hyperparameterwaarden te kiezen waarvan het denkt dat ze de nauwkeurigheidsmetriek op onze validatiegegevens zullen maximaliseren. We hebben een geschikte gekozen objectieve maatstaf voor XGBoost uit onze documentatie.

Bovendien kunnen we profiteren van parallellisatie met max_parallel_jobs. Dit kan een krachtig hulpmiddel zijn, vooral voor strategieën waarvan de proeven onafhankelijk worden geselecteerd, zonder rekening te houden met (leren van) de uitkomsten van eerdere proeven. We zullen deze andere strategieën en parameters verder onderzoeken in ons volgende bericht. Voor dit bericht gebruiken we Bayesiaans, wat een uitstekende standaardstrategie is.

We definiëren ook max_jobs om te definiëren hoeveel proeven er in totaal moeten worden uitgevoerd. Wijk gerust af van ons voorbeeld en gebruik een kleiner aantal om geld te besparen.

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
}

We bellen nog een keer fit(), op dezelfde manier als toen we eerder in de post een enkele trainingsbaan lanceerden. Maar deze keer op het tunerobject, niet op het schatterobject. Dit start de afstemmingstaak en op zijn beurt begint AMT met trainingstaken.

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}.')

Het volgende diagram breidt onze eerdere architectuur uit door HPO op te nemen met SageMaker AMT.

We zien dat onze HPO-taak is ingediend. Afhankelijk van het aantal proeven, gedefinieerd door n_jobs en het niveau van parallellisatie, kan dit enige tijd duren. Voor ons voorbeeld kan het tot 30 minuten duren voor 50 pogingen met slechts een parallellisatieniveau van 3.

tuning job submitted: bayesian-221102-2053.

Wanneer deze afstemmingstaak is voltooid, gaan we de informatie bekijken die voor ons beschikbaar is op de SageMaker-console.

Onderzoek AMT-taken op de console

Laten we onze afstemmingstaak op de SageMaker-console vinden door te kiezen Trainingen in het navigatievenster en dan Taken voor het afstemmen van hyperparameters. Dit geeft ons een lijst met onze AMT-taken, zoals weergegeven in de volgende schermafbeelding. Hier vinden we onze bayesian-221102-2053 afstemmingsopdracht en ontdek dat deze nu voltooid is.

Laten we de resultaten van deze HPO-klus eens nader bekijken.

We hebben onderzocht hoe de resultaten programmatisch kunnen worden geëxtraheerd in de notitieboekje. Eerst via de SageMaker Python-SDK, een open-source Python-bibliotheek van een hoger niveau, die een speciale API biedt voor SageMaker. Dan door Boto3, die ons voorziet van API's op een lager niveau voor SageMaker en andere AWS-services.

Met behulp van de SageMaker Python SDK kunnen we de resultaten van onze HPO-taak verkrijgen:

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

Hierdoor konden we de resultaten van elk van onze proeven analyseren in een Pandas DataFrame, zoals te zien is in de volgende schermafbeelding.

Laten we nu weer van perspectief wisselen en kijken hoe de resultaten eruit zien op de SageMaker-console. Vervolgens kijken we naar onze aangepaste visualisaties.

Kies op dezelfde pagina onze bayesian-221102-2053 tuning job geeft ons een lijst met proeven die zijn uitgevoerd voor onze tuning job. Elke HPO-proef hier is een SageMaker-trainingstaak. Herinner me eerder toen we ons enkele XGBoost-model trainden en de trainingstaak in de SageMaker-console onderzochten. We kunnen hetzelfde doen voor onze beproevingen hier.

Als we onze beproevingen onderzoeken, zien we dat bayesian-221102-2053-048-b59ec7b4 creëerde het best presterende model, met een validatienauwkeurigheid van ongeveer 89.815%. Laten we eens kijken welke hyperparameters tot deze prestatie hebben geleid door de Beste opleidingsbaan Tab.

We kunnen een gedetailleerd overzicht zien van de best geëvalueerde hyperparameters.

We kunnen meteen zien welke hyperparameterwaarden tot deze superieure prestatie hebben geleid. We willen echter meer weten. Kun je raden wat? We zien dat alpha neemt een geschatte waarde aan van 0.052456 en evenzo eta is ingesteld op 0.433495. Dit vertelt ons dat deze waarden goed werkten, maar het zegt ons weinig over de hyperparameterruimte zelf. We kunnen ons bijvoorbeeld afvragen of 0.433495 voor eta was de hoogst geteste waarde, of dat er ruimte is voor groei en modelverbetering door hogere waarden te selecteren.

Daarvoor moeten we uitzoomen en een veel bredere kijk nemen om te zien hoe andere waarden voor onze hyperparameters presteerden. Een manier om veel gegevens tegelijk te bekijken, is door onze hyperparameterwaarden van onze HPO-proeven in een grafiek uit te zetten. Zo zien we hoe deze waarden relatief gepresteerd hebben. In de volgende sectie halen we deze gegevens uit SageMaker en visualiseren we deze.

Visualiseer onze beproevingen

De SageMaker SDK levert ons de gegevens voor onze verkenning, en de notebooks geven u daar een kijkje in. Maar er zijn veel manieren om het te gebruiken en te visualiseren. In dit bericht delen we een voorbeeld met behulp van de Altair statistische visualisatiebibliotheek, die we gebruiken om een ​​meer visueel overzicht van onze onderzoeken te maken. Deze zijn te vinden in de amtviz pakket, dat we leveren als onderdeel van het monster:

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

De kracht van deze visualisaties wordt meteen duidelijk bij het uitzetten van de validatienauwkeurigheid van onze proeven (y-as) in de tijd (x-as). Het volgende diagram aan de linkerkant toont de validatienauwkeurigheid in de loop van de tijd. We kunnen duidelijk zien dat de prestaties van het model verbeteren naarmate we in de loop van de tijd meer proeven uitvoeren. Dit is een direct en verwacht resultaat van het runnen van HPO met een Bayesiaanse strategie. In ons volgende bericht zien we hoe dit zich verhoudt tot andere strategieën en zien we dat dit niet voor alle strategieën het geval hoeft te zijn.

Laten we, na de algehele voortgang in de loop van de tijd te hebben bekeken, nu eens kijken naar onze hyperparameterruimte.

De volgende grafieken tonen de validatienauwkeurigheid op de y-as, waarbij elke grafiek wordt weergegeven max_depth, alpha, eta en min_child_weight respectievelijk op de x-as. We hebben onze hele HPO-taak in elke grafiek uitgezet. Elk punt is een enkele proef en elke grafiek bevat alle 50 proeven, maar gescheiden voor elke hyperparameter. Dit betekent dat onze best presterende proef, #48, wordt weergegeven door precies één blauwe stip in elk van deze grafieken (die we voor u hebben gemarkeerd in de volgende afbeelding). We kunnen de prestaties visueel vergelijken binnen de context van alle andere 49 onderzoeken. Laten we dus goed kijken.

Fascinerend! We zien onmiddellijk welke regio's van onze gedefinieerde bereiken in onze hyperparameterruimte het meest presteren! Terugdenkend aan onze eta waarde, is het nu duidelijk dat bemonsteringswaarden dichter bij 0 slechtere prestaties opleverden, terwijl dichter bij onze grens, 0.5, betere resultaten opleveren. Het omgekeerde lijkt waar te zijn voor alpha en max_depth lijkt een beperktere reeks voorkeurswaarden te hebben. Kijken naar max_depth, kunt u ook zien hoe het gebruik van een Bayesiaanse strategie SageMaker AMT instrueert om vaker waarden te testen waarvan het heeft geleerd dat ze in het verleden goed werkten.

Kijkend naar onze eta waarde, kunnen we ons afvragen of het de moeite waard is om meer naar rechts te verkennen, misschien verder dan 0.45? Blijft het wegslepen naar een lagere nauwkeurigheid, of hebben we hier meer gegevens nodig? Deze verwondering maakt deel uit van het doel van onze eerste HPO-klus. Het geeft ons inzicht in welke gebieden van de hyperparameterruimte we verder moeten verkennen.

Als je graag meer wilt weten, en net zo enthousiast bent als wij over deze inleiding op het onderwerp, houd ons dan in de gaten voor ons volgende bericht, waar we meer zullen vertellen over de verschillende HPO-strategieën, ze met elkaar zullen vergelijken en oefen training met ons eigen Python-script.

Opruimen

Om ongewenste kosten te voorkomen wanneer u klaar bent met het experimenteren met HPO, moet u alle bestanden in uw S3-bucket met het voorvoegsel verwijderen amt-visualize-demo en ook sluit Studio-bronnen af.

Voer de volgende code uit in uw notebook om alle S3-bestanden uit dit bericht te verwijderen.

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

Als u de datasets of de modelartefacten wilt behouden, kunt u het voorvoegsel in de code wijzigen in amt-visualize-demo/data om alleen de gegevens te verwijderen of amt-visualize-demo/output om alleen de modelartefacten te verwijderen.

Conclusie

In dit bericht hebben we een model getraind en afgestemd met behulp van de ingebouwde SageMaker-versie van het XGBoost-algoritme. Door HPO met SageMaker AMT te gebruiken, leerden we over de hyperparameters die goed werken voor dit specifieke algoritme en deze dataset.

We hebben verschillende manieren gezien om de resultaten van onze taak voor het afstemmen van hyperparameters te beoordelen. Beginnend met het extraheren van de hyperparameters van de beste proef, leerden we ook hoe we een beter begrip konden krijgen van hoe onze proeven in de loop van de tijd waren gevorderd en welke hyperparameterwaarden van invloed zijn.

Met behulp van de SageMaker-console zagen we ook hoe we dieper in individuele trainingsruns konden duiken en hun logboeken konden bekijken.

Vervolgens hebben we uitgezoomd om al onze onderzoeken samen te bekijken en hun prestaties te beoordelen in relatie tot andere onderzoeken en hyperparameters.

We hebben geleerd dat we op basis van de waarnemingen van elke proef door de hyperparameterruimte konden navigeren om te zien dat kleine veranderingen in onze hyperparameterwaarden een enorme impact kunnen hebben op de prestaties van ons model. Met SageMaker AMT kunnen we hyperparameteroptimalisatie uitvoeren om op efficiënte wijze goede hyperparameterwaarden te vinden en de modelprestaties te maximaliseren.

In de toekomst zullen we verschillende HPO-strategieën bekijken die worden aangeboden door SageMaker AMT en hoe we onze eigen aangepaste trainingscode kunnen gebruiken. Laat het ons weten in de reacties als je een vraag hebt of een gebied wilt voorstellen dat we in toekomstige berichten moeten behandelen.

Tot die tijd wensen wij u en uw modellen veel leer- en afstemmingsplezier!

Referenties

citaten:

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

Over de auteurs

Andreas Ellul is een oplossingsarchitect bij Amazon Web Services. Hij werkt met kleine en middelgrote bedrijven in Duitsland. Buiten zijn werk verkent Andrew graag de natuur te voet of met de fiets.

Elina Lesyk is een Solutions Architect gevestigd in München. Haar focus ligt op zakelijke klanten uit de financiële dienstverlening. In haar vrije tijd leert Elina graag gitaartheorie in het Spaans om te leren en te gaan hardlopen.

Mariano Kamp is een Principal Solutions Architect bij Amazon Web Services. Hij werkt samen met financiële dienstverleners in Duitsland aan machine learning. In zijn vrije tijd wandelt Mariano graag met zijn vrouw.