Spåra dina ML-experiment från början med dataversionskontroll och Amazon SageMaker-experiment

Dataforskare arbetar ofta för att förstå effekterna av olika dataförbearbetnings- och funktionsteknikstrategier i kombination med olika modellarkitekturer och hyperparametrar. Att göra det kräver att du täcker stora parameterutrymmen iterativt, och det kan vara överväldigande att hålla reda på tidigare körda konfigurationer och resultat samtidigt som experimenten är reproducerbara.

Det här inlägget leder dig genom ett exempel på hur du spårar dina experiment över kod, data, artefakter och mätvärden med hjälp av Amazon SageMaker-experiment i samband med Dataversionskontroll (DVC). Vi visar hur du kan använda DVC sida vid sida med Amazon SageMaker bearbetnings- och utbildningsjobb. Vi tränar olika CatBoost-modeller på California bostadsdataset från StatLib-förvaret, och ändra holdout-strategier samtidigt som du håller reda på dataversionen med DVC. I varje enskilt experiment spårar vi in- och utmatningsartefakter, kod och mätvärden med SageMaker-experiment.

SageMaker-experiment

SageMaker Experiments är en AWS-tjänst för att spåra experiment med maskininlärning (ML). De SageMaker Experiment Python SDK är ett gränssnitt på hög nivå till den här tjänsten som hjälper dig att spåra experimentinformation med Python.

Målet med SageMaker Experiments är att göra det så enkelt som möjligt att skapa experiment, fylla dem med försök, lägga till spårnings- och härstamningsinformation och köra analyser över försök och experiment.

När vi diskuterar SageMaker-experiment hänvisar vi till följande begrepp:

• Experiment – En samling relaterade försök. Du lägger till försök till ett experiment som du vill jämföra tillsammans.
• Försök – En beskrivning av ett ML-arbetsflöde i flera steg. Varje steg i arbetsflödet beskrivs av en testkomponent.
• Provkomponent – En beskrivning av ett enstaka steg i ett ML-arbetsflöde, såsom datarensning, funktionsextraktion, modellträning eller modellutvärdering.
• Tracker – En Python-kontexthanterare för att logga information om en enskild testkomponent (till exempel parametrar, mätvärden eller artefakter).

Dataversionskontroll

Data Version Control (DVC) är en ny typ av programvara för dataversionshantering, arbetsflöde och experimenthantering som bygger på gå (även om det kan fungera fristående). DVC minskar klyftan mellan etablerade tekniska verktygsuppsättningar och datavetenskapliga behov, så att du kan dra nytta av nya pass samtidigt som man återanvänder befintlig kompetens och intuition.

Datavetenskapsexperimentdelning och samarbete kan göras genom ett vanligt Git-flöde (commits, förgrening, taggning, pull-förfrågningar) på samma sätt som det fungerar för mjukvaruingenjörer. Med Git och DVC kan datavetenskap och ML-team versionsexperimentera, hantera stora datamängder och göra projekt reproducerbara.

DVC har följande funktioner:

• DVC är en kostnadsfria , öppen källa kommandorad verktyg.
• DVC fungerar ovanpå Git repositories och har ett liknande kommandoradsgränssnitt och flöde som Git. DVC kan också fungera fristående, men utan versionshantering kapacitet.
• Dataversionering aktiveras genom att ersätta stora filer, datauppsättningskataloger, ML-modeller och så vidare med små metafiler (lätt att hantera med Git). Dessa platshållare pekar på originaldata, som är frikopplad från källkodshantering.
• Du kan använda lokal eller molnlagring för att lagra projektets data separat från dess kodbas. Så här kan datavetare överföra stora datamängder eller dela en GPU-utbildad modell med andra.
• DVC gör datavetenskapliga projekt reproducerbara genom att skapa lätta rörledningar genom att använda implicita beroendegrafer och genom att kodifiera de inblandade data och artefakter.
• DVC är plattformsoberoende. Det körs på alla större operativsystem (Linux, macOS och Windows) och fungerar oberoende av programmeringsspråken (Python, R, Julia, skalskript och så vidare) eller ML-bibliotek (Keras, TensorFlow, PyTorch, Scipy och mer) som används i projektet.
• DVC är snabb att installera och kräver ingen speciell infrastruktur, och det är inte heller beroende av API:er eller externa tjänster. Det är ett fristående CLI-verktyg.

