Spor ML-eksperimentene dine fra ende til annen med dataversjonskontroll og Amazon SageMaker-eksperimenter

Dataforskere jobber ofte med å forstå effekten av ulike dataforbehandlings- og funksjonsteknikkstrategier i kombinasjon med ulike modellarkitekturer og hyperparametre. Å gjøre det krever at du dekker store parameterrom iterativt, og det kan være overveldende å holde styr på tidligere kjørte konfigurasjoner og resultater samtidig som eksperimenter er reproduserbare.

Dette innlegget leder deg gjennom et eksempel på hvordan du sporer eksperimentene dine på tvers av kode, data, artefakter og beregninger ved å bruke Amazon SageMaker-eksperimenter i forbindelse med Dataversjonskontroll (DVC). Vi viser hvordan du kan bruke DVC side om side med Amazon SageMaker bearbeidings- og opplæringsjobber. Vi trener forskjellige CatBoost-modeller på California boligdatasettet fra StatLib-depot, og endre holdout-strategier mens du holder styr på dataversjonen med DVC. I hvert enkelt eksperiment sporer vi input og output artefakter, kode og beregninger ved hjelp av SageMaker Experiments.

SageMaker eksperimenter

SageMaker Experiments er en AWS-tjeneste for sporing av maskinlæringseksperimenter (ML). De SageMaker Experiments Python SDK er et grensesnitt på høyt nivå til denne tjenesten som hjelper deg med å spore eksperimentinformasjon ved hjelp av Python.

Målet med SageMaker Experiments er å gjøre det så enkelt som mulig å lage eksperimenter, fylle dem med forsøk, legge til sporings- og avstamningsinformasjon og kjøre analyser på tvers av forsøk og eksperimenter.

Når vi diskuterer SageMaker-eksperimenter, refererer vi til følgende konsepter:

• Eksperiment – En samling relaterte forsøk. Du legger til forsøk i et eksperiment som du vil sammenligne sammen.
• Trial – En beskrivelse av en flertrinns ML-arbeidsflyt. Hvert trinn i arbeidsflyten er beskrevet av en prøvekomponent.
• Prøvekomponent – En beskrivelse av et enkelt trinn i en ML-arbeidsflyt, for eksempel datarensing, funksjonsutvinning, modellopplæring eller modellevaluering.
• Tracker – En Python-kontekstbehandling for å logge informasjon om en enkelt prøvekomponent (for eksempel parametere, beregninger eller artefakter).

Dataversjonskontroll

Data Version Control (DVC) er en ny type dataversjons-, arbeidsflyt- og eksperimentadministrasjonsprogramvare som bygger på gå (selv om det kan fungere frittstående). DVC reduserer gapet mellom etablerte tekniske verktøysett og datavitenskapelige behov, slik at du kan dra nytte av nye egenskaper samtidig som man gjenbruker eksisterende ferdigheter og intuisjon.

Deling og samarbeid med datavitenskapelige eksperimenter kan gjøres gjennom en vanlig Git-flyt (forpliktelser, forgrening, tagging, pull-forespørsler) på samme måte som det fungerer for programvareingeniører. Med Git og DVC kan datavitenskap og ML-team versjonseksperimenter, administrere store datasett og gjøre prosjekter reproduserbare.

DVC har følgende funksjoner:

• DVC er en gratis, åpen kilde kommandolinje verktøyet.
• DVC fungerer på toppen av Git-repositories og har et lignende kommandolinjegrensesnitt og flyt som Git. DVC kan også fungere frittstående, men uten versjonskontroll evner.
• Dataversjon er aktivert ved å erstatte store filer, datasettkataloger, ML-modeller og så videre med små metafiler (lett å håndtere med Git). Disse plassholderne peker på de originale dataene, som er frikoblet fra kildekodeadministrasjonen.
• Du kan bruke lokal eller skylagring for å lagre prosjektets data atskilt fra kodebasen. Slik kan dataforskere overføre store datasett eller dele en GPU-trent modell med andre.
• DVC gjør datavitenskapelige prosjekter reproduserbare ved å lage lette rørledninger ved å bruke implisitte avhengighetsgrafer, og ved å kodifisere data og artefakter som er involvert.
• DVC er plattformagnostisk. Den kjører på alle større operativsystemer (Linux, macOS og Windows), og fungerer uavhengig av programmeringsspråkene (Python, R, Julia, shell-skript og så videre) eller ML-biblioteker (Keras, TensorFlow, PyTorch, Scipy og mer) brukt i prosjektet.
• DVC er rask til installere og krever ikke spesiell infrastruktur, og er heller ikke avhengig av APIer eller eksterne tjenester. Det er et frittstående CLI-verktøy.

