Volgende generatie Amazon SageMaker-experimenten - Organiseer, volg en vergelijk uw machine learning-trainingen op schaal

Vandaag kondigen we graag updates aan voor onze Amazon SageMaker-experimenten vermogen van Amazon Sage Maker waarmee u machine learning (ML)-experimenten en modelversies kunt organiseren, volgen, vergelijken en evalueren vanuit elke geïntegreerde ontwikkelomgeving (IDE) met behulp van de SageMaker Python SDK of boto3, inclusief lokale Jupyter Notebooks.

Machine learning (ML) is een iteratief proces. Bij het oplossen van een nieuwe use case doorlopen datawetenschappers en ML-engineers verschillende parameters om de beste modelconfiguraties (ook wel hyperparameters genoemd) te vinden die in productie kunnen worden gebruikt om de geïdentificeerde zakelijke uitdaging op te lossen. Na verloop van tijd, na het experimenteren met meerdere modellen en hyperparameters, wordt het moeilijk voor ML-teams om modelruns efficiënt te beheren om de optimale te vinden zonder een tool om de verschillende experimenten bij te houden. Systemen voor het volgen van experimenten stroomlijnen de processen om verschillende iteraties te vergelijken en helpen de samenwerking en communicatie in een team te vereenvoudigen, waardoor de productiviteit toeneemt en tijd wordt bespaard. Dit wordt bereikt door ML-experimenten op een moeiteloze manier te organiseren en te beheren om er conclusies uit te trekken, bijvoorbeeld door de trainingsrun met de beste nauwkeurigheid te vinden.

Om deze uitdaging op te lossen, biedt SageMaker SageMaker Experiments, een volledig geïntegreerde SageMaker-mogelijkheid. Het biedt de flexibiliteit om uw modelstatistieken, parameters, bestanden, artefacten te loggen, grafieken van de verschillende metrieken te plotten, verschillende metadata vast te leggen, ze te doorzoeken en de reproduceerbaarheid van modellen te ondersteunen. Datawetenschappers kunnen snel de prestaties en hyperparameters vergelijken voor modelevaluatie door middel van visuele grafieken en tabellen. Ze kunnen ook SageMaker-experimenten gebruiken om de gemaakte grafieken te downloaden en de modelevaluatie te delen met hun belanghebbenden.

Met de nieuwe updates voor SageMaker Experiments maakt het nu deel uit van de SageMaker SDK, wat het werk van datawetenschappers vereenvoudigt en de noodzaak wegneemt om een ​​extra bibliotheek te installeren om meerdere modeluitvoeringen te beheren. We introduceren de volgende nieuwe kernconcepten:

• Experiment: Een verzameling runs die bij elkaar zijn gegroepeerd. Een experiment omvat uitvoeringen voor meerdere typen die overal kunnen worden gestart met behulp van de SageMaker Python SDK.
• lopen: Elke uitvoeringsstap van een modeltrainingsproces. Een run bestaat uit alle invoer, parameters, configuraties en resultaten voor één iteratie van modeltraining. Aangepaste parameters en statistieken kunnen worden vastgelegd met behulp van de log_parameter, log_parameters en log_metric functies. Aangepaste input en output kunnen worden gelogd met behulp van de log_file functie.

De concepten die worden geïmplementeerd als onderdeel van een Run class zijn beschikbaar vanaf elke IDE waar de SageMaker Python SDK is geïnstalleerd. Voor SageMaker Training, verwerking en

Transform Jobs, wordt de SageMaker Experiment Run automatisch doorgegeven aan de job als de job wordt aangeroepen binnen een run-context. U kunt het run-object herstellen met behulp van load_run() van je baan. Ten slotte kunnen datawetenschappers met de integratie van de nieuwe functionaliteiten ook automatisch een verwarringsmatrix, precisie- en recall-grafieken en een ROC-curve voor classificatiegebruiksgevallen loggen met behulp van de run.log_confusion_matrix, run.log_precision_recall en run.log_roc_curve functies resp.

In deze blogpost zullen we voorbeelden geven van het gebruik van de nieuwe SageMaker Experiments-functionaliteiten in een Jupyter-notebook via de SageMaker SDK. We zullen deze mogelijkheden demonstreren met behulp van een PyTorch voorbeeld om een ​​MNIST-classificatievoorbeeld met handgeschreven cijfers te trainen. Het experiment zal als volgt worden georganiseerd:

