Næste generation af Amazon SageMaker-eksperimenter – Organiser, spor og sammenlign dine maskinlæringstræninger i stor skala

I dag er vi glade for at kunne annoncere opdateringer til vores Amazon SageMaker-eksperimenter evne til Amazon SageMaker der lader dig organisere, spore, sammenligne og evaluere maskinlæringseksperimenter (ML) og modelversioner fra ethvert integreret udviklingsmiljø (IDE) ved hjælp af SageMaker Python SDK eller boto3, inklusive lokale Jupyter Notebooks.

Machine learning (ML) er en iterativ proces. Når man løser en ny use case, itererer dataforskere og ML-ingeniører gennem forskellige parametre for at finde de bedste modelkonfigurationer (alias hyperparametre), der kan bruges i produktionen til at løse den identificerede forretningsudfordring. Over tid, efter at have eksperimenteret med flere modeller og hyperparametre, bliver det svært for ML-teams effektivt at styre modelkørsler for at finde den optimale uden et værktøj til at holde styr på de forskellige eksperimenter. Eksperimentsporingssystemer strømliner processerne for at sammenligne forskellige iterationer og hjælper med at forenkle samarbejde og kommunikation i et team og derved øge produktiviteten og spare tid. Dette opnås ved at organisere og styre ML-eksperimenter på en ubesværet måde for at drage konklusioner fra dem, for eksempel at finde træningsforløbet med den bedste nøjagtighed.

For at løse denne udfordring leverer SageMaker SageMaker Experiments, en fuldt integreret SageMaker-funktion. Det giver fleksibiliteten til at logge dine modelmetrikker, parametre, filer, artefakter, plotdiagrammer fra de forskellige metrikker, fange forskellige metadata, søge gennem dem og understøtte modelreproducerbarhed. Dataforskere kan hurtigt sammenligne ydeevnen og hyperparametrene til modelevaluering gennem visuelle diagrammer og tabeller. De kan også bruge SageMaker Experiments til at downloade de oprettede diagrammer og dele modelevalueringen med deres interessenter.

Med de nye opdateringer til SageMaker Experiments er det nu en del af SageMaker SDK, hvilket forenkler dataforskernes arbejde og eliminerer behovet for at installere et ekstra bibliotek til at administrere flere modeludførelser. Vi introducerer følgende nye kernekoncepter:

• Eksperiment: En samling af kørsler, der er grupperet sammen. Et eksperiment inkluderer kørsler for flere typer, der kan startes fra hvor som helst ved hjælp af SageMaker Python SDK.
• Kør: Hvert udførelsestrin i en modeltræningsproces. En kørsel består af alle input, parametre, konfigurationer og resultater for én iteration af modeltræning. Brugerdefinerede parametre og metrics kan logges ved hjælp af log_parameter, log_parametersog log_metric funktioner. Brugerdefineret input og output kan logges ved hjælp af log_file funktion.

De koncepter, der implementeres som en del af en Run klasse gøres tilgængelige fra enhver IDE, hvor SageMaker Python SDK er installeret. Til SageMaker Træning, Bearbejdning og

Transform job, SageMaker Experiment Run overføres automatisk til jobbet, hvis jobbet påkaldes i en kørselskontekst. Du kan gendanne det kørende objekt vha load_run() fra dit job. Endelig kan dataforskere med integrationen af ​​de nye funktioner også automatisk logge en forvirringsmatrix, præcisions- og genkaldelsesgrafer og en ROC-kurve for klassificeringsbrugstilfælde ved hjælp af run.log_confusion_matrix, run.log_precision_recallog run.log_roc_curve funktioner, hhv.

I dette blogindlæg vil vi give eksempler på, hvordan du bruger de nye SageMaker Experiments-funktioner i en Jupyter-notesbog via SageMaker SDK. Vi vil demonstrere disse egenskaber ved hjælp af en PyTorch eksempel for at træne et MNIST håndskrevne cifre klassifikationseksempel. Forsøget vil blive organiseret som følger:

1. Oprettelse af eksperimentets kørsler og logningsparametre: Vi vil først oprette et nyt eksperiment, starte en ny kørsel for dette eksperiment og logge parametre til det.
2. Logning af modelpræstationsmålinger: Vi vil logge modelpræstationsmålinger og plotmetriske grafer.
3. Sammenligning af modelkørsler: Vi vil sammenligne forskellige modelkørsler i henhold til modelhyperparametrene. Vi vil diskutere, hvordan man sammenligner disse kørsler, og hvordan man bruger SageMaker Experiments til at vælge den bedste model.
4. Kørsel af eksperimenter fra SageMaker jobs: Vi vil også give et eksempel på, hvordan du automatisk deler dit eksperiment kontekst med et SageMaker-bearbejdnings-, trænings- eller batchtransformationsjob. Dette giver dig mulighed for automatisk at gendanne din løbskontekst med load_run funktion i dit job.
5. Integration af SageMaker Clarify-rapporter: Vi vil demonstrere, hvordan vi nu kan integrere SageMaker afklare bias og forklaringsrapporter til en enkelt visning med din trænede modelrapport.

Forudsætninger

Til dette blogindlæg vil vi bruge Amazon SageMaker Studio for at vise, hvordan man logger metrics fra en Studio-notesbog ved hjælp af de opdaterede SageMaker Experiments-funktioner. For at udføre kommandoerne i vores eksempel har du brug for følgende forudsætninger:

• SageMaker Studio Domain
• SageMaker Studio brugerprofil med SageMaker fuld adgang
• En SageMaker Studio notesbog med mindst en ml.t3.medium forekomst type

Hvis du ikke har et SageMaker-domæne og en brugerprofil tilgængelig, kan du oprette et ved hjælp af dette hurtig opsætningsvejledning.

Logningsparametre

Til denne øvelse vil vi bruge fakkelsyn, en PyTorch-pakke, der giver populære datasæt, modelarkitekturer og almindelige billedtransformationer til computersyn. SageMaker Studio giver et sæt af Docker-billeder til almindelige datavidenskabelige use cases, der er gjort tilgængelige i Amazon ECR. Til PyTorch har du mulighed for at vælge billeder optimeret til CPU- eller GPU-træning. Til dette eksempel vil vi vælge billedet PyTorch 1.12 Python 3.8 CPU Optimized og Python 3 kerne. Eksemplerne beskrevet nedenfor vil fokusere på SageMaker Experiments-funktionaliteterne og er ikke kodefuldendte.

Lad os downloade dataene med torchvision pakke og spore antallet af dataprøver for tog- og testdatasættene som parametre med SageMaker Experiments. For dette eksempel, lad os antage train_set , test_set som allerede downloadet torchvision datasæt.

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)

I dette eksempel bruger vi run.log_parameters at logge antallet af tog- og testdataprøver og run.log_file at uploade de rå datasæt til Amazon S3 og logge dem som input til vores eksperiment.

Træning af en model og logning af modelmetrics

Nu hvor vi har downloadet vores MNIST-datasæt, lad os træne en CNN model at genkende cifrene. Mens vi træner modellen, ønsker vi at indlæse vores eksisterende eksperimentkørsel, logge nye parametre til den og spore modellens ydeevne ved at logge modelmetrics.

Vi kan bruge load_run funktion til at indlæse vores tidligere løb og bruge den til at logge vores modeltræning

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"
    )

Så kan vi bruge run.log_parameter , run.log_parameters at logge en eller flere modelparametre til vores kørsel.

# 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
})

Og vi kan bruge run.log_metric at logge præstationsmålinger til vores eksperiment.

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

