De complete gids voor machine learning op AWS met Amazon SageMaker

Hoewel de meeste mensen Amazon associëren met snelle leveringen en content, is het bedrijf ook zeer populair onder developers. Zo biedt Amazon Web Services (AWS) cloudtechnologieën voor meer dan 1 miljoen actieve gebruikers, variërend van grote ondernemingen tot mkb’s.

In dit artikel focussen we op AWS SageMaker, een speciaal platform binnen het AWS-ecosysteem voor end-to-end machine-learning(ML)-workflows op grote schaal. Aan het einde van dit artikel hebben we een model gedeployed waar we verzoeken naartoe kunnen sturen om voorspellingen te genereren voor een classificatietaak.

Wat is Amazon SageMaker?

Amazon SageMaker is een volledig beheerde service die tools en infrastructuur biedt om machine-learningmodellen te bouwen, te trainen en te deployen. Het vereenvoudigt de ML-workflow, zodat data scientists en developers snel en efficiënt modellen kunnen maken, trainen en uitrollen.

In een typisch machine-learningproject doorloop je meerdere fasen:

• Data-inname, opschoning en verkenning.
• Feature engineering en selectie.
• Modeltraining en hyperparametertuning.
• Deployen en modelmonitoring.

Elke fase vereist een andere set tools en een team van experts om alles naadloos te orkestreren. Amazon SageMaker brengt dit hele proces samen op één platform. Enkele voordelen:

• End-to-end machine-learningservice: Biedt een complete set tools voor elke fase van de ML-levenscyclus, van datapreparatie tot modeldeploy en monitoring.
• Geïntegreerde ontwikkelomgeving: SageMaker Studio biedt een IDE die de hele ML-workflow vereenvoudigt, zodat je modellen kunt bouwen, trainen en deployen vanuit één interface.
• Gebruiksvriendelijk: Met features zoals SageMaker Autopilot kunnen ook gebruikers zonder codeerervaring met een paar klikken hoogwaardige modellen genereren.
• Schaalbaarheid: Schaalt infrastructuur automatisch op voor training en deployment, zodat prestaties optimaal zijn zonder handmatig ingrijpen.
• Kosteneffectief: Biedt opties zoals Spot Training en multi-model endpoints om trainings- en hostingskosten te verlagen.
• Ondersteuning voor populaire ML-frameworks: Maakt het mogelijk om favoriete frameworks te gebruiken, waaronder TensorFlow, PyTorch en XGBoost.
• Geautomatiseerde hyperparametertuning: Vindt automatisch de best presterende modelconfiguratie door hyperparameters te tunen.
• Robuuste modeldeployment: Vereenvoudigt het uitrollen van modellen als real-time API’s of batchvoorspeldiensten, waardoor integratie in applicaties eenvoudig is.
• Uitgebreide monitoring: SageMaker Model Monitor volgt continu de modelprestaties en detecteert datadrift en anomalieën in productie.
• Modelregister: Beheert de levenscyclus van ML-modellen, inclusief versiebeheer, goedkeuringsworkflows en deploymentgeschiedenis.
• Naadloze integratie: Integreert gemakkelijk met andere AWS-services, zoals Amazon S3 voor dataopslag, AWS Glue voor datapreparatie, AWS Lambda voor event-driven verwerking en Amazon CloudWatch voor monitoring en logging.
• Security en compliance: Zorgt voor databescherming en naleving van industrienormen met robuuste beveiligingsfeatures, waaronder VPC-ondersteuning, versleuteling en IAM-beleid.

Deze voordelen maken Amazon SageMaker tot een krachtig en flexibel platform voor het bouwen, trainen en deployen van ML-modellen op schaal.

Je AWS-console en -omgeving instellen voor SageMaker

Zoals genoemd is SageMaker onderdeel van het AWS-ecosysteem, dat bestaat uit veel cloudoplossingen voor opslag, netwerken, databases, analytics en machine learning. Al deze oplossingen werken samen met SageMaker om je ML-workflow te stroomlijnen.

Daarom moet je een AWS-account aanmaken als je dat nog niet hebt.

1. Een AWS-account aanmaken

Ga naar https://aws.amazon.com/ en volg de stappen om een nieuw account te maken.

