Următoarea generație de experimente Amazon SageMaker – Organizați, urmăriți și comparați antrenamentele de învățare automată la scară

Astăzi, suntem bucuroși să anunțăm actualizări ale noastre Experimente Amazon SageMaker capacitatea de Amazon SageMaker care vă permite să organizați, să urmăriți, să comparați și să evaluați experimente de învățare automată (ML) și versiuni de model din orice mediu de dezvoltare integrat (IDE) folosind SageMaker Python SDK sau boto3, inclusiv notebook-uri Jupyter locale.

Învățarea automată (ML) este un proces iterativ. Atunci când rezolvă un nou caz de utilizare, oamenii de știință de date și inginerii ML iterează prin diverși parametri pentru a găsi cele mai bune configurații de model (alias hiperparametri) care pot fi utilizate în producție pentru a rezolva provocarea identificată de afaceri. De-a lungul timpului, după ce au experimentat mai multe modele și hiperparametri, devine dificil pentru echipele de ML să gestioneze eficient rulările de model pentru a-l găsi pe cel optim, fără un instrument care să țină evidența diferitelor experimente. Sistemele de urmărire a experimentelor eficientizează procesele pentru a compara diferite iterații și ajută la simplificarea colaborării și comunicării într-o echipă, crescând astfel productivitatea și economisind timp. Acest lucru se realizează prin organizarea și gestionarea experimentelor ML într-un mod fără efort pentru a trage concluzii din acestea, de exemplu, găsirea cursei de antrenament cu cea mai bună acuratețe.

Pentru a rezolva această provocare, SageMaker oferă SageMaker Experiments, o capacitate SageMaker complet integrată. Oferă flexibilitatea de a înregistra valorile modelului, parametrii, fișierele, artefactele, graficele din diferitele valori, capturarea diferitelor metadate, căutarea prin ele și susținerea reproductibilității modelului. Oamenii de știință de date pot compara rapid performanța și hiperparametrii pentru evaluarea modelului prin diagrame și tabele vizuale. De asemenea, pot folosi SageMaker Experiments pentru a descărca diagramele create și pentru a partaja evaluarea modelului cu părțile interesate.

Odată cu noile actualizări ale SageMaker Experiments, este acum o parte a SDK-ului SageMaker, simplificând munca cercetătorului de date și eliminând necesitatea instalării unei biblioteci suplimentare pentru a gestiona mai multe execuții de model. Introducem următoarele concepte de bază noi:

• Experiment: O colecție de curse care sunt grupate împreună. Un experiment include rulări pentru mai multe tipuri care pot fi inițiate de oriunde utilizând SDK-ul SageMaker Python.
• Alerga: Fiecare pas de execuție a unui proces de formare a modelului. O rulare constă din toate intrările, parametrii, configurațiile și rezultatele pentru o iterație a antrenării modelului. Parametrii și valorile personalizate pot fi înregistrați folosind log_parameter, log_parameters, și log_metric funcții. Intrările și ieșirile personalizate pot fi înregistrate folosind log_file Funcția.

Conceptele care sunt implementate ca parte a a Run clasa sunt puse la dispoziție din orice IDE unde este instalat SageMaker Python SDK. Pentru instruire, procesare și procesare SageMaker

Transform Jobs, Executarea SageMaker Experiment este transmisă automat jobului dacă jobul este invocat într-un context de rulare. Puteți recupera obiectul rulat folosind load_run() din slujba ta. În cele din urmă, odată cu integrarea noilor funcționalități, oamenii de știință de date pot, de asemenea, să înregistreze automat o matrice de confuzie, grafice de precizie și reamintire și o curbă ROC pentru cazurile de utilizare de clasificare folosind run.log_confusion_matrix, run.log_precision_recall, și run.log_roc_curve funcții, respectiv.

În această postare pe blog, vom oferi exemple despre cum să utilizați noile funcționalități SageMaker Experiments într-un notebook Jupyter prin intermediul SDK-ului SageMaker. Vom demonstra aceste capacități folosind a PyTorch exemplu pentru a antrena un exemplu de clasificare a cifrelor scrise de mână MNIST. Experimentul va fi organizat după cum urmează:

1. Crearea rulajelor experimentului și a parametrilor de înregistrare: vom crea mai întâi un nou experiment, vom începe o nouă rulare pentru acest experiment și vom înregistra parametrii pentru acesta.
2. Înregistrarea valorilor de performanță a modelului: Vom înregistra valorile de performanță ale modelului și vom reprezenta grafice de valori.
3. Compararea curselor de model: Vom compara diferite rulări de model în funcție de hiperparametrii modelului. Vom discuta despre cum să comparăm aceste rulări și cum să folosiți SageMaker Experiments pentru a selecta cel mai bun model.
4. Desfășurarea experimentelor din joburile SageMaker: Vom oferi, de asemenea, un exemplu despre cum să partajați automat contextul experimentului cu o lucrare de procesare, instruire sau transformare în loturi SageMaker. Acest lucru vă permite să vă recuperați automat contextul de rulare cu load_run funcţionează în interiorul locului de muncă.
5. Integrarea rapoartelor SageMaker Clarify: Vom demonstra cum ne putem integra acum SageMaker Clarify rapoarte de părtinire și explicabilitate într-o singură vizualizare cu raportul model antrenat.

Cerințe preliminare

Pentru această postare pe blog, vom folosi Amazon SageMaker Studio pentru a prezenta cum să înregistrați valorile dintr-un blocnotes Studio folosind funcționalitățile actualizate SageMaker Experiments. Pentru a executa comenzile prezentate în exemplul nostru, aveți nevoie de următoarele condiții preliminare:

• Domeniul SageMaker Studio
• Profil de utilizator SageMaker Studio cu acces complet SageMaker
• Un notebook SageMaker Studio cu cel puțin un ml.t3.medium tipul instanței

Dacă nu aveți un domeniu SageMaker și un profil de utilizator disponibile, puteți crea unul folosind aceasta ghid de configurare rapidă.

Parametrii de înregistrare

Pentru acest exercițiu, vom folosi viziunea cu torță, un pachet PyTorch care oferă seturi de date populare, arhitecturi de model și transformări comune de imagine pentru viziunea computerizată. SageMaker Studio oferă un set de Imagini Docker pentru cazuri comune de utilizare a științei datelor care sunt disponibile în Amazon ECR. Pentru PyTorch, aveți opțiunea de a selecta imagini optimizate pentru antrenamentul CPU sau GPU. Pentru acest exemplu, vom selecta imaginea PyTorch 1.12 Python 3.8 CPU Optimized si Python 3 nucleu. Exemplele descrise mai jos se vor concentra pe funcționalitățile SageMaker Experiments și nu sunt complete de cod.

Să descarcăm datele cu torchvision împachetați și urmăriți numărul de mostre de date pentru tren și testați seturile de date ca parametri cu SageMaker Experiments. Pentru acest exemplu, să presupunem train_set și test_set așa cum a fost deja descărcat torchvision seturi de date.

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)

În acest exemplu, folosim run.log_parameters să înregistreze numărul de mostre de date de tren și de testare și run.log_file pentru a încărca seturile de date brute pe Amazon S3 și a le înregistra ca intrări în experimentul nostru.

Antrenarea unui model și înregistrarea valorilor modelului

Acum că ne-am descărcat setul de date MNIST, să antrenăm a Modelul CNN pentru a recunoaște cifrele. În timp ce antrenăm modelul, dorim să încărcăm experimentul existent, să înregistrăm noi parametri în acesta și să urmărim performanța modelului prin înregistrarea valorilor modelului.

Putem folosi load_run funcția pentru a încărca rularea noastră anterioară și a o folosi pentru a înregistra antrenamentul nostru model

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

Putem folosi apoi run.log_parameter și run.log_parameters pentru a înregistra unul sau mai mulți parametri de model în rularea noastră.

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

Și putem folosi run.log_metric pentru a înregistra valorile de performanță în experimentul nostru.

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

