Ontdek geavanceerde technieken voor hyperparameteroptimalisatie met Amazon SageMaker Automatic Model Tuning | Amazon-webservices

Het creëren van hoogwaardige machine learning-oplossingen (ML) is afhankelijk van het verkennen en optimaliseren van trainingsparameters, ook wel hyperparameters genoemd. Hyperparameters zijn de knoppen en hefbomen die we gebruiken om het trainingsproces aan te passen, zoals leersnelheid, batchgrootte, regularisatiesterkte en andere, afhankelijk van het specifieke model en de taak die voorhanden is. Het verkennen van hyperparameters omvat het systematisch variëren van de waarden van elke parameter en het observeren van de impact op de modelprestaties. Hoewel dit proces extra inspanningen vergt, zijn de voordelen aanzienlijk. Hyperparameteroptimalisatie (HPO) kan leiden tot snellere trainingtijden, verbeterde modelnauwkeurigheid en betere generalisatie naar nieuwe gegevens.

Vanaf de post vervolgen we onze reis Optimaliseer hyperparameters met Amazon SageMaker Automatic Model Tuning. We hebben eerder een enkele taakoptimalisatie onderzocht, de resultaten van het ingebouwde algoritme van SageMaker gevisualiseerd en geleerd over de impact van bepaalde hyperparameterwaarden. Naast het gebruik van HPO als eenmalige optimalisatie aan het einde van de modelcreatiecyclus, kunnen we het ook op een gemoedelijke manier in meerdere stappen gebruiken. Elke afstemmingstaak helpt ons dichter bij goede prestaties te komen, maar daarnaast leren we ook hoe gevoelig het model is voor bepaalde hyperparameters en kunnen we dit inzicht gebruiken om de volgende afstemmingstaak te informeren. We kunnen de hyperparameters en hun waardebereiken herzien op basis van wat we hebben geleerd en daarom deze optimalisatie-inspanning in een gesprek veranderen. En op dezelfde manier waarop wij als ML-beoefenaars tijdens deze runs kennis vergaren, Amazon SageMaker automatische modelafstemming (AMT) bij een warme start kan deze kennis die hij bij eerdere tuningklussen heeft opgedaan, ook bij de volgende tuningklus behouden blijven.

In dit bericht voeren we meerdere HPO-taken uit met een aangepast trainingsalgoritme en verschillende HPO-strategieën, zoals Bayesiaanse optimalisatie en willekeurig zoeken. We brengen ook warme starts in actie en vergelijken onze proeven visueel om de verkenning van de hyperparameterruimte te verfijnen.

Geavanceerde concepten van SageMaker AMT

In de volgende secties gaan we dieper in op elk van de volgende onderwerpen en laten we zien hoe SageMaker AMT u kan helpen deze in uw ML-projecten te implementeren:

• Gebruik aangepaste trainingscode en het populaire ML-framework Scikit-learn in SageMaker Training
• Definieer aangepaste evaluatiestatistieken op basis van de logboeken voor evaluatie en optimalisatie
• Voer HPO uit met een passende strategie
• Gebruik warme starts om een ​​enkele hyperparameterzoekopdracht om te zetten in een dialoog met ons model
• Gebruik geavanceerde visualisatietechnieken met behulp van onze oplossingsbibliotheek om twee HPO-strategieën te vergelijken en de resultaten van vacatures af te stemmen

Of u nu de ingebouwde algoritmen gebruikt die in ons eerste bericht zijn gebruikt of uw eigen trainingscode, SageMaker AMT biedt een naadloze gebruikerservaring voor het optimaliseren van ML-modellen. Het biedt belangrijke functionaliteit waarmee u zich kunt concentreren op het ML-probleem terwijl u automatisch de proeven en resultaten bijhoudt. Tegelijkertijd beheert het automatisch de onderliggende infrastructuur voor u.

In dit bericht gaan we af van een ingebouwd algoritme van SageMaker en gebruiken we aangepaste code. Wij gebruiken een Random Forest van SkLearn. Maar we houden ons aan dezelfde ML-taak en dataset als in onze eerste bericht, dat handgeschreven cijfers detecteert. We behandelen de inhoud van het Jupyter-notebook 2_geavanceerde_afstemming_met_aangepaste_training_en_visualisatie.ipynb en nodigen u uit om de code naast elkaar aan te roepen om verder te lezen.

Laten we dieper duiken en ontdekken hoe we aangepaste trainingscode kunnen gebruiken, implementeren en uitvoeren, terwijl we de hyperparameter-zoekruimte verkennen om onze resultaten te optimaliseren.

Hoe u een ML-model bouwt en hyperparameteroptimalisatie uitvoert