Tijdens het aanmeldproces voeg je factureringsinformatie toe en verifieer je je telefoonnummer. Maak je geen zorgen—je betaalt pas zodra je daadwerkelijk sommige SageMaker-functionaliteiten gaat gebruiken (die doorgaans kostenefficiënt zijn). 

Na afloop kom je in je AWS-console, die er meestal uitziet zoals in de onderstaande afbeelding. Let op: sommige consolewidgets kunnen bij jou anders zijn.

2. Een notebook-instance maken

We maken nu een JupyterLab-sessie om code uit te voeren op de cloudmachines van Amazon.

Zoek in je AWS-console via de zoekbalk bovenaan naar het SageMaker-dashboard:

Scroll vervolgens naar beneden naar het tabblad “Notebooks” en kies daar “Notebooks instances”. Je ziet nog geen instances, dus we moeten er een aanmaken:

Klik rechtsboven op “Create notebook instance” om een nieuw notebook te maken. Vul daarna het volgende in:

• Geef je notebook een naam. In dit voorbeeld heb ik sagemaker-test gebruikt.
• Met het veld “Notebook instance type” kies je het type machine voor de kernel van je notebook. Ik kies ml.t3.large, met 8 GB RAM en 2 CPU-cores. Ten tijde van schrijven kost dit ongeveer $0,12 per uur (raadpleeg de SageMaker-prijspagina voor actuele informatie).
• Kies in “Permissions and encryption” de optie “Create new user”. Hiermee wordt automatisch een IAM-gebruiker gemaakt met de vereiste permissies om je notebookinstance te draaien.

Klik op “Create notebook instance” zodra je alles hebt ingevuld. 

Wanneer de status van “Pending” naar “inService” verandert, kun je JupyterLab openen door naast het notebook op “Open in JupyterLab” te klikken:

Zodra de instance actief is, begint de tijd en daarmee de facturatie te lopen. Neem je even pauze, vergeet dan niet de instance te stoppen via “Actions” > “Stop” om onnodige kosten te voorkomen. De idle shutdown staat standaard op twee uur:

Als je een notebookinstance stopt, kun je deze later weer starten. Je omgeving blijft behouden.

Een dataset uploaden voor gebruik in AWS SageMaker

In deze sectie leren we hoe je een lokaal bestand naar de servers van Amazon uploadt, wat nodig is voor SageMaker.

1. Een voorbeelddataset downloaden

We bouwen een multiclass-classifier met de Dry Bean-dataset uit de UCI ML-repository. Deze bevat 13k voorbeelden van bonen met 15 numerieke metingen. 

De taak is om ze te classificeren in zeven soorten bonen: Seker, Barbunya, Bombay, Cali, Dermosan, Horoz en Sira.

De zeven soorten bonen: Seker, Barbunya, Bombay, Cali, Dermosan, Horoz en Sira.

Sla na het downloaden het Excel-bestand uit de ZIP op in je lokale datamap in JupyterLab en voeg daarna de volgende code toe aan je notebook:

from pathlib import Path

cwd = Path.cwd()
data_path = cwd / "data" / "Dry_Bean_Dataset.xlsx"

Door vervolgens de onderstaande code toe te voegen, kunnen we het Excel-bestand met pandas inlezen en als CSV opslaan:

import pandas as pd

beans = pd.read_excel(data_path)
beans.to_csv(cwd / "data" / "dry_bean.csv", index=False)

2. Een S3-bucket maken en er data naartoe uploaden

Onze dataset moet in een S3-bucket staan zodat SageMaker er toegang toe heeft. AWS S3 is een cloudopslagoplossing waarmee je projectgerelateerde objecten in buckets op de servers van Amazon bewaart.

Volg deze stappen om een bucket te maken:

• Ga naar de S3-console. Je kunt “S3” zoeken in de zoekbalk.
• Klik op “Create bucket”.
• Geef je bucket een naam.
• De naam van de bucket moet wereldwijd uniek zijn, dus je kunt niet dry-bean-bucket gebruiken zoals ik deed.
• Laat de rest van de velden op de standaardinstellingen staan.
• Klik op “Create bucket”.

Klik na het maken van de bucket erop om het eerder opgeslagen CSV-bestand te uploaden:

• Klik in de bucket op “Upload” en vervolgens op “Add files”.
• Selecteer het CSV-bestand.
• Klik opnieuw op “Upload”.