SageMaker-eksperimenter og DVC-eksempel

Følgende GitHub-eksempel viser hvordan du bruker DVC i SageMaker-miljøet. Spesielt ser vi på hvordan du bygger et tilpasset bilde med DVC-biblioteker installert som standard for å gi et konsistent utviklingsmiljø til dataforskerne dine i Amazon SageMaker Studio, og hvordan du kjører DVC sammen med SageMaker administrert infrastruktur for prosessering og opplæring. Videre viser vi hvordan du beriker SageMaker-sporingsinformasjon med dataversjonsinformasjon fra DVC, og visualiserer dem i Studio-konsollen.

Følgende diagram illustrerer løsningsarkitekturen og arbeidsflyten.

Bygg et tilpasset Studio-bilde med DVC allerede installert

I dette GitHub repository, forklarer vi hvordan du lager et tilpasset bilde for Studio som allerede har DVC installert. Fordelen med å lage et bilde og gjøre det tilgjengelig for alle Studio-brukere er at det skaper et konsistent miljø for Studio-brukerne, som de også kan kjøre lokalt. Selv om utvalget er basert på AWS Cloud9, kan du også bygge beholderen på din lokale maskin så lenge du har Docker installert og kjører. Denne prøven er basert på følgende Dockerfile og miljø.yml. Det resulterende Docker-bildet lagres i Amazon Elastic Container Registry (Amazon EMR) i AWS-kontoen din. 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 nå opprette et nytt Studio-domene or oppdatere et eksisterende Studio-domene som har tilgang til det nyopprettede Docker-bildet.

Vi bruker AWS skyutviklingssett (AWS CDK) for å opprette følgende ressurser via AWS skyformasjon:

• En SageMaker-utførelsesrolle med de riktige tillatelsene til ditt nye eller eksisterende Studio-domene
• Et SageMaker-bilde og SageMaker-bildeversjon fra Docker-bildet conda-env-dvc-kernel som vi laget tidligere
• An AppImageConfig som spesifiserer hvordan kjernegatewayen skal konfigureres
• En Studio-bruker (data-scientist-dvc) med riktig SageMaker-utførelsesrolle og det tilpassede Studio-bildet som er tilgjengelig for det

For detaljerte instruksjoner, se Knytt et tilpasset bilde til SageMaker Studio.

Kjør laboratoriet

For å kjøre laboratoriet, fullfør følgende trinn:

1. I Studio-domenet starter du Studio for data-scientist-dvc bruker.
2. Velg Git-ikonet, og velg deretter Klone et depot.
   
