Gebruik uw eigen trainingsscripts en selecteer automatisch het beste model met behulp van hyperparameteroptimalisatie in Amazon SageMaker

Het succes van elke pijplijn voor machine learning (ML) hangt niet alleen af ​​van de kwaliteit van het gebruikte model, maar ook van het vermogen om dit model te trainen en te herhalen. Een van de belangrijkste manieren om een ​​ML-model te verbeteren, is door beter afstembare parameters te kiezen, ook wel bekend als hyperparameters. Dit staat bekend als hyperparameter optimalisatie (HPO). Dit handmatig afstemmen kan echter vaak omslachtig zijn vanwege de grootte van de zoekruimte, waarbij soms duizenden trainingsiteraties nodig zijn.

Dit bericht laat zien hoe Amazon Sage Maker stelt u in staat om niet alleen uw eigen modelalgoritme mee te nemen met behulp van de scriptmodus, maar ook om het ingebouwde HPO-algoritme te gebruiken. U leert hoe u eenvoudig de gewenste evaluatiemetriek kunt uitvoeren naar Amazon Cloud Watch, waaruit u deze statistiek kunt extraheren om het automatische HPO-algoritme te begeleiden. Vervolgens kunt u een HPO-afstemmingstaak maken die verschillende trainingstaken en bijbehorende rekenresources orkestreert. Na voltooiing kunt u de beste trainingstaak zien volgens de evaluatiestatistieken.

Overzicht oplossingen

We doorlopen de volgende stappen:

1. Gebruik de scriptmodus van SageMaker om ons eigen model bovenop een door AWS beheerde container te plaatsen.
2. Pas ons trainingsscript aan om onze evaluatiestatistiek af te drukken.
3. Zoek de statistiek in CloudWatch Logs.
4. Extraheer de statistiek uit CloudWatch.
5. Gebruik HPO om het beste model te selecteren door af te stemmen op deze evaluatiestatistiek.
6. Bewaak de HPO en vind de beste trainingsbaan.

Voorwaarden

Voor deze walkthrough moet u aan de volgende vereisten voldoen:

Gebruik aangepaste algoritmen op een door AWS beheerde container

Verwijzen naar Neem je eigen model mee met de scriptmodus van Amazon SageMaker voor een meer gedetailleerde kijk op het toevoegen van een aangepast model aan SageMaker met behulp van een door AWS beheerde container.

We maken gebruik van de MNIST-gegevensset voor dit voorbeeld. MNIST is een veelgebruikte dataset voor handgeschreven cijferclassificatie, bestaande uit 70,000 gelabelde grijswaardenafbeeldingen van 28 × 28 pixels van handgeschreven cijfers. De dataset is opgesplitst in 60,000 trainingsbeelden en 10,000 testbeelden, die 10 klassen bevatten (één voor elk cijfer).

1. Open uw notebook-exemplaar en voer de volgende opdracht uit om het mnist.py file:

   !wget https://raw.githubusercontent.com/aws/amazon-sagemaker-examples/main/hyperparameter_tuning/pytorch_mnist/mnist.py

   Voordat we de gegevens ophalen en opslaan, maken we een SageMaker-sessie. We moeten ook de S3-bucket en het voorvoegsel specificeren om te gebruiken voor trainings- en modelgegevens. Dit moet binnen dezelfde regio vallen als de notebookinstantie, training en hosting. De volgende code gebruikt de standaard emmer als het al bestaat, of maakt een nieuwe aan als dat niet het geval is. We moeten ook de IAM-rol ARN opnemen om training en hosting toegang te geven tot uw gegevens. We gebruiken get_execution_role() om de IAM-rol op te halen die u voor uw notebookinstantie hebt gemaakt.

2. Maak een sessie aan met de volgende code:

   import sagemaker
   from sagemaker.tuner import (
   IntegerParameter,
   CategoricalParameter,
   ContinuousParameter,
   HyperparameterTuner,
   )
   session = sagemaker.Session()
   bucket = session.default_bucket()
   prefix = "sagemaker/DEMO-custom-hpo"
   role = sagemaker.get_execution_role()

3. Laten we nu de gegevens ophalen, opslaan in onze lokale map /data, en upload het naar Amazon S3:

   from torchvision.datasets import MNIST
   from torchvision import transforms
   MNIST.mirrors = ["https://sagemaker-sample-files.s3.amazonaws.com/datasets/image/MNIST/"]
   MNIST(
   "data",
   download=True,
   transform=transforms.Compose(
   [transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))]
   ),
   )
   inputs = session.upload_data(path="data", bucket=bucket, key_prefix=prefix)

   We kunnen nu een schatter maken om de PyTorch-trainingstaak in te stellen. We concentreren ons hier niet op de eigenlijke trainingscode (mnist.py) tot in detail. Laten we eens kijken hoe we dit trainingsscript gemakkelijk kunnen aanroepen om een ​​trainingstaak te initialiseren.