Pentru modelele de clasificare, puteți utiliza și run.log_confusion_matrix, run.log_precision_recall, și run.log_roc_curve, pentru a reprezenta automat matricea de confuzie, graficul de precizie a reamintirii și curba ROC a modelului dvs. Deoarece modelul nostru rezolvă o problemă de clasificare multiclasă, să înregistrăm doar matricea de confuzie pentru aceasta.

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

Când ne uităm la detaliile rulării noastre, acum putem vedea valorile generate așa cum se arată în captura de ecran de mai jos:

Pagina cu detalii despre rulare oferă mai multe informații despre valori.

Iar parametrii noului model sunt urmăriți pe pagina de prezentare generală a parametrilor.

De asemenea, puteți analiza performanța modelului dvs. în funcție de clasă folosind matricea de confuzie trasată automat, care poate fi, de asemenea, descărcată și utilizată pentru diferite rapoarte. Și puteți reprezenta grafice suplimentare pentru a analiza performanța modelului dvs. pe baza valorilor înregistrate.

Compararea mai multor parametri ai modelului

În calitate de cercetător de date, doriți să găsiți cel mai bun model posibil. Aceasta include antrenarea unui model de mai multe ori cu hiperparametri diferiți și compararea performanței modelului cu acei hiperparametri. Pentru a face acest lucru, SageMaker Experiments ne permite să creăm mai multe executări în același experiment. Să explorăm acest concept antrenând modelul nostru cu diferite num_hidden_channels și 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
            )

Acum creăm șase noi curse pentru experimentul nostru. Fiecare va înregistra parametrii modelului, valorile și matricea de confuzie. Putem apoi compara rulările pentru a selecta modelul cel mai performant pentru problemă. Când analizăm alergările, putem reprezenta graficele metrice pentru diferitele alergări ca un singur grafic, comparând performanța alergărilor în diferite etape (sau epoci) de antrenament.

Utilizarea SageMaker Experiments cu SageMaker instruire, procesare și transformare în loturi

În exemplul de mai sus, am folosit SageMaker Experiments pentru a înregistra performanța modelului dintr-un notebook SageMaker Studio unde modelul a fost antrenat local în blocnotes. Putem face același lucru pentru a înregistra performanța modelului din joburile de procesare, instruire și transformare în loturi SageMaker. Cu noile capabilități de trecere automată a contextului, nu trebuie să partajăm în mod specific configurația experimentului cu jobul SageMaker, deoarece va fi capturat automat.

Exemplul de mai jos se va concentra pe funcționalitățile SageMaker Experiments și nu este codul complet.

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

În fișierul nostru script model, putem obține contextul de rulare folosind load_run(). În joburile de procesare și instruire SageMaker, nu trebuie să furnizăm configurația experimentului pentru încărcarea configurației. Pentru joburile de transformare în loturi, trebuie să oferim experiment_name și run_name pentru a încărca configurația experimentului.

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

În plus față de informațiile pe care le obținem atunci când rulăm SageMaker Experiments dintr-un script de notebook, rularea dintr-un job SageMaker va popula automat parametrii și ieșirile jobului.

Noul SDK SageMaker Experiments asigură, de asemenea, compatibilitatea cu versiunea anterioară utilizând conceptele de încercare și componente de încercare. Orice experiment declanșat folosind versiunea anterioară SageMaker Experiments va fi disponibil automat în noua interfață de utilizare, pentru analiza experimentelor.

Integrarea SageMaker Clarify și modelarea rapoartelor de instruire

SageMaker Clarify ajută la îmbunătățirea modelelor noastre ML prin detectare prejudecată potențială si ajutand explica modul în care aceste modele fac predicții. Clarify oferă containere pre-construite care rulează ca lucrări de procesare SageMaker după ce modelul dvs. a fost instruit, folosind informații despre datele dvs. (configurarea datelor), modelul (configurarea modelului) și coloanele de date sensibile pe care dorim să le analizăm pentru posibile părtiniri (prejudecăți). configurație). Până acum, SageMaker Experiments afișează rapoartele noastre de instruire a modelului și Clarify ca componente individuale de probă care au fost conectate printr-o probă.

