Neste generasjon Amazon SageMaker-eksperimenter – Organiser, spor og sammenlign maskinlæringstreningene dine i stor skala

I dag er vi glade for å annonsere oppdateringer til vår Amazon SageMaker-eksperimenter evne til Amazon SageMaker som lar deg organisere, spore, sammenligne og evaluere maskinlæringseksperimenter (ML) og modellversjoner fra et hvilket som helst integrert utviklingsmiljø (IDE) ved å bruke SageMaker Python SDK eller boto3, inkludert lokale Jupyter Notebooks.

Maskinlæring (ML) er en iterativ prosess. Når de løser en ny brukssak, itererer dataforskere og ML-ingeniører gjennom ulike parametere for å finne de beste modellkonfigurasjonene (også kjent som hyperparametre) som kan brukes i produksjonen for å løse den identifiserte forretningsutfordringen. Over tid, etter å ha eksperimentert med flere modeller og hyperparametre, blir det vanskelig for ML-team å effektivt administrere modellkjøringer for å finne den optimale uten et verktøy for å holde styr på de forskjellige eksperimentene. Eksperimentsporingssystemer effektiviserer prosessene for å sammenligne ulike iterasjoner og hjelper til med å forenkle samarbeid og kommunikasjon i et team, og dermed øke produktiviteten og spare tid. Dette oppnås ved å organisere og administrere ML-eksperimenter på en enkel måte for å trekke konklusjoner fra dem, for eksempel finne treningsløpet med best nøyaktighet.

For å løse denne utfordringen tilbyr SageMaker SageMaker Experiments, en fullt integrert SageMaker-funksjon. Det gir fleksibiliteten til å logge modellberegninger, parametere, filer, artefakter, plottdiagrammer fra de forskjellige metrikkene, fange ulike metadata, søke gjennom dem og støtte modellreproduserbarhet. Dataforskere kan raskt sammenligne ytelsen og hyperparametrene for modellevaluering gjennom visuelle diagrammer og tabeller. De kan også bruke SageMaker-eksperimenter til å laste ned de opprettede diagrammene og dele modellevalueringen med sine interessenter.

Med de nye oppdateringene til SageMaker Experiments er den nå en del av SageMaker SDK, som forenkler dataforskerarbeidet og eliminerer behovet for å installere et ekstra bibliotek for å administrere flere modellutførelser. Vi introduserer følgende nye kjernekonsepter:

• Eksperiment: En samling av løp som er gruppert sammen. Et eksperiment inkluderer kjøringer for flere typer som kan startes fra hvor som helst ved å bruke SageMaker Python SDK.
• Kjør: Hvert utførelsestrinn i en modelltreningsprosess. En kjøring består av alle inndata, parametere, konfigurasjoner og resultater for én iterasjon av modelltrening. Egendefinerte parametere og beregninger kan logges ved hjelp av log_parameter, log_parametersog log_metric funksjoner. Egendefinerte input og output kan logges ved å bruke log_file funksjon.

Konseptene som implementeres som en del av en Run klasse gjøres tilgjengelig fra enhver IDE der SageMaker Python SDK er installert. For SageMaker Training, Processing and

Transformer jobber, SageMaker-eksperimentkjøringen sendes automatisk til jobben hvis jobben påkalles i en kjøringskontekst. Du kan gjenopprette kjøreobjektet ved å bruke load_run() fra jobben din. Til slutt, med integreringen av de nye funksjonalitetene, kan dataforskere også automatisk logge en forvirringsmatrise, presisjons- og gjenkallingsgrafer og en ROC-kurve for brukstilfeller for klassifisering ved å bruke run.log_confusion_matrix, run.log_precision_recallog run.log_roc_curve funksjoner, henholdsvis.

I dette blogginnlegget vil vi gi eksempler på hvordan du bruker de nye SageMaker Experiments-funksjonene i en Jupyter-notatbok via SageMaker SDK. Vi vil demonstrere disse egenskapene ved å bruke en PyTorch eksempel for å trene et MNIST-håndskrevne sifreklassifiseringseksempel. Eksperimentet vil bli organisert som følger:

1. Opprette eksperimentets kjøringer og loggingsparametere: Vi vil først opprette et nytt eksperiment, starte en ny kjøring for dette eksperimentet og logge parametere til det.
2. Logging av modellytelsesmålinger: Vi vil logge modellytelsesmålinger og plottmetriske grafer.
3. Sammenligning av modellkjøringer: Vi vil sammenligne forskjellige modellkjøringer i henhold til modellhyperparametrene. Vi vil diskutere hvordan man sammenligner disse kjøringene og hvordan man bruker SageMaker Experiments for å velge den beste modellen.
4. Kjøre eksperimenter fra SageMaker-jobber: Vi vil også gi et eksempel på hvordan du automatisk deler eksperimentets kontekst med en SageMaker-behandlings-, opplærings- eller batchtransformasjonsjobb. Dette lar deg automatisk gjenopprette løpskonteksten med load_run funksjon i jobben din.
5. Integrering av SageMaker Clarify-rapporter: Vi skal vise hvordan vi nå kan integrere SageMaker Avklare bias og forklaringsrapporter til én enkelt visning med den opplærte modellrapporten.

Forutsetninger

For dette blogginnlegget vil vi bruke Amazon SageMaker Studio for å vise frem hvordan du logger beregninger fra en Studio-notatbok ved å bruke de oppdaterte SageMaker Experiments-funksjonene. For å utføre kommandoene presentert i vårt eksempel, trenger du følgende forutsetninger:

• SageMaker Studio Domain
• SageMaker Studio brukerprofil med SageMaker full tilgang
• En SageMaker Studio-notisbok med minst en ml.t3.medium instanstype

Hvis du ikke har et SageMaker-domene og brukerprofil tilgjengelig, kan du opprette en ved å bruke denne hurtiginstallasjonsveiledning.

Loggingsparametere

For denne øvelsen vil vi bruke fakkelsyn, en PyTorch-pakke som gir populære datasett, modellarkitekturer og vanlige bildetransformasjoner for datasyn. SageMaker Studio gir et sett med Docker-bilder for vanlige datavitenskapelige brukstilfeller som er gjort tilgjengelig i Amazon ECR. For PyTorch har du muligheten til å velge bilder optimalisert for CPU- eller GPU-trening. For dette eksemplet velger vi bildet PyTorch 1.12 Python 3.8 CPU Optimized og Python 3 kjerne. Eksemplene beskrevet nedenfor vil fokusere på SageMaker Experiments-funksjonene og er ikke kodefullstendige.

La oss laste ned dataene med torchvision pakke og spore antall dataprøver for tog- og testdatasettene som parametere med SageMaker Experiments. For dette eksemplet, la oss anta train_set og test_set som allerede lastet ned torchvision datasett.

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 eksemplet bruker vi run.log_parameters å logge antall tog- og testdataprøver og run.log_file for å laste opp de rå datasettene til Amazon S3 og logge dem som input til eksperimentet vårt.

Trening av en modell og logging av modellberegninger

Nå som vi har lastet ned MNIST-datasettet vårt, la oss trene en CNN-modell for å gjenkjenne sifrene. Mens vi trener modellen, ønsker vi å laste inn vår eksisterende eksperimentkjøring, logge nye parametere til den og spore modellytelsen ved å logge modellberegninger.

Vi kan bruke load_run funksjon for å laste vår forrige løp og bruke den til å logge modelltreningen vår

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

Da kan vi bruke run.log_parameter og run.log_parameters for å logge én eller flere modellparametere til kjøringen vår.

# 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 bruke run.log_metric for å logge ytelsesberegninger til eksperimentet vårt.

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