Ga daarna terug naar de JupyterLab-interface, want we gaan eindelijk code draaien!

End-to-end workflow voor modeltraining en deployment in AWS SageMaker

In deze sectie doorlopen we een end-to-end workflow die ons van een CSV-dataset naar een model op een endpoint brengt. Maar voordat we in de technische details duiken, kijken we eerst op hoofdlijnen naar wat we gaan doen.

Een high-level overzicht van ML-workflows in SageMaker

Machine learning doen in SageMaker is net iets anders dan lokaal. We hebben de eerste stappen al behandeld:

• Een AWS-account aanmaken.
• Een notebookinstance aanmaken.
• Een S3-bucket maken voor het project.

Net als je lokale notebooks zijn SageMaker-notebookinstances bedoeld voor exploratieve analyse—datacleaning, verkenning, inname en basisexperimenten.

Zodra je bij de modeltrainingsfase komt, verwacht SageMaker dat je volgens zijn regels werkt. Concreet: om je eigen modellen als endpoints te deployen, heeft SageMaker een trainingsscript nodig dat het volgende doet:

• Laadt de data van de bron.
• Traindt er één model op.
• Slaat het model en de artefacten op.
• Rapporteert de metrics.

Het script moet ook variabelen dynamisch als command-lineargumenten accepteren. Alles wat je later wilt kunnen wijzigen (modelhyperparameters, bestands­paden, enz.) moet dus als CLI-argument worden ingesteld.

Zodra het script klaar is, voer je het in speciale estimators van SageMaker. Dit zijn “companions” voor populaire ML-bibliotheken zoals scikit-learn, XGBoost, TensorFlow, PyTorch, enz. Met deze estimators bouwt SageMaker Docker-containers rondom je script en deployt het als een endpoint om op schaal te serven.

Al het bovenstaande zal duidelijker worden wanneer we het stap voor stap doornemen. 

1. De notebookinstance instellen voor SageMaker

Laten we beginnen met het importeren van de benodigde libraries in het notebook sagemaker-test dat je eerder maakte:

import boto3
import numpy as np
import pandas as pd
import sagemaker
from sagemaker import get_execution_role
from sklearn.model_selection import train_test_split

Dit doen sommige van deze imports:

• sagemaker is de officiële Python-SDK om ML-modellen te trainen en te deployen op Amazon SageMaker. Met de SDK kun je modellen trainen en uitrollen met populaire deep-learningframeworks, door Amazon geleverde algoritmen of je eigen algoritmen in SageMaker-compatibele Docker-images.
• boto3 is nog een officiële Python-SDK, maar die vormt de brug tussen je code en alle AWS-services, niet alleen SageMaker. Meer leren over boto3 doe je in deze course. 

Maak na de imports een paar resources aan die we door de tutorial heen nodig hebben:

sm_boto3 = boto3.client("sagemaker")
sess = sagemaker.Session()

• In de code hierboven maken we eerst een SageMaker-clientobject met boto3. 
• Daarna maken we een SageMaker-sessie. 

Met beide objecten kunnen we op verschillende manieren met het SageMaker-platform interacteren.

Definieer nu een paar globale variabelen die we nodig hebben:

region = sess.boto_session.region_name
BUCKET_URI = "s3://dry-bean-bucket"
BUCKET_NAME = "dry-bean-bucket"
DATASET_PATH = f"{BUCKET_URI}/dry_bean.csv"
TARGET_NAME = "Class"

Deze variabelen spreken voor zich en we gebruiken ze in de rest van de tutorial.

2. Data laden uit een S3-bucket in SageMaker

In de meeste dataprojecten staat je trainingsdataset in een cloudopslagoplossing zoals BigQuery, GCS of een AWS S3-bucket. Wij gebruikten de laatste, dus laten we die met pandas laden. Voeg de volgende code toe en voer die uit:

dry_bean = pd.read_csv(DATASET_PATH)
dry_bean.head()

Een voordeel van werken in een Sagemaker-notebook is dat we direct met pandas uit S3 kunnen lezen. Alle SageMaker-omgevingen zijn met je credentials geconfigureerd, zodat pandas de CSV uit de bucket kan downloaden. Deze code zou lokaal niet hebben gewerkt.

3. EDA uitvoeren in SageMaker

