Esperimenti Amazon SageMaker di nuova generazione: organizza, monitora e confronta i tuoi corsi di machine learning su larga scala

Oggi siamo felici di annunciare gli aggiornamenti al nostro Esperimenti Amazon SageMaker capacità di Amazon Sage Maker che ti consente di organizzare, monitorare, confrontare e valutare esperimenti di machine learning (ML) e versioni del modello da qualsiasi ambiente di sviluppo integrato (IDE) utilizzando SageMaker Python SDK o boto3, inclusi i Jupyter Notebook locali.

L'apprendimento automatico (ML) è un processo iterativo. Quando risolvono un nuovo caso d'uso, i data scientist e gli ingegneri ML eseguono l'iterazione attraverso vari parametri per trovare le migliori configurazioni del modello (ovvero gli iperparametri) che possono essere utilizzate in produzione per risolvere la sfida aziendale identificata. Nel corso del tempo, dopo aver sperimentato più modelli e iperparametri, diventa difficile per i team ML gestire in modo efficiente le esecuzioni del modello per trovare quello ottimale senza uno strumento per tenere traccia dei diversi esperimenti. I sistemi di tracciamento degli esperimenti semplificano i processi per confrontare diverse iterazioni e aiutano a semplificare la collaborazione e la comunicazione in un team, aumentando così la produttività e risparmiando tempo. Ciò si ottiene organizzando e gestendo gli esperimenti ML in modo semplice per trarne conclusioni, ad esempio trovando l'addestramento eseguito con la massima precisione.

Per risolvere questa sfida, SageMaker fornisce SageMaker Experiments, una funzionalità SageMaker completamente integrata. Fornisce la flessibilità di registrare le metriche del modello, i parametri, i file, gli artefatti, tracciare i grafici dalle diverse metriche, acquisire vari metadati, ricercarli e supportare la riproducibilità del modello. I data scientist possono confrontare rapidamente le prestazioni e gli iperparametri per la valutazione del modello tramite tabelle e grafici visivi. Possono anche utilizzare SageMaker Experiments per scaricare i grafici creati e condividere la valutazione del modello con le parti interessate.

Con i nuovi aggiornamenti di SageMaker Experiments, ora fa parte di SageMaker SDK, semplificando il lavoro dei data scientist ed eliminando la necessità di installare una libreria aggiuntiva per gestire più esecuzioni di modelli. Stiamo introducendo i seguenti nuovi concetti fondamentali:

• Sperimentare: una raccolta di esecuzioni raggruppate insieme. Un esperimento include esecuzioni per più tipi che possono essere avviati da qualsiasi luogo utilizzando SageMaker Python SDK.
• Correre: ogni fase di esecuzione di un processo di addestramento del modello. Un'esecuzione è costituita da tutti gli input, i parametri, le configurazioni e i risultati per un'iterazione dell'addestramento del modello. I parametri e le metriche personalizzati possono essere registrati utilizzando il file log_parameter, log_parameterse log_metric funzioni. L'input e l'output personalizzati possono essere registrati utilizzando il file log_file funzione.

I concetti implementati come parte di a Run sono resi disponibili da qualsiasi IDE in cui è installato SageMaker Python SDK. Per SageMaker Formazione, Elaborazione e

Transform Jobs, l'esecuzione dell'esperimento SageMaker viene passata automaticamente al lavoro se il lavoro viene richiamato all'interno di un contesto di esecuzione. È possibile ripristinare l'oggetto di esecuzione utilizzando load_run() dal tuo lavoro. Infine, con l'integrazione delle nuove funzionalità, i data scientist possono anche registrare automaticamente una matrice di confusione, grafici di precisione e richiamo e una curva ROC per i casi d'uso di classificazione utilizzando il run.log_confusion_matrix, run.log_precision_recalle run.log_roc_curve funzioni, rispettivamente.

In questo post del blog, forniremo esempi di come utilizzare le nuove funzionalità di SageMaker Experiments in un notebook Jupyter tramite SageMaker SDK. Dimostreremo queste capacità utilizzando a PyTorch esempio per addestrare un esempio di classificazione delle cifre scritte a mano MNIST. L'esperimento sarà organizzato come segue:

