Spor dine ML-eksperimenter fra ende til anden med Data Version Control og Amazon SageMaker Experiments

Dataforskere arbejder ofte på at forstå virkningerne af forskellige dataforbehandlings- og funktionsteknologiske strategier i kombination med forskellige modelarkitekturer og hyperparametre. At gøre det kræver, at du dækker store parameterrum iterativt, og det kan være overvældende at holde styr på tidligere kørte konfigurationer og resultater, samtidig med at eksperimenter er reproducerbare.

Dette indlæg leder dig gennem et eksempel på, hvordan du sporer dine eksperimenter på tværs af kode, data, artefakter og metrics ved at bruge Amazon SageMaker-eksperimenter i forbindelse med Dataversionskontrol (DVC). Vi viser, hvordan du kan bruge DVC side om side med Amazon SageMaker forarbejdnings- og uddannelsesjobs. Vi træner forskellige CatBoost-modeller på det californiske boligdatasæt fra StatLib-depot, og ændre holdout-strategier, mens du holder styr på dataversionen med DVC. I hvert enkelt eksperiment sporer vi input og output artefakter, kode og metrikker ved hjælp af SageMaker Experiments.

SageMaker-eksperimenter

SageMaker Experiments er en AWS-tjeneste til sporing af maskinlæringseksperimenter (ML). Det SageMaker Experiments Python SDK er en grænseflade på højt niveau til denne tjeneste, der hjælper dig med at spore eksperimentoplysninger ved hjælp af Python.

Målet med SageMaker Experiments er at gøre det så enkelt som muligt at oprette eksperimenter, udfylde dem med forsøg, tilføje sporings- og afstamningsoplysninger og køre analyser på tværs af forsøg og eksperimenter.

Når vi diskuterer SageMaker-eksperimenter, henviser vi til følgende begreber:

• Eksperiment – En samling af relaterede forsøg. Du tilføjer forsøg til et eksperiment, som du vil sammenligne sammen.
• Trial – En beskrivelse af en flertrins ML-arbejdsgang. Hvert trin i arbejdsgangen er beskrevet af en prøvekomponent.
• Prøve komponent – En beskrivelse af et enkelt trin i en ML-arbejdsgang, såsom datarensning, funktionsudtræk, modeltræning eller modelevaluering.
• Tracker – En Python-kontekstmanager til at logge oplysninger om en enkelt prøvekomponent (for eksempel parametre, metrikker eller artefakter).

Dataversionskontrol

Data Version Control (DVC) er en ny type software til dataversionering, workflow og eksperimentstyring, der bygger på Git (selvom det kan fungere selvstændigt). DVC reducerer kløften mellem etablerede tekniske værktøjssæt og datavidenskabelige behov, så du kan drage fordel af nye funktioner samtidig med at man genbruger eksisterende færdigheder og intuition.

Deling og samarbejde med datavidenskabseksperimenter kan udføres gennem et almindeligt Git-flow (commits, branching, tagging, pull-anmodninger) på samme måde som det fungerer for softwareingeniører. Med Git og DVC kan datavidenskabs- og ML-teams versionseksperimenter, administrere store datasæt og gøre projekter reproducerbare.

DVC har følgende funktioner:

• DVC er en gratis, open source kommandolinjen værktøj.
• DVC arbejder oven på Git-repositories og har en lignende kommandolinjegrænseflade og flow som Git. DVC kan også fungere selvstændigt, men uden versionering kapaciteter.
• Dataversionering er aktiveret ved at erstatte store filer, datasætbiblioteker, ML-modeller og så videre med små metafiler (let at håndtere med Git). Disse pladsholdere peger på de originale data, som er afkoblet fra kildekodestyring.
• Du kan bruge on-premises eller cloud storage til at gemme projektets data adskilt fra dets kodebase. Sådan kan dataforskere overføre store datasæt eller dele en GPU-trænet model med andre.
• DVC gør datavidenskabelige projekter reproducerbare ved at skabe letvægtsprojekter rørledninger ved hjælp af implicitte afhængighedsgrafer og ved at kodificere de involverede data og artefakter.
• DVC er platformagnostisk. Det kører på alle større operativsystemer (Linux, macOS og Windows) og fungerer uafhængigt af programmeringssprogene (Python, R, Julia, shell-scripts og så videre) eller ML-biblioteker (Keras, TensorFlow, PyTorch, Scipy og mere) brugt i projektet.
• DVC er hurtig til installere og kræver ikke speciel infrastruktur, og det afhænger heller ikke af API'er eller eksterne tjenester. Det er et selvstændigt CLI-værktøj.