Tijd besteden aan EDA (Exploratory Data Analysis) hoort bij elk project en ook hier maken we er ruimte voor. We gaan echter niet diep analyseren, omdat dat ons afleidt van het hoofdonderwerp. 

We beperken ons tot wat samenvattende statistieken en grafieken:

dry_bean.info()

<class 'pandas.core.frame.DataFrame'>

RangeIndex: 13611 entries, 0 to 13610

Data columns (total 17 columns):

#   Column           Non-Null Count  Dtype 

---  ------           --------------  ----- 

0   Area             13611 non-null  int64 

1   Perimeter        13611 non-null  float64

2   MajorAxisLength  13611 non-null  float64

3   MinorAxisLength  13611 non-null  float64

4   AspectRation     13611 non-null  float64

5   Eccentricity     13611 non-null  float64

6   ConvexArea       13611 non-null  int64 

7   EquivDiameter    13611 non-null  float64

8   Extent           13611 non-null  float64

9   Solidity         13611 non-null  float64

10  roundness        13611 non-null  float64

11  Compactness      13611 non-null  float64

12  ShapeFactor1     13611 non-null  float64

13  ShapeFactor2     13611 non-null  float64

14  ShapeFactor3     13611 non-null  float64

15  ShapeFactor4     13611 non-null  float64

16  Class            13611 non-null  object

dtypes: float64(14), int64(2), object(1)

memory usage: 1.8+ MB

Hieruit blijkt dat er 16 numerieke features zijn en één target met de naam Class. De dataset is klein—slechts 13k voorbeelden—dus we hebben geen krachtige machines nodig en maken weinig kosten om een model te trainen.

Laten we vervolgens een pair plot maken van een paar belangrijke features met seaborn:

import seaborn as sns

sns.pairplot(
   dry_bean,
   vars=["Area", "MajorAxisLength", "MinorAxisLength", "Eccentricity", "roundness"],
   hue="Class",
);

De grafieken laten zien dat de bonen duidelijk verschillen in hun fysieke metingen. De groene bonen (Bombay) vallen extra op.

We kunnen ook een correlatiematrix plotten om de relaties tussen features te zien:

import matplotlib.pyplot as plt

correlation = dry_bean.corr(numeric_only=True)

# Maak een vierkante heatmap met centrum op 0
sns.heatmap(correlation, center=0, square=True, cmap="coolwarm", vmin=-1, vmax=1)
plt.show()

De plot toont veel perfect gecorreleerde (positief en negatief) features, wat logisch is omdat alle features met fysieke metingen samenhangen.

Vanaf hier kun je de verkenning zelf voortzetten.

4. Data voorbereiden voor modeltraining in SageMaker

Na de verkenning pak je eventuele kwaliteits- of logische problemen in je dataset aan en engineer je waar nodig nieuwe features voordat je gaat trainen. 

De dataset Dry Bean is vrij schoon, dus ons werk is eenvoudig. We hoeven alleen de target te encoden omdat die tekst bevat. Dat doen we met scikit-learn:

from sklearn.preprocessing import LabelEncoder

# Voor preprocessing
df = dry_bean.copy(deep=True)

# Encode de target
le = LabelEncoder()
df[TARGET_NAME] = le.fit_transform(df[TARGET_NAME])

Na de preprocessing moeten we de dataset splitsen:

from sklearn.model_selection import train_test_split

# Split de data in twee sets
train, test = train_test_split(df, random_state=1, test_size=0.2)

Je kunt de data eventueel verder splitsen in een derde validatieset, maar we houden het nu simpel.

Sla de datasets nu op als CSV’s:

train.to_csv("dry-bean-train.csv")
test.to_csv("dry-bean-test.csv")

En upload ze naar onze S3-bucket:

# Verstuur data naar S3. SageMaker haalt trainingsdata uit S3
trainpath = sess.upload_data(
   path="dry-bean-train.csv",
   bucket=BUCKET_NAME,
   key_prefix="sagemaker/sklearncontainer",
)

testpath = sess.upload_data(
   path="dry-bean-test.csv",
   bucket=BUCKET_NAME,
   key_prefix="sagemaker/sklearncontainer",
)

De functie .upload_data() van het session-object geeft het volledige pad terug naar het geüploade bestand, opgeslagen in respectievelijk de variabelen trainpath en testpath. Die paden gebruiken we later.

