Naslednja generacija eksperimentov Amazon SageMaker – organizirajte, sledite in primerjajte svoja usposabljanja strojnega učenja v velikem obsegu

Danes z veseljem objavljamo posodobitve našega Eksperimenti Amazon SageMaker zmožnost Amazon SageMaker ki vam omogoča organiziranje, sledenje, primerjavo in ocenjevanje poskusov strojnega učenja (ML) in različic modelov iz katerega koli integriranega razvojnega okolja (IDE) z uporabo SDK SageMaker Python ali boto3, vključno z lokalnimi prenosniki Jupyter.

Strojno učenje (ML) je ponavljajoč se proces. Pri reševanju novega primera uporabe podatkovni znanstveniki in inženirji ML ponavljajo različne parametre, da bi našli najboljše konfiguracije modela (tudi hiperparametre), ki jih je mogoče uporabiti v proizvodnji za reševanje ugotovljenega poslovnega izziva. Sčasoma, po eksperimentiranju z več modeli in hiperparametri, postane za ekipe ML težko učinkovito upravljati modele, da bi našli optimalnega brez orodja za spremljanje različnih poskusov. Sistemi za sledenje poskusom racionalizirajo postopke za primerjavo različnih iteracij in pomagajo poenostaviti sodelovanje in komunikacijo v skupini, s čimer povečajo produktivnost in prihranijo čas. To dosežemo z organizacijo in upravljanjem eksperimentov ML na preprost način, da iz njih potegnemo zaključke, na primer z iskanjem vadbene vožnje z najboljšo natančnostjo.

Za rešitev tega izziva SageMaker ponuja SageMaker Experiments, popolnoma integrirano zmogljivost SageMaker. Zagotavlja prilagodljivost za beleženje metrik, parametrov, datotek, artefaktov vašega modela, risanje grafikonov iz različnih metrik, zajemanje različnih metapodatkov, iskanje po njih in podporo ponovljivosti modela. Podatkovni znanstveniki lahko hitro primerjajo zmogljivost in hiperparametre za vrednotenje modela prek vizualnih grafikonov in tabel. Uporabijo lahko tudi SageMaker Experiments za prenos ustvarjenih grafikonov in delitev ocene modela s svojimi deležniki.

Z novimi posodobitvami za SageMaker Experiments je zdaj del SDK SageMaker, ki poenostavlja delo podatkovnega znanstvenika in odpravlja potrebo po namestitvi dodatne knjižnice za upravljanje izvajanja več modelov. Predstavljamo naslednje nove ključne koncepte:

• Preizkusna: zbirka tekov, ki so združeni skupaj. Poskus vključuje izvajanja za več vrst, ki jih je mogoče sprožiti od koder koli z uporabo SDK-ja SageMaker Python.
• Run: Vsak izvedbeni korak procesa modelnega usposabljanja. Zagon je sestavljen iz vseh vnosov, parametrov, konfiguracij in rezultatov za eno ponovitev usposabljanja modela. Parametre in meritve po meri je mogoče zabeležiti z uporabo log_parameter, log_parametersin log_metric funkcije. Vhod in izhod po meri je mogoče zabeležiti z uporabo log_file Funkcija.

Koncepti, ki se izvajajo kot del a Run razreda so na voljo v katerem koli IDE, kjer je nameščen SDK SageMaker Python. Za SageMaker usposabljanje, obdelavo in

Transform Jobs, se SageMaker Experiment Run samodejno posreduje opravilu, če je opravilo priklicano v kontekstu izvajanja. Zagnani objekt lahko obnovite z uporabo load_run() iz svoje službe. Nazadnje lahko z integracijo novih funkcionalnosti podatkovni znanstveniki samodejno beležijo matriko zmede, grafe natančnosti in priklica ter krivuljo ROC za primere uporabe klasifikacije z uporabo run.log_confusion_matrix, run.log_precision_recallin run.log_roc_curve funkcije oz.

