Volg uw ML-experimenten van begin tot eind met Data Version Control en Amazon SageMaker Experiments

Datawetenschappers werken vaak aan het begrijpen van de effecten van verschillende datavoorbewerkings- en feature-engineeringstrategieën in combinatie met verschillende modelarchitecturen en hyperparameters. Hiervoor moet u grote parameterruimten iteratief afdekken, en het kan overweldigend zijn om eerder uitgevoerde configuraties en resultaten bij te houden terwijl experimenten reproduceerbaar blijven.

Dit bericht leidt u door een voorbeeld van hoe u uw experimenten kunt volgen in code, gegevens, artefacten en statistieken met behulp van Amazon SageMaker-experimenten in combinatie met Gegevensversiebeheer (DVC). We laten zien hoe u DVC naast elkaar kunt gebruiken: Amazon Sage Maker verwerkings- en opleidingstaken. We trainen verschillende CatBoost-modellen op de California-behuizingsdataset van de StatLib-repository, en verander holdout-strategieën terwijl u de gegevensversie bijhoudt met DVC. In elk afzonderlijk experiment volgen we invoer- en uitvoerartefacten, code en statistieken met behulp van SageMaker-experimenten.

SageMaker-experimenten

SageMaker Experiments is een AWS-service voor het volgen van machine learning-experimenten (ML). De SageMaker Experimenteert Python SDK is een interface op hoog niveau voor deze service waarmee u experimentinformatie kunt volgen met behulp van Python.

Het doel van SageMaker Experiments is om het zo eenvoudig mogelijk te maken om experimenten te maken, ze te vullen met proeven, tracking- en afstammingsinformatie toe te voegen en analyses uit te voeren over proeven en experimenten.

Bij het bespreken van SageMaker-experimenten verwijzen we naar de volgende concepten:

• Experiment – Een verzameling gerelateerde proeven. U voegt proeven toe aan een experiment dat u met elkaar wilt vergelijken.
• proces – Een beschrijving van een multi-step ML-workflow. Elke stap in de workflow wordt beschreven door een proefcomponent.
• Proefcomponent – Een beschrijving van een enkele stap in een ML-workflow, zoals het opschonen van gegevens, het extraheren van functies, modeltraining of modelevaluatie.
• Tracker – Een Python-contextmanager voor het loggen van informatie over een enkele proefcomponent (bijvoorbeeld parameters, metrieken of artefacten).

Gegevensversiebeheer

Data Version Control (DVC) is een nieuw type software voor gegevensversiebeheer, workflow en experimentbeheer dat voortbouwt op: Git (hoewel het ook stand-alone kan werken). DVC verkleint de kloof tussen gevestigde technische toolsets en datawetenschapsbehoeften, zodat u kunt profiteren van nieuwe functionaliteiten terwijl bestaande vaardigheden en intuïtie worden hergebruikt.

Het delen en samenwerken van datawetenschapsexperimenten kan via een reguliere Git-stroom (commits, branching, tagging, pull-verzoeken) op dezelfde manier als voor software-engineers. Met Git en DVC kunnen datawetenschaps- en ML-teams versie-experimenten uitvoeren, grote datasets beheren en projecten reproduceerbaar maken.

DVC heeft de volgende kenmerken:

• DVC is een gratis, open source opdrachtregel gereedschap.
• DVC werkt bovenop Git-repositories en heeft een vergelijkbare opdrachtregelinterface en stroom als Git. DVC kan ook standalone werken, maar zonder versiebeheer mogelijkheden.
• Gegevensversiebeheer wordt ingeschakeld door grote bestanden, datasetdirectory's, ML-modellen, enzovoort te vervangen door kleine metabestanden (gemakkelijk te hanteren met Git). Deze tijdelijke aanduidingen verwijzen naar de oorspronkelijke gegevens, die losgekoppeld zijn van het broncodebeheer.
• U kunt on-premises of cloudopslag gebruiken om de projectgegevens los van de codebasis op te slaan. Zo kunnen datawetenschappers grote datasets overdragen of een GPU-getraind model met anderen delen.
• DVC maakt data science-projecten reproduceerbaar door lichtgewicht te creëren pijpleidingen met behulp van impliciete afhankelijkheidsgrafieken en door de betrokken gegevens en artefacten te coderen.
• DVC is platformonafhankelijk. Het draait op alle belangrijke besturingssystemen (Linux, macOS en Windows) en werkt onafhankelijk van de programmeertalen (Python, R, Julia, shellscripts, enzovoort) of ML-bibliotheken (Keras, TensorFlow, PyTorch, Scipy en meer) gebruikt in het project.
• DVC is snel te installeren en vereist geen speciale infrastructuur en is ook niet afhankelijk van API's of externe services. Het is een op zichzelf staande CLI-tool.