5. Een trainingsscript schrijven voor SageMaker

Plak in een nieuwe notebookcel de volgende code:

%%writefile script.py

import argparse
import os
import joblib
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import balanced_accuracy_score

if __name__ == "__main__":
   print("extracting arguments")
   parser = argparse.ArgumentParser()

   # Hyperparameters sent by the client are passed as command-line arguments to the script.
   parser.add_argument("--n-estimators", type=int, default=10)
   parser.add_argument("--min-samples-leaf", type=int, default=3)

   # Data, model, and output directories
   parser.add_argument("--model-dir", type=str, default=os.environ.get("SM_MODEL_DIR"))
   parser.add_argument("--train", type=str, default=os.environ.get("SM_CHANNEL_TRAIN"))
   parser.add_argument("--test", type=str, default=os.environ.get("SM_CHANNEL_TEST"))
   parser.add_argument("--train-file", type=str, default="dry-bean-train.csv")
   parser.add_argument("--test-file", type=str, default="dry-bean-test.csv")
   args, _ = parser.parse_known_args()
   
   print("reading data")

   train_df = pd.read_csv(os.path.join(args.train, args.train_file))
   test_df = pd.read_csv(os.path.join(args.test, args.test_file))

   print("building training and testing datasets")

   X_train = train_df.drop("Class", axis=1)
   X_test = test_df.drop("Class", axis=1)
   y_train = train_df[["Class"]]
   y_test = test_df[["Class"]]

   # Train model
   print("training model")

   model = RandomForestClassifier(
       n_estimators=args.n_estimators,
       min_samples_leaf=args.min_samples_leaf,
       n_jobs=-1,
   )

   model.fit(X_train, y_train)

   # Print abs error
   print("validating model")

   bal_acc_train = balanced_accuracy_score(y_train, model.predict(X_train))
   bal_acc_test = balanced_accuracy_score(y_test, model.predict(X_test))

   print(f"Train balanced accuracy: {bal_acc_train:.3f}")
   print(f"Test balanced accuracy: {bal_acc_test:.3f}")

   # Persist model
   path = os.path.join(args.model_dir, "model.joblib")
   joblib.dump(model, path)
   print("model persisted at " + path)

De magic command %%writefile script.py zet de inhoud van de cel om in een Python-script in plaats van het uit te voeren.

Laten we nu stap voor stap door het script gaan:

import argparse
import os
import joblib
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import balanced_accuracy_score

Eerst importeren we de benodigde libraries. 

if __name__ == "__main__":
   print("extracting arguments")
   parser = argparse.ArgumentParser()
   
   # Hyperparameters sent by the client are passed as command-line arguments to the script.
   parser.add_argument("--n-estimators", type=int, default=10)
   parser.add_argument("--min-samples-leaf", type=int, default=3)

   # Data, model, and output directories
   parser.add_argument("--model-dir", type=str, default=os.environ.get("SM_MODEL_DIR"))
   parser.add_argument("--train", type=str, default=os.environ.get("SM_CHANNEL_TRAIN"))
   parser.add_argument("--test", type=str, default=os.environ.get("SM_CHANNEL_TEST"))
   parser.add_argument("--train-file", type=str, default="dry-bean-train.csv")
   parser.add_argument("--test-file", type=str, default="dry-bean-test.csv")
   args, _ = parser.parse_known_args()

Daarna maken we een argumentparser om command-lineargumenten te lezen. Zoals gezegd moet elke waarde die je later wilt kunnen wijzigen als CLI-argument worden doorgegeven. Dit deel definieert die argumenten:

• Twee hyperparameters voor het RandomForestClassifier-object.
• Vijf in- en uitvoerpaden, waaronder modelartefacten en datasetbestanden.

Let op de standaardwaarden voor de mappen model-dir, train en test: dat zijn omgevingsvariabelen. Die komen uit de SageMaker SDK-documentatie, waar ook richtlijnen staan voor dit soort scripts.

print("reading data")
train_df = pd.read_csv(os.path.join(args.train, args.train_file))
test_df = pd.read_csv(os.path.join(args.test, args.test_file))
print("building training and testing datasets")
X_train = train_df.drop("Class", axis=1)
X_test = test_df.drop("Class", axis=1)
y_train = train_df[["Class"]]
y_test = test_df[["Class"]]