Til klassificeringsmodeller kan du også bruge run.log_confusion_matrix, run.log_precision_recallog run.log_roc_curve, for automatisk at plotte forvirringsmatricen, præcisionsgenkaldelsesgrafen og ROC-kurven for din model. Da vores model løser et klassifikationsproblem med flere klasser, lad os kun logge forvirringsmatricen for det.

# 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")

Når vi ser på vores løbsdetaljer, kan vi nu se de genererede metrics som vist på skærmbilledet nedenfor:

Siden med kørselsdetaljer giver yderligere oplysninger om metrics.

Og de nye modelparametre spores på parameteroversigtssiden.

Du kan også analysere din modelpræstation efter klasse ved hjælp af den automatisk plottede forvirringsmatrix, som også kan downloades og bruges til forskellige rapporter. Og du kan plotte ekstra grafer for at analysere din models ydeevne baseret på de loggede metrics.

Sammenligning af flere modelparametre

Som data scientist vil du gerne finde den bedst mulige model. Det inkluderer træning af en model flere gange med forskellige hyperparametre og sammenligning af modellens ydeevne med disse hyperparametre. For at gøre det giver SageMaker Experiments os mulighed for at oprette flere kørsler i det samme eksperiment. Lad os udforske dette koncept ved at træne vores model med forskellige num_hidden_channels , 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
            )

Vi er nu ved at oprette seks nye kørsler til vores eksperiment. Hver enkelt vil logge modelparametrene, metrikken og forvirringsmatrixen. Vi kan derefter sammenligne kørslerne for at vælge den bedste model til problemet. Når vi analyserer kørslerne, kan vi plotte de metriske grafer for de forskellige kørsler som et enkelt plot, og sammenligne præstationen af ​​kørslerne på tværs af de forskellige træningstrin (eller epoker).

Brug af SageMaker-eksperimenter med SageMaker-træning, bearbejdning og batchtransformationsjob

I eksemplet ovenfor brugte vi SageMaker Experiments til at logge modellens ydeevne fra en SageMaker Studio notesbog, hvor modellen blev trænet lokalt i notesbogen. Vi kan gøre det samme for at logge modelydeevne fra SageMaker-bearbejdning, træning og batchtransformationsjob. Med de nye muligheder for automatisk kontekstoverførsel behøver vi ikke specifikt at dele eksperimentkonfigurationen med SageMaker-jobbet, da det automatisk vil blive fanget.

Eksemplet nedenfor vil fokusere på SageMaker Experiments-funktionaliteterne og er ikke kodefuldendt.

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

I vores modelscriptfil kan vi få kørselskonteksten vha load_run(). I SageMaker behandlings- og træningsjob behøver vi ikke at levere eksperimentkonfigurationen for at indlæse konfigurationen. Til batch-transformationsjob skal vi levere experiment_name , run_name for at indlæse eksperimentets konfiguration.

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

Ud over de oplysninger, vi får, når vi kører SageMaker Experiments fra et notesbogsscript, vil kørslen fra et SageMaker-job automatisk udfylde jobparametrene og -output.

Den nye SageMaker Experiments SDK sikrer også bagudkompatibilitet med den tidligere version ved hjælp af koncepterne for forsøg og prøvekomponenter. Ethvert eksperiment, der udløses ved hjælp af den tidligere SageMaker Experiments-version, vil automatisk blive gjort tilgængeligt i den nye brugergrænseflade til analyse af eksperimenterne.

Integration af SageMaker Clarify og modellering af træningsrapporter

SageMaker Clarify hjælper med at forbedre vores ML-modeller ved at detektere potentiel bias og hjælpe forklare hvordan disse modeller laver forudsigelser. Clarify leverer forudbyggede containere, der kører som SageMaker-bearbejdningsjob, efter din model er blevet trænet, ved hjælp af oplysninger om dine data (datakonfiguration), model (modelkonfiguration) og de følsomme datakolonner, som vi ønsker at analysere for mulig bias (bias) konfiguration). Indtil nu har SageMaker Experiments vist vores modeltræning og Clarify-rapporter som individuelle prøvekomponenter, der var forbundet via en prøveversion.