SageMaker Experiments og DVC prøve

Følgende GitHub-eksempel viser, hvordan du bruger DVC i SageMaker-miljøet. Vi ser især på, hvordan man opbygger et brugerdefineret billede med DVC-biblioteker installeret som standard for at give et konsistent udviklingsmiljø til dine dataforskere i Amazon SageMaker Studio, og hvordan man kører DVC sammen med SageMaker-styret infrastruktur til behandling og træning. Desuden viser vi, hvordan man beriger SageMaker-sporingsinformation med dataversionsinformation fra DVC og visualiserer dem i Studio-konsollen.

Følgende diagram illustrerer løsningsarkitekturen og arbejdsgangen.

Byg et brugerdefineret Studio-billede med DVC allerede installeret

I denne GitHub repository, forklarer vi, hvordan man opretter et brugerdefineret billede til Studio, der allerede har DVC installeret. Fordelen ved at skabe et billede og gøre det tilgængeligt for alle Studio-brugere er, at det skaber et konsistent miljø for Studio-brugerne, som de også kunne køre lokalt. Selvom prøven er baseret på AWS Cloud9, kan du også bygge containeren på din lokale maskine, så længe du har Docker installeret og kører. Denne prøve er baseret på følgende Dockerfil , miljø.yml. Det resulterende Docker-billede gemmes i Amazon Elastic Container Registry (Amazon EMR) på din AWS-konto. Se følgende kode:

# Login to ECR
aws --region ${REGION} ecr get-login-password | docker login --username AWS --password-stdin ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom

# Create the ECR repository
aws --region ${REGION} ecr create-repository --repository-name smstudio-custom

# Build the image - it might take a few minutes to complete this step
docker build . -t ${IMAGE_NAME} -t ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:${IMAGE_NAME}

# Push the image to ECR
docker push ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:${IMAGE_NAME}

Du kan nu oprette et nyt Studio-domæne or opdatere et eksisterende Studio-domæne der har adgang til det nyoprettede Docker-billede.

Vi anvender AWS Cloud Development Kit (AWS CDK) for at oprette følgende ressourcer via AWS CloudFormation:

• En SageMaker-udførelsesrolle med de rigtige tilladelser til dit nye eller eksisterende Studio-domæne
• Et SageMaker-billede og SageMaker-billedversion fra Docker-billedet conda-env-dvc-kernel som vi oprettede tidligere
• An AppImageConfig der specificerer, hvordan kerne-gatewayen skal konfigureres
• En Studio-bruger (data-scientist-dvc) med den korrekte SageMaker-udførelsesrolle og det tilpassede Studio-billede, der er tilgængeligt for det

For detaljerede instruktioner, se Knyt et brugerdefineret billede til SageMaker Studio.

Kør laboratoriet

For at køre laboratoriet skal du udføre følgende trin:

1. I Studio-domænet skal du starte Studio for data-scientist-dvc bruger.
2. Vælg Git-ikonet, og vælg derefter Klon et depot.
   
3. Indtast URL'en for depotet (https://github.com/aws-samples/amazon-sagemaker-experiments-dvc-demo) og vælg Klon.
4. I filbrowseren skal du vælge amazon-sagemaker-experiments-dvc-demo repository.
5. Åbne dvc_sagemaker_script_mode.ipynb notesbog.
6. Til Brugerdefineret billede, vælg billedet conda-env-dvc-kernel.
7. Vælg Type.
   

Konfigurer DVC til dataversionering