1. Uitvoeren van experimenten en logparameters maken: We maken eerst een nieuw experiment, starten een nieuwe run voor dit experiment en loggen er parameters in.
2. Prestatiestatistieken van het logboekregistratiemodel:We loggen de prestatiestatistieken van het model en plotten metrische grafieken.
3. Modelruns vergelijken:We zullen verschillende modelruns vergelijken volgens de hyperparameters van het model. We zullen bespreken hoe u die runs kunt vergelijken en hoe u SageMaker-experimenten kunt gebruiken om het beste model te selecteren.
4. Experimenten uitvoeren vanuit SageMaker-taken: We zullen ook een voorbeeld geven van hoe u de context van uw experiment automatisch kunt delen met een SageMaker-verwerkings-, trainings- of batchtransformatietaak. Hierdoor kunt u automatisch uw uitvoeringscontext herstellen met de load_run functioneren binnen je baan.
5. Integratie van SageMaker Clarify-rapporten: We zullen laten zien hoe we nu kunnen integreren SageMaker verduidelijken vooringenomenheid en verklaarbaarheidsrapporten naar één weergave met uw getrainde modelrapport.

Voorwaarden

Voor deze blogpost zullen we gebruiken Amazon SageMaker Studio om te laten zien hoe metrische gegevens van een Studio-notebook kunnen worden gelogd met behulp van de bijgewerkte SageMaker Experiments-functionaliteiten. Om de opdrachten uit ons voorbeeld uit te voeren, hebt u de volgende vereisten nodig:

• SageMaker Studio-domein
• SageMaker Studio-gebruikersprofiel met volledige toegang tot SageMaker
• Een SageMaker Studio-notebook met minimaal een ml.t3.medium instantietype

Als u geen SageMaker-domein en gebruikersprofiel beschikbaar heeft, kunt u er een maken met deze snelle installatiegids.

Logboekparameters

Voor deze oefening zullen we gebruiken fakkelvisie, een PyTorch-pakket dat populaire datasets, modelarchitecturen en algemene beeldtransformaties voor computervisie biedt. SageMaker Studio biedt een set van Docker-afbeeldingen voor veelgebruikte data science use cases die beschikbaar worden gesteld in Amazon ECR. Voor PyTorch heeft u de mogelijkheid om afbeeldingen te selecteren die zijn geoptimaliseerd voor CPU- of GPU-training. Voor dit voorbeeld selecteren we de afbeelding PyTorch 1.12 Python 3.8 CPU Optimized en Python 3 pit. De hieronder beschreven voorbeelden zijn gericht op de functionaliteiten van SageMaker Experiments en zijn niet volledig code.

Laten we de gegevens downloaden met de torchvision verpak en volg het aantal datamonsters voor de trein- en testdatasets als parameters met SageMaker Experiments. Laten we voor dit voorbeeld aannemen train_set en test_set zoals al gedownload torchvision gegevenssets.

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 dit voorbeeld gebruiken we de run.log_parameters om het aantal trein- en testgegevensmonsters te loggen en run.log_file om de onbewerkte datasets naar Amazon S3 te uploaden en ze te loggen als input voor ons experiment.

Een model trainen en modelstatistieken vastleggen

Nu we onze MNIST-dataset hebben gedownload, gaan we a CNN-model om de cijfers te herkennen. Tijdens het trainen van het model willen we onze bestaande experimentuitvoering laden, er nieuwe parameters in loggen en de modelprestaties volgen door modelstatistieken vast te leggen.

We kunnen de load_run functie om onze vorige run te laden en deze te gebruiken om onze modeltraining te loggen

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

We kunnen dan gebruik maken van run.log_parameter en run.log_parameters om een ​​of meerdere modelparameters in onze run te loggen.

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

En we kunnen gebruiken run.log_metric om prestatiestatistieken in ons experiment te loggen.

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