Med de nye SageMaker-eksperimenter kan vi også integrere SageMaker Clarify-rapporter med vores modeltræning med én kilde til sandhed, der giver os mulighed for at forstå vores model yderligere. For at få en integreret rapport er alt, hvad vi skal gøre, at have det samme løbenavn for vores træning og afklare job. Følgende eksempel viser, hvordan vi kan integrere rapporterne ved hjælp af en XGBoost model at forudsige indkomsten for voksne i hele USA. Modellen bruger UCI voksendatasæt. Til denne øvelse antager vi, at modellen allerede var trænet, og at vi allerede har beregnet data-, model- og biaskonfigurationerne.

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,
    )

Med denne opsætning får vi en kombineret visning, der inkluderer modelmetrikker, fælles input og output og Clarify-rapporterne for statistisk skævhed og forklaring af modellen.

Konklusion

I dette indlæg udforskede vi den nye generation af SageMaker Experiments, en integreret del af SageMaker SDK. Vi demonstrerede, hvordan du logger dine ML-arbejdsgange fra hvor som helst med den nye Run-klasse. Vi præsenterede den nye Experiments UI, der giver dig mulighed for at spore dine eksperimenter og plotte grafer for en enkelt kørsels-metrik samt at sammenligne flere kørsler med den nye analysefunktion. Vi gav eksempler på logningseksperimenter fra en SageMaker Studio notesbog og fra et SageMaker Studio træningsjob. Til sidst viste vi, hvordan man integrerer modeltræning og SageMaker Clarify-rapporter i en samlet visning, så du kan forstå din model yderligere.

Vi opfordrer dig til at prøve de nye Experiments-funktioner og oprette forbindelse til Machine Learning & AI-fællesskab hvis du har spørgsmål eller feedback!

Om forfatterne

Maira Ladeira Tanke er Machine Learning Specialist hos AWS. Med en baggrund i Data Science har hun 9 års erfaring med at arkitekte og bygge ML-applikationer med kunder på tværs af brancher. Som teknisk leder hjælper hun kunder med at accelerere deres opnåelse af forretningsværdi gennem nye teknologier og innovative løsninger. I sin fritid nyder Maira at rejse og tilbringe tid med sin familie et varmt sted.

Mani Khanuja er en Artificial Intelligence and Machine Learning Specialist SA hos Amazon Web Services (AWS). Hun hjælper kunder med maskinlæring til at løse deres forretningsudfordringer ved hjælp af AWS. Hun bruger det meste af sin tid på at dykke dybt og undervise kunder i AI/ML-projekter relateret til computervision, naturlig sprogbehandling, prognoser, ML på kanten og meget mere. Hun brænder for ML på kanten, derfor har hun skabt sit eget laboratorium med selvkørende kit og prototypefremstillingsproduktionslinje, hvor hun bruger meget af sin fritid.

Dewen Qi er softwareudviklingsingeniør hos AWS. Hun deltager i øjeblikket i at opbygge en samling platformtjenester og værktøjer i AWS SageMaker for at hjælpe kunder med at få deres ML-projekter til at lykkes. Hun brænder også for at bringe konceptet MLOps til et bredere publikum. Uden for arbejdet nyder Dewen at øve sig på cello.

Abhishek Agarwal er Senior Product Manager for Amazon SageMaker. Han brænder for at arbejde med kunder og gøre machine learning mere tilgængelig. I sin fritid nyder Abhishek at male, cykle og lære om innovative teknologier.

Dana Benson er en softwareingeniør, der arbejder i Amazon SageMaker Experiments, Lineage og Search-teamet. Inden Dana kom til AWS, brugte han tid på at aktivere smart home-funktionalitet i Alexa og mobilbestilling hos Starbucks.