1. Creazione di esecuzioni dell'esperimento e parametri di registrazione: creeremo prima un nuovo esperimento, avvieremo una nuova esecuzione per questo esperimento e registreremo i parametri in esso.
2. Misurazioni delle prestazioni del modello di registrazione: Registreremo le metriche delle prestazioni del modello e tracceremo i grafici delle metriche.
3. Confronto delle esecuzioni del modello:Confronteremo diverse esecuzioni del modello in base agli iperparametri del modello. Discuteremo su come confrontare queste esecuzioni e su come utilizzare SageMaker Experiments per selezionare il modello migliore.
4. Esecuzione di esperimenti dai processi SageMaker: Forniremo anche un esempio di come condividere automaticamente il contesto del tuo esperimento con un processo di elaborazione, addestramento o trasformazione batch di SageMaker. Ciò consente di ripristinare automaticamente il contesto di esecuzione con il file load_run funzione all'interno del tuo lavoro.
5. Integrazione dei report SageMaker Clarify: Dimostreremo come possiamo ora integrarci SageMaker Chiarire report di bias e spiegabilità in un'unica vista con il report del modello addestrato.

Prerequisiti

Per questo post sul blog, useremo Amazon Sage Maker Studio per mostrare come registrare le metriche da un notebook di Studio utilizzando le funzionalità aggiornate di SageMaker Experiments. Per eseguire i comandi presentati nel nostro esempio, sono necessari i seguenti prerequisiti:

• Dominio SageMaker Studio
• Profilo utente di SageMaker Studio con accesso completo a SageMaker
• Un notebook SageMaker Studio con almeno un ml.t3.medium tipo di istanza

Se non disponi di un dominio SageMaker e di un profilo utente, puoi crearne uno utilizzando questo guida rapida all'installazione.

Parametri di registrazione

Per questo esercizio, useremo fiaccola, un pacchetto PyTorch che fornisce set di dati, architetture di modelli e trasformazioni di immagini comuni per la visione artificiale. SageMaker Studio fornisce una serie di Immagini docker per casi d'uso comuni di data science resi disponibili in Amazon ECR. Per PyTorch, hai la possibilità di selezionare immagini ottimizzate per l'addestramento di CPU o GPU. Per questo esempio, selezioneremo l'immagine PyTorch 1.12 Python 3.8 CPU Optimized e la Python 3 nocciolo. Gli esempi descritti di seguito si concentreranno sulle funzionalità di SageMaker Experiments e non sono completi di codice.

Scarichiamo i dati con il torchvision Impacchettare e tenere traccia del numero di campioni di dati per il treno e testare i set di dati come parametri con SageMaker Experiments. Per questo esempio, supponiamo train_set ed test_set come già scaricato torchvision set di dati.

from sagemaker.session import Session
from sagemaker.experiments.run import Run
import os

# create an experiment and start a new run
experiment_name = "local-experiment-example"
run_name = "experiment-run"

with Run(experiment_name=experiment_name, sagemaker_session=Session(), run_name=run_name) as run:
    run.log_parameters({
        "num_train_samples": len(train_set.data),
        "num_test_samples": len(test_set.data)
    })
    for f in os.listdir(train_set.raw_folder):
        print("Logging", train_set.raw_folder+"/"+f)
        run.log_file(train_set.raw_folder+"/"+f, name=f, is_output=False)

In questo esempio, usiamo il run.log_parameters per registrare il numero di campioni di dati di addestramento e test e run.log_file per caricare i set di dati non elaborati su Amazon S3 e registrarli come input per il nostro esperimento.

Addestramento di un modello e registrazione delle metriche del modello

Ora che abbiamo scaricato il nostro set di dati MNIST, addestriamo a modello CNN riconoscere le cifre Durante l'addestramento del modello, vogliamo caricare l'esecuzione dell'esperimento esistente, registrarvi nuovi parametri e tenere traccia delle prestazioni del modello registrando le metriche del modello.