V tej objavi v spletnem dnevniku bomo ponudili primere uporabe novih funkcij SageMaker Experiments v prenosnem računalniku Jupyter prek SDK-ja SageMaker. Te zmožnosti bomo prikazali z uporabo a PyTorch primer za usposabljanje primera klasifikacije ročno napisanih števk MNIST. Poskus bo organiziran na naslednji način:

1. Ustvarjanje potekov eksperimenta in beleženje parametrov: Najprej bomo ustvarili nov poskus, začeli novo izvedbo za ta poskus in vanj zabeležili parametre.
2. Beleženje meritev uspešnosti modela: Zabeležili bomo metrike uspešnosti modela in izrisali metrične grafe.
3. Primerjava modelov: Primerjali bomo različne izvedbe modela glede na hiperparametre modela. Razpravljali bomo o tem, kako primerjati te serije in kako uporabiti eksperimente SageMaker za izbiro najboljšega modela.
4. Izvajanje poskusov iz opravil SageMaker: Zagotovili bomo tudi primer, kako samodejno deliti kontekst vašega eksperimenta z opravilom obdelave, usposabljanja ali paketnega preoblikovanja SageMaker. To vam omogoča samodejno obnovitev konteksta izvajanja z load_run delujejo znotraj vaše službe.
5. Integracija poročil SageMaker Clarify: Pokazali bomo, kako se lahko zdaj integriramo SageMaker Pojasni poročila o pristranskosti in razložljivosti v en sam pogled z vašim usposobljenim modelnim poročilom.

Predpogoji

Za to objavo v blogu bomo uporabili Amazon SageMaker Studio za predstavitev, kako beležiti meritve iz prenosnega računalnika Studio z uporabo posodobljenih funkcij SageMaker Experiments. Za izvajanje ukazov, predstavljenih v našem primeru, potrebujete naslednje predpogoje:

• Domena SageMaker Studio
• Uporabniški profil SageMaker Studio s polnim dostopom do SageMaker
• Prenosnik SageMaker Studio z vsaj ml.t3.medium vrsta primerka

Če nimate na voljo domene SageMaker in uporabniškega profila, ga lahko ustvarite s tem vodnik za hitro namestitev.

Parametri beleženja

Za to vajo bomo uporabili torchvision, paket PyTorch, ki ponuja priljubljene nabore podatkov, arhitekture modelov in pogoste transformacije slik za računalniški vid. SageMaker Studio ponuja nabor Docker slike za običajne primere uporabe znanosti o podatkih, ki so na voljo v Amazon ECR. Za PyTorch imate možnost izbire slik, optimiziranih za usposabljanje CPE ali GPE. Za ta primer bomo izbrali sliko PyTorch 1.12 Python 3.8 CPU Optimized in Python 3 jedro. Spodaj opisani primeri se osredotočajo na funkcionalnosti SageMaker Experiments in niso popolna koda.

Prenesimo podatke z torchvision pakirajte in sledite številu vzorcev podatkov za nabore podatkov o vlaku in testu kot parametre s SageMaker Experiments. Za ta primer predpostavimo train_set in test_set kot že preneseno torchvision nabor podatkov

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)

V tem primeru uporabljamo run.log_parameters za beleženje števila vzorcev podatkov o vlakih in preskusih ter run.log_file da naložite neobdelane nabore podatkov v Amazon S3 in jih zabeležite kot vnose v naš poskus.

Usposabljanje modela in beleženje metrik modela

Zdaj, ko smo prenesli naš nabor podatkov MNIST, urimo a Model CNN prepoznati števke. Med usposabljanjem modela želimo naložiti naš obstoječi potek poskusa, vanj zabeležiti nove parametre in slediti učinkovitosti modela z beleženjem metrik modela.

Lahko uporabimo load_run funkcijo za nalaganje našega prejšnjega izvajanja in uporabo za beleženje našega usposabljanja modela

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

Nato lahko uporabimo run.log_parameter in run.log_parameters za beleženje enega ali več parametrov modela v naš zagon.

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

In lahko uporabimo run.log_metric za beleženje meritev uspešnosti v naš poskus.

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