SageMaker Experiment och DVC-exempel

Följande GitHub-exempel visar hur du använder DVC i SageMaker-miljön. Vi tittar särskilt på hur man bygger en anpassad bild med DVC-bibliotek installerade som standard för att tillhandahålla en konsekvent utvecklingsmiljö för dina datavetare i Amazon SageMaker Studio, och hur man kör DVC tillsammans med SageMaker hanterad infrastruktur för bearbetning och utbildning. Dessutom visar vi hur man berikar SageMaker-spårningsinformation med dataversionsinformation från DVC och visualiserar dem i Studio-konsolen.

Följande diagram illustrerar lösningsarkitekturen och arbetsflödet.

Bygg en anpassad Studio-avbildning med DVC redan installerat

I detta GitHub repository, förklarar vi hur man skapar en anpassad bild för Studio som redan har DVC installerat. Fördelen med att skapa en bild och göra den tillgänglig för alla Studio-användare är att det skapar en konsekvent miljö för Studio-användarna, som de också skulle kunna köra lokalt. Även om provet är baserat på AWS Cloud9, kan du också bygga behållaren på din lokala dator så länge du har Docker installerat och kört. Detta exempel är baserat på följande Dockerfile och miljö.yml. Den resulterande Docker-bilden lagras i Amazon Elastic Container Registry (Amazon EMR) i ditt AWS-konto. Se följande kod:

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

Nu kan du skapa en ny Studio-domän or uppdatera en befintlig Studio-domän som har tillgång till den nyskapade Docker-bilden.

Vi använder AWS Cloud Development Kit (AWS CDK) för att skapa följande resurser via AWS molnformation:

• En SageMaker-exekveringsroll med rätt behörigheter till din nya eller befintliga Studio-domän
• En SageMaker-bild och SageMaker-bildversion från Docker-bilden conda-env-dvc-kernel som vi skapade tidigare
• An AppImageConfig som anger hur kärn-gatewayen ska konfigureras
• En Studio-användare (data-scientist-dvc) med rätt SageMaker-exekveringsroll och den anpassade Studio-bilden som är tillgänglig för den

För detaljerade instruktioner, se Koppla en anpassad bild till SageMaker Studio.

Kör labbet

Utför följande steg för att köra labbet:

1. I Studio-domänen, starta Studio för data-scientist-dvc användaren.
2. Välj Git-ikonen och välj sedan Klona ett arkiv.
   
