AWS SageMaker Studio Lab: een praktische hands-on gids

Hoe je je aanmeldt en projecten start

Beginnen met SageMaker Studio Lab is vrij eenvoudig, zeker vergeleken met het opzetten van een hele AWS-omgeving.

In de volgende secties laat ik je zien wat je moet doen om aan de slag te gaan.

Account aanmaken en onboarding

Om Studio Lab te gebruiken, moet je eerst toegang aanvragen. Zo werkt het:

1. Ga naar de SageMaker Studio Lab-pagina.
2. Klik op “Request free account” en vul een paar basisgegevens in (e-mail, use case, enz.).
3. Wacht op je uitnodiging. Goedkeuring duurt meestal van een paar uur tot een paar dagen.
4. Na goedkeuring ontvang je een e-mail met de link naar de account-registratiepagina. Maak je account aan met je goedgekeurde e-mailadres en stel een wachtwoord en gebruikersnaam in. Dit account is anders dan je AWS-account, en er is geen creditcard nodig.

In mijn geval kreeg ik binnen 24 uur goedkeuring.

Je omgeving instellen

Eenmaal binnen kun je je computertype kiezen en vervolgens op “Start runtime” klikken.

SageMaker Studio Lab-landingspagina. Afbeelding door de auteur.

Bij de eerste start wordt je ook gevraagd je mobiele nummer in te voeren, waarna er een zescijferige verificatiecode naar dat nummer wordt gestuurd. 

Zodra je omgeving draait, kom je in een JupyterLab-omgeving terecht en zie je het notebook Getting Started.ipynb.

Studio Lab wordt geleverd met een Python-basisimage en slechts een paar vooraf geïnstalleerde libraries om ruimte te besparen voor libraries die jij wilt installeren. 

Naast de standaard conda-omgeving ondersteunt Studio Lab ook de SageMaker Distribution, die een krachtigere, samengestelde omgeving is die door AWS is ontworpen om te matchen met de configuratie van Amazon SageMaker Studio. Het bevat pakketten zoals PyTorch, TensorFlow, NumPy, scikit-learn en Pandas.

Je kunt altijd pakketten installeren in de bestaande Conda-omgeving door %conda install <package> of %pip install <package> rechtstreeks in een notebookcel uit te voeren. 

Je kunt ook requirements.txt of environment.yml gebruiken om complete omgevingen te reproduceren. Dit maakt het eenvoudig om tutorials te volgen.

Maar onthoud dat je slechts 15GB opslag hebt, dus vermijd het installeren van zware pakketten als dat niet nodig is. 

Je geïnstalleerde pakketten blijven ook behouden over verschillende sessies heen.

Projectinitialisatie en GitHub-integratie

Studio Lab integreert goed met GitHub, wat betekent dat je kunt:

• Publieke of private repositories clonen via HTTPS of SSH
• Code pushen en pullen rechtstreeks via de JupyterLab Git-extensie
• Notebooks delen door te linken naar de repo (handig voor samenwerking of opdrachten)

Als je lesgeeft of leert, maakt dit het supermakkelijk om startercode te verspreiden of werk in te leveren voor review, vooral in klaslokalen, bootcamps of zelfstudiegroepen.

Wil je verder gaan dan GitHub en met echte ML-workflows werken? Prbeer de cursus End-to-End Machine Learning om te zien hoe je complete projecten structureert.

Praktische voorbeelden voor machine learning

SageMaker Studio Lab is een ideale plek om ideeën te testen, tutorials te volgen of kleine projecten from scratch te bouwen. Of je nu leert over regressie of met beelddata speelt, het platform ondersteunt de meeste taken op beginner- tot gemiddeld niveau soepel. 

Ik neem je nu mee door praktische voorbeelden die je meteen kunt proberen.

Je vindt de voorbeeldnotebooks in mijn GitHub-repository. Clone die repo gewoon in je Studio Lab-sessie.

Je kunt ook direct op de Open Studio Lab-badges klikken in mijn README.md-bestand, want dat opent het notebook direct voor je in Studio Lab.

Screenshot van het README-bestand met Open in Studio Lab-badges. Afbeelding door de auteur.

Een eenvoudig regressiemodel trainen

Dit is de Hello World van machine learning: een eenvoudig regressiemodel trainen.

Wat je in dit kleine voorbeeld doet:

• De Iris-dataset laden met seaborn.
• De relatie tussen variabelen visueel verkennen.
• Een lineair regressiemodel trainen met scikit-learn.
• De regressielijn plotten en de modelprestatie evalueren.

De code voor dit voorbeeld staat in het notebook simple-regression.ipynb.

Open het notebook en selecteer als kernel sagemaker-distribution:Python.