Vi opretter en undermappe, hvor vi forbereder dataene: sagemaker-dvc-sample. I denne undermappe initialiserer vi et nyt Git-lager og indstiller fjernbetjeningen til et lager, vi opretter i AWS CodeCommit. Målet er at have DVC-konfigurationer og filer til datasporing versioneret i dette lager. Git tilbyder dog native muligheder til at styre underprojekter via for eksempel git-undermoduler og git-undertræer, og du kan udvide denne prøve til at bruge et hvilket som helst af de førnævnte værktøjer, der passer bedst til din arbejdsgang.

Den største fordel ved at bruge CodeCommit med SageMaker i vores tilfælde er dens integration med AWS identitets- og adgangsstyring (IAM) til godkendelse og autorisation, hvilket betyder, at vi kan bruge IAM-roller til at skubbe og trække data uden behov for at hente legitimationsoplysninger (eller SSH-nøgler). Indstilling af de relevante tilladelser på SageMaker-udførelsesrollen gør det også muligt for Studio-notebooken og SageMaker-trænings- og behandlingsjobbet at interagere sikkert med CodeCommit.

Selvom du kan erstatte CodeCommit med enhver anden kildekontroltjeneste, såsom GitHub, Gitlab eller Bitbucket, skal du overveje, hvordan du håndterer legitimationsoplysningerne til dit system. En mulighed er at gemme disse legitimationsoplysninger på AWS Secrets Manager og hent dem under kørsel fra Studio-notesbogen samt fra SageMaker-behandlings- og træningsjob.

Bearbejde og træne med DVC og SageMaker

I dette afsnit udforsker vi to forskellige tilgange til at tackle vores problem, og hvordan vi kan holde styr på de to tests ved hjælp af SageMaker Experiments i henhold til den konceptuelle arkitektur på højt niveau, vi viste dig tidligere.

Opsæt et SageMaker-eksperiment

For at spore denne test i SageMaker skal vi oprette et eksperiment. Vi skal også definere forsøget inden for eksperimentet. For nemheds skyld overvejer vi blot ét forsøg til eksperimentet, men du kan have et hvilket som helst antal forsøg inden for et eksperiment, for eksempel hvis du vil teste forskellige algoritmer.

Vi laver et eksperiment ved navn DEMO-sagemaker-experiments-dvc med to forsøg, dvc-trial-single-file , dvc-trial-multi-files, der hver repræsenterer en anden version af datasættet.

Lad os skabe DEMO-sagemaker-experiments-dvc eksperiment:

from smexperiments.experiment import Experiment
from smexperiments.trial import Trial
from smexperiments.trial_component import TrialComponent
from smexperiments.tracker import Tracker

experiment_name = 'DEMO-sagemaker-experiments-dvc'