Voor classificatiemodellen kunt u ook gebruiken run.log_confusion_matrix, run.log_precision_recall en run.log_roc_curve, om automatisch de verwarringsmatrix, de precisieherinneringsgrafiek en de ROC-curve van uw model uit te zetten. Aangezien ons model een classificatieprobleem met meerdere klassen oplost, loggen we alleen de verwarringsmatrix ervoor.

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

Als we naar onze rundetails kijken, kunnen we nu de gegenereerde statistieken zien zoals weergegeven in de onderstaande schermafbeelding:

De pagina met uitvoeringsdetails biedt meer informatie over de metrische gegevens.

En de nieuwe modelparameters worden bijgehouden op de parameteroverzichtspagina.

U kunt uw modelprestaties ook per klasse analyseren met behulp van de automatisch geplotte verwarringsmatrix, die ook kan worden gedownload en voor verschillende rapporten kan worden gebruikt. En u kunt extra grafieken plotten om de prestaties van uw model te analyseren op basis van de geregistreerde statistieken.

Meerdere modelparameters vergelijken

Als datawetenschapper wil je het best mogelijke model vinden. Dat omvat het meerdere keren trainen van een model met verschillende hyperparameters en het vergelijken van de prestaties van het model met die hyperparameters. Om dit te doen, stelt SageMaker Experiments ons in staat om meerdere runs in hetzelfde experiment te maken. Laten we dit concept verkennen door ons model met verschillende te trainen num_hidden_channels en 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
            )

We maken nu zes nieuwe uitvoeringen voor ons experiment. Elk logt de modelparameters, statistieken en verwarringsmatrix. Vervolgens kunnen we de runs vergelijken om het best presterende model voor het probleem te selecteren. Bij het analyseren van de hardloopsessies kunnen we de metrische grafieken voor de verschillende hardloopsessies als een enkele plot plotten, waarbij de prestaties van de hardloopsessies over de verschillende trainingsstappen (of tijdperken) worden vergeleken.

SageMaker gebruiken Experimenteert met SageMaker-trainings-, verwerkings- en batchtransformatietaken

In het bovenstaande voorbeeld hebben we SageMaker-experimenten gebruikt om de modelprestaties van een SageMaker Studio-notebook vast te leggen, waarbij het model lokaal in het notebook werd getraind. We kunnen hetzelfde doen om de modelprestaties van SageMaker-verwerkings-, trainings- en batchtransformatietaken vast te leggen. Met de nieuwe mogelijkheden voor het automatisch doorgeven van context hoeven we de experimentconfiguratie niet specifiek te delen met de SageMaker-taak, omdat deze automatisch wordt vastgelegd.

Het onderstaande voorbeeld zal zich richten op de functionaliteiten van SageMaker Experiments en is niet compleet met code.

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

In ons modelscriptbestand kunnen we de run-context krijgen met behulp van load_run(). In SageMaker-verwerkings- en trainingstaken hoeven we de experimentconfiguratie niet op te geven om de configuratie te laden. Voor batchtransformatietaken moeten we zorgen experiment_name en run_name om de configuratie van het experiment te laden.

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

Naast de informatie die we krijgen bij het uitvoeren van SageMaker-experimenten vanuit een notebookscript, zal de uitvoering van een SageMaker-taak automatisch de taakparameters en -uitvoer invullen.

De nieuwe SageMaker Experiments SDK zorgt ook voor achterwaartse compatibiliteit met de vorige versie met behulp van de concepten van proeven en proefcomponenten. Elk experiment dat wordt geactiveerd met de vorige versie van SageMaker Experiments, wordt automatisch beschikbaar gemaakt in de nieuwe gebruikersinterface voor het analyseren van de experimenten.

Integratie van SageMaker Trainingsrapporten verduidelijken en modelleren

SageMaker Clarify helpt onze ML-modellen te verbeteren door te detecteren mogelijke vooringenomenheid en helpen verklaren hoe deze modellen voorspellingen doen. Clarify biedt kant-en-klare containers die worden uitgevoerd als SageMaker-verwerkingstaken nadat uw model is getraind, met behulp van informatie over uw gegevens (gegevensconfiguratie), model (modelconfiguratie) en de kolommen met gevoelige gegevens die we willen analyseren op mogelijke vertekening (bias configuratie). Tot nu toe toonde SageMaker Experiments onze modeltraining en Clarify-rapporten als individuele proefcomponenten die via een proef waren verbonden.