3. Skriv inn nettadressen til depotet (https://github.com/aws-samples/amazon-sagemaker-experiments-dvc-demo) og velg Clone.
4. I filleseren velger du amazon-sagemaker-experiments-dvc-demo oppbevaringssted.
5. Åpne dvc_sagemaker_script_mode.ipynb notisbok.
6. Til Egendefinert bilde, velg bildet conda-env-dvc-kernel.
7. Velg Plukke ut.
   

Konfigurer DVC for dataversjon

Vi lager en underkatalog der vi forbereder dataene: sagemaker-dvc-sample. Innenfor denne underkatalogen initialiserer vi et nytt Git-depot og setter fjernkontrollen til et depot vi oppretter i AWS CodeCommit. Målet er å ha DVC-konfigurasjoner og filer for datasporing versjonert i dette depotet. Git tilbyr imidlertid innfødte muligheter for å administrere underprosjekter via for eksempel git-undermoduler og git-undertrær, og du kan utvide denne prøven til å bruke hvilket som helst av de nevnte verktøyene som passer best til arbeidsflyten din.

Den største fordelen med å bruke CodeCommit med SageMaker i vårt tilfelle er integrasjonen med AWS identitets- og tilgangsadministrasjon (IAM) for autentisering og autorisasjon, noe som betyr at vi kan bruke IAM-roller til å pushe og trekke data uten å måtte hente legitimasjon (eller SSH-nøkler). Ved å angi de riktige tillatelsene for SageMaker-utførelsesrollen kan Studio-notatboken og SageMaker-trenings- og prosesseringsjobben samhandle sikkert med CodeCommit.

Selv om du kan erstatte CodeCommit med en hvilken som helst annen kildekontrolltjeneste, for eksempel GitHub, Gitlab eller Bitbucket, må du vurdere hvordan du håndterer legitimasjonen for systemet ditt. En mulighet er å lagre disse legitimasjonene på AWS Secrets Manager og hente dem på kjøretid fra Studio-notisboken så vel som fra SageMaker-behandlings- og opplæringsjobbene.

Behandle og trene med DVC og SageMaker

I denne delen utforsker vi to forskjellige tilnærminger for å takle problemet vårt og hvordan vi kan holde styr på de to testene ved å bruke SageMaker Experiments i henhold til den konseptuelle arkitekturen på høyt nivå vi viste deg tidligere.

Sett opp et SageMaker-eksperiment

For å spore denne testen i SageMaker, må vi lage et eksperiment. Vi må også definere forsøket i eksperimentet. For enkelhets skyld vurderer vi bare ett forsøk for eksperimentet, men du kan ha et hvilket som helst antall forsøk i et eksperiment, for eksempel hvis du vil teste forskjellige algoritmer.

Vi lager et eksperiment som heter DEMO-sagemaker-experiments-dvc med to forsøk, dvc-trial-single-file og dvc-trial-multi-files, som hver representerer en annen versjon av datasettet.

La oss lage 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 enkeltfiler for opplæring og validering

I denne delen lager vi et behandlingsskript som henter rådataene direkte fra Amazon enkel lagringstjeneste (Amazon S3) som inngang; behandler det for å lage tog-, validerings- og testdatasett; og lagrer resultatene tilbake til Amazon S3 ved hjelp av DVC. Videre viser vi hvordan du kan spore utdata-artefakter generert av DVC med SageMaker når du kjører prosesserings- og treningsjobber og via SageMaker-eksperimenter.

Først lager vi dvc-trial-single-file prøveversjon og legg den til DEMO-sagemaker-experiments-dvc eksperiment. Ved å gjøre det holder vi alle prøvekomponenter relatert til denne testen organisert på en meningsfull måte.

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

Bruk DVC i en SageMaker-behandlingsjobb for å lage enkeltfilversjonen

I denne delen lager vi et behandlingsskript som henter rådataene direkte fra Amazon S3 som input ved å bruke den administrerte datainnlastingsfunksjonen til SageMaker; behandler det for å lage tog-, validerings- og testdatasett; og lagrer resultatene tilbake til Amazon S3 ved hjelp av DVC. Det er veldig viktig å forstå at når vi bruker DVC til å lagre data til Amazon S3 (eller hente data fra Amazon S3), mister vi SageMaker-administrerte datainnlastingsfunksjoner, noe som potensielt kan ha en innvirkning på ytelsen og kostnadene for våre behandlings- og opplæringsjobber , spesielt når du arbeider med svært store datasett. For mer informasjon om de forskjellige SageMaker native input-modusfunksjonene, se Få tilgang til treningsdata.

Til slutt forener vi DVC-sporingsfunksjoner med SageMaker-sporingsfunksjoner når vi kjører behandlingsjobber via SageMaker Experiments.

Behandlingsskriptet forventer adressen til Git-depotet og grenen vi ønsker å lage for å lagre DVC-metadataene som sendes via miljøvariabler. Selve datasettene er lagret i Amazon S3 av DVC. Selv om miljøvariabler spores automatisk i SageMaker Experiments og er synlige i prøvekomponentparameterne, kan det være lurt å berike prøvekomponentene med ytterligere informasjon, som deretter blir tilgjengelig for visualisering i Studio-grensesnittet ved hjelp av et sporingsobjekt. I vårt tilfelle inkluderer prøvekomponentparameterne følgende:

• DVC_REPO_URL
• DVC_BRANCH
• USER
• data_commit_hash
• train_test_split_ratio

Forbehandlingsskriptet kloner Git-depotet; genererer tog-, validerings- og testdatasett; og synkroniserer den ved hjelp av DVC. Som nevnt tidligere, når vi bruker DVC, kan vi ikke dra nytte av native SageMaker-datalastingsfunksjoner. Bortsett fra ytelsesstraffene vi kan lide på store datasett, mister vi også de automatiske sporingsmulighetene for utdataartefaktene. Men takket være trackeren og DVC Python API kan vi kompensere for disse manglene, hente slik informasjon under kjøretid og lagre den i prøvekomponenten med liten innsats. Merverdien ved å gjøre det er å ha én oversikt over input- og output-artefakter som tilhører denne spesifikke behandlingsjobben.

Det fullstendige forbehandlingen av Python-skriptet er tilgjengelig 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 gir oss muligheten til å kjøre vårt behandlingsskript på containerbilder administrert av AWS som er optimalisert for å kjøre på AWS-infrastrukturen. Hvis skriptet vårt krever ytterligere avhengigheter, kan vi levere en requirements.txt fil. Når vi starter prosesseringsjobben bruker SageMaker pip-install å installere alle bibliotekene vi trenger (for eksempel DVC-relaterte biblioteker). Dersom du trenger å ha en tettere kontroll på alle biblioteker installert på containerne, kan du ta med egen container i SageMaker, f.eks. prosessering og trening.

Vi har nå alle ingrediensene for å kjøre SageMaker-behandlingsjobben vår:

• Et behandlingsskript som kan behandle flere argumenter (--train-test-split-ratio) og to miljøvariabler (DVC_REPO_URL og DVC_BRANCH)
• A requiremets.txt fil
• Et Git-depot (i CodeCommit)
• Et SageMaker-eksperiment og utprøving

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 kjører deretter behandlingsjobben med preprocessing-experiment.py manus, experiment_config, dvc_repo_urlog dvc_branch vi definerte 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"]
)