For klassifiseringsmodeller kan du også bruke run.log_confusion_matrix, run.log_precision_recallog run.log_roc_curve, for automatisk å plotte forvirringsmatrisen, presisjonsgjenkallingsgrafen og ROC-kurven til modellen din. Siden modellen vår løser et klassifiseringsproblem med flere klasser, la oss bare logge forvirringsmatrisen for den.

# 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å løpsdetaljene våre, kan vi nå se de genererte beregningene som vist på skjermbildet nedenfor:

Siden med kjøringsdetaljer gir mer informasjon om beregningene.

Og de nye modellparametrene spores på parameteroversiktssiden.

Du kan også analysere modellens ytelse etter klasse ved å bruke den automatisk plottede forvirringsmatrisen, som også kan lastes ned og brukes til forskjellige rapporter. Og du kan plotte ekstra grafer for å analysere ytelsen til modellen din basert på de loggede beregningene.

Sammenligning av flere modellparametere

Som dataforsker ønsker du å finne den best mulige modellen. Det inkluderer å trene en modell flere ganger med forskjellige hyperparametre og sammenligne ytelsen til modellen med disse hyperparametrene. For å gjøre det lar SageMaker Experiments oss lage flere kjøringer i samme eksperiment. La oss utforske dette konseptet ved å trene modellen vår med forskjellige num_hidden_channels og 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 lager nå seks nye kjøringer for eksperimentet vårt. Hver og en vil logge modellparametrene, beregningene og forvirringsmatrisen. Vi kan deretter sammenligne kjøringene for å velge den modellen som gir best ytelse for problemet. Når vi analyserer løpene, kan vi plotte de metriske grafene for de forskjellige løpene som et enkelt plott, og sammenligne ytelsen til løpene på tvers av de forskjellige treningstrinn (eller epoker).

Bruk av SageMaker-eksperimenter med SageMaker-trening, prosessering og batch-transformeringsjobber

I eksemplet ovenfor brukte vi SageMaker-eksperimenter til å logge modellytelse fra en SageMaker Studio-notisbok der modellen ble trent lokalt i notatboken. Vi kan gjøre det samme for å logge modellytelse fra SageMaker-prosessering, opplæring og batchtransformasjonsjobber. Med de nye funksjonene for automatisk overføring av kontekst trenger vi ikke spesifikt å dele eksperimentkonfigurasjonen med SageMaker-jobben, siden den vil bli fanget opp automatisk.

Eksemplet nedenfor vil fokusere på SageMaker Experiments-funksjonene og er ikke kodefullstendig.

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 modellskriptfilen vår kan vi få kjørekonteksten ved å bruke load_run(). I SageMaker-behandlings- og opplæringsjobber trenger vi ikke å oppgi eksperimentkonfigurasjonen for å laste inn konfigurasjonen. For batch-transformeringsjobber må vi tilby experiment_name og run_name for å laste eksperimentets konfigurasjon.

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

I tillegg til informasjonen vi får når vi kjører SageMaker-eksperimenter fra et notatbokskript, vil kjøringen fra en SageMaker-jobb automatisk fylle ut jobbparametrene og utdataene.

Den nye SageMaker Experiments SDK sikrer også bakoverkompatibilitet med den forrige versjonen ved å bruke konseptene prøveversjoner og prøvekomponenter. Ethvert eksperiment som utløses med den forrige SageMaker Experiments-versjonen vil automatisk bli gjort tilgjengelig i det nye brukergrensesnittet for å analysere eksperimentene.

Integrering av SageMaker Clarify og modeller treningsrapporter

SageMaker Clarify hjelper til med å forbedre ML-modellene våre ved å oppdage potensiell forspenning og hjelper forklare hvordan disse modellene lager spådommer. Clarify leverer forhåndsbygde containere som kjører som SageMaker-behandlingsjobber etter at modellen din har blitt opplært, ved hjelp av informasjon om dataene dine (datakonfigurasjon), modell (modellkonfigurasjon) og de sensitive datakolonnene som vi ønsker å analysere for mulig skjevhet (bias) konfigurasjon). Frem til nå har SageMaker Experiments vist vår modelltrening og klargjøringsrapporter som individuelle prøvekomponenter som var koblet sammen via en prøveversjon.