Zodra de dynamische waarden zijn gedefinieerd, lezen en bouwen we de train- en testdatasets. In plaats van hard-gecodeerde paden gebruiken we args.argument-waarden. 

# Train model
print("training model")
   
model = RandomForestClassifier(
    n_estimators=args.n_estimators,
    min_samples_leaf=args.min_samples_leaf,
    n_jobs=-1,
)

model.fit(X_train, y_train)

# Print abs error
print("validating model")
   
bal_acc_train = balanced_accuracy_score(y_train, model.predict(X_train))
bal_acc_test = balanced_accuracy_score(y_test, model.predict(X_test))

print(f"Train balanced accuracy: {bal_acc_train:.3f}")
print(f"Test balanced accuracy: {bal_acc_test:.3f}")

We trainen het model, evalueren het op zowel train- als testset en printen de prestaties. 

# Persist model
path = os.path.join(args.model_dir, "model.joblib")
joblib.dump(model, path)
print("model persisted at " + path)

Tot slot slaan we het model op in de modelmap met joblib.

Als je deze cel draait, verschijnt het bestand script.py in je JupyterLab-omgeving. Je kunt checken of het werkt door het zo uit te voeren:

! python script.py --n-estimators 100 \

                  --min-samples-leaf 2 \

                  --model-dir ./ \

                  --train ./ \

                  --test ./ \

extracting arguments

reading data

building training and testing datasets

validating model

Train balanced accuracy: 1.000

Test balanced accuracy: 0.998

model persisted at ./modejoblib

Mooi, we hebben 99% balanced accuracy—beter wordt het niet! Dat betekent dat we een training job kunnen starten.

6. Een custom training job maken in SageMaker

We geven het script nu door aan een SageMaker-estimatorobject. In de context van AWS is een training job een proces waarbij een model wordt getraind met een specifieke algoritme-implementatie, dataset en compute-resources die AWS SageMaker levert. In tegenstelling tot lokaal trainen draait deze job in de cloud op schaalbare infrastructuur, met meer rekenkracht, snellere verwerking en de mogelijkheid grotere datasets aan te kunnen.

Voeg de volgende code toe in een nieuwe cel:

# We use the Estimator from the SageMaker Python SDK
from sagemaker.sklearn.estimator import SKLearn
FRAMEWORK_VERSION = "0.23-1"

sklearn_estimator = SKLearn(
   entry_point="script.py",
   role=get_execution_role(),
   instance_count=1,
   instance_type="ml.c5.xlarge",
   framework_version=FRAMEWORK_VERSION,
   base_job_name="rf-scikit",
   hyperparameters={
       "n-estimators": 100,
       "min-samples-leaf": 3,
   },
)

In de code hierboven behandelt de klasse SKLearn scikit-learn-scripts. Een paar essentiële parameters:

• entry_point: Het pad naar het script.
• role: De gebruikersrol met toegang tot SageMaker.
• instance_count: Het aantal machines om te starten.
• instance_type: Het type machine.

Geef bij hyperparameters alleen de parameters door die je in het trainingsscript hebt gedefinieerd. Anders krijg je een fout. 

Nu kunnen we de estimator fitten op onze data:

# Launch training job, with asynchronous call
sklearn_estimator.fit({"train": trainpath, "test": testpath}, wait=True)

Zoals eerder in deze tutorial vermeld, zijn trainpath en testpath S3-bucketpaden naar onze CSV-bestanden. 

Zodra je de cel draait, start de training:

INFO:sagemaker:Creating training-job with name: rf-scikit-2024-06-04-10-36-31-142

2024-06-04 10:36:31 Starting - Starting the training job...

2024-06-04 10:36:46 Starting - Preparing the instances for training...

2024-06-04 10:37:13 Downloading - Downloading input data...

2024-06-04 10:37:53 Training - Training image download completed. Training in progress...

SageMaker downloadt de benodigde Docker-image om scikit-learncode te draaien en voert je script uit. Na afloop zie je het volgende bericht:

2024-06-04 10:38:17 Uploading - Uploading generated training model

2024-06-04 10:38:17 Completed - Training job completed

Training seconds: 65

Billable seconds: 65

Als je in je SageMaker-dashboard naar “SageMaker” > “Traning” > “Training Jobs” gaat, zie je de training job daar ook terug.