Behandlingsjobben tar omtrent 5 minutter å fullføre. Nå kan du se prøvedetaljene for enkeltfildatasettet.

Følgende skjermbilde viser hvor du kan finne den lagrede informasjonen i Studio. Legg merke til verdiene for dvc-trial-single-file in DVC_BRANCH, DVC_REPO_URLog data_commit_hash på parametere fanen.

Legg også merke til inngangs- og utdatadetaljene på Artifacts fanen.

Lag en estimator og tilpass modellen med enkeltfildataversjon

For å bruke DVC-integrasjon i en SageMaker-treningsjobb, består vi en dvc_repo_url og dvc_branch som miljøvariabler når du oppretter Estimator-objektet.

Vi trener på dvc-trial-single-file gren først.

Når vi henter data med DVC, bruker vi følgende datasettstruktur:

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

Nå lager vi en Scikit-learn Estimator ved å bruke SageMaker Python SDK. Dette lar oss spesifisere følgende:

• Banen til Python-kildefilen, som skal kjøres som inngangspunkt til trening.
• IAM-rollen som kontrollerer tillatelser for å få tilgang til Amazon S3- og CodeCommit-data og kjøre SageMaker-funksjoner.
• En liste over ordbøker som definerer beregningene som brukes til å evaluere treningsjobbene.
• Antall og type treningsinstanser. Vi bruker én ml.m5.stor instans.
• Hyperparametere som brukes til trening.
• Miljøvariabler som skal brukes under treningsjobben. Vi bruker 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 kaller tilpasningsmetoden til Estimator med experiment_config vi definerte tidligere for å starte treningen.

%%time
estimator.fit(experiment_config=experiment_config)

Opplæringsjobben tar ca. 5 minutter å fullføre. Loggene viser disse linjene, og indikerer filene trukket av 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 for opplæring og validering

Vi lager en ny dvc-trial-multi-files prøveversjon og legg den til gjeldende 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 forskjell fra det første behandlingsskriptet, lager vi nå flere filer fra det originale datasettet for opplæring og validering og lagrer DVC-metadataene i en annen gren.

Du kan utforske det andre forbehandlingspython-skriptet 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"]
)

Behandlingsjobben tar omtrent 5 minutter å fullføre. Nå kan du se prøvedetaljene for datasettet med flere filer.