3. Ange URL:en till förvaret (https://github.com/aws-samples/amazon-sagemaker-experiments-dvc-demo) och välj klon.
4. I filläsaren väljer du amazon-sagemaker-experiments-dvc-demo förvaret.
5. Öppna dvc_sagemaker_script_mode.ipynb anteckningsbok.
6. För Anpassad bild, välj bilden conda-env-dvc-kärna.
7. Välja Välja.
   

Konfigurera DVC för dataversionering

Vi skapar en underkatalog där vi förbereder data: sagemaker-dvc-sample. Inom den här underkatalogen initierar vi ett nytt Git-förråd och ställer in fjärrkontrollen till ett förråd som vi skapar i AWS CodeCommit. Målet är att ha DVC-konfigurationer och filer för dataspårning versionerade i detta arkiv. Däremot erbjuder Git inbyggda möjligheter för att hantera delprojekt via till exempel git-undermoduler och git-underträd, och du kan utöka detta exempel till att använda något av de ovannämnda verktygen som bäst passar ditt arbetsflöde.

Den största fördelen med att använda CodeCommit med SageMaker i vårt fall är dess integration med AWS identitets- och åtkomsthantering (IAM) för autentisering och auktorisering, vilket innebär att vi kan använda IAM-roller för att pusha och dra data utan att behöva hämta inloggningsuppgifter (eller SSH-nycklar). Genom att ställa in lämpliga behörigheter för SageMaker-exekveringsrollen kan Studio-anteckningsboken och SageMakers utbildnings- och bearbetningsjobb interagera säkert med CodeCommit.

Även om du kan ersätta CodeCommit med vilken annan källkontrolltjänst som helst, som GitHub, Gitlab eller Bitbucket, måste du överväga hur du hanterar autentiseringsuppgifterna för ditt system. En möjlighet är att lagra dessa referenser på AWS Secrets Manager och hämta dem under körning från Studio-anteckningsboken såväl som från SageMakers bearbetnings- och utbildningsjobb.

Bearbeta och träna med DVC och SageMaker

I det här avsnittet utforskar vi två olika tillvägagångssätt för att tackla vårt problem och hur vi kan hålla reda på de två testerna med SageMaker Experiments enligt den konceptuella arkitektur på hög nivå som vi visade dig tidigare.

Ställ in ett SageMaker-experiment

För att spåra detta test i SageMaker måste vi skapa ett experiment. Vi måste också definiera försöket inom experimentet. För enkelhetens skull överväger vi bara ett försök för experimentet, men du kan ha hur många försök som helst inom ett experiment, till exempel om du vill testa olika algoritmer.

Vi skapar ett experiment som heter DEMO-sagemaker-experiments-dvc med två försök, dvc-trial-single-file och dvc-trial-multi-files, var och en representerar en annan version av datamängden.

Låt oss skapa DEMO-sagemaker-experiments-dvc experimentera:

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: Generera enskilda filer för utbildning och validering

I det här avsnittet skapar vi ett bearbetningsskript som hämtar rådata direkt från Amazon enkel lagringstjänst (Amazon S3) som ingång; bearbetar det för att skapa tåg-, validerings- och testdatauppsättningarna; och lagrar resultaten tillbaka till Amazon S3 med DVC. Dessutom visar vi hur du kan spåra output-artefakter som genereras av DVC med SageMaker när du kör bearbetnings- och utbildningsjobb och via SageMaker-experiment.

Först skapar vi dvc-trial-single-file testversion och lägg till den i DEMO-sagemaker-experiments-dvc experimentera. Genom att göra det håller vi alla testkomponenter relaterade till detta test organiserade på ett meningsfullt sätt.

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

Använd DVC i ett SageMaker-bearbetningsjobb för att skapa versionen av en enda fil

I det här avsnittet skapar vi ett bearbetningsskript som hämtar rådata direkt från Amazon S3 som indata med hjälp av SageMakers hanterade dataladdningskapacitet; bearbetar det för att skapa tåg-, validerings- och testdatauppsättningarna; och lagrar resultaten tillbaka till Amazon S3 med DVC. Det är mycket viktigt att förstå att när vi använder DVC för att lagra data till Amazon S3 (eller hämta data från Amazon S3), förlorar vi SageMaker hanterade dataladdningsmöjligheter, vilket potentiellt kan ha en inverkan på prestanda och kostnader för våra bearbetnings- och utbildningsjobb , speciellt när du arbetar med mycket stora datamängder. För mer information om de olika SageMakers inbyggda inmatningsfunktioner, se Få tillgång till utbildningsdata.

Slutligen förenar vi DVC-spårningsmöjligheter med SageMaker-spårningsfunktioner när vi kör bearbetningsjobb via SageMaker Experiments.

Bearbetningsskriptet förväntar sig adressen till Git-förvaret och grenen vi vill skapa för att lagra DVC-metadata som skickas via miljövariabler. Själva datamängderna lagras i Amazon S3 av DVC. Även om miljövariabler spåras automatiskt i SageMaker Experiments och är synliga i testkomponentens parametrar, kanske vi vill berika testkomponenterna med ytterligare information, som sedan blir tillgänglig för visualisering i Studio UI med ett spårningsobjekt. I vårt fall inkluderar testkomponenternas parametrar följande:

• DVC_REPO_URL
• DVC_BRANCH
• USER
• data_commit_hash
• train_test_split_ratio

Förbearbetningsskriptet klonar Git-förvaret; genererar tåg-, validerings- och testdatauppsättningarna; och synkroniserar den med DVC. Som nämnts tidigare, när vi använder DVC, kan vi inte dra fördel av inbyggda SageMakers dataladdningsfunktioner. Förutom de prestationspåföljder vi kan drabbas av på stora datamängder, förlorar vi också de automatiska spårningsmöjligheterna för utdataartefakterna. Men tack vare spåraren och DVC Python API kan vi kompensera för dessa brister, hämta sådan information under körning och lagra den i testkomponenten med liten ansträngning. Mervärdet genom att göra det är att ha en enda vy av in- och utmatningsartefakterna som hör till detta specifika bearbetningsjobb.

Det fullständiga förbearbetningsskriptet för Python finns tillgängligt 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 ger oss möjligheten att köra vårt bearbetningsskript på containerbilder som hanteras av AWS som är optimerade för att köras på AWS-infrastrukturen. Om vårt skript kräver ytterligare beroenden kan vi tillhandahålla en requirements.txt fil. När vi startar bearbetningsjobbet använder SageMaker pip-install för att installera alla bibliotek vi behöver (till exempel DVC-relaterade bibliotek). Om du behöver ha en hårdare kontroll av alla bibliotek installerade på containrarna kan du ta med din egen container i SageMaker t.ex. bearbetning och utbildning.

Vi har nu alla ingredienser för att köra vårt SageMaker-bearbetningsjobb:

• Ett bearbetningsskript som kan bearbeta flera argument (--train-test-split-ratio) och två miljövariabler (DVC_REPO_URL och DVC_BRANCH)
• A requiremets.txt fil
• Ett Git-förråd (i CodeCommit)
• Ett SageMaker-experiment och försök

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ör sedan bearbetningsjobbet med preprocessing-experiment.py manus, experiment_config, dvc_repo_urloch dvc_branch vi definierade tidigare.

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

Bearbetningsjobbet tar cirka 5 minuter att slutföra. Nu kan du se testdetaljerna för datauppsättningen med en enda fil.

Följande skärmdump visar var du kan hitta den lagrade informationen i Studio. Notera värdena för dvc-trial-single-file in DVC_BRANCH, DVC_REPO_URLoch data_commit_hash på parametrar fliken.

Notera också in- och utdatadetaljerna på Artefakter fliken.

Skapa en estimator och anpassa modellen med en fildataversion

För att använda DVC-integration i ett SageMaker-utbildningsjobb klarar vi en dvc_repo_url och dvc_branch som miljövariabler när du skapar Estimator-objektet.

Vi tränar på dvc-trial-single-file gren först.

När vi hämtar data med DVC använder vi följande datauppsättningsstruktur:

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

Nu skapar vi en Scikit-learn Estimator med hjälp av SageMaker Python SDK. Detta gör att vi kan specificera följande:

• Sökvägen till Python-källfilen, som bör köras som ingångspunkt till träning.
• IAM-rollen som kontrollerar behörigheter för åtkomst till Amazon S3- och CodeCommit-data och för att köra SageMaker-funktioner.
• En lista över ordböcker som definierar de mått som används för att utvärdera utbildningsjobben.
• Antalet och typen av träningstillfällen. Vi använder en ml.m5.stor instans.
• Hyperparametrar som används för träning.
• Miljövariabler att använda under träningsjobbet. Vi använder DVC_REPO_URL, DVC_BRANCHoch 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 anropar anpassningsmetoden för Estimatorn med experiment_config som vi definierade tidigare för att starta träningen.

%%time
estimator.fit(experiment_config=experiment_config)

Utbildningsjobbet tar cirka 5 minuter att genomföra. Loggarna visar dessa rader, vilket indikerar filerna som hämtas 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: Generera flera filer för utbildning och validering

Vi skapar en ny dvc-trial-multi-files testversion och lägg till den i strömmen DEMO-sagemaker-experiments-dvc experimentera.

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

Till skillnad från det första bearbetningsskriptet skapar vi nu flera filer från den ursprungliga datamängden för träning och validering och lagrar DVC-metadata i en annan gren.

Du kan utforska det andra förbearbetande Python-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"]
)