Hoe ziet een typisch proces voor het bouwen van een ML-oplossing eruit? Hoewel er veel mogelijke gebruiksscenario's en een grote verscheidenheid aan ML-taken bestaan, raden we het volgende mentale model aan voor een stapsgewijze aanpak:

1. Begrijp uw ML-scenario en selecteer een algoritme op basis van de vereisten. U wilt bijvoorbeeld een beeldherkenningstaak oplossen met behulp van een begeleid leeralgoritme. In dit bericht blijven we het handgeschreven beeldherkenningsscenario en dezelfde dataset gebruiken als in ons eerste bericht.
2. Bepaal welke implementatie van het algoritme in SageMaker Training u wilt gebruiken. Er zijn verschillende opties, binnen SageMaker of externe. Bovendien moet u definiëren welke onderliggende statistiek het beste bij uw taak past en waarvoor u wilt optimaliseren (zoals nauwkeurigheid, F1-score of ROC). SageMaker ondersteunt vier opties, afhankelijk van uw behoeften en middelen:
   • Gebruik een vooraf getraind model via Amazon SageMaker JumpStart, die u kant-en-klaar kunt gebruiken of gewoon kunt verfijnen.
   • Gebruik een van de ingebouwde algoritmen voor training en afstemming, zoals XGBoost, zoals we in ons vorige bericht deden.
   • Train en stem een ​​aangepast model af op basis van een van de belangrijkste raamwerken zoals Scikit-learn, TensorFlow of PyTorch. AWS biedt hiervoor een selectie van vooraf gemaakte Docker-images. Voor dit bericht gebruiken we deze optie, waarmee je snel kunt experimenteren door je eigen code uit te voeren bovenop een vooraf gemaakte containerimage.
   • Neem uw eigen aangepaste Docker-image mee voor het geval u een raamwerk of software wilt gebruiken die anderszins niet wordt ondersteund. Deze optie vergt de meeste inspanning, maar biedt ook de hoogste mate van flexibiliteit en controle.
3. Train het model met uw gegevens. Afhankelijk van de implementatie van het algoritme uit de vorige stap, kan dit zo eenvoudig zijn als het verwijzen naar uw trainingsgegevens en het uitvoeren van de trainingstaak of door het aanvullend leveren van aangepaste code voor training. In ons geval gebruiken we aangepaste trainingscode in Python op basis van Scikit-learn.
4. Pas hyperparameteroptimalisatie toe (als een “gesprek” met uw ML-model). Na de training wilt u doorgaans de prestaties van uw model optimaliseren door de meest veelbelovende combinatie van waarden voor de hyperparameters van uw algoritme te vinden.

Afhankelijk van uw ML-algoritme en modelgrootte kan de laatste stap van hyperparameteroptimalisatie een grotere uitdaging blijken te zijn dan verwacht. De volgende vragen zijn typisch voor ML-beoefenaars in deze fase en komen u misschien bekend voor:

• Welke soort hyperparameters zijn van invloed op mijn ML-probleem?
• Hoe kan ik effectief een enorme hyperparameterruimte doorzoeken om de best presterende waarden te vinden?
• Hoe beïnvloedt de combinatie van bepaalde hyperparameterwaarden mijn prestatiestatistiek?
• Kosten zijn belangrijk; Hoe kan ik mijn middelen op een efficiënte manier inzetten?
• Welke soort afstemmingsexperimenten zijn de moeite waard en hoe kan ik ze vergelijken?

Het is niet eenvoudig om deze vragen te beantwoorden, maar er is goed nieuws. SageMaker AMT neemt u het zware werk uit handen, zodat u zich kunt concentreren op het kiezen van de juiste HPO-strategie en waardebereiken die u wilt verkennen. Bovendien vergemakkelijkt onze visualisatieoplossing het iteratieve analyse- en experimenteerproces om efficiënt goed presterende hyperparameterwaarden te vinden.

In de volgende secties bouwen we een model voor cijferherkenning helemaal opnieuw met behulp van Scikit-learn en laten we al deze concepten in actie zien.

Overzicht oplossingen

SageMaker biedt een aantal zeer handige functies om ons model te trainen, evalueren en afstemmen. Het omvat alle functionaliteit van een end-to-end ML-levenscyclus, zodat we onze Jupyter-notebook niet eens hoeven te verlaten.

In ons eerste bericht gebruikten we het ingebouwde algoritme XGBoost van SageMaker. Voor demonstratiedoeleinden schakelen we dit keer over op een Random Forest-classifier, omdat we dan kunnen laten zien hoe u uw eigen trainingscode kunt opgeven. We hebben ervoor gekozen om ons eigen Python-script aan te bieden en Scikit-learn als raamwerk te gebruiken. Hoe geven we nu aan dat we een specifiek ML-framework willen gebruiken? Zoals we zullen zien, gebruikt SageMaker een andere AWS-service op de achtergrond om een ​​vooraf gebouwde Docker-containerimage op te halen voor training:Amazon Elastic Container-register (Amazone ECR).