Med de nye SageMaker-eksperimentene kan vi også integrere SageMaker Clarify-rapporter med modellopplæringen vår med én kilde til sannhet som lar oss forstå modellen vår ytterligere. For en integrert rapport trenger vi bare å ha samme løpenavn for opplærings- og klargjøringsjobbene våre. Følgende eksempel viser hvordan vi kan integrere rapportene ved å bruke en XGBoost -modell å forutsi inntekten til voksne over hele USA. Modellen bruker UCI voksen datasett. For denne øvelsen antar vi at modellen allerede var trent og at vi allerede har beregnet data-, modell- og skjevhetskonfigurasjonene.

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 dette oppsettet får vi en kombinert visning som inkluderer modellberegningene, felles input og output, og Clarify-rapportene for statistisk skjevhet og forklaring av modellen.

konklusjonen

I dette innlegget utforsket vi den nye generasjonen SageMaker Experiments, en integrert del av SageMaker SDK. Vi demonstrerte hvordan du logger ML-arbeidsflytene dine fra hvor som helst med den nye Run-klassen. Vi presenterte det nye brukergrensesnittet for eksperimenter som lar deg spore eksperimentene dine og plotte grafer for en enkelt kjøringsmetrik, samt å sammenligne flere kjøringer med den nye analysefunksjonen. Vi ga eksempler på loggeksperimenter fra en SageMaker Studio-notisbok og fra en SageMaker Studio-opplæringsjobb. Til slutt viste vi hvordan du integrerer modellopplæring og SageMaker Clarify-rapporter i en enhetlig visning, slik at du kan forstå modellen din ytterligere.

Vi oppfordrer deg til å prøve ut de nye eksperimenter-funksjonene og koble deg til Maskinlæring og AI-fellesskap hvis du har spørsmål eller tilbakemeldinger!

Om forfatterne

Maira Ladeira Tanke er maskinlæringsspesialist hos AWS. Med bakgrunn fra Data Science har hun 9 års erfaring med å arkitekte og bygge ML-applikasjoner med kunder på tvers av bransjer. Som teknisk leder hjelper hun kunder med å akselerere oppnåelsen av forretningsverdi gjennom nye teknologier og innovative løsninger. På fritiden liker Maira å reise og tilbringe tid med familien et varmt sted.

Mani Khanuja er en Artificial Intelligence and Machine Learning Specialist SA hos Amazon Web Services (AWS). Hun hjelper kunder som bruker maskinlæring for å løse forretningsutfordringene deres ved hjelp av AWS. Hun bruker mesteparten av tiden sin på å dykke dypt og lære kunder om AI/ML-prosjekter relatert til datasyn, naturlig språkbehandling, prognoser, ML på kanten og mer. Hun er lidenskapelig opptatt av ML på kanten, derfor har hun laget sitt eget laboratorium med selvkjørende sett og produksjonslinje for prototyper, hvor hun tilbringer mye av fritiden sin.

Dewen Qi er programvareutviklingsingeniør ved AWS. Hun deltar for tiden i å bygge en samling av plattformtjenester og verktøy i AWS SageMaker for å hjelpe kundene med å gjøre deres ML-prosjekter vellykkede. Hun brenner også for å bringe konseptet MLOps til et bredere publikum. Utenom jobben liker Dewen å øve på cello.

Abhishek Agarwal er senior produktsjef for Amazon SageMaker. Han brenner for å jobbe med kunder og gjøre maskinlæring mer tilgjengelig. På fritiden liker Abhishek å male, sykle og lære om innovative teknologier.

Dana Benson er en programvareingeniør som jobber i Amazon SageMaker Experiments, Lineage og Search-teamet. Før hun begynte i AWS, brukte Dana tid på å aktivere smarthusfunksjonalitet i Alexa og mobilbestilling hos Starbucks.