SageMaker-experimenten en DVC-voorbeeld

De volgende GitHub-voorbeeld laat zien hoe u DVC binnen de SageMaker-omgeving kunt gebruiken. We bekijken in het bijzonder hoe u een aangepast image kunt bouwen met standaard geïnstalleerde DVC-bibliotheken om een ​​consistente ontwikkelomgeving te bieden aan uw datawetenschappers in Amazon SageMaker Studioen hoe u DVC kunt gebruiken naast de door SageMaker beheerde infrastructuur voor verwerking en training. Verder laten we zien hoe u SageMaker-trackinginformatie kunt verrijken met gegevensversie-informatie van DVC en deze kunt visualiseren in de Studio-console.

Het volgende diagram illustreert de oplossingsarchitectuur en workflow.

Bouw een aangepast Studio-image met DVC al geïnstalleerd

In deze GitHub-repository, leggen we uit hoe u een aangepaste afbeelding voor Studio maakt waarop DVC al is geïnstalleerd. Het voordeel van het maken van een afbeelding en het beschikbaar maken voor alle Studio-gebruikers is dat het een consistente omgeving creëert voor de Studio-gebruikers, die ze ook lokaal kunnen uitvoeren. Hoewel de steekproef is gebaseerd op: AWS-Cloud9, kunt u de container ook op uw lokale computer bouwen zolang Docker is geïnstalleerd en actief is. Dit voorbeeld is gebaseerd op het volgende: Dockerfile en omgeving.yml. De resulterende Docker-afbeelding wordt opgeslagen in Amazon Elastic Container-register (Amazon EMR) in uw AWS-account. Zie de volgende code:

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

U kunt nu een nieuw Studio-domein maken or een bestaand Studio-domein bijwerken die toegang heeft tot de nieuw gemaakte Docker-afbeelding.

Wij gebruiken AWS Cloud-ontwikkelingskit (AWS CDK) om de volgende bronnen te maken via: AWS CloudFormatie:

• Een SageMaker-uitvoeringsrol met de juiste machtigingen voor uw nieuwe of bestaande Studio-domein
• Een SageMaker-afbeelding en SageMaker-afbeeldingsversie van de Docker-afbeelding conda-env-dvc-kernel die we eerder hebben gemaakt
• An AppImageConfig dat specificeert hoe de kernelgateway moet worden geconfigureerd
• Een Studio-gebruiker (data-scientist-dvc) met de juiste SageMaker-uitvoeringsrol en de aangepaste Studio-afbeelding die ervoor beschikbaar is

Raadpleeg voor gedetailleerde instructies: Koppel een aangepaste afbeelding aan SageMaker Studio.

Voer het laboratorium uit

Voer de volgende stappen uit om het lab uit te voeren:

1. Start in het Studio-domein Studio voor de data-scientist-dvc gebruiker.
2. Kies het Git-pictogram en kies vervolgens Een opslagplaats klonen.
   