Za klasifikacijske modele lahko uporabite tudi run.log_confusion_matrix, run.log_precision_recallin run.log_roc_curve, da samodejno izrišete matriko zmede, graf natančnega priklica in krivuljo ROC vašega modela. Ker naš model rešuje problem večrazredne klasifikacije, zabeležimo samo matriko zmede zanj.

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

Ko si ogledujemo podrobnosti našega izvajanja, lahko zdaj vidimo ustvarjene meritve, kot je prikazano na spodnjem posnetku zaslona:

Stran s podrobnostmi o izvajanju vsebuje dodatne informacije o meritvah.

In parametri novega modela se spremljajo na strani s pregledom parametrov.

Učinkovitost svojega modela lahko analizirate tudi po razredih z uporabo samodejno izrisane matrike zmede, ki jo lahko tudi prenesete in uporabite za različna poročila. Poleg tega lahko narišete dodatne grafe za analizo uspešnosti vašega modela na podlagi zabeleženih meritev.

Primerjava več parametrov modela

Kot podatkovni znanstvenik želite najti najboljši možni model. To vključuje večkratno usposabljanje modela z različnimi hiperparametri in primerjavo delovanja modela s temi hiperparametri. Da bi to naredili, nam SageMaker Experiments omogoča ustvarjanje več izvedb v istem poskusu. Raziščimo ta koncept tako, da naš model usposobimo z različnimi num_hidden_channels in 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
            )

Zdaj ustvarjamo šest novih izvedb za naš poskus. Vsak bo zabeležil parametre modela, metrike in matriko zmede. Nato lahko primerjamo izvedbe, da izberemo najuspešnejši model za težavo. Pri analizi tekov lahko narišemo metrične grafe za različne teke kot en sam diagram in primerjamo uspešnost tekov v različnih korakih (ali obdobjih) treninga.

Uporaba eksperimentov SageMaker z opravili usposabljanja, obdelave in paketnega preoblikovanja SageMaker

V zgornjem primeru smo uporabili eksperimente SageMaker za beleženje zmogljivosti modela iz prenosnega računalnika SageMaker Studio, kjer je bil model učen lokalno v prenosnem računalniku. Enako lahko naredimo za beleženje zmogljivosti modela iz opravil obdelave, usposabljanja in paketnega preoblikovanja SageMaker. Z novimi zmožnostmi samodejnega podajanja konteksta nam konfiguracije eksperimenta ni treba posebej deliti z opravilom SageMaker, saj bo samodejno zajeta.

Spodnji primer se osredotoča na funkcionalnosti SageMaker Experiments in ni popolna koda.

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

V naši modelni skriptni datoteki lahko pridobimo kontekst izvajanja z uporabo load_run(). Pri opravilih obdelave in usposabljanja SageMaker nam ni treba zagotoviti konfiguracije poskusa za nalaganje konfiguracije. Za opravila paketnega preoblikovanja moramo zagotoviti experiment_name in run_name da naložite konfiguracijo poskusa.

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

Poleg informacij, ki jih dobimo pri zagonu SageMaker Experiments iz skripta prenosnega računalnika, bo zagon iz opravila SageMaker samodejno zapolnil parametre in rezultate opravila.

Novi SDK za eksperimente SageMaker prav tako zagotavlja združljivost za nazaj s prejšnjo različico z uporabo konceptov preizkusov in preskusnih komponent. Vsak poskus, sprožen s prejšnjo različico SageMaker Experiments, bo samodejno na voljo v novem uporabniškem vmesniku za analizo poskusov.

Integracija SageMaker Clarify in poročil o usposabljanju modelov

SageMaker Clarify pomaga izboljšati naše modele ML z zaznavanjem potencialna pristranskost in pomagati razložiti kako ti modeli dajejo napovedi. Clarify ponuja vnaprej zgrajene vsebnike, ki se izvajajo kot opravila obdelave SageMaker, potem ko je bil vaš model usposobljen, z uporabo informacij o vaših podatkih (konfiguracija podatkov), modelu (konfiguracija modela) in stolpcih občutljivih podatkov, ki jih želimo analizirati za morebitno pristranskost (pristranskost konfiguracijo). Do zdaj je SageMaker Experiments prikazoval naše usposabljanje modelov in poročila Clarify kot posamezne preskusne komponente, ki so bile povezane prek preskusa.