We behandelen de volgende stappen in detail, inclusief codefragmenten en diagrammen om de punten met elkaar te verbinden. Zoals eerder vermeld: als u de kans heeft, opent u de notebook en voert u de codecellen stap voor stap uit om de artefacten in uw AWS-omgeving te creëren. Er is geen betere manier van actief leren.

1. Laad eerst de gegevens en bereid ze voor. We gebruiken Amazon eenvoudige opslagservice (Amazon S3) om een ​​bestand te uploaden met onze handgeschreven cijfergegevens.
2. Bereid vervolgens het trainingsscript en de raamwerkafhankelijkheden voor. We bieden de aangepaste trainingscode in Python, verwijzen naar enkele afhankelijke bibliotheken en voeren een testrun uit.
3. Om de aangepaste objectieve statistieken te definiëren, laat SageMaker ons een reguliere expressie definiëren om de statistieken die we nodig hebben uit de containerlogbestanden te extraheren.
4. Train het model met behulp van het scikit-learn-framework. Door te verwijzen naar een vooraf gebouwde containerimage, creëren we een bijbehorend Estimator-object en geven we ons aangepaste trainingsscript door.
5. Met AMT kunnen wij verschillende HPO-strategieën uitproberen. We concentreren ons voor dit bericht op twee ervan: willekeurig zoeken en Bayesiaans zoeken.
6. Kies tussen SageMaker HPO-strategieën.
7. Visualiseer, analyseer en vergelijk tuningresultaten. Met ons visualisatiepakket kunnen we ontdekken welke strategie beter presteert en welke hyperparameterwaarden de beste prestaties leveren op basis van onze statistieken.
8. Ga door met het verkennen van de hyperparameterruimte en start met een warme start van HPO-banen.

AMT zorgt voor het schalen en beheren van de onderliggende rekeninfrastructuur waarop de verschillende afstemmingstaken kunnen worden uitgevoerd Amazon Elastic Compute-cloud (Amazon EC2)-instanties. Op deze manier hoeft u zichzelf niet te belasten met het inrichten van instances, het afhandelen van besturingssysteem- en hardwareproblemen of het zelf verzamelen van logbestanden. De ML-framework-afbeelding wordt opgehaald uit Amazon ECR en de modelartefacten inclusief afstemmingsresultaten worden opgeslagen in Amazon S3. Alle logboeken en statistieken worden verzameld Amazon Cloud Watch voor gemakkelijke toegang en verdere analyse indien nodig.

Voorwaarden

Omdat dit een vervolg is op een serie is het raadzaam, maar niet noodzakelijkerwijs verplicht, om dit te lezen ons eerste bericht over SageMaker AMT en HPO. Afgezien daarvan is basiskennis van ML-concepten en programmeren in Python nuttig. We raden u ook aan elke stap in de handleiding te volgen bijbehorende notebook uit onze GitHub-repository tijdens het lezen van dit bericht. De notebook kan onafhankelijk van de eerste worden uitgevoerd, maar heeft code uit submappen nodig. Zorg ervoor dat u de volledige repository in uw omgeving kloont, zoals beschreven in het README-bestand.

Experimenteren met de code en het gebruik van de interactieve visualisatieopties verbetert uw leerervaring aanzienlijk. Dus, controleer het alsjeblieft.

Laad de gegevens en bereid ze voor

Als eerste stap zorgen we ervoor dat het gedownloade cijfers gegevens die we nodig hebben voor training is toegankelijk voor SageMaker. Met Amazon S3 kunnen we dit op een veilige en schaalbare manier doen. Raadpleeg het notebook voor de volledige broncode en pas deze gerust aan met uw eigen gegevens.

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'

De digits.csv bestand bevat featuregegevens en labels. Elk cijfer wordt weergegeven door pixelwaarden in een 8×8-afbeelding, zoals weergegeven in de volgende afbeelding voor het cijfer 4.

Bereid het trainingsscript en de raamwerkafhankelijkheden voor

Nu de gegevens in onze S3-bucket zijn opgeslagen, kunnen we ons aangepaste trainingsscript definiëren op basis van Scikit leren in Python. SageMaker geeft ons de mogelijkheid om later eenvoudigweg naar het Python-bestand te verwijzen voor training. Eventuele afhankelijkheden zoals de Scikit-learn- of pandas-bibliotheken kunnen op twee manieren worden geleverd:

• Ze kunnen expliciet worden gespecificeerd in a requirements.txt filet
• Ze zijn vooraf geïnstalleerd in de onderliggende ML-containerimage, die wordt geleverd door SageMaker of op maat wordt gemaakt