Possiamo usare il load_run funzione per caricare la nostra esecuzione precedente e usarla per registrare il nostro addestramento del modello

with load_run(experiment_name=experiment_name, run_name=run_name, sagemaker_session=Session()) as run:
    train_model(
        run=run,
        train_set=train_set,
        test_set=test_set,
        epochs=10,
        hidden_channels=5,
        optimizer="adam"
    )

Possiamo quindi usare run.log_parameter ed run.log_parameters per registrare uno o più parametri del modello nella nostra corsa.

# log the parameters of your model
run.log_parameter("device", "cpu")
run.log_parameters({
    "data_dir": data_dir,
    "optimizer": optimizer,
    "epochs": epochs,
    "hidden_channels": hidden_channels
})

E possiamo usare run.log_metric per registrare le metriche delle prestazioni nel nostro esperimento.

run.log_metric(name=metric_type+":loss", value=loss, step=epoch)
run.log_metric(name=metric_type+":accuracy", value=accuracy, step=epoch)

Per i modelli di classificazione, puoi anche utilizzare run.log_confusion_matrix, run.log_precision_recalle run.log_roc_curve, per tracciare automaticamente la matrice di confusione, il grafico di richiamo della precisione e la curva ROC del modello. Poiché il nostro modello risolve un problema di classificazione multiclasse, registriamo solo la matrice di confusione per esso.

# log confusion matrix
with torch.no_grad():
    for data, target in test_loader:
        data, target = data.to(device), target.to(device)
        output = model(data)
        pred = output.max(1, keepdim=True)[1] 
        run.log_confusion_matrix(target, pred, "Confusion-Matrix-Test-Data")

Quando osserviamo i dettagli della nostra corsa, ora possiamo vedere le metriche generate come mostrato nello screenshot qui sotto:

La pagina dei dettagli della corsa fornisce ulteriori informazioni sulle metriche.

E i nuovi parametri del modello vengono tracciati nella pagina di panoramica dei parametri.

Puoi anche analizzare le prestazioni del tuo modello per classe utilizzando la matrice di confusione tracciata automaticamente, che può anche essere scaricata e utilizzata per diversi report. E puoi tracciare grafici extra per analizzare le prestazioni del tuo modello in base alle metriche registrate.

Confronto di più parametri del modello

Come data scientist, vuoi trovare il miglior modello possibile. Ciò include l'addestramento di un modello più volte con diversi iperparametri e il confronto delle prestazioni del modello con tali iperparametri. Per fare ciò, SageMaker Experiments ci consente di creare più esecuzioni nello stesso esperimento. Esploriamo questo concetto addestrando il nostro modello con diversi num_hidden_channels ed optimizers.

# define the list of parameters to train the model with
num_hidden_channel_param = [5, 10, 20]
optimizer_param = ["adam", "sgd"]
run_id = 0
# train the model using SageMaker Experiments to track the model parameters, 
# metrics and performance
sm_session = Session()
for i, num_hidden_channel in enumerate(num_hidden_channel_param):
    for k, optimizer in enumerate(optimizer_param):
        run_id += 1
        run_name = "experiment-run-"+str(run_id)
        print(run_name)
        print(f"Training model with: {num_hidden_channel} hidden channels and {optimizer} as optimizer")
        # Defining an experiment run for each model training run
        with Run(experiment_name=experiment_name, run_name=run_name, sagemaker_session=sm_session) as run:
            train_model(
                run=run, 
                train_set=train_set,
                test_set=test_set,
                epochs=10, 
                hidden_channels=num_hidden_channel,
                optimizer=optimizer
            )

Ora stiamo creando sei nuove esecuzioni per il nostro esperimento. Ognuno registrerà i parametri del modello, le metriche e la matrice di confusione. Possiamo quindi confrontare le esecuzioni per selezionare il modello con le migliori prestazioni per il problema. Quando si analizzano le corse, è possibile tracciare i grafici delle metriche per le diverse corse come un singolo grafico, confrontando le prestazioni delle corse attraverso le diverse fasi di allenamento (o epoche).