Z novimi eksperimenti SageMaker lahko integriramo tudi poročila SageMaker Clarify z našim usposabljanjem za modele z enim virom resnice, ki nam omogoča nadaljnje razumevanje našega modela. Za integrirano poročilo je vse, kar moramo storiti, to, da imamo isto ime izvajanja za naša opravila usposabljanja in Clarify. Naslednji primer prikazuje, kako lahko integriramo poročila z uporabo Model XGBoost napovedati dohodek odraslih v ZDA. Model uporablja Nabor podatkov UCI za odrasle. Za to vajo predvidevamo, da je bil model že usposobljen in da smo že izračunali podatke, model in konfiguracije pristranskosti.

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

S to nastavitvijo dobimo kombiniran pogled, ki vključuje metrike modela, skupne vhode in izhode ter poročila Clarify za statistično pristranskost in razložljivost modela.

zaključek

V tej objavi smo raziskali novo generacijo SageMaker Experiments, integriranega dela SDK SageMaker. Z novim razredom Run smo prikazali, kako lahko svoje poteke dela ML prijavite od koder koli. Predstavili smo nov uporabniški vmesnik Experiments, ki vam omogoča sledenje vašim poskusom in risanje grafov za posamezno meritev izvajanja ter primerjavo več izvajanj z novo zmožnostjo analize. Zagotovili smo primere poskusov beleženja iz prenosnega računalnika SageMaker Studio in iz izobraževalnega dela SageMaker Studio. Nazadnje smo pokazali, kako integrirati usposabljanje modela in poročila SageMaker Clarify v poenoten pogled, kar vam omogoča nadaljnje razumevanje vašega modela.

Priporočamo vam, da preizkusite nove funkcije eksperimentov in se povežete z Skupnost strojnega učenja in umetne inteligence če imate kakršna koli vprašanja ali povratne informacije!

O avtorjih

Maira Ladeira Tanke je specialist za strojno učenje pri AWS. Z ozadjem na področju podatkovne znanosti ima 9 let izkušenj z arhitekturo in gradnjo aplikacij ML s strankami v različnih panogah. Kot tehnični vodja pomaga strankam pospešiti doseganje poslovne vrednosti z nastajajočimi tehnologijami in inovativnimi rešitvami. V prostem času Maira rada potuje in preživlja čas z družino nekje na toplem.

Mani Khanuja je strokovnjak za umetno inteligenco in strojno učenje SA pri Amazon Web Services (AWS). Strankam, ki uporabljajo strojno učenje, pomaga rešiti njihove poslovne izzive z uporabo AWS. Večino svojega časa posveti globokemu potapljanju in poučevanju strank o projektih AI/ML, povezanih z računalniškim vidom, obdelavo naravnega jezika, napovedovanjem, ML na robu in več. Navdušena je nad ML at edge, zato je ustvarila lasten laboratorij s samovozečim kompletom in proizvodno linijo za izdelavo prototipov, kjer preživi veliko svojega prostega časa.

Dewen Qi je inženir za razvoj programske opreme pri AWS. Trenutno sodeluje pri gradnji zbirke storitev in orodij platforme v AWS SageMaker, da bi strankam pomagala pri uspešnih projektih ML. Prav tako je strastno približati koncept MLOps širšemu občinstvu. Zunaj službe Dewen rad vadi violončelo.

Abhishek Agarwal je višji produktni vodja za Amazon SageMaker. Navdušuje ga delo s strankami in omogočanje dostopnejšega strojnega učenja. V prostem času Abhishek uživa v slikanju, kolesarjenju in spoznavanju inovativnih tehnologij.

Dana Benson je programski inženir, ki dela v skupini Amazon SageMaker Experiments, Lineage in Search. Preden se je pridružila AWS, je Dana nekaj časa namenila omogočanju funkcionalnosti pametnega doma v Alexa in mobilnemu naročanju v Starbucksu.