Beide opties worden over het algemeen beschouwd als standaardmanieren voor afhankelijkheidsbeheer, dus u bent er misschien al mee bekend. SageMaker ondersteunt een verscheidenheid aan ML-frameworks in een kant-en-klare beheerde omgeving. Dit omvat veel van de meest populaire data science- en ML-frameworks zoals PyTorch, TensorFlow of Scikit-learn, zoals in ons geval. Wij gebruiken geen extra requirements.txt bestand, maar voel je vrij om enkele bibliotheken toe te voegen om het uit te proberen.

De code van onze implementatie bevat een methode genaamd fit(), die een nieuwe classificator voor de cijferherkenningstaak creëert en deze traint. In tegenstelling tot ons eerste bericht waarin we het ingebouwde XGBoost-algoritme van SageMaker gebruikten, gebruiken we nu a RandomForestClassifier geleverd door de ML-bibliotheek sklearn. De oproep van de fit() methode op het classificatorobject start het trainingsproces met behulp van een subset (80%) van onze CSV-gegevens:

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

Bekijk het volledige script in ons Jupyter-notebook op GitHub.

Heeft u geprobeerd het script rechtstreeks uit te voeren voordat u containerresources voor het volledige trainingsproces opstartte? Dit is een goede gewoonte om er snel voor te zorgen dat de code geen syntaxisfouten bevat, om in een vroeg stadium te controleren op overeenkomende dimensies van uw gegevensstructuren en enkele andere fouten.

Er zijn twee manieren om uw code lokaal uit te voeren. Ten eerste kun je het meteen in de notebook uitvoeren, waardoor je ook de Python Debugger kunt gebruiken 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)

U kunt het train-script ook uitvoeren vanaf de opdrachtregel, op dezelfde manier als u het in een container wilt gebruiken. Dit ondersteunt ook het instellen van verschillende parameters en het indien nodig overschrijven van de standaardwaarden, bijvoorbeeld:

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

Als uitvoer kunt u de eerste resultaten zien voor de prestaties van het model op basis van de objectieve meetprecisie, herinnering en F1-score. Bijvoorbeeld, pre: 0.970 rec: 0.969 f1: 0.969.

Niet slecht voor zo'n snelle training. Maar waar komen deze cijfers vandaan en wat doen we ermee?

Definieer aangepaste objectieve statistieken

Vergeet niet dat het ons doel is om ons model volledig te trainen en af ​​te stemmen op basis van de objectieve meetgegevens die wij relevant achten voor onze taak. Omdat we een aangepast trainingsscript gebruiken, moeten we deze statistieken voor SageMaker expliciet definiëren.

Ons script geeft tijdens de training de nauwkeurigheid, herinnering en F1-score van de statistieken door, eenvoudigweg door gebruik te maken van de print functie:

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

De standaarduitvoer wordt vastgelegd door SageMaker en als logstream naar CloudWatch verzonden. Om de metrische waarden op te halen en er later mee te werken in SageMaker AMT, moeten we wat informatie verstrekken over hoe we die uitvoer kunnen parseren. We kunnen dit bereiken door reguliere expressie-instructies te definiëren (voor meer informatie, zie Bewaak en analyseer trainingstaken met behulp van 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.]+)'}] 

Laten we samen door de eerste metrische definitie in de voorgaande code lopen. SageMaker zoekt naar uitvoer in het logboek dat begint met pre: en wordt gevolgd door een of meer witruimte en vervolgens een getal dat we willen extraheren. Daarom gebruiken we het ronde haakje. Elke keer dat SageMaker zo’n waarde vindt, verandert het deze in een CloudWatch-statistiek met de naam valid-precision.

Train het model met behulp van het Scikit-learn-framework

Nadat we ons trainingsscript hebben gemaakt train.py en SageMaker instrueren over het monitoren van de statistieken binnen CloudWatch, definiëren we a SageMaker-schatter voorwerp. Het initieert de trainingstaak en gebruikt het exemplaartype dat we specificeren. Maar hoe kan dit exemplaartype verschillen van het exemplaar dat u uitvoert? Amazon SageMaker Studio notitieboekje aan, en waarom? SageMaker Studio voert uw trainings- (en gevolgtrekkings-) taken uit op afzonderlijke rekeninstanties dan uw notebook. Hierdoor kunt u in uw notebook blijven werken terwijl de taken op de achtergrond worden uitgevoerd.

De parameter framework_version verwijst naar de Scikit-learn-versie die we gebruiken voor onze trainingsopdracht. Als alternatief kunnen we passeren image_uri aan de estimator. U kunt controleren of uw favoriete framework of ML-bibliotheek beschikbaar is als vooraf gebouwde SageMaker Docker-image en gebruik het zoals het is of met extensies.