3. Voer de URL van de repository in (https://github.com/aws-samples/amazon-sagemaker-experiments-dvc-demo) en kies Kloon.
4. Kies in de bestandsbrowser de amazon-sagemaker-experiments-dvc-demo repository.
5. Open de dvc_sagemaker_script_mode.ipynb notebook.
6. Voor Aangepaste afbeelding, kies de afbeelding conda-env-dvc-kernel.
7. Kies kies.
   

DVC configureren voor gegevensversiebeheer

We maken een submap waarin we de gegevens voorbereiden: sagemaker-dvc-sample. Binnen deze submap initialiseren we een nieuwe Git-repository en stellen we de remote in op een repository die we maken in AWS Codecommit. Het doel is om DVC-configuraties en bestanden voor het bijhouden van gegevens in deze repository te hebben. Git biedt echter native mogelijkheden om subprojecten te beheren via bijvoorbeeld git-submodules en git-substructuren, en je kunt dit voorbeeld uitbreiden om elk van de bovengenoemde tools te gebruiken die het beste bij je workflow passen.

Het belangrijkste voordeel van het gebruik van CodeCommit met SageMaker in ons geval is de integratie met AWS Identiteits- en toegangsbeheer (IAM) voor authenticatie en autorisatie, wat betekent dat we IAM-rollen kunnen gebruiken om gegevens te pushen en op te halen zonder de noodzaak om inloggegevens (of SSH-sleutels) op te halen. Door de juiste machtigingen voor de SageMaker-uitvoeringsrol in te stellen, kunnen de Studio-notebook en de SageMaker-trainings- en verwerkingstaak ook veilig communiceren met CodeCommit.

Hoewel u CodeCommit kunt vervangen door elke andere bronbeheerservice, zoals GitHub, Gitlab of Bitbucket, moet u overwegen hoe u met de inloggegevens voor uw systeem omgaat. Een mogelijkheid is om deze inloggegevens op te slaan op: AWS-geheimenmanager en haal ze tijdens runtime op uit de Studio-notebook en uit de SageMaker-verwerkings- en trainingstaken.

Verwerk en train met DVC en SageMaker

In deze sectie onderzoeken we twee verschillende benaderingen om ons probleem aan te pakken en hoe we de twee tests kunnen bijhouden met SageMaker Experiments volgens de conceptuele architectuur op hoog niveau die we u eerder hebben laten zien.

Een SageMaker-experiment opzetten

Om deze test in SageMaker te volgen, moeten we een experiment maken. We moeten ook de proef binnen het experiment definiëren. Voor de eenvoud beschouwen we slechts één proef voor het experiment, maar u kunt een willekeurig aantal proeven binnen een experiment hebben, bijvoorbeeld als u verschillende algoritmen wilt testen.

We maken een experiment met de naam DEMO-sagemaker-experiments-dvc met twee proeven, dvc-trial-single-file en dvc-trial-multi-files, die elk een andere versie van de dataset vertegenwoordigen.

Laten we de . maken DEMO-sagemaker-experiments-dvc experiment:

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: Genereer enkele bestanden voor training en validatie

In deze sectie maken we een verwerkingsscript dat de onbewerkte gegevens rechtstreeks ophaalt van Amazon eenvoudige opslagservice (Amazon S3) als ingang; verwerkt het om de trein-, validatie- en testdatasets te maken; en slaat de resultaten terug op Amazon S3 op met behulp van DVC. Verder laten we zien hoe u uitvoerartefacten kunt volgen die door DVC zijn gegenereerd met SageMaker bij het uitvoeren van verwerkings- en trainingstaken en via SageMaker Experiments.

Eerst maken we de dvc-trial-single-file proef en voeg het toe aan de DEMO-sagemaker-experiments-dvc experiment. Door dit te doen, houden we alle proefcomponenten die verband houden met deze test op een zinvolle manier georganiseerd.

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

Gebruik DVC in een SageMaker-verwerkingstaak om de versie met één bestand te maken

In deze sectie maken we een verwerkingsscript dat de onbewerkte gegevens rechtstreeks van Amazon S3 als invoer krijgt met behulp van de beheerde gegevenslaadmogelijkheid van SageMaker; verwerkt het om de trein-, validatie- en testdatasets te maken; en slaat de resultaten terug op Amazon S3 op met behulp van DVC. Het is erg belangrijk om te begrijpen dat wanneer we DVC gebruiken om gegevens op te slaan op Amazon S3 (of gegevens op te halen uit Amazon S3), we de door SageMaker beheerde mogelijkheden voor het laden van gegevens verliezen, wat mogelijk een impact kan hebben op de prestaties en kosten van onze verwerkings- en trainingstaken , vooral bij het werken met zeer grote datasets. Voor meer informatie over de verschillende mogelijkheden van de SageMaker native invoermodus, zie: Toegang tot trainingsgegevens.

Ten slotte verenigen we DVC-trackingmogelijkheden met SageMaker-trackingmogelijkheden bij het uitvoeren van verwerkingstaken via SageMaker Experiments.

Het verwerkingsscript verwacht het adres van de Git-repository en de branch die we willen maken om de DVC-metadata op te slaan die zijn doorgegeven via omgevingsvariabelen. De datasets zelf worden door DVC opgeslagen in Amazon S3. Hoewel omgevingsvariabelen automatisch worden gevolgd in SageMaker Experiments en zichtbaar zijn in de parameters van de proefcomponenten, willen we de proefcomponenten misschien verrijken met meer informatie, die vervolgens beschikbaar wordt voor visualisatie in de Studio UI met behulp van een tracker-object. In ons geval omvatten de parameters van de proefcomponenten het volgende:

• DVC_REPO_URL
• DVC_BRANCH
• USER
• data_commit_hash
• train_test_split_ratio

Het voorverwerkingsscript kloont de Git-repository; genereert de trein-, validatie- en testdatasets; en synchroniseert het met behulp van DVC. Zoals eerder vermeld, kunnen we bij het gebruik van DVC geen gebruik maken van de native SageMaker-mogelijkheden voor het laden van gegevens. Afgezien van de prestatiestraffen die we kunnen oplopen bij grote datasets, verliezen we ook de automatische trackingmogelijkheden voor de uitvoerartefacten. Dankzij de tracker en de DVC Python API kunnen we deze tekortkomingen echter compenseren, dergelijke informatie tijdens runtime ophalen en met weinig moeite opslaan in de proefcomponent. De toegevoegde waarde hiervan is om in één oogopslag de invoer- en uitvoerartefacten te hebben die bij deze specifieke verwerkingstaak horen.

Het volledige voorbewerkingspython-script is beschikbaar in de: 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 geeft ons de mogelijkheid om ons verwerkingsscript uit te voeren op containerimages die worden beheerd door AWS en die zijn geoptimaliseerd om op de AWS-infrastructuur te draaien. Als ons script extra afhankelijkheden vereist, kunnen we een requirements.txt het dossier. Wanneer we de verwerkingstaak starten, gebruikt SageMaker pip-install om alle benodigde bibliotheken te installeren (bijvoorbeeld DVC-gerelateerde bibliotheken). Als u een strakkere controle wilt hebben over alle bibliotheken die op de containers zijn geïnstalleerd, kunt u uw eigen container in SageMaker meenemen, bijvoorbeeld voor verwerking en training.

We hebben nu alle ingrediënten om onze SageMaker-verwerkingstaak uit te voeren:

• Een verwerkingsscript dat verschillende argumenten kan verwerken (--train-test-split-ratio) en twee omgevingsvariabelen (DVC_REPO_URL en DVC_BRANCH)
• A requiremets.txt filet
• Een Git-repository (in CodeCommit)
• Een SageMaker-experiment en proef

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
}