Cu noile experimente SageMaker, putem, de asemenea, să integrăm rapoartele SageMaker Clarify cu instruirea modelului nostru, având o singură sursă de adevăr care ne permite să înțelegem în continuare modelul nostru. Pentru un raport integrat, tot ce trebuie să facem este să avem același nume de rulare pentru joburile noastre de instruire și Clarify. Următorul exemplu demonstrează cum putem integra rapoartele folosind un Model XGBoost pentru a prezice veniturile adulților din Statele Unite. Modelul folosește Set de date UCI pentru adulți. Pentru acest exercițiu, presupunem că modelul a fost deja antrenat și că am calculat deja configurațiile de date, model și părtinire.

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

Cu această configurare, obținem o vizualizare combinată care include valorile modelului, intrările și ieșirile comune și rapoartele Clarify pentru părtinire și explicabilitate statistică a modelului.

Concluzie

În această postare, am explorat noua generație de experimente SageMaker, o parte integrată a SDK-ului SageMaker. Am demonstrat cum să vă înregistrați fluxurile de lucru ML de oriunde cu noua clasă Run. Am prezentat noua interfață de utilizare Experiments, care vă permite să urmăriți experimentele și să trasați grafice pentru o singură măsurătoare de rulare, precum și să comparați mai multe rulări cu noua capacitate de analiză. Am oferit exemple de experimente de înregistrare în jurnal dintr-un blocnotes SageMaker Studio și dintr-un job de instruire SageMaker Studio. În cele din urmă, am arătat cum să integrați formarea modelului și rapoartele SageMaker Clarify într-o vizualizare unificată, permițându-vă să înțelegeți mai bine modelul dvs.

Vă încurajăm să încercați noile funcționalități Experiments și să vă conectați la Învățare automată și comunitate AI dacă aveți întrebări sau feedback!

Despre Autori

Maira Ladeira Tanke este specialist în învățare automată la AWS. Cu experiență în Data Science, ea are 9 ani de experiență în arhitectura și construirea de aplicații ML cu clienți din diverse industrii. În calitate de lider tehnic, ea ajută clienții să-și accelereze atingerea valorii afacerii prin tehnologii emergente și soluții inovatoare. În timpul liber, Mairei îi place să călătorească și să petreacă timpul cu familia ei într-un loc cald.

Mani Khanuja este un specialist SA în inteligență artificială și învățare automată la Amazon Web Services (AWS). Ea ajută clienții care folosesc învățarea automată pentru a-și rezolva provocările de afaceri folosind AWS. Ea își petrece cea mai mare parte a timpului scufundându-se adânc și învățând clienții cu privire la proiecte AI/ML legate de viziunea computerizată, procesarea limbajului natural, prognoza, ML la margine și multe altele. Este pasionată de ML at edge, prin urmare, și-a creat propriul laborator cu kit de auto-conducere și linie de producție de prototipuri, unde își petrece mult timp liber.

Dewen Qi este inginer de dezvoltare software la AWS. În prezent, participă la construirea unei colecții de servicii și instrumente de platformă în AWS SageMaker pentru a ajuta clienții să-și facă proiectele ML de succes. Ea este, de asemenea, pasionată de a aduce conceptul MLOps unui public mai larg. În afara serviciului, lui Dewen îi place să practice violoncelul.

Abhishek Agarwal este Senior Product Manager pentru Amazon SageMaker. Este pasionat de lucrul cu clienții și de a face învățarea automată mai accesibilă. În timpul liber, lui Abhishek îi place să picteze, să meargă cu bicicleta și să învețe despre tehnologii inovatoare.

Dana Benson este un inginer software care lucrează în echipa Amazon SageMaker Experiments, Lineage și Search. Înainte de a se alătura AWS, Dana a petrecut timp activând funcționalitatea de casă inteligentă în Alexa și comandă mobilă la Starbucks.