Bovendien kunnen we SageMaker-trainingstaken uitvoeren op EC2 Spot Instances door in te stellen use_spot_instances naar True. Het zijn instanties met reservecapaciteit die dat wel kunnen Bespaar tot 90% van de kosten. Deze exemplaren bieden flexibiliteit bij het uitvoeren van de trainingstaken.

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

Nadat het Estimator-object is ingesteld, starten we de training door de fit() functie, die het pad levert naar de trainingsdataset op Amazon S3. We kunnen dezelfde methode gebruiken om validatie- en testgegevens te verstrekken. Wij stellen de wait parameter True zodat we het getrainde model kunnen gebruiken in de volgende codecellen.

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

Definieer hyperparameters en voer afstemmingstaken uit

Tot nu toe hebben we het model getraind met één set hyperparameterwaarden. Maar waren die waarden goed? Of kunnen we op zoek gaan naar betere? Laten we de gebruiken HyperparameterTuner-klasse om een ​​systematische zoekopdracht uit te voeren in de hyperparameterruimte. Hoe zoeken we deze ruimte met de tuner? De noodzakelijke parameters zijn de naam van de objectieve statistiek en het doelstellingstype die de optimalisatie zullen begeleiden. De optimalisatiestrategie is een ander belangrijk argument voor de tuner omdat deze de zoekruimte verder definieert. Hier volgen vier verschillende strategieën waaruit u kunt kiezen:

• Raster zoeken
• Willekeurig zoeken
• Bayesiaanse optimalisatie (standaard)
• Hyperband

We beschrijven deze strategieën verder en voorzien je van wat begeleiding om er later in dit bericht een te kiezen.

Voordat we ons tunerobject definiëren en uitvoeren, laten we ons begrip samenvatten vanuit een architectuurperspectief. We hebben het architecturale overzicht van SageMaker AMT besproken in onze laatste post en geef hier voor het gemak een fragment ervan weer.

We kunnen kiezen welke hyperparameters we willen afstemmen of statisch laten. Voor dynamische hyperparameters bieden wij hyperparameter_ranges die kan worden gebruikt om te optimaliseren voor afstembare hyperparameters. Omdat we een Random Forest-classificator gebruiken, hebben we de hyperparameters uit de Scikit-leer Random Forest-documentatie.

Ook beperken we de middelen met het maximale aantal trainingsbanen en parallelle trainingsbanen die de tuner kan gebruiken. We zullen zien hoe deze limieten ons helpen de resultaten van verschillende strategieën met elkaar te vergelijken.

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 } 

Vergelijkbaar met die van de schatter fit functie starten we een stemtaak die de tuner aanroept fit:

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

Dit is alles wat we hoeven te doen om SageMaker de trainingstaken te laten uitvoeren (n=50) op de achtergrond, elk met een andere set hyperparameters. We verkennen de resultaten later in dit bericht. Maar laten we eerst beginnen met een nieuwe afstemmingsklus, deze keer met toepassing van de Bayesiaanse optimalisatiestrategie. We zullen beide strategieën visueel vergelijken nadat ze zijn voltooid.

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)

Houd er rekening mee dat beide tunertaken parallel kunnen worden uitgevoerd, omdat SageMaker de vereiste rekeninstanties onafhankelijk van elkaar orkestreert. Dat is heel nuttig voor beoefenaars die tegelijkertijd met verschillende benaderingen experimenteren, zoals wij hier doen.

Kies tussen SageMaker HPO-strategieën

Als het gaat om afstemmingsstrategieën, heb je een paar opties met SageMaker AMT: rasterzoeken, willekeurig zoeken, Bayesiaanse optimalisatie en Hyperband. Deze strategieën bepalen hoe de automatische afstemmingsalgoritmen de gespecificeerde bereiken van hyperparameters onderzoeken.

Willekeurig zoeken is vrij eenvoudig. Het selecteert willekeurig combinaties van waarden uit de opgegeven bereiken en kan op een sequentiële of parallelle manier worden uitgevoerd. Het is alsof je geblinddoekt darts gooit, in de hoop het doel te raken. We zijn met deze strategie begonnen, maar zullen de resultaten verbeteren met een andere?

Bayesiaanse optimalisatie hanteert een andere aanpak dan willekeurig zoeken. Het houdt rekening met de geschiedenis van eerdere selecties en kiest waarden die waarschijnlijk de beste resultaten zullen opleveren. Als u wilt leren van eerdere verkenningen, kunt u dit alleen bereiken door na de vorige een nieuwe afstemmingstaak uit te voeren. Klinkt logisch, toch? Op deze manier is Bayesiaanse optimalisatie afhankelijk van de voorgaande runs. Maar ziet u welke HPO-strategie een hogere parallellisatie mogelijk maakt?