Utilizzo di SageMaker Experiments con i processi di addestramento, elaborazione e trasformazione in batch di SageMaker

Nell'esempio precedente, abbiamo utilizzato SageMaker Experiments per registrare le prestazioni del modello da un notebook SageMaker Studio in cui il modello è stato addestrato localmente nel notebook. Possiamo fare lo stesso per registrare le prestazioni del modello dai processi di elaborazione, addestramento e trasformazione batch di SageMaker. Con le nuove funzionalità di passaggio automatico del contesto, non è necessario condividere in modo specifico la configurazione dell'esperimento con il processo SageMaker, poiché verrà acquisita automaticamente.

L'esempio seguente si concentrerà sulle funzionalità di SageMaker Experiments e non è completo di codice.

from sagemaker.pytorch import PyTorch
from sagemaker.experiments.run import Run
from sagemaker.session import Session
from sagemaker import get_execution_role
role = get_execution_role()

# set new experiment configuration
exp_name = "training-job-experiment-example"
run_name = "experiment-run-example"

# Start training job with experiment setting
with Run(experiment_name=exp_name, run_name=run_name, sagemaker_session=Session()) as run:
    est = PyTorch(
        entry_point="",
        dependencies=[""],
        role=role,
        model_dir=False,
        framework_version="1.12",
        py_version="py38",
        instance_type='ml.c5.xlarge',
        instance_count=1,
            hyperparameters={
            "epochs": 10,
            "hidden_channels":5,
            "optimizer": "adam",
        },
        keep_alive_period_in_seconds=3600
    )
    
    est.fit()

Nel nostro file di script del modello, possiamo ottenere il contesto di esecuzione utilizzando load_run(). Nei processi di elaborazione e formazione di SageMaker, non è necessario fornire la configurazione dell'esperimento per caricare la configurazione. Per i lavori di trasformazione batch, dobbiamo fornire experiment_name ed run_name per caricare la configurazione dell'esperimento.

with load_run() as run:
    run.log_parameters({...})
    train_model(run, ...)

Oltre alle informazioni che otteniamo durante l'esecuzione di SageMaker Experiments da uno script del notebook, l'esecuzione da un processo SageMaker popolerà automaticamente i parametri e gli output del processo.

Il nuovo SageMaker Experiments SDK garantisce inoltre la retrocompatibilità con la versione precedente utilizzando i concetti di prove e componenti di prova. Qualsiasi esperimento attivato utilizzando la versione precedente di SageMaker Experiments verrà automaticamente reso disponibile nella nuova interfaccia utente per l'analisi degli esperimenti.

Integrazione di SageMaker Clarify e modelli di rapporti di addestramento

SageMaker Clarify aiuta a migliorare i nostri modelli ML rilevando potenziale pregiudizio e aiutare spiegare come questi modelli fanno previsioni. Clarify fornisce contenitori predefiniti che vengono eseguiti come processi di elaborazione SageMaker dopo che il tuo modello è stato addestrato, utilizzando le informazioni sui tuoi dati (configurazione dei dati), sul modello (configurazione del modello) e sulle colonne di dati sensibili che vogliamo analizzare per possibili distorsioni (distorsioni configurazione). Fino ad ora, SageMaker Experiments mostrava il nostro addestramento del modello e i report Chiarire come singoli componenti di prova collegati tramite una prova.

Con i nuovi SageMaker Experiments, possiamo anche integrare i report SageMaker Clarify con il nostro addestramento del modello avendo una fonte di verità che ci consente di comprendere ulteriormente il nostro modello. Per un report integrato, tutto ciò che dobbiamo fare è avere lo stesso nome di esecuzione per i nostri lavori di formazione e chiarimento. L'esempio seguente mostra come possiamo integrare i report utilizzando un file Modello XGBoost per prevedere il reddito degli adulti negli Stati Uniti. Il modello utilizza il Set di dati per adulti UCI. Per questo esercizio, supponiamo che il modello sia già stato addestrato e che abbiamo già calcolato i dati, il modello e le configurazioni di bias.

