AWS SageMaker Studio Lab: una guida pratica e operativa

Come registrarsi e avviare progetti

Iniziare con SageMaker Studio Lab è piuttosto semplice, soprattutto rispetto alla configurazione di un intero ambiente AWS.

Nelle sezioni seguenti ti mostrerò cosa fare per metterti in moto.

Creazione dell'account e onboarding

Per usare Studio Lab, devi prima richiedere l'accesso. Ecco il processo:

1. Vai alla pagina SageMaker Studio Lab.
2. Clicca su “Request free account” e compila alcuni dettagli di base (email, caso d'uso, ecc.).
3. Attendi l'invito. L'approvazione richiede in genere da poche ore a pochi giorni.
4. Una volta approvato, riceverai un'email con il link alla pagina di registrazione. Crea il tuo account con l'indirizzo email approvato e imposta password e username. Questo account è diverso dal tuo account AWS e non è richiesta alcuna carta di credito.

Nel mio caso, ho ricevuto l'approvazione entro 24 ore.

Configurazione dell'ambiente

Una volta dentro, puoi selezionare il tipo di calcolo e poi cliccare su “Start runtime”.

Pagina di atterraggio di SageMaker Studio Lab. Immagine dell'autore.

Al primo avvio, ti verrà anche chiesto di inserire il numero di cellulare, a cui verrà inviato un codice di verifica a sei cifre. 

Quando l'ambiente è attivo, atterrerai in un ambiente JupyterLab e dovresti vedere il notebook Getting Started.ipynb.

Studio Lab include un'immagine base di Python e solo poche librerie preinstallate per lasciare spazio a quelle che vuoi installare tu. 

Oltre all'ambiente conda predefinito, Studio Lab supporta anche la SageMaker Distribution, che è un ambiente più potente e curato progettato da AWS per rispecchiare la configurazione di Amazon SageMaker Studio. Contiene pacchetti come PyTorch, TensorFlow, NumPy, scikit-learn e Pandas.

Puoi sempre installare i pacchetti nell'ambiente Conda esistente eseguendo %conda install <package> o %pip install <package> direttamente da una cella del notebook. 

Puoi anche usare requirements.txt o environment.yml per replicare ambienti completi. Questo rende facile seguire i tutorial.

Ma tieni presente che hai solo 15GB di spazio, quindi è meglio evitare di installare pacchetti pesanti quando non servono. 

Anche i pacchetti installati persistono tra sessioni diverse.

Inizializzazione del progetto e integrazione con GitHub

Studio Lab si integra bene con GitHub, il che significa che puoi:

• Clonare repository pubblici o privati usando HTTPS o SSH
• Fare push e pull del codice direttamente dall'estensione Git di JupyterLab
• Condividere i notebook linkando al repo (ottimo per collaborazioni o compiti)

Se insegni o stai imparando, questo rende estremamente facile distribuire codice iniziale o inviare il lavoro per la revisione, soprattutto in aule, bootcamp o gruppi di studio autonomi.

Vuoi andare oltre GitHub e lavorare con workflow ML reali? Prova il corso End-to-End Machine Learning per vedere come strutturare progetti completi.

Esempi pratici per il machine learning

SageMaker Studio Lab è un luogo perfetto per testare idee, seguire tutorial o costruire piccoli progetti da zero. Che tu stia imparando la regressione o giocando con dati di immagini, la piattaforma supporta senza problemi la maggior parte dei compiti da principiante a intermedio. 

Ora ti guiderò attraverso esempi pratici che puoi provare subito.

Puoi trovare i notebook di esempio nel mio repository GitHub. Ti basta clonare quel repo nella tua sessione di Studio Lab.

In alternativa, puoi cliccare direttamente sui badge Open Studio Lab nel mio file README.md, così si aprirà il notebook direttamente in Studio Lab.

Screenshot del file README con badge Open in Studio Lab. Immagine dell'autore.

Addestrare un semplice modello di regressione

Questo è l'Hello World del machine learning: addestrare un semplice modello di regressione.

Cosa farai in questo piccolo esempio:

• Caricare il dataset Iris usando seaborn.
• Esplorare visivamente la relazione tra le variabili.
• Addestrare un modello di regressione lineare usando scikit-learn.
• Tracciare la linea di regressione e valutare le prestazioni del modello.

Il codice per questo esempio è nel notebook simple-regression.ipynb.

Apri il notebook e come kernel seleziona sagemaker-distribution:Python.

Selezione del kernel per il notebook simple-regression.ipynb in Studio Lab. Immagine dell'autore.

L'obiettivo di questo compito ML è prevedere la lunghezza del petalo a partire dalla lunghezza del sepalo nel noto dataset Iris. 

Esegui semplicemente tutte le celle del notebook per seguire l'esempio.

Di seguito trovi il codice completo per questo esempio: 

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()Offerto da

Questo esempio si allena in pochi secondi sul runtime CPU di Studio Lab, e i grafici aiutano a visualizzare le prestazioni del modello. Anche se è un inizio semplice, questo schema costituisce il nucleo di molti compiti di regressione nel mondo reale.

Esempio di classificazione di immagini

MNIST è un ottimo punto di partenza per imparare la classificazione di immagini. È piccolo, pulito e funziona bene anche in ambienti con risorse limitate come Studio Lab.

In questo esempio farai:

• Caricamento del dataset MNIST usando tensorflow.keras.datasets
• Creazione di una semplice rete neurale densa
• Addestramento e valutazione del modello
• Visualizzazione di alcune predizioni per vedere come si comporta il modello

Puoi eseguire questo esempio nell'ambiente CPU oppure, se vuoi prestazioni migliori, nell'ambiente GPU (che a volte può essere più difficile da ottenere).

Il codice per questo esempio si trova nel notebook image-classifier.ipynb o qui sotto:

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()Offerto da

Apri il notebook e come kernel seleziona sagemaker-distribution:Python.

Questo esempio gira fluido sulla CPU ed è molto più veloce con la GPU attiva. Puoi ampliarlo aggiungendo strati convoluzionali, aumentando le epoche o visualizzando le cifre misclassificate.

Se vuoi andare oltre, il percorso Developing AI Applications ti guida attraverso casi d'uso reali di deep learning.

Preprocessing dei dati e visualizzazione

Passiamo ora al terzo esempio, essenziale per applicazioni ML reali: preprocessing dei dati e visualizzazione.

La maggior parte dei dataset reali è disordinata e richiede un'ampia pulizia e ispezione manuale per essere utilizzabile. Quindi saper plottare i dati e preprocessarli è fondamentale per sviluppare applicazioni pratiche di machine learning.

Per mostrare preprocessing e visualizzazione dei dati, useremo il dataset Palmer Penguins.

Palmer Penguins è uno dei migliori dataset per principianti per imparare pulizia e visualizzazione dei dati. È come il dataset Iris, ma con variabili più interessanti e un contesto reale più chiaro.

Il codice per questo esempio è disponibile nel notebook data-preprocessing-and-visualization.ipynb. 

Anche qui, seleziona il kernel sagemaker-distribution:Python per seguire l'esempio.

Qui sotto trovi il codice completo:

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()Offerto da

Questi semplici grafici rivelano già pattern interessanti, come cluster a livello di specie e differenze tra pinguini maschi e femmine.

Condivisione dei notebook e collaborazione

Quando il tuo notebook è pronto, condividerlo è semplice:

• Salva il file .ipynb direttamente in un repository GitHub
• Invita altri a visualizzarlo, commentarlo o eseguirlo dal loro ambiente Studio Lab

Puoi persino aggiungere un badge Open in Studio Lab al tuo file README.md o ai notebook nel tuo repo pubblico su GitHub. 

Ti basta aggiungere il seguente snippet al file README.md:

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

Puoi dare un'occhiata al file README.md nel mio repo per vedere come funziona in pratica.

Se lavori con compagni di team o docenti, questo approccio rende revisione tra pari, feedback e riproducibilità estremamente fluidi. Puoi anche includere requirements.txt per assicurarti che installino le stesse dipendenze.

Casi d'uso e applicazioni didattiche

SageMaker Studio Lab può essere usato non solo come sandbox per il machine learning, ma anche come strumento pratico per la didattica, l'esperimentazione rapida e il prototyping leggero. Poiché è gratuito, facile da accedere e gira nel browser, apre un'ampia gamma di casi d'uso per chi impara, per i docenti e per gli sviluppatori.

Apprendimento accademico e autodidatta

Studio Lab è già utilizzato in aule universitarie, corsi online e coding boot camp come strumento didattico. 

I vantaggi:

• Nessun setup locale richiesto: gli studenti possono iniziare a scrivere codice subito, indipendentemente dal dispositivo che usano.
• Storage persistente: salva i dati tra le sessioni per riprendere da dove avevi lasciato.
• Pacchetti preinstallati: coprono la maggior parte dei corsi ML da base a intermedio.
• JupyterLab: l'interfaccia di JupyterLab è ben nota e adatta a demo e coding interattivo.

Come docente, puoi facilmente:

• Condividere repo GitHub con codice di partenza.
• Creare compiti come notebook e ospitarli direttamente.
• Promuovere la riproducibilità insegnando una corretta gestione degli ambienti.

Come studente o autodidatta, Studio Lab ti offre uno spazio per:

• Esercitarti con dati reali.
• Seguire i tutorial.
• Inviare progetti per la revisione.

Prototyping ed esperimenti leggeri

Studio Lab non è pensato per carichi enterprise, ma funziona piuttosto bene per il prototyping. 

Puoi usarlo se vuoi:

• Testare un'idea di modellazione.
• Eseguire confronti di benchmark.
• Pulire ed esplorare nuovi dataset.
• Condividere una demo rapida con un collega.

È quindi ideale per:

• Hackathon, dove tempo e risorse di calcolo sono limitati.
• Ricerca nelle fasi iniziali, quando le idee sono ancora in fase di definizione.
• Progetti personali, quando ti serve solo mettere in piedi qualcosa senza gestire infrastrutture.

L'ho usato quando volevo testare rapidamente del codice trovato in giro, o quando preparavo una demo per uno dei miei articoli. 

Confronti e principali limitazioni

SageMaker Studio Lab viene spesso confrontato con strumenti come Google Colab, JupyterHub e persino con il completo SageMaker Studio. Tuttavia, pur sembrando simili in superficie, punti di forza, limitazioni e casi d'uso ideali differiscono in modo significativo.

Confrontiamo Studio Lab con Google Colab.

Studio Lab vs Google Colab

Hardware e prestazioni

In pratica:

• Studio Lab è migliore se vuoi un ambiente coerente con storage persistente (ottimo per corsi o progetti più lunghi).
• Google Colab è migliore se lavori di più con i servizi Google (come Google Drive) e vuoi condividere molti notebook (cosa un po' più semplice in Google).

Vuoi lavorare a lungo termine con gli strumenti AWS? Studio Lab funge da trampolino più efficace verso SageMaker Studio e workflow basati sul cloud.

Esperienza utente e stabilità dell'interfaccia

Studio Lab gira su JupyterLab, mentre Colab è basato sui Jupyter Notebook classici.

Questo significa che Studio Lab offre layout a schede, terminali, file explorer e ambienti conda personalizzati. 

Colab, a sua volta, è più leggero ma manca di isolamento degli ambienti e riproducibilità out-of-the-box. 

Se sei abituato a JupyterLab (o vuoi un'esperienza più simile a un IDE), Studio Lab risulta più strutturato ed estensibile.

Costo e accessibilità

Entrambe le piattaforme sono gratuite, ma con alcune differenze chiave:

• Studio Lab: 100% gratuito, nessuna versione premium, nessuna integrazione di fatturazione.
• Colab: il livello gratuito è limitato. Sono disponibili abbonamenti Pro/Pro+ per accedere a risorse migliori.

Studio Lab è ideale per chi impara o per i docenti che vogliono una piattaforma affidabile e prevedibile per l'insegnamento o la sperimentazione. Colab può offrire più potenza, ma spesso al costo di instabilità o della necessità di un upgrade.

Limitazioni di Studio Lab

Essendo gratuito, Studio Lab ha anche alcuni aspetti negativi.

Vediamo a cosa prestare attenzione.

Vincoli di risorse

Studio Lab presenta i seguenti vincoli di risorse:

• Limiti di sessione: 4 ore per sessione (CPU/GPU), con quote giornaliere.
• Nessun job parallelo: una sola sessione runtime alla volta.
• Accesso al runtime: ottieni un runtime solo se le risorse sono disponibili. A me a volte è capitato di dover aspettare un po' prima di poter avviare un runtime (anche CPU).
• Storage: limite rigido di 15 GB, che può non bastare per dataset grandi o checkpoint di modelli.

Per progetti piccoli e medi, resta gestibile. Tuttavia, tieni conto di queste limitazioni quando decidi come strutturare il lavoro e archiviare i dati.

Lacune di funzionalità e workaround

Studio Lab non supporta:

• Integrazione diretta con servizi AWS come S3, endpoint SageMaker o ruoli IAM.
• Networking personalizzato o port forwarding.
• Job in background o servizi di lunga durata.

Ma puoi almeno aggirare alcune di queste lacune:

• Usa Hugging Face Datasets o URL S3 pubblici per i dati.
• Usa GitHub per versioning e condivisione dei checkpoint.
• Esegui lo streaming dei dati in tempo reale invece di scaricare tutto in anticipo.
• Usa servizi AWS a pagamento se vuoi ospitare un'applicazione o un modello, ma sviluppalo comunque in Studio Lab.

Se stai costruendo pipeline di produzione o ti serve piena integrazione cloud, valuta il passaggio ad Amazon SageMaker Studio o a un ambiente gestito con accesso IAM al cloud.

Conclusione

Amazon SageMaker Studio Lab è ottimo se cerchi accessibilità, flessibilità e sviluppo ML gratuito. Rimuove barriere comuni all'ingresso, come setup cloud o fatturazione. Questo ti permette di concentrarti su apprendimento, sperimentazione e prototipazione. 

Per studenti, autodidatti e docenti, Studio Lab è un ambiente eccellente per:

• Esercitarti con Python e workflow ML
• Eseguire piccoli modelli di deep learning
• Collaborare tramite GitHub
• Esplorare dataset reali in un'interfaccia JupyterLab

Ci sono limitazioni? Certo! Lavori con time-out di sessione, nessuna integrazione AWS diretta e un limite di storage di 15 GB. Ma per sperimentazione leggera e apprendimento pratico, questi compromessi sono ragionevoli e accettabili per uno strumento gratuito.

Se stai iniziando il tuo percorso nel machine learning o cerchi un modo semplice e riproducibile per testare idee, Studio Lab è più che sufficiente per cominciare.

Vuoi portare le tue competenze ML al livello successivo? Esplora AWS Cloud Technology and Services per iniziare a creare ambienti pronti per la produzione.