Hyperband is een interessante! Het maakt gebruik van een multi-fidelity-strategie, wat betekent dat het op dynamische wijze middelen toewijst aan de meest veelbelovende opleidingsbanen en de banen die ondermaats presteren, tegenhoudt. Daarom gaat Hyperband rekenefficiënt om met middelen en leert het van eerdere trainingsbanen. Na het stoppen van de slecht presterende configuraties wordt een nieuwe configuratie gestart, waarvan de waarden willekeurig worden gekozen.

Afhankelijk van uw behoeften en de aard van uw model kunt u kiezen tussen willekeurig zoeken, Bayesiaanse optimalisatie of Hyperband als afstemmingsstrategie. Elk heeft zijn eigen aanpak en voordelen, dus het is belangrijk om te overwegen welke het beste werkt voor uw ML-verkenning. Het goede nieuws voor ML-beoefenaars is dat u de beste HPO-strategie kunt selecteren door de impact van elke proef op de objectieve maatstaf visueel te vergelijken. In het volgende gedeelte zien we hoe we de impact van verschillende strategieën visueel kunnen identificeren.

Visualiseer, analyseer en vergelijk tuningresultaten

Als onze tuningklussen klaar zijn, wordt het spannend. Welke resultaten leveren ze op? Wat voor soort boost kunt u verwachten op onze statistiek vergeleken met uw basismodel? Wat zijn de best presterende hyperparameters voor onze use case?

Een snelle en eenvoudige manier om de HPO-resultaten te bekijken is door naar de SageMaker-console te gaan. Onder Taken voor het afstemmen van hyperparameterskunnen we (per afstemmingstaak) de combinatie van hyperparameterwaarden zien die zijn getest en de beste prestaties hebben geleverd, zoals gemeten door onze objectieve metriek (valid-f1).

Is dat alles wat je nodig hebt? Als ML-beoefenaar ben je misschien niet alleen geïnteresseerd in die waarden, maar wil je zeker ook meer leren over de innerlijke werking van je model om het volledige potentieel ervan te verkennen en je intuïtie te versterken met empirische feedback.

Een goede visualisatietool kan u enorm helpen de verbetering van HPO in de loop van de tijd te begrijpen en empirische feedback te krijgen over ontwerpbeslissingen van uw ML-model. Het toont de impact van elke individuele hyperparameter op uw objectieve metriek en biedt richtlijnen om uw afstemmingsresultaten verder te optimaliseren.

We maken gebruik van de amtviz aangepast visualisatiepakket om tuningtaken te visualiseren en analyseren. Het is eenvoudig te gebruiken en biedt handige functies. We demonstreren het voordeel ervan door enkele individuele grafieken te interpreteren en ten slotte willekeurige zoekopdrachten naast Bayesiaanse optimalisatie te vergelijken.

Laten we eerst een visualisatie maken voor willekeurig zoeken. Dit kunnen wij doen door te bellen visualize_tuning_job() oppompen van amtviz en ons eerste tunerobject als argument doorgeven:

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

U zult een aantal grafieken zien, maar laten we het stap voor stap bekijken. Het eerste spreidingsdiagram uit de uitvoer ziet er als volgt uit en geeft ons al enkele visuele aanwijzingen die we in geen enkele tabel zouden herkennen.

Elke stip vertegenwoordigt de prestatie van een individuele trainingsopdracht (onze doelstelling). valid-f1 op de y-as) op basis van de starttijd (x-as), geproduceerd door een specifieke set hyperparameters. Daarom kijken we naar de prestaties van ons model naarmate het vordert tijdens de afstemmingstaak.

De stippellijn markeert het beste resultaat dat tot nu toe is gevonden en geeft verbetering in de loop van de tijd aan. De beste twee trainingsbanen behaalden een F1-score van rond de 0.91.

Zie je naast de stippellijn die de cumulatieve voortgang weergeeft, ook een trend in de grafiek?

Waarschijnlijk niet. En dit wordt verwacht, omdat we de resultaten van de willekeurige HPO-strategie bekijken. Elke trainingstaak werd uitgevoerd met behulp van een andere, maar willekeurig geselecteerde set hyperparameters. Als we door zouden gaan met onze afstemming (of een andere zouden uitvoeren met dezelfde instelling), zouden we in de loop van de tijd waarschijnlijk betere resultaten zien, maar we weten het niet zeker. Willekeurigheid is een lastig iets.

De volgende grafieken helpen u de invloed van hyperparameters op de algehele prestaties te meten. Alle hyperparameters worden gevisualiseerd, maar kortheidshalve concentreren we ons op twee ervan: n-estimators en max-depth.