4. In de volgende code nemen we een ingangspuntscript op met de naam mnist.py dat onze aangepaste trainingscode bevat:

   from sagemaker.pytorch import PyTorch
   estimator = PyTorch(
   entry_point="mnist.py",
   role=role,
   py_version="py3",
   framework_version="1.8.0",
   instance_count=1,
   instance_type="ml.c5.2xlarge",
   hyperparameters={"epochs": 5},
   )

5. Om ervoor te zorgen dat deze trainingstaak correct is geconfigureerd, met werkende trainingscode, kunnen we een trainingstaak starten door deze aan te passen aan de gegevens die we hebben geüpload naar Amazon S3. SageMaker zorgt ervoor dat onze gegevens beschikbaar zijn in het lokale bestandssysteem, zodat ons trainingsscript de gegevens gewoon van schijf kan lezen:

   estimator.fit({"training": inputs})

We creëren echter geen enkele opleidingsbaan. We gebruiken de automatische modelafstemming van SageMaker door middel van een hyperparameterafstemmingstaak. Modelafstemming is volledig agnostisch ten opzichte van het daadwerkelijke modelalgoritme. Raadpleeg voor meer informatie over alle hyperparameters die u kunt afstemmen Voer automatische modelafstemming uit met SageMaker.

Voor elke hyperparameter die we willen optimaliseren, moeten we het volgende definiëren:

• Een naam
• Een type (parameters kunnen een geheel getal, continu of categorisch zijn)
• Een reeks waarden om te verkennen
• Een schaaltype (lineair, logaritmisch, omgekeerd logaritmisch of automatisch); hiermee kunnen we bepalen hoe een specifiek parameterbereik wordt verkend

We moeten ook de statistiek definiëren waarvoor we optimaliseren. Het kan elke numerieke waarde zijn, zolang het maar zichtbaar is in het trainingslogboek en u een reguliere expressie kunt doorgeven om het te extraheren.

Als we naar regel 181 in mnist.py kijken, kunnen we zien hoe we naar de logger printen:

logger.info(
"Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)n".format(
test_loss, correct, len(test_loader.dataset), 100.0 * correct / len(test_loader.dataset)
)

We kunnen deze uitvoer zelfs zien in de logboeken van de trainingstaak die we zojuist hebben uitgevoerd. Door de logboekgroep te openen /aws/sagemaker/TrainingJobs op de CloudWatch-console zouden we een loggebeurtenis moeten hebben die begint met pytorch-training- gevolgd door een tijdstempel en gegenereerde naam.

De volgende schermafbeelding markeert het logboek waarnaar we op zoek zijn.

Laten we nu beginnen met het bouwen van onze taak voor het afstemmen van hyperparameters.

6. Zoals vermeld, moeten we eerst wat informatie over de hyperparameters definiëren, onder het object als volgt:

   hyperparameter_ranges = {
   "lr": ContinuousParameter(0.001, 0.1),
   "batch-size": CategoricalParameter([32, 64, 128, 256, 512]),
   }

   Hier hebben we onze twee hyperparameters gedefinieerd. De leersnelheid (lr) is een continue parameter (dus een continue waarde) in het bereik van 0.001 tot 0.1. De batchgrootte (batch-size) is een categorische parameter met de voorafgaande discrete waarden.

   Vervolgens specificeren we de objectieve metriek die we willen afstemmen en de definitie ervan. Dit omvat de reguliere expressie (regex) die nodig is om die statistiek te extraheren uit de CloudWatch-logboeken van de trainingstaak die we eerder zagen. We specificeren ook een beschrijvende naam gemiddeld testverlies en het doeltype als Minimaliseren, dus de hyperparameterafstemming probeert de objectieve metriek te minimaliseren bij het zoeken naar de beste hyperparameterinstelling.

7. Specificeer de metriek met de volgende code:

   metric_definitions = [{"Name": "average test loss", "Regex": "Test set: Average loss: ([0-9.]+)"}]
   objective_metric_name = "average test loss"
   objective_type = "Minimize"

   Nu zijn we klaar om onze te maken HyperparameterTuner object. Naast de naam, het type en de definitie van de doelstellingsmetriek, geven we de hyperparameter_ranges object en de schatter die we eerder hebben gemaakt. We specificeren ook het aantal banen dat we in totaal willen uitvoeren, samen met het aantal dat parallel moet lopen. We hebben het maximale aantal banen gekozen als 9, maar u zou doorgaans kiezen voor een veel hoger aantal (zoals 50) voor optimale prestaties.

8. Maak de HyperparameterTuner object met de volgende code:

   tuner = HyperparameterTuner(
   estimator,
   objective_metric_name,
   hyperparameter_ranges,
   metric_definitions,
   max_jobs=9,
   max_parallel_jobs=3,
   objective_type=objective_type,
   )

Voordat we met de afstemmingstaak beginnen, is het vermeldenswaard hoe de combinaties van hyperparameters worden bepaald. Om goede resultaten te krijgen, moet u de juiste reeksen kiezen om te verkennen. Standaard wordt de Bayesiaanse zoekstrategie gebruikt, verderop in beschreven Hoe Hyperparameter Tuning werkt.

Bij Bayesiaanse optimalisatie wordt hyperparameterafstemming behandeld als een regressie probleem. Om dit regressieprobleem op te lossen, raadt het welke hyperparametercombinaties de beste resultaten opleveren, en voert het trainingstaken uit om deze waarden te testen. Het gebruikt regressie om de volgende set hyperparameterwaarden te kiezen om te testen. Er is een duidelijke afweging tussen exploiteren en verkennen die de zoekstrategie hier maakt. Het kan hyperparameterwaarden kiezen die dicht bij de combinatie liggen die resulteerde in de beste eerdere trainingstaak om de prestaties stapsgewijs te verbeteren. Of het kan waarden kiezen die verder weg liggen, om te proberen een nieuw bereik van waarden te verkennen dat nog niet goed wordt begrepen.

U kunt echter andere zoekstrategieën specificeren. De volgende strategieën worden ondersteund in SageMaker:

• Raster zoeken – Probeert elke mogelijke combinatie uit het opgegeven bereik van hyperparameters.
• Willekeurig zoeken – Probeert willekeurige combinaties uit het opgegeven waardenbereik. Het is niet afhankelijk van de resultaten van eerdere trainingstaken, dus u kunt het maximale aantal gelijktijdige trainingstaken uitvoeren zonder de prestaties van de afstemming te beïnvloeden.
• Hyperband zoeken - Gebruikt zowel tussen- als eindresultaten van trainingstaken om tijdperken opnieuw toe te wijzen aan goed gebruikte hyperparameterconfiguraties, en stopt automatisch degenen die ondermaats presteren.

U kunt ook onderzoeken of u uw eigen algoritme kunt gebruiken, zoals uitgelegd in Breng uw eigen algoritme voor hyperparameteroptimalisatie op Amazon SageMaker.

9. Vervolgens starten we training op het tunerobject zelf (niet de schatter), aanroepend .fit() en het S3-pad doorgeven aan onze trein- en testdataset:

   tuner.fit({"training": inputs})

We kunnen dan de voortgang van onze afstemmingstaak volgen op de SageMaker-console, op de Taken voor het afstemmen van hyperparameters bladzijde. De afstemmingstaak activeert de onderliggende rekenresources die nodig zijn door elke afzonderlijke trainingsrun en de bijbehorende rekenkracht te orkestreren.

Dan is het gemakkelijk om alle individuele trainingstaken te zien die zijn voltooid of bezig zijn, samen met de bijbehorende objectieve metrische waarde. In de volgende schermafbeelding kunnen we zien dat de eerste reeks trainingstaken is voltooid, die er volgens onze specificaties in totaal drie bevat max_parallel_jobs waarde van 3. Na voltooiing kunnen we de beste trainingsbaan vinden - degene die het gemiddelde testverlies minimaliseert - op de Beste opleidingsbaan Tab.

Opruimen

Verwijder de resources die u hebt geïnitialiseerd om toekomstige kosten te voorkomen. Dit zijn de S3-bucket, de IAM-rol en de SageMaker-notebookinstantie.

Conclusie

In dit bericht hebben we besproken hoe we ons eigen model in SageMaker kunnen brengen en vervolgens geautomatiseerde hyperparameteroptimalisatie kunnen gebruiken om de beste trainingstaak te selecteren. We hebben de populaire MNIST-dataset gebruikt om te kijken hoe we een aangepaste objectieve metriek kunnen specificeren waarop de HPO-taak moet optimaliseren. Door deze objectieve metriek uit CloudWatch te extraheren en verschillende hyperparameterwaarden te specificeren, kunnen we de HPO-taak eenvoudig starten en monitoren.

Als u meer informatie nodig heeft of wilt zien hoe onze klanten HPO gebruiken, raadpleeg dan Amazon SageMaker automatische modelafstemming. Pas vandaag nog uw eigen model aan voor geautomatiseerde optimalisatie van hyperparameters in SageMaker.

Over de auteur

Sam prijs is een Professional Services Consultant gespecialiseerd in AI/ML en data-analyse bij Amazon Web Services. Hij werkt nauw samen met klanten in de publieke sector in de gezondheidszorg en life sciences om uitdagende problemen op te lossen. Als hij dit niet doet, speelt Sam graag gitaar en tennis en ziet hij zijn favoriete indiebands.