Bearbetningsjobbet tar cirka 5 minuter att slutföra. Nu kan du se testdetaljerna för datauppsättningen med flera filer.

Följande skärmbilder visar var du kan hitta den lagrade informationen inom SageMaker Experiments i Testkomponenter avsnittet i Studio UI. Notera värdena för dvc-trial-multi-files in DVC_BRANCH, DVC_REPO_URLoch data_commit_hash på parametrar fliken.

Du kan också granska in- och utdatadetaljerna på Artefakter fliken.

Vi tränar nu på dvc-trial-multi-files gren. När vi hämtar data med DVC använder vi följande datauppsättningsstruktur:

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å samma sätt som vi gjorde tidigare skapar vi en ny Scikit-learn Estimator med testnamnet dvc-trial-multi-files och påbörja träningsjobbet.

%%time

estimator.fit(experiment_config=experiment_config)

Utbildningsjobbet tar cirka 5 minuter att genomföra. På träningsjobbloggarna som matas ut till notebook-datorn kan du se dessa linjer, som indikerar filerna som hämtas 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 din modell i SageMaker

När du har tränat din ML-modell kan du distribuera den med SageMaker. För att distribuera en beständig, realtidsslutpunkt som gör en förutsägelse åt gången, använder vi SageMaker värdtjänster i realtid.