Onze twee beste trainingsbanen gebruikten n-estimators van ongeveer 20 en 80, en max-depth van respectievelijk ongeveer 10 en 18. De exacte hyperparameterwaarden worden voor elke punt (trainingstaak) via tooltip weergegeven. Ze worden zelfs dynamisch gemarkeerd in alle diagrammen en geven u een multidimensionaal beeld! Heb je dat gezien? Elke hyperparameter wordt als een afzonderlijk diagram uitgezet tegen de objectieve metriek.

Wat voor inzichten krijgen we nu? n-estimators?

Op basis van het linkerdiagram lijkt het erop dat zeer lage waardebereiken (onder de 10) vaker slechte resultaten opleveren vergeleken met hogere waarden. Daarom kunnen hogere waarden ervoor zorgen dat uw model beter presteert, interessant.

Daarentegen is de correlatie van de max-depth hyperparameter voor onze objectieve metriek is vrij laag. We kunnen niet duidelijk zeggen welke waardebereiken vanuit een algemeen perspectief beter presteren.

Samenvattend kan willekeurig zoeken u helpen om zelfs in relatief korte tijd een goed presterende reeks hyperparameters te vinden. Bovendien is het niet gericht op een goede oplossing, maar geeft het een evenwichtig beeld van de zoekruimte. Het gebruik van uw hulpbronnen is echter mogelijk niet erg efficiënt. Het blijft trainingstaken uitvoeren met hyperparameters in waardebereiken waarvan bekend is dat ze slechte resultaten opleveren.

Laten we de resultaten van onze tweede afstemmingsklus bekijken met behulp van Bayesiaanse optimalisatie. We kunnen gebruiken amtviz om de resultaten op dezelfde manier te visualiseren als we tot nu toe hebben gedaan voor de willekeurige zoektuner. Of, nog beter, we kunnen de mogelijkheid van de functie gebruiken om beide afstemmingstaken in één set grafieken te vergelijken. Wel handig!

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

Er zijn nu meer stippen omdat we de resultaten van alle trainingstaken visualiseren voor zowel de willekeurige zoekopdracht (oranje stippen) als de Bayesiaanse optimalisatie (blauwe stippen). Aan de rechterkant zie je een dichtheidsgrafiek die de verdeling van alle F1-scores visualiseert. Een meerderheid van de trainingsbanen behaalde resultaten in het bovenste deel van de F1-schaal (ruim 0.6) – dat is goed!

Wat is hier de belangrijkste conclusie? Het spreidingsdiagram laat duidelijk het voordeel van Bayesiaanse optimalisatie zien. Het levert in de loop van de tijd betere resultaten op omdat het kan leren van eerdere runs. Daarom bereikten we met Bayesiaans aanzienlijk betere resultaten dan willekeurig (0.967 vs. 0.919) met hetzelfde aantal trainingsopdrachten.

Er is nog meer waar je mee kunt doen amtviz. Laten we erin boren.

Als u SageMaker AMT de instructie geeft om een ​​groter aantal taken uit te voeren voor afstemming, kan het een rommelige boel worden als u veel proefversies tegelijk ziet. Dat is een van de redenen waarom we deze grafieken interactief hebben gemaakt. U kunt op elke hyperparameterspreidingsdiagram klikken en slepen om in te zoomen op bepaalde waardebereiken en uw visuele interpretatie van de resultaten te verfijnen. Alle andere grafieken worden automatisch bijgewerkt. Dat is behoorlijk nuttig, nietwaar? Zie de volgende grafieken als voorbeeld en probeer het zelf in uw notitieboekje!

Als tuning-maximalist kunt u ook besluiten dat het uitvoeren van een andere afstemmingstaak voor hyperparameters de prestaties van uw model verder zou kunnen verbeteren. Maar deze keer kan een specifieker bereik van hyperparameterwaarden worden onderzocht, omdat u al (grofweg) weet waar u betere resultaten kunt verwachten. U kunt er bijvoorbeeld voor kiezen om u te concentreren op waarden tussen 100 en 200 n-estimators, zoals weergegeven in de grafiek. Hierdoor kan AMT zich concentreren op de meest veelbelovende trainingsopdrachten en wordt uw afstemmingsefficiëntie verhoogd.

Het opsommen, amtviz biedt u een uitgebreide reeks visualisatiemogelijkheden waarmee u de impact van de hyperparameters van uw model op de prestaties beter kunt begrijpen en slimmere beslissingen kunt nemen bij uw afstemmingsactiviteiten.

Ga door met het verkennen van de hyperparameterruimte en start met een warme start van HPO-banen

We hebben gezien dat AMT ons helpt de hyperparameter-zoekruimte efficiënt te verkennen. Maar wat als we meerdere afstemmingsrondes nodig hebben om onze resultaten iteratief te verbeteren? Zoals in het begin vermeld, willen we een optimalisatiefeedbackcyclus tot stand brengen: ons ‘gesprek’ met het model. Moeten we elke keer opnieuw beginnen?