Vervolgens voeren we de verwerkingstaak uit met de preprocessing-experiment.py script, experiment_config, dvc_repo_url en dvc_branch we eerder hebben gedefinieerd.

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

De verwerkingstaak duurt ongeveer 5 minuten. Nu kunt u de proefgegevens voor de dataset met één bestand bekijken.

De volgende schermafbeelding laat zien waar u de opgeslagen informatie in Studio kunt vinden. Let op de waarden voor dvc-trial-single-file in DVC_BRANCH, DVC_REPO_URL en data_commit_hash op de parameters Tab.

Let ook op de invoer- en uitvoergegevens op de Artifacts Tab.

Maak een schatter en pas het model aan met de gegevensversie van één bestand

Om DVC-integratie te gebruiken binnen een SageMaker-trainingstaak, geven we een: dvc_repo_url en dvc_branch als omgevingsvariabelen wanneer u het Estimator-object maakt.

We trainen op de dvc-trial-single-file eerst filiaal.

Bij het ophalen van gegevens met DVC gebruiken we de volgende datasetstructuur:

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

Nu maken we een Scikit-leerschatter met behulp van de SageMaker Python-SDK. Dit stelt ons in staat om het volgende te specificeren:

• Het pad naar het Python-bronbestand, dat moet worden uitgevoerd als toegangspunt voor training.
• De IAM-rol die de machtigingen beheert voor toegang tot Amazon S3- en CodeCommit-gegevens en het uitvoeren van SageMaker-functies.
• Een lijst met woordenboeken die de metrieken definiëren die worden gebruikt om de trainingstaken te evalueren.
• Het aantal en type trainingsinstanties. We gebruiken één ml.m5.large instantie.
• Hyperparameters die worden gebruikt voor training.
• Omgevingsvariabelen om te gebruiken tijdens de trainingstaak. We gebruiken DVC_REPO_URL, DVC_BRANCH en 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
}

We noemen de fit-methode van de Estimator met de experiment_config die we eerder hebben gedefinieerd om de training te starten.

%%time
estimator.fit(experiment_config=experiment_config)

De trainingstaak duurt ongeveer 5 minuten. De logs tonen die regels, die de bestanden aangeven die door DVC zijn opgehaald:

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: Genereer meerdere bestanden voor training en validatie

We creëren een nieuwe dvc-trial-multi-files trial en voeg het toe aan de huidige DEMO-sagemaker-experiments-dvc experiment.

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

Anders dan bij het eerste verwerkingsscript, creëren we nu uit de originele dataset meerdere bestanden voor training en validatie en slaan we de DVC-metadata op in een andere branch.

U kunt het tweede voorbewerkingspython-script verkennen op 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"]
)

De verwerkingstaak duurt ongeveer 5 minuten. Nu kunt u de proefgegevens voor de dataset met meerdere bestanden bekijken.

De volgende schermafbeeldingen laten zien waar u de opgeslagen informatie in SageMaker Experiments kunt vinden in de: Proefcomponenten sectie binnen de Studio UI. Let op de waarden voor dvc-trial-multi-files in DVC_BRANCH, DVC_REPO_URL en data_commit_hash op de parameters Tab.