7. Spot Instances gebruiken tijdens training om kosten te verlagen

Omdat onze dataset klein is, kwamen we weg met een goedkope, licht geconfigureerde machine voor training: ml.c5.xlarge. In je eigen projecten werk je misschien met datasets met miljoenen records of enorme afbeeldingsdatasets. Dan heb je machines met veel meer power en GPU’s nodig.

Deze machines on demand gebruiken kan erg duur zijn. Om kosten te drukken biedt Amazon Spot Training-instances. Daarmee kun je krachtige compute-resources voor een lage prijs kiezen met één kanttekening—de training start niet meteen. SageMaker wacht tot de vraag laag is en de door jou gevraagde machine beschikbaar komt. 

Om Spot Training in te schakelen, voeg je slechts een paar regels toe aan het vorige codeblok:

spot_sklearn_estimator = SKLearn(
   entry_point="script.py",
   role=get_execution_role(),
   instance_count=1,
   instance_type="ml.c5.xlarge",
   framework_version=FRAMEWORK_VERSION,
   base_job_name="rf-scikit",
   hyperparameters={
       "n-estimators": 100,
       "min-samples-leaf": 3,
   },
   use_spot_instances=True,
   max_wait=7200,
   max_run=3600,
)

Door use_spot_instances op True te zetten, laat je spot_sklearn_estimator spottraining gebruiken. Je kunt ook de maximale wachttijd instellen tot een spotinstance beschikbaar is en de maximale looptijd voor de training. 

De training start wanneer je opnieuw .fit() aanroept:

# Launch training job, with asynchronous call
spot_sklearn_estimator.fit({"train": trainpath, "test": testpath}, wait=True)

8. Hyperparametertuning met SageMaker

Met hetzelfde trainingsscript kunnen we via een vergelijkbare workflow een hypergetuned model produceren. 

We importeren eerst de klasse IntegerParameter uit sagemaker.tuner:

from sagemaker.tuner import IntegerParameter

Met IntegerParameter kan SageMaker tunebereiken definiëren voor parameters die gehele waarden accepteren. De module tuner bevat ook klassen voor andere parametertypen:

• CategoricalParameter: Definieert hyperparameters met een discrete set categorische waarden.
• ContinuousParameter: Definieert tunebereiken voor hyperparameters met continue waarden.

We blijven in deze tutorial bij IntegerParameter, omdat we slechts twee parameters van Random Forest tunen:

# We use the Hyperparameter Tuner
from sagemaker.tuner import IntegerParameter

# Define exploration boundaries
hyperparameter_ranges = {
   "n-estimators": IntegerParameter(20, 100),
   "min-samples-leaf": IntegerParameter(2, 6),
}

Maak vervolgens een tunerobject aan:

# Create Optimizer
Optimizer = sagemaker.tuner.HyperparameterTuner(
   estimator=sklearn_estimator,
   hyperparameter_ranges=hyperparameter_ranges,
   base_tuning_job_name="RF-tuner",
   objective_type="Maximize",
   objective_metric_name="balanced-accuracy",
   metric_definitions=[
       {"Name": "balanced-accuracy", "Regex": "Test balanced accuracy: ([0-9.]+).*$"}
   ],  # Extract tracked metric from logs with regexp
   max_jobs=10,
   max_parallel_jobs=2,
)

Belangrijke parameters van de Optimizer:

• estimator: Het estimatorobject dat compatibel is met je trainingsscript.
• hyperparameter_ranges: Het bereik van parameters, gedefinieerd met klassen uit de tuner-module.
• objective_type: Of je de metric wilt maximaliseren of minimaliseren. Balanced accuracy wil je maximaliseren.
• metric_definitions: De naam van de te optimaliseren metrics en hoe je ze uit de trainingslogs haalt.

De parameter metric_definitions is wat lastiger omdat die veel flexibiliteit biedt in hoe je metrics definieert. 

In het trainingsscript rapporteren we balanced accuracy met de volgende logregel:

print(f"Train balanced accuracy: {bal_acc_train:.3f}")
print(f"Test balanced accuracy: {bal_acc_test:.3f}")

Wat metric_definitions van ons vraagt, is die boodschap vangen met een reguliere expressie. We hebben dus de volgende dictionary, die een aangepaste naam geeft aan de metric die begint met “Test balanced accuracy”.