Met de nieuwe SageMaker-experimenten kunnen we ook SageMaker Clarify-rapporten integreren met onze modeltraining met één bron van waarheid waarmee we ons model beter kunnen begrijpen. Voor een geïntegreerd rapport hoeven we alleen maar dezelfde runnaam te hebben voor onze trainings- en Clarify-taken. Het volgende voorbeeld laat zien hoe we de rapporten kunnen integreren met behulp van een XGBoost-model om het inkomen van volwassenen in de Verenigde Staten te voorspellen. Het model maakt gebruik van de UCI-gegevensset voor volwassenen. Voor deze oefening gaan we ervan uit dat het model al is getraind en dat we de data-, model- en biasconfiguraties al hebben berekend.

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

Met deze opstelling krijgen we een gecombineerde weergave met de modelstatistieken, gezamenlijke invoer en uitvoer, en de Clarify-rapporten voor statistische vertekening en verklaarbaarheid van het model.

Conclusie

In dit bericht hebben we de nieuwe generatie SageMaker-experimenten onderzocht, een geïntegreerd onderdeel van SageMaker SDK. We hebben gedemonstreerd hoe u uw ML-workflows overal kunt loggen met de nieuwe Run-klasse. We hebben de nieuwe gebruikersinterface voor experimenten gepresenteerd waarmee u uw experimenten kunt volgen en grafieken kunt plotten voor een enkele meeteenheid, maar ook om meerdere uitvoeringen te vergelijken met de nieuwe analysemogelijkheid. We hebben voorbeelden gegeven van logboekexperimenten van een SageMaker Studio-notebook en van een SageMaker Studio-trainingstaak. Ten slotte hebben we laten zien hoe u modeltraining en SageMaker Clarify-rapporten kunt integreren in een uniforme weergave, zodat u uw model beter kunt begrijpen.

We moedigen u aan om de nieuwe functionaliteiten van Experimenten uit te proberen en verbinding te maken met de Machine Learning & AI-gemeenschap als u vragen of feedback heeft!

Over de auteurs

Maira Ladeira Tanke is Machine Learning-specialist bij AWS. Met een achtergrond in Data Science heeft ze 9 jaar ervaring met het ontwerpen en bouwen van ML-applicaties bij klanten in verschillende sectoren. Als technisch leider helpt ze klanten hun zakelijke waarde sneller te realiseren door middel van opkomende technologieën en innovatieve oplossingen. In haar vrije tijd houdt Maira ervan om te reizen en tijd door te brengen met haar familie op een warme plek.

Mani Khanuja is een Artificial Intelligence en Machine Learning Specialist SA bij Amazon Web Services (AWS). Ze helpt klanten die machine learning gebruiken om hun zakelijke uitdagingen op te lossen met behulp van de AWS. Ze besteedt het grootste deel van haar tijd aan het duiken in de diepte en het onderwijzen van klanten aan AI/ML-projecten met betrekking tot computervisie, natuurlijke taalverwerking, prognoses, ML aan de rand en meer. Ze is gepassioneerd door ML op het randje, daarom heeft ze haar eigen laboratorium gecreëerd met een zelfrijdende kit en productielijn voor het maken van prototypes, waar ze veel van haar vrije tijd doorbrengt.

Dewen Qi is Software Development Engineer bij AWS. Ze neemt momenteel deel aan het bouwen van een verzameling platformdiensten en tools in AWS SageMaker om klanten te helpen hun ML-projecten succesvol te maken. Ze is ook gepassioneerd om het concept van MLOps naar een breder publiek te brengen. Buiten het werk beoefent Dewen graag cello.

Abishek Agarwal is Senior Product Manager voor Amazon SageMaker. Hij is gepassioneerd door het werken met klanten en het toegankelijker maken van machine learning. In zijn vrije tijd houdt Abhishek van schilderen, fietsen en leren over innovatieve technologieën.

Dan Benson is een software-engineer die werkt in het Amazon SageMaker Experiments-, Lineage- en Search-team. Voordat ze bij AWS kwam, besteedde Dana tijd aan het mogelijk maken van smart home-functionaliteit in Alexa en mobiel bestellen bij Starbucks.