with Run(
    experiment_name='clarify-experiment',
    run_name="joint-run",
    sagemaker_session=sagemaker_session,
) as run:
    xgb.fit({"train": train_input}, logs=False)
    clarify_processor.run_bias(
        data_config=bias_data_config,
        bias_config=bias_config,
        model_config=model_config,
        model_predicted_label_config=predictions_config,
        pre_training_methods="all",
        post_training_methods="all",
    )
    clarify_processor.run_explainability(
        data_config=explainability_data_config,
        model_config=model_config,
        explainability_config=shap_config,
    )

Con questa configurazione, otteniamo una vista combinata che include le metriche del modello, gli input e gli output congiunti e i report Clarify per la distorsione statistica e la spiegabilità del modello.

Conclusione

In questo post, abbiamo esplorato la nuova generazione di SageMaker Experiments, una parte integrata di SageMaker SDK. Abbiamo dimostrato come registrare i tuoi flussi di lavoro ML da qualsiasi luogo con la nuova classe Run. Abbiamo presentato la nuova interfaccia utente Esperimenti che ti consente di tenere traccia dei tuoi esperimenti e tracciare grafici per una singola metrica di esecuzione, nonché di confrontare più esecuzioni con la nuova funzionalità di analisi. Abbiamo fornito esempi di esperimenti di registrazione da un notebook SageMaker Studio e da un lavoro di formazione SageMaker Studio. Infine, abbiamo mostrato come integrare l'addestramento del modello e i report SageMaker Clarify in una vista unificata, consentendoti di comprendere meglio il tuo modello.

Ti invitiamo a provare le nuove funzionalità di Esperimenti e a connetterti con il Apprendimento automatico e comunità di intelligenza artificiale se avete domande o feedback!

Informazioni sugli autori

Maira Ladeira Tanke è uno specialista di Machine Learning presso AWS. Con un background in Data Science, ha 9 anni di esperienza nell'architettura e nella creazione di applicazioni ML con clienti di tutti i settori. In qualità di responsabile tecnico, aiuta i clienti ad accelerare il raggiungimento del valore aziendale attraverso tecnologie emergenti e soluzioni innovative. Nel tempo libero, Maira ama viaggiare e trascorrere del tempo con la sua famiglia in un luogo caldo.

Mani Khanuja è una SA specializzata in Intelligenza Artificiale e Machine Learning presso Amazon Web Services (AWS). Aiuta i clienti che utilizzano l'apprendimento automatico per risolvere le loro sfide aziendali utilizzando AWS. Trascorre la maggior parte del suo tempo immergendosi in profondità e insegnando ai clienti progetti AI/ML relativi a visione artificiale, elaborazione del linguaggio naturale, previsione, ML all'edge e altro ancora. È appassionata di ML all'edge, quindi ha creato il suo laboratorio con kit di guida autonoma e linea di produzione di prototipi, dove trascorre molto del suo tempo libero.

Dewen Qi è un ingegnere di sviluppo software presso AWS. Attualmente partecipa alla creazione di una raccolta di servizi e strumenti di piattaforma in AWS SageMaker per aiutare i clienti a realizzare con successo i loro progetti ML. È anche appassionata di portare il concetto di MLOps a un pubblico più ampio. Al di fuori del lavoro, a Dewen piace esercitarsi con il violoncello.

Abhishek Agarwal è Senior Product Manager per Amazon SageMaker. È appassionato di lavorare con i clienti e rendere il machine learning più accessibile. Nel suo tempo libero, Abhishek ama dipingere, andare in bicicletta e conoscere tecnologie innovative.

Dan Benson è un ingegnere del software che lavora nel team di Amazon SageMaker Experiments, Lineage e Search. Prima di entrare in AWS, Dana ha dedicato del tempo all'abilitazione della funzionalità smart home in Alexa e agli ordini mobili presso Starbucks.