{
   "Name": "balanced-accuracy",
   "Regex": "Test balanced accuracy: ([0-9.]+).*$",
}

De rest van de code is bekend:

Optimizer.fit({"train": trainpath, "test": testpath})

INFO:sagemaker:Creating hyperparameter tuning job with name: RF-tuner-240604-1049

Zodra de optimizer klaar is met tunen, kun je de resultaten als DataFrame tonen:

# Get tuner results in a df
results = Optimizer.analytics().dataframe()

while results.empty:
   time.sleep(1)
   results = Optimizer.analytics().dataframe()

results.head()

Haal daarna de best presterende estimator op:

best_estimator = Optimizer.best_estimator()

9. Modellen deployen naar endpoints in SageMaker 

Zodra je hebt gekozen welk model je voor je experimenten gebruikt, kun je het met alle artefacten naar SageMaker uploaden. Dat kan met boto3:

artifact_path = sm_boto3.describe_training_job(
   TrainingJobName=best_estimator.latest_training_job.name
)["ModelArtifacts"]["S3ModelArtifacts"]

print("Model artifact persisted at " + artifact)

Model artifact persisted at s3://sagemaker-us-east-1-496320894061/RF-tuner-240604-1049-009-38d75f35/output/model.tar.gz

De functie describe_training_job() neemt een estimatorobject en pusht het naar een standaard S3-locatie die SageMaker aanbiedt. Hierboven zie je dat het model voor het uploaden in een tarball is omgezet.

Geüploade modellen zie je terug in het gedeelte “Inference” > “Models” van je SageMaker-dashboard:

Als je op een model klikt, zie je rechtsboven de knop “Create endpoint”:

Je kunt het model via die knop deployen of via code door terug te gaan naar de notebookinstance en de methode .deploy() te gebruiken:

from sagemaker.sklearn.model import SKLearnModel

model = SKLearnModel(
   model_data=artifact_path,
   role=get_execution_role(),
   entry_point="script.py",
   framework_version=FRAMEWORK_VERSION,
)

Dit keer gebruiken we de klasse SKLearnModel, bedoeld voor al getrainde modellen. Je geeft de S3-locatie van de artefacten en het script waarmee het is getraind. Daarna kun je de code draaien om te deployen:

predictor = model.deploy(instance_type="ml.c5.large", initial_instance_count=1)
INFO:sagemaker:Creating model with name: sagemaker-scikit-learn-2024-06-04-11-03-54-465
INFO:sagemaker:Creating endpoint-config with name sagemaker-scikit-learn-2024-06-04-11-03-54-960
INFO:sagemaker:Creating endpoint with name sagemaker-scikit-learn-2024-06-04-11-03-54-960

Vervolgens zou je het endpoint moeten zien in het gedeelte “Inference” > “Endpoints” van je SageMaker-dashboard:

Om het te gebruiken voor voorspellingen, kun je in je notebook de methode .predict() op het endpointobject aanroepen:

preds = predictor.predict(test.sample(4).drop("Class", axis=1))
preds

array([3, 0, 1, 2])

Gefeliciteerd, je hebt zojuist je eerste model met SageMaker gedeployed!

Vergeet niet het endpoint te verwijderen als je klaar bent, want dit brengt continu kosten met zich mee:

sm_boto3.delete_endpoint(EndpointName=predictor.endpoint)

Vergeet ook niet: elke notebookinstance in SageMaker heeft een apart tabblad met voorbeeldnotebooks die de verschillende features van SageMaker laten zien:

Bekijk ook de officiële documentatie van de SageMaker Python-SDK.

Conclusie

Vandaag hebben we geleerd hoe je een van de populairste enterprise-ML-platforms gebruikt: AWS SageMaker. We hebben alles behandeld, van het aanmaken van een AWS-account tot het deployen van ML-modellen als endpoints met SageMaker.

Zoals bij elk platform hebben we slechts aan de oppervlakte gekrast. Je kunt nog veel meer doen als je het in je projecten combineert met andere AWS-technologieën. Hier zijn enkele gerelateerde resources om te bekijken:

• Cursus AWS Technology and Services
• Cursus Introduction to AWS
• Cursus Streaming Data with AWS Kinesis and Lambda
• Een uitgebreide gids voor het beheersen van AWS Step Functions