from sagemaker.serializers import CSVSerializer

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

Först får vi den senaste testdatauppsättningen lokalt på utvecklingsnotebooken i Studio. För detta ändamål kan vi använda dvc.api.read() för att ladda rådata som lagrades i Amazon S3 av SageMaker-bearbetningsjobbet.

import io
import dvc.api

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

Sedan förbereder vi data med Pandas, laddar en CSV-testfil och ringer predictor.predict för att anropa SageMaker-slutpunkten som skapats tidigare, med data, och få förutsägelser.

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

Ta bort slutpunkten

Du bör ta bort slutpunkter när de inte längre används, eftersom de faktureras av den tid som distribueras (för mer information, se Amazon SageMaker Prissättning). Se till att ta bort slutpunkten för att undvika oväntade kostnader.

predictor.delete_endpoint()

Städa upp

Innan du tar bort alla resurser du skapat, se till att alla appar har tagits bort från data-scientist-dvc användare, inklusive alla KernelGateway-appar, såväl som standardappen JupiterServer.

Sedan kan du förstöra AWS CDK-stacken genom att köra följande kommando:

cdk destroy

Om du använde en befintlig domän, kör även följande kommandon:

# 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

Slutsats

I det här inlägget gick du igenom ett exempel på hur du spårar dina experiment över kod, data, artefakter och mätvärden genom att använda SageMaker-experiment och SageMaker-bearbetnings- och utbildningsjobb i kombination med DVC. Vi skapade en Docker-bild innehållande DVC, som krävdes för Studio som utvecklingsnotebook, och visade hur du kan använda bearbetnings- och utbildningsjobb med DVC. Vi förberedde två versioner av data och använde DVC för att hantera den med Git. Sedan använde du SageMaker Experiments för att spåra bearbetningen och träningen med de två versionerna av data för att få en enhetlig bild av parametrar, artefakter och mätvärden i en enda glasruta. Slutligen distribuerade du modellen till en SageMaker-slutpunkt och använde en testdatauppsättning från den andra datauppsättningsversionen för att anropa SageMaker-slutpunkten och få förutsägelser.

Som nästa steg kan du utöka den befintliga anteckningsboken och introducera din egen strategi för funktionsutveckling och använda DVC och SageMaker för att köra dina experiment. Låt oss bygga!

För ytterligare läsning, se följande resurser:

Om författarna

Paolo Di Francesco är lösningsarkitekt på AWS. Han har erfarenhet av telekommunikation och mjukvaruteknik. Han brinner för maskininlärning och fokuserar för närvarande på att använda sin erfarenhet för att hjälpa kunder att nå sina mål på AWS, särskilt i diskussioner kring MLOps. Utanför jobbet tycker han om att spela fotboll och läsa.

Eitan Sela är en lösningsarkitekt för maskininlärning med Amazon Web Services. Han arbetar med AWS-kunder för att ge vägledning och teknisk assistans, och hjälpa dem att bygga och driva maskininlärningslösningar på AWS. På fritiden tycker Eitan om att jogga och läsa de senaste maskininlärningsartiklarna.