U kunt de invoer- en uitvoergegevens ook bekijken op de Artifacts Tab.

We trainen nu op de dvc-trial-multi-files tak. Bij het ophalen van gegevens met DVC gebruiken we de volgende datasetstructuur:

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

Net zoals we eerder deden, maken we een nieuwe Scikit-leerschatter met de proefnaam dvc-trial-multi-files en start de opleiding.

%%time

estimator.fit(experiment_config=experiment_config)

De trainingstaak duurt ongeveer 5 minuten. Op de trainingstaaklogboeken die naar de notebook worden uitgevoerd, kunt u die regels zien, die de bestanden aangeven die door DVC zijn opgehaald:

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 uw model in SageMaker

Nadat u uw ML-model hebt getraind, kunt u het implementeren met SageMaker. Om een ​​persistent, realtime eindpunt te implementeren dat één voorspelling tegelijk doet, gebruiken we SageMaker realtime hostingdiensten.

from sagemaker.serializers import CSVSerializer

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

Eerst krijgen we de nieuwste testdataset lokaal op het ontwikkelnotebook in Studio. Voor dit doel kunnen we gebruik maken van dvc.api.read() om de onbewerkte gegevens te laden die zijn opgeslagen in Amazon S3 door de SageMaker-verwerkingstaak.

import io
import dvc.api

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

Vervolgens bereiden we de gegevens voor met Panda's, laden een test-CSV-bestand en bellen predictor.predict om het eerder gemaakte SageMaker-eindpunt met gegevens aan te roepen en voorspellingen te krijgen.

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

Het eindpunt verwijderen

U moet eindpunten verwijderen wanneer ze niet meer in gebruik zijn, omdat ze worden gefactureerd tegen de tijd dat ze zijn geïmplementeerd (zie voor meer informatie Amazon SageMaker-prijzen). Zorg ervoor dat u het eindpunt verwijdert om onverwachte kosten te voorkomen.

predictor.delete_endpoint()

Opruimen

Voordat u alle door u gemaakte bronnen verwijdert, moet u ervoor zorgen dat alle apps zijn verwijderd uit de data-scientist-dvc gebruiker, inclusief alle KernelGateway-apps, evenals de standaard JupiterServer-app.

Vervolgens kunt u de AWS CDK-stack vernietigen door de volgende opdracht uit te voeren:

cdk destroy

Als je een bestaand domein hebt gebruikt, voer dan ook de volgende opdrachten uit:

# 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

Conclusie

In dit bericht hebt u een voorbeeld doorgenomen van hoe u uw experimenten kunt volgen in code, gegevens, artefacten en metrieken door gebruik te maken van SageMaker Experiments en SageMaker-verwerkings- en trainingstaken in combinatie met DVC. We hebben een Docker-image gemaakt met DVC, die nodig was voor Studio als ontwikkelnotebook, en hebben laten zien hoe je verwerkings- en trainingstaken kunt gebruiken met DVC. We hebben twee versies van de gegevens voorbereid en DVC gebruikt om deze met Git te beheren. Vervolgens heb je SageMaker Experiments gebruikt om de verwerking en training bij te houden met de twee versies van de gegevens om een ​​uniform beeld te krijgen van parameters, artefacten en metrieken in één enkel venster. Ten slotte hebt u het model op een SageMaker-eindpunt geïmplementeerd en een testgegevensset uit de tweede gegevenssetversie gebruikt om het SageMaker-eindpunt aan te roepen en voorspellingen te krijgen.

Als volgende stap kunt u de bestaande notebook uitbreiden en uw eigen feature-engineeringstrategie introduceren en DVC en SageMaker gebruiken om uw experimenten uit te voeren. Laten we gaan bouwen!

Raadpleeg de volgende bronnen voor meer informatie:

Over de auteurs

Paul Di Francesco is oplossingsarchitect bij AWS. Hij heeft ervaring in de telecommunicatie en software engineering. Hij is gepassioneerd door machine learning en richt zich momenteel op het gebruik van zijn ervaring om klanten te helpen hun doelen op AWS te bereiken, met name in discussies over MLOps. Naast zijn werk houdt hij van voetballen en lezen.

Eitan Sela is een Machine Learning Specialist Solutions Architect bij Amazon Web Services. Hij werkt samen met AWS-klanten om begeleiding en technische assistentie te bieden en hen te helpen bij het bouwen en gebruiken van machine learning-oplossingen op AWS. In zijn vrije tijd jogt Eitan graag en leest hij de nieuwste artikelen over machine learning.