Følgende skjermbilder viser hvor du kan finne den lagrede informasjonen i SageMaker Experiments i Prøvekomponenter delen i Studio UI. Legg merke til verdiene for dvc-trial-multi-files in DVC_BRANCH, DVC_REPO_URLog data_commit_hash på parametere fanen.

Du kan også se gjennom inngangs- og utdatadetaljene på Artifacts fanen.

Vi trener nå på dvc-trial-multi-files gren. Når vi henter data med DVC, bruker vi følgende datasettstruktur:

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åte som vi gjorde før, oppretter vi en ny Scikit-learn Estimator med prøvenavnet dvc-trial-multi-files og starte treningsjobben.

%%time

estimator.fit(experiment_config=experiment_config)

Opplæringsjobben tar ca. 5 minutter å fullføre. På treningsjobbloggene som sendes ut til den bærbare datamaskinen, kan du se disse linjene, som indikerer filene hentet av 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 modellen din i SageMaker

Etter at du har trent ML-modellen din, kan du distribuere den ved hjelp av SageMaker. For å distribuere et vedvarende endepunkt i sanntid som gir én prediksjon om gangen, bruker vi SageMaker sanntids hostingtjenester.

from sagemaker.serializers import CSVSerializer

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

Først får vi det siste testdatasettet lokalt på utviklingsnotisboken i Studio. Til dette formålet kan vi bruke dvc.api.read() for å laste inn rådataene som ble lagret i Amazon S3 av SageMaker-behandlingsjobben.

import io
import dvc.api

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

Deretter forbereder vi dataene ved hjelp av Pandas, laster inn en test CSV-fil og ringer predictor.predict å påkalle SageMaker-endepunktet opprettet tidligere, med data, og få spådommer.

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

Slett endepunktet

Du bør slette endepunkter når de ikke lenger er i bruk, fordi de faktureres etter utplassert tidspunkt (for mer informasjon, se Amazon SageMaker-priser). Sørg for å slette endepunktet for å unngå uventede kostnader.

predictor.delete_endpoint()

Rydd opp

Før du fjerner alle ressursene du opprettet, sørg for at alle appene er slettet fra data-scientist-dvc bruker, inkludert alle KernelGateway-apper, samt standard JupiterServer-appen.

Deretter kan du ødelegge AWS CDK-stakken ved å kjøre følgende kommando:

cdk destroy

Hvis du brukte et eksisterende domene, kjør også 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

konklusjonen

I dette innlegget gikk du gjennom et eksempel på hvordan du kan spore eksperimentene dine på tvers av kode, data, artefakter og beregninger ved å bruke SageMaker Experiments og SageMaker prosesserings- og opplæringsjobber i forbindelse med DVC. Vi laget et Docker-bilde som inneholder DVC, som var nødvendig for Studio som utviklingsnotisbok, og viste hvordan du kan bruke prosesserings- og opplæringsjobber med DVC. Vi forberedte to versjoner av dataene og brukte DVC for å administrere dem med Git. Deretter brukte du SageMaker Experiments til å spore behandlingen og treningen med de to versjonene av dataene for å få en enhetlig visning av parametere, artefakter og beregninger i en enkelt glassrute. Til slutt distribuerte du modellen til et SageMaker-endepunkt og brukte et testdatasett fra den andre datasettversjonen for å påkalle SageMaker-endepunktet og få spådommer.

Som neste trinn kan du utvide den eksisterende notatboken og introdusere din egen funksjonsteknologiske strategi og bruke DVC og SageMaker til å kjøre eksperimentene dine. La oss bygge!

For ytterligere lesing, se følgende ressurser:

Om forfatterne

Paolo Di Francesco er løsningsarkitekt i AWS. Han har erfaring innen telekommunikasjon og programvareutvikling. Han er lidenskapelig opptatt av maskinlæring og fokuserer for tiden på å bruke sin erfaring til å hjelpe kundene med å nå sine mål på AWS, spesielt i diskusjoner rundt MLOps. Utenom jobben liker han å spille fotball og lese.

Eitan Sela er en maskinlæringsspesialist løsningsarkitekt med Amazon Web Services. Han jobber med AWS-kunder for å gi veiledning og teknisk assistanse, og hjelpe dem med å bygge og drifte maskinlæringsløsninger på AWS. På fritiden liker Eitan å jogge og lese de siste maskinlæringsartiklene.