Laten we eens kijken naar het concept van het runnen van a warme start hyperparameter-afstemmingstaak. Het start geen nieuwe tuning-taken vanuit het niets, maar hergebruikt wat is geleerd in de vorige HPO-runs. Dit helpt ons efficiënter om te gaan met onze afstemmingstijd en computerbronnen. We kunnen verder herhalen bovenop onze eerdere resultaten. Om warme starts te gebruiken, creëren we een WarmStartConfig en specificeer warm_start_type as IDENTICAL_DATA_AND_ALGORITHM. Dit betekent dat we de hyperparameterwaarden wijzigen, maar dat we de gegevens of het algoritme niet wijzigen. We vertellen AMT om de eerdere kennis over te dragen naar onze nieuwe tuningklus.

Door te verwijzen naar onze eerdere Bayesiaanse optimalisatie- en willekeurige zoekafstemmingstaken als parents, we kunnen ze allebei gebruiken voor de warme start:

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

Raadpleeg de volgende grafieken om de voordelen van het gebruik van warme starts te zien. Deze worden gegenereerd door amtviz op een vergelijkbare manier als we eerder deden, maar deze keer hebben we nog een tuning-klus toegevoegd op basis van een warme start.

In het linkerdiagram kunnen we zien dat nieuwe afstemmingstaken meestal in de rechterbovenhoek van de prestatiestatistiekgrafiek liggen (zie oranje gemarkeerde punten). Bij de warme start zijn inderdaad de eerdere resultaten hergebruikt en daarom staan ​​die datapunten in de topresultaten voor de F1-score. Deze verbetering wordt ook weerspiegeld in de dichtheidsgrafiek aan de rechterkant.

Met andere woorden, AMT selecteert automatisch veelbelovende sets hyperparameterwaarden op basis van de kennis uit eerdere onderzoeken. Dit wordt weergegeven in het volgende diagram. Het algoritme test bijvoorbeeld een lage waarde voor n-estimators minder vaak omdat bekend is dat deze slechte F1-scores opleveren. Dankzij warme starts verspillen we daar geen middelen aan.

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 SageMaker Studio-bronnen af.

Voer de volgende code uit in uw notitieblok 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

We hebben geleerd hoe de kunst van het bouwen van ML-oplossingen het onderzoeken en optimaliseren van hyperparameters inhoudt. Het aanpassen van deze knoppen en hendels is een veeleisend maar lonend proces dat leidt tot snellere trainingtijden, verbeterde modelnauwkeurigheid en over het algemeen betere ML-oplossingen. De SageMaker AMT-functionaliteit helpt ons meerdere afstemmingstaken uit te voeren en deze warm te starten, en biedt gegevenspunten voor verdere beoordeling, visuele vergelijking en analyse.

In dit bericht hebben we gekeken naar HPO-strategieën die we gebruiken met SageMaker AMT. We zijn begonnen met willekeurig zoeken, een eenvoudige maar performante strategie waarbij hyperparameters willekeurig uit een zoekruimte worden bemonsterd. Vervolgens hebben we de resultaten vergeleken met Bayesiaanse optimalisatie, waarbij probabilistische modellen worden gebruikt om de zoektocht naar optimale hyperparameters te begeleiden. Nadat we via eerste tests een geschikte HPO-strategie en goede hyperparameterwaardebereiken hadden geïdentificeerd, lieten we zien hoe we warme starts kunnen gebruiken om toekomstige HPO-banen te stroomlijnen.

U kunt de zoekruimte voor hyperparameters verkennen door kwantitatieve resultaten te vergelijken. We hebben de visuele vergelijking naast elkaar voorgesteld en het noodzakelijke pakket voor interactieve verkenning geleverd. Laat ons in de reacties weten hoe nuttig het voor u was tijdens uw hyperparameter-afstemmingstraject!

Over de auteurs

Umit Yoldas is een Senior Solutions Architect bij Amazon Web Services. Hij werkt met zakelijke klanten in verschillende sectoren in Duitsland. Hij is gedreven om AI-concepten te vertalen naar oplossingen uit de echte wereld. Buiten zijn werk brengt hij graag tijd door met zijn gezin, geniet hij van lekker eten en doet hij aan fitness.

Elina Lesyk is een Solutions Architect gevestigd in München. Ze richt zich op zakelijke klanten uit de financiële dienstverlening. In haar vrije tijd kun je Elina op sommige IT-bijeenkomsten applicaties met generatieve AI zien bouwen, een nieuw idee bedenken om de klimaatverandering snel op te lossen, of door het bos rennen om zich voor te bereiden op een halve marathon met een typische afwijking van het geplande schema.

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

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/explore-advanced-techniques-for-hyperparameter-optimization-with-amazon-sagemaker-automatic-model-tuning/