Kernelkeuze voor het notebook simple-regression.ipynb in Studio Lab. Afbeelding door de auteur.

Het doel van deze ML-taak is om petallengte te voorspellen op basis van sepal-lengte uit de bekende Iris-dataset. 

Voer gewoon alle cellen in het notebook uit om dit voorbeeld te volgen.

Hieronder vind je de volledige code voor dat voorbeeld: 

import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# Load dataset
df = sns.load_dataset("iris")

# Visualize the relationship
sns.scatterplot(data=df, x="sepal_length", y="petal_length", hue="species")
plt.title("Sepal Length vs Petal Length")
plt.show()

# Select features
X = df[["sepal_length"]]
y = df["petal_length"]

# Train/test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Fit model
model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# Evaluation
print("MSE:", mean_squared_error(y_test, y_pred))
print("R² Score:", r2_score(y_test, y_pred))

# Plot regression line
plt.figure(figsize=(8, 5))
sns.regplot(x=X_test["sepal_length"], y=y_test, ci=None, label="Actual", scatter_kws={"s": 50})
plt.plot(X_test["sepal_length"], y_pred, color="red", label="Predicted", linewidth=2)
plt.title("Linear Regression: Predicting Petal Length")
plt.xlabel("Sepal Length")
plt.ylabel("Petal Length")
plt.legend()
plt.show()

Dit voorbeeld traint in seconden op de CPU-runtime van Studio Lab en de plots helpen de modelprestatie te visualiseren. Hoewel het een eenvoudige start is, vormt dit patroon de kern van veel regressietaken in de praktijk.

Voorbeeld beeldclassificatie

MNIST is een uitstekend startpunt om beeldclassificatie te leren. Het is klein, schoon en werkt goed, zelfs in omgevingen met beperkte resources zoals Studio Lab.

In dit voorbeeld ga je:

• De MNIST-dataset laden met tensorflow.keras.datasets
• Een simpel, dense neuraal netwerk bouwen
• Het model trainen en evalueren
• Een paar voorspellingen visualiseren om te zien hoe het model presteert

Je kunt dit voorbeeld draaien in de CPU-runtime, of—als je betere performance wilt—in de GPU-omgeving (die soms lastiger te krijgen is).

De code voor dit voorbeeld vind je in het notebook image-classifier.ipynb of hieronder:

import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np

# Load dataset
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()

# Normalize pixel values
X_train = X_train / 255.0
X_test = X_test / 255.0

# Visualize an example image
plt.imshow(X_train[0], cmap="gray")
plt.title(f"Label: {y_train[0]}")
plt.axis("off")
plt.show()

# Build the model
model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

# Compile the model
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Train the model
history = model.fit(X_train, y_train, epochs=3, validation_split=0.1)

# Evaluate the model
test_loss, test_acc = model.evaluate(X_test, y_test)
print("Test accuracy:", test_acc)

# Predict on test set
predictions = model.predict(X_test)

# Show example prediction
index = 0
plt.imshow(X_test[index], cmap="gray")
plt.title(f"Predicted: {np.argmax(predictions[index])}, Actual: {y_test[index]}")
plt.axis("off")
plt.show()

Open het notebook en selecteer als kernel sagemaker-distribution:Python.

Dit voorbeeld draait soepel op de CPU en is veel sneller met de GPU ingeschakeld. Je kunt het uitbreiden met convolutionele lagen, meer epochs of het visualiseren van fout geclassificeerde cijfers.

Als je hiermee verder wilt, leidt het track Developing AI Applications je door real-world deep learning-usecases.

Datapreprocessing en visualisatie

Dan nu het derde voorbeeld, essentieel voor ML-toepassingen in de praktijk: datapreprocessing en visualisatie.

De meeste datasets in de praktijk zijn rommelig en vereisen grondige opschoning en handmatige inspectie voordat ze bruikbaar zijn. Daarom is kunnen plotten en preprocessen cruciaal voor het ontwikkelen van praktische ML-toepassingen.

Om datapreprocessing en visualisatie te laten zien, gebruiken we de Palmer Penguins-dataset.

Palmer Penguins is een van de beste beginnersvriendelijke datasets om data cleaning en visualisatie te leren. Het is vergelijkbaar met de Iris-dataset, maar met interessantere variabelen en een duidelijkere real-world context.

De code voor dit voorbeeld staat in het notebook data-preprocessing-and-visualization.ipynb. 

Selecteer opnieuw de kernel sagemaker-distribution:Python om dit voorbeeld te volgen.

De volledige code vind je hieronder:

import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt

# Load the dataset
df = sns.load_dataset("penguins")

# Quick overview
print(df.head())

# Check for datatypes and NaN values
print(df.info())

# Check missing values
print(df.isnull().sum())