# create the experiment if it doesn't exist
try:
    my_experiment = Experiment.load(experiment_name=experiment_name)
    print("existing experiment loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_experiment = Experiment.create(
            experiment_name = experiment_name,
            description = "How to integrate DVC"
        )
        print("new experiment created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

Test 1: Generer enkelte filer til træning og validering

I dette afsnit opretter vi et behandlingsscript, der henter rådataene direkte fra Amazon Simple Storage Service (Amazon S3) som input; behandler det for at skabe tog-, validerings- og testdatasæt; og gemmer resultaterne tilbage til Amazon S3 ved hjælp af DVC. Desuden viser vi, hvordan du kan spore output-artefakter genereret af DVC med SageMaker, når du kører behandlings- og træningsjob og via SageMaker Experiments.

Først skaber vi dvc-trial-single-file prøve og tilføje det til DEMO-sagemaker-experiments-dvc eksperiment. Ved at gøre det holder vi alle prøvekomponenter relateret til denne test organiseret på en meningsfuld måde.

first_trial_name = "dvc-trial-single-file"

try:
    my_first_trial = Trial.load(trial_name=first_trial_name)
    print("existing trial loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_first_trial = Trial.create(
            experiment_name=experiment_name,
            trial_name=first_trial_name,
        )
        print("new trial created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

Brug DVC i et SageMaker-behandlingsjob til at oprette den enkelte filversion

I dette afsnit opretter vi et behandlingsscript, der får rådataene direkte fra Amazon S3 som input ved hjælp af SageMakers administrerede dataindlæsningskapacitet; behandler det for at skabe tog-, validerings- og testdatasæt; og gemmer resultaterne tilbage til Amazon S3 ved hjælp af DVC. Det er meget vigtigt at forstå, at når vi bruger DVC til at gemme data til Amazon S3 (eller trække data fra Amazon S3), mister vi SageMaker administrerede dataindlæsningsfunktioner, hvilket potentielt kan have en indvirkning på ydeevnen og omkostningerne ved vores behandlings- og træningsjob , især når du arbejder med meget store datasæt. For mere information om de forskellige SageMaker native input-funktioner, se Få adgang til træningsdata.

Endelig forener vi DVC-sporingsfunktioner med SageMaker-sporingsfunktioner, når vi kører behandlingsjob via SageMaker Experiments.

Behandlingsscriptet forventer adressen på Git-lageret og den gren, vi vil oprette, for at gemme DVC-metadataene, der sendes via miljøvariabler. Selve datasættene er gemt i Amazon S3 af DVC. Selvom miljøvariabler automatisk spores i SageMaker Experiments og er synlige i prøvekomponentens parametre, vil vi måske berige prøvekomponenterne med yderligere information, som derefter bliver tilgængelige for visualisering i Studio UI ved hjælp af et sporingsobjekt. I vores tilfælde inkluderer prøvekomponentparametrene følgende:

• DVC_REPO_URL
• DVC_BRANCH
• USER
• data_commit_hash
• train_test_split_ratio

Forbehandlingsscriptet kloner Git-lageret; genererer tog-, validerings- og testdatasæt; og synkroniserer den ved hjælp af DVC. Som nævnt tidligere, når vi bruger DVC, kan vi ikke drage fordel af indbyggede SageMaker-dataindlæsningsmuligheder. Bortset fra de præstationsstraffe, vi kan lide på store datasæt, mister vi også de automatiske sporingsmuligheder for output-artefakter. Men takket være trackeren og DVC Python API kan vi kompensere for disse mangler, hente sådanne oplysninger under kørsel og gemme dem i prøvekomponenten med en lille indsats. Merværdien ved at gøre det er at have en samlet visning af input- og outputartefakter, der hører til dette specifikke behandlingsjob.

Det fulde forbehandlings-Python-script er tilgængeligt i GitHub repo.

with Tracker.load() as tracker:
    tracker.log_parameters({"data_commit_hash": commit_hash})
    for file_type in file_types:
        path = dvc.api.get_url(
            f"{data_path}/{file_type}/california_{file_type}.csv",
            repo=dvc_repo_url,
            rev=dvc_branch
        )
        tracker.log_output(name=f"california_{file_type}",value=path)

SageMaker giver os muligheden for at køre vores behandlingsscript på containerbilleder administreret af AWS, som er optimeret til at køre på AWS-infrastrukturen. Hvis vores script kræver yderligere afhængigheder, kan vi levere en requirements.txt fil. Når vi starter forarbejdningsjobbet, bruger SageMaker pip-install at installere alle de biblioteker, vi har brug for (for eksempel DVC-relaterede biblioteker). Skal du have en strammere kontrol med alle biblioteker installeret på containerne, kan du medbringe din egen container i SageMaker, f.eks. forarbejdning og træning.

Vi har nu alle ingredienserne til at køre vores SageMaker-bearbejdningsjob:

• Et behandlingsscript, der kan behandle flere argumenter (--train-test-split-ratio) og to miljøvariable (DVC_REPO_URL , DVC_BRANCH)
• A requiremets.txt fil
• Et Git-lager (i CodeCommit)
• Et SageMaker eksperiment og forsøg

from sagemaker.processing import FrameworkProcessor, ProcessingInput
from sagemaker.sklearn.estimator import SKLearn

dvc_repo_url = "codecommit::{}://sagemaker-dvc-sample".format(region)
dvc_branch = my_first_trial.trial_name

script_processor = FrameworkProcessor(
    estimator_cls=SKLearn,
    framework_version='0.23-1',
    instance_count=1,
    instance_type='ml.m5.xlarge',
    env={
        "DVC_REPO_URL": dvc_repo_url,
        "DVC_BRANCH": dvc_branch,
        "USER": "sagemaker"
    },
    role=role
)

experiment_config={
    "ExperimentName": my_experiment.experiment_name,
    "TrialName": my_first_trial.trial_name
}

Vi kører derefter forarbejdningsjobbet med preprocessing-experiment.py manuskript, experiment_config, dvc_repo_urlog dvc_branch vi definerede tidligere.

%%time

script_processor.run(
    code='./source_dir/preprocessing-experiment.py',
    dependencies=['./source_dir/requirements.txt'],
    inputs=[ProcessingInput(source=s3_data_path, destination="/opt/ml/processing/input")],
    experiment_config=experiment_config,
    arguments=["--train-test-split-ratio", "0.2"]
)

Behandlingsjobbet tager cirka 5 minutter at fuldføre. Nu kan du se prøvedetaljerne for enkeltfildatasættet.

Følgende skærmbillede viser, hvor du kan finde de lagrede oplysninger i Studio. Bemærk værdierne for dvc-trial-single-file in DVC_BRANCH, DVC_REPO_URLog data_commit_hash på den parametre fane.

Bemærk også input- og outputdetaljerne på Artifacts fane.

Opret en estimator og tilpas modellen med en enkelt fildataversion

For at bruge DVC-integration i et SageMaker-uddannelsesjob, består vi en dvc_repo_url , dvc_branch som miljøvariable, når du opretter Estimator-objektet.

Vi træner på dvc-trial-single-file gren først.

Når vi trækker data med DVC, bruger vi følgende datasætstruktur:

dataset
    |-- train
    |   |-- california_train.csv
    |-- test
    |   |-- california_test.csv
    |-- validation
    |   |-- california_validation.csv

Nu opretter vi en Scikit-learn Estimator ved hjælp af SageMaker Python SDK. Dette giver os mulighed for at specificere følgende:

• Stien til Python-kildefilen, som skal køres som indgangspunkt til træning.
• IAM-rollen, der kontrollerer tilladelser til at få adgang til Amazon S3- og CodeCommit-data og køre SageMaker-funktioner.
• En liste over ordbøger, der definerer de målinger, der bruges til at evaluere træningsjob.
• Antallet og typen af ​​træningstilfælde. Vi bruger en ml.m5.large instans.
• Hyperparametre, der bruges til træning.
• Miljøvariabler til brug under træningsjobbet. Vi bruger DVC_REPO_URL, DVC_BRANCHog USER.

metric_definitions = [{'Name': 'median-AE', 'Regex': "AE-at-50th-percentile: ([0-9.]+).*$"}]

hyperparameters={ 
        "learning_rate" : 1,
        "depth": 6
    }
estimator = SKLearn(
    entry_point='train.py',
    source_dir='source_dir',
    role=role,
    metric_definitions=metric_definitions,
    hyperparameters=hyperparameters,
    instance_count=1,
    instance_type='ml.m5.large',
    framework_version='0.23-1',
    base_job_name='training-with-dvc-data',
    environment={
        "DVC_REPO_URL": dvc_repo_url,
        "DVC_BRANCH": dvc_branch,
        "USER": "sagemaker"
    }
)

experiment_config={
    "ExperimentName": my_experiment.experiment_name,
    "TrialName": my_first_trial.trial_name
}

Vi kalder estimatorens tilpasningsmetode med den experiment_config, vi definerede tidligere, for at starte træningen.

%%time
estimator.fit(experiment_config=experiment_config)

Træningsjobbet tager cirka 5 minutter at gennemføre. Logfilerne viser disse linjer, der angiver filerne, der trækkes af DVC:

Running dvc pull command
A       train/california_train.csv
A       test/california_test.csv
A       validation/california_validation.csv
3 files added and 3 files fetched
Starting the training.
Found train files: ['/opt/ml/input/data/dataset/train/california_train.csv']
Found validation files: ['/opt/ml/input/data/dataset/train/california_train.csv']

Test 2: Generer flere filer til træning og validering

Vi skaber en ny dvc-trial-multi-files prøveversion og tilføje den til den nuværende DEMO-sagemaker-experiments-dvc eksperiment.

second_trial_name = "dvc-trial-multi-files"
try:
    my_second_trial = Trial.load(trial_name=second_trial_name)
    print("existing trial loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_second_trial = Trial.create(
            experiment_name=experiment_name,
            trial_name=second_trial_name,
        )
        print("new trial created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

Til forskel fra det første behandlingsscript opretter vi nu flere filer ud fra det originale datasæt til træning og validering og gemmer DVC-metadataene i en anden gren.

Du kan udforske det andet forbehandlings-Python-script på GitHub.

%%time

script_processor.run(
    code='./source_dir/preprocessing-experiment-multifiles.py',
    dependencies=['./source_dir/requirements.txt'],
    inputs=[ProcessingInput(source=s3_data_path, destination="/opt/ml/processing/input")],
    experiment_config=experiment_config,
    arguments=["--train-test-split-ratio", "0.1"]
)

Behandlingsjobbet tager cirka 5 minutter at fuldføre. Nu kan du se prøvedetaljerne for datasættet med flere filer.

Følgende skærmbilleder viser, hvor du kan finde de lagrede oplysninger i SageMaker Experiments i Prøve komponenter afsnittet i Studio UI. Bemærk værdierne for dvc-trial-multi-files in DVC_BRANCH, DVC_REPO_URLog data_commit_hash på den parametre fane.

Du kan også gennemgå input- og outputdetaljerne på Artifacts fane.

Vi træner nu på dvc-trial-multi-files afdeling. Når vi trækker data med DVC, bruger vi følgende datasætstruktur:

dataset
    |-- train
    |   |-- california_train_1.csv
    |   |-- california_train_2.csv
    |   |-- california_train_3.csv
    |   |-- california_train_4.csv
    |   |-- california_train_5.csv
    |-- test
    |   |-- california_test.csv
    |-- validation
    |   |-- california_validation_1.csv
    |   |-- california_validation_2.csv
    |   |-- california_validation_3.csv

På samme måde som vi gjorde før, opretter vi en ny Scikit-learn Estimator med prøvenavnet dvc-trial-multi-files og starte træningsjobbet.

%%time

estimator.fit(experiment_config=experiment_config)

Træningsjobbet tager cirka 5 minutter at gennemføre. På træningsjobloggene, der udlæses til notesbogen, kan du se disse linjer, der angiver filerne, der trækkes af DVC:

Running dvc pull command
A       validation/california_validation_2.csv
A       validation/california_validation_1.csv
A       validation/california_validation_3.csv
A       train/california_train_4.csv
A       train/california_train_5.csv
A       train/california_train_2.csv
A       train/california_train_3.csv
A       train/california_train_1.csv
A       test/california_test.csv
9 files added and 9 files fetched
Starting the training.
Found train files: ['/opt/ml/input/data/dataset/train/california_train_2.csv', '/opt/ml/input/data/dataset/train/california_train_5.csv', '/opt/ml/input/data/dataset/train/california_train_4.csv', '/opt/ml/input/data/dataset/train/california_train_1.csv', '/opt/ml/input/data/dataset/train/california_train_3.csv']
Found validation files: ['/opt/ml/input/data/dataset/validation/california_validation_2.csv', '/opt/ml/input/data/dataset/validation/california_validation_1.csv', '/opt/ml/input/data/dataset/validation/california_validation_3.csv']

Host din model i SageMaker

Når du har trænet din ML-model, kan du implementere den ved hjælp af SageMaker. For at implementere et vedvarende, real-time slutpunkt, der laver én forudsigelse ad gangen, bruger vi SageMaker real-time hosting-tjenester.

from sagemaker.serializers import CSVSerializer

predictor = estimator.deploy(1, "ml.t2.medium", serializer=CSVSerializer())

Først får vi det seneste testdatasæt lokalt på udviklingsnotesbogen i Studio. Til dette formål kan vi bruge dvc.api.read() for at indlæse de rå data, der blev gemt i Amazon S3 af SageMaker-behandlingsjobbet.

import io
import dvc.api

raw = dvc.api.read(
    "dataset/test/california_test.csv",
    repo=dvc_repo_url,
    rev=dvc_branch
)

Derefter forbereder vi dataene ved hjælp af Pandas, indlæser en test CSV-fil og ringer predictor.predict at påberåbe SageMaker-slutpunktet, der er oprettet tidligere, med data og få forudsigelser.

test = pd.read_csv(io.StringIO(raw), sep=",", header=None)
X_test = test.iloc[:, 1:].values
y_test = test.iloc[:, 0:1].values

predicted = predictor.predict(X_test)
for i in range(len(predicted)-1):
    print(f"predicted: {predicted[i]}, actual: {y_test[i][0]}")

Slet slutpunktet

Du bør slette endepunkter, når de ikke længere er i brug, fordi de faktureres efter det tidspunkt, der er implementeret (for mere information, se Amazon SageMaker-priser). Sørg for at slette slutpunktet for at undgå uventede omkostninger.

predictor.delete_endpoint()

Ryd op

Før du fjerner alle de ressourcer, du har oprettet, skal du sørge for, at alle apps er slettet fra data-scientist-dvc bruger, inklusive alle KernelGateway-apps, såvel som standard JupiterServer-appen.

Så kan du ødelægge AWS CDK-stakken ved at køre følgende kommando:

cdk destroy

Hvis du brugte et eksisterende domæne, skal du også køre følgende kommandoer:

# inject your DOMAIN_ID into the configuration file
sed -i 's/<your-sagemaker-studio-domain-id>/'"$DOMAIN_ID"'/' ../update-domain-no-custom-images.json
# update the sagemaker studio domain
aws --region ${REGION} sagemaker update-domain --cli-input-json file://../update-domain-no-custom-images.json

Konklusion

I dette indlæg gennemgik du et eksempel på, hvordan du sporer dine eksperimenter på tværs af kode, data, artefakter og metrikker ved at bruge SageMaker Experiments og SageMaker behandlings- og træningsjob i forbindelse med DVC. Vi lavede et Docker-billede indeholdende DVC, som var påkrævet for Studio som udviklingsnotesbog, og viste, hvordan du kan bruge behandlings- og træningsjob med DVC. Vi forberedte to versioner af dataene og brugte DVC til at administrere dem med Git. Derefter brugte du SageMaker Experiments til at spore behandlingen og træningen med de to versioner af dataene for at få en samlet visning af parametre, artefakter og metrikker i en enkelt rude. Endelig implementerede du modellen til et SageMaker-slutpunkt og brugte et testdatasæt fra den anden datasætversion til at påkalde SageMaker-endepunktet og få forudsigelser.

Som næste trin kan du udvide den eksisterende notesbog og introducere din egen feature engineering strategi og bruge DVC og SageMaker til at køre dine eksperimenter. Lad os bygge!

For yderligere læsning henvises til følgende ressourcer:

Om forfatterne

Paul DiFrancesco er løsningsarkitekt hos AWS. Han har erfaring inden for telekommunikation og software engineering. Han brænder for machine learning og fokuserer i øjeblikket på at bruge sin erfaring til at hjælpe kunder med at nå deres mål på AWS, især i diskussioner omkring MLOps. Uden for arbejdet nyder han at spille fodbold og læse.

Eitan Sela er en Machine Learning Specialist Solutions Architect med Amazon Web Services. Han arbejder sammen med AWS-kunder for at yde vejledning og teknisk assistance og hjælpe dem med at bygge og betjene maskinlæringsløsninger på AWS. I sin fritid nyder Eitan at jogge og læse de seneste maskinlæringsartikler.