# Drop rows with missing values (simplest option for this example)
df_clean = df.dropna()

# Histogram of bill length
plt.hist(df_clean["bill_length_mm"], bins=20, color="skyblue", edgecolor="black")
plt.title("Distribution of Bill Length")
plt.xlabel("Bill Length (mm)")
plt.ylabel("Frequency")
plt.show()

# Box plot of body mass by species
sns.boxplot(data=df_clean, x="species", y="body_mass_g", palette="pastel")
plt.title("Body Mass Distribution by Species")
plt.ylabel("Body Mass (g)")
plt.show()

# Scatterplot to explore relationships
sns.scatterplot(data=df_clean, x="bill_length_mm", y="bill_depth_mm", hue="species", style="sex")
plt.title("Bill Length vs. Depth by Species and Sex")
plt.xlabel("Bill Length (mm)")
plt.ylabel("Bill Depth (mm)")
plt.legend()
plt.show()

Deze eenvoudige plots laten al interessante patronen zien, zoals clusters per soort en verschillen tussen mannetjes- en vrouwtjespinguïns.

Notebooks delen en samenwerken

Als je notebook klaar is, is delen eenvoudig:

• Sla het .ipynb-bestand direct op in een GitHub-repository
• Nodig anderen uit om het te bekijken, becommentariëren of vanuit hun eigen Studio Lab-omgeving te draaien

Je kunt zelfs een Open in Studio Lab-badge toevoegen aan je README.md-bestand of notebooks in je publieke GitHub-repo. 

Voeg simpelweg het volgende toe aan je README.md-bestand:

[![Open In Studio Lab](https://studiolab.sagemaker.aws/studiolab.svg)](https://studiolab.sagemaker.aws/import/github/org/repo/blob/master/path/to/notebook.ipynb)

Je kunt het README.md-bestand in mijn repo bekijken om te zien hoe dat in de praktijk werkt.

Werk je met teamgenoten of instructeurs, dan maakt deze aanpak peerreview, feedback en reproduceerbaarheid ontzettend soepel. Je kunt zelfs requirements.txt toevoegen om te zorgen dat zij dezelfde dependencies installeren.

Use cases en educatieve toepassingen

SageMaker Studio Lab is niet alleen een speelplaats voor machine learning, maar ook een praktisch hulpmiddel voor onderwijs, snelle experimenten en lichtgewicht prototyping. Doordat het gratis is, makkelijk toegankelijk en in de browser draait, opent het een breed scala aan use cases voor lerenden, docenten en developers.

Academisch en in je eigen tempo leren

Studio Lab wordt al gebruikt in universitaire klaslokalen, online cursussen en coding bootcamps als lesinstrument. 

De voordelen:

• Geen lokale setup nodig: studenten kunnen meteen coderen, ongeacht het apparaat dat ze gebruiken.
• Persistente opslag: data tussen sessies opslaan, zodat je verder kunt waar je gebleven was.
• Vooraf geïnstalleerde pakketten: dekken de meeste ML-cursussen op beginner- tot gemiddeld niveau.
• JupyterLab: de JupyterLab-UI is bekend en geschikt voor demo’s en interactieve code.

Als docent kun je eenvoudig:

• GitHub-repo’s met startercode delen.
• Opdrachten als notebooks maken en direct hosten.
• Reproduceerbaarheid stimuleren door goed omgevingsbeheer te doceren.

Als student of zelflerende biedt Studio Lab je een plek om:

• Met echte data te oefenen.
• Tutorials te volgen.
• Projecten in te leveren voor review.

Prototyping en lichtgewicht experimenten

Studio Lab is niet gebouwd voor enterprise-workloads, maar het werkt prima voor prototyping. 

Je kunt het gebruiken als je wilt:

• Een modelidee testen.
• Benchmark-vergelijkingen draaien.
• Nieuwe datasets schoonmaken en verkennen.
• Een snelle demo delen met een teamgenoot.

Het is daarom ideaal voor:

• Hackathons, waar tijd en compute beperkt zijn.
• Onderzoek in een vroeg stadium, wanneer ideeën nog in de maak zijn.
• Sideprojects, waarbij je gewoon iets snel wilt laten draaien zonder infrastructuur te beheren.

Ik gebruikte het wanneer ik snel code wilde testen die ik ergens vond, of wanneer ik een demo voorbereidde voor een van mijn artikelen. 

Vergelijkingen en belangrijke beperkingen

SageMaker Studio Lab wordt vaak vergeleken met tools zoals Google Colab, JupyterHub en zelfs het volledige SageMaker Studio. Hoewel deze platforms oppervlakkig op elkaar lijken, verschillen hun sterke punten, beperkingen en ideale use cases aanzienlijk.

Laten we Studio Lab vergelijken met Google Colab.

Studio Lab vs. Google Colab

Hardware en performance

In de praktijk:

• Studio Lab is beter als je een consistente omgeving met persistente opslag wilt (geweldig voor coursework of langere projecten).
• Google Colab is beter als je meer met Google-diensten werkt (zoals Google Drive) en je je notebooks veel wilt delen (dat gaat in Google net iets makkelijker).

Wil je op de lange termijn met AWS-tools werken? Studio Lab is een effectievere tussenstap naar SageMaker Studio en cloudgebaseerde workflows.

Gebruikerservaring en interface-stabiliteit

Studio Lab draait op JupyterLab, terwijl Colab is gebaseerd op klassieke Jupyter Notebooks.

Dit betekent dat Studio Lab tabbladen, terminals, bestandsverkenners en custom conda-omgevingen biedt. 

Colab voelt op zijn beurt lichter aan, maar mist standaard omgevingsisolatie en reproduceerbaarheid. 

Als je gewend bent aan JupyterLab (of een meer IDE-achtige ervaring wilt), voelt Studio Lab gestructureerder en uitbreidbaarder.

Kosten en toegankelijkheid

Beide platforms zijn gratis, maar met enkele belangrijke verschillen:

• Studio Lab: 100% gratis, geen premiumversie, geen enkele billing-integratie.
• Colab: gratis tier is beperkt. Pro/Pro+-abonnementen zijn beschikbaar voor betere resources.

Studio Lab is ideaal voor lerenden of docenten die een betrouwbaar en voorspelbaar platform willen voor onderwijs of experimenten. Colab kan meer power bieden, maar vaak ten koste van stabiliteit of de noodzaak om te upgraden.

Beperkingen van Studio Lab

Omdat Studio Lab gratis is, zijn er ook wat nadelen.

Laten we kijken waar je rekening mee moet houden.

Resourcebeperkingen

Studio Lab kent de volgende resourcebeperkingen:

• Sessielimieten: 4 uur per sessie (CPU/GPU), met dagelijkse quota’s.
• Geen parallelle jobs: slechts één runtime-sessie tegelijk.
• Runtime-toegang: je krijgt alleen een runtime als er resources beschikbaar zijn. Bij mij duurde het soms even voordat ik een runtime kon starten (zelfs voor CPU).
• Opslag: harde limiet van 15 GB, wat mogelijk niet genoeg is voor grote datasets of modelcheckpoints.

Voor kleine en middelgrote projecten blijft dit beheersbaar. Houd bovenstaande beperkingen wel in gedachten bij het bepalen hoe je je werk structureert en data opslaat.

Feature-gaps en workarounds

Studio Lab ondersteunt niet:

• Directe integratie met AWS-diensten zoals S3, SageMaker-endpoints of IAM-rollen.
• Custom networking of port forwarding.
• Backgroundjobs of langlopende services.

Maar je kunt sommige hiaten omzeilen:

• Gebruik Hugging Face Datasets of publieke S3-URL’s voor data.
• Gebruik GitHub voor versiebeheer en het delen van checkpoints.
• Stream data realtime in plaats van alles vooraf te downloaden.
• Gebruik betaalde AWS-diensten als je een applicatie of model wilt hosten, maar ontwikkel het nog steeds in Studio Lab.

Als je productieklare pipelines bouwt of volledige cloudintegratie nodig hebt, overweeg dan over te stappen op Amazon SageMaker Studio of een beheerde omgeving met cloud-IAM-toegang.

Conclusie

Amazon SageMaker Studio Lab is geweldig als je toegankelijke, flexibele en gratis ML-ontwikkeling nodig hebt. Het haalt veelvoorkomende drempels weg, zoals cloudupzet of billing. Zo kun jij je focussen op leren, experimenteren en prototypen. 

Voor studenten, zelflerenden en docenten is Studio Lab een uitstekende omgeving om te:

• Oefenen met Python en ML-workflows
• Kleine deep learning-modellen draaien
• Samenwerken via GitHub
• Echte datasets verkennen in een JupyterLab-interface

Zijn er beperkingen? Zeker! Je werkt met sessietime-outs, geen directe AWS-integraties en een opslaglimiet van 15 GB. Maar voor lichtgewicht experimenten en hands-on leren zijn die trade-offs redelijk en ook acceptabel voor een gratis tool.

Begin je net aan je ML-reis of zoek je een eenvoudige, reproduceerbare manier om ideeën te testen, dan is Studio Lab meer dan genoeg om te starten.

Wil je je ML-skills naar een hoger niveau tillen? Ontdek AWS Cloud Technology and Services om te beginnen met het creëren van productieklare omgevingen.