Verfolgen Sie Ihre ML-Experimente durchgängig mit Data Version Control und Amazon SageMaker Experiments

Datenwissenschaftler arbeiten oft daran, die Auswirkungen verschiedener Datenvorverarbeitungs- und Feature-Engineering-Strategien in Kombination mit verschiedenen Modellarchitekturen und Hyperparametern zu verstehen. Dazu müssen Sie iterativ große Parameterräume abdecken, und es kann überwältigend sein, den Überblick über zuvor ausgeführte Konfigurationen und Ergebnisse zu behalten und gleichzeitig die Experimente reproduzierbar zu halten.

Dieser Beitrag führt Sie durch ein Beispiel, wie Sie Ihre Experimente mithilfe von Code, Daten, Artefakten und Metriken nachverfolgen können Amazon SageMaker-Experimente in Verbindung mit Datenversionskontrolle (DVC). Wir zeigen, wie Sie DVC nebeneinander nutzen können Amazon Sage Maker Verarbeitungs- und Ausbildungsberufe. Wir trainieren verschiedene CatBoost-Modelle auf dem kalifornischen Gehäusedatensatz aus dem StatLib-Repository, und ändern Sie Holdout-Strategien, während Sie die Datenversion mit DVC verfolgen. In jedem einzelnen Experiment verfolgen wir Eingabe- und Ausgabeartefakte, Code und Metriken mithilfe von SageMaker-Experimenten.

SageMaker-Experimente

SageMaker Experiments ist ein AWS-Service zum Verfolgen von Experimenten zum maschinellen Lernen (ML). Das SageMaker-Experimente Python SDK ist eine High-Level-Schnittstelle zu diesem Dienst, mit der Sie Experimentinformationen mit Python nachverfolgen können.

Das Ziel von SageMaker-Experimenten besteht darin, es so einfach wie möglich zu machen, Experimente zu erstellen, sie mit Studien zu füllen, Tracking- und Herkunftsinformationen hinzuzufügen und Analysen über Studien und Experimente hinweg durchzuführen.

Bei der Erörterung von SageMaker-Experimenten beziehen wir uns auf die folgenden Konzepte:

• Experiment – Eine Sammlung verwandter Studien. Sie fügen einem Experiment Versuche hinzu, die Sie miteinander vergleichen möchten.
• Test – Eine Beschreibung eines mehrstufigen ML-Workflows. Jeder Schritt im Workflow wird durch eine Testkomponente beschrieben.
• Testkomponente – Eine Beschreibung eines einzelnen Schritts in einem ML-Workflow, wie z. B. Datenbereinigung, Merkmalsextraktion, Modelltraining oder Modellbewertung.
• Tracker – Ein Python-Kontextmanager zum Protokollieren von Informationen zu einer einzelnen Testkomponente (z. B. Parameter, Metriken oder Artefakte).

Datenversionskontrolle

Data Version Control (DVC) ist eine neue Art von Datenversionierungs-, Workflow- und Experimentverwaltungssoftware, die darauf aufbaut Git (obwohl es eigenständig funktionieren kann). DVC verringert die Lücke zwischen etablierten Engineering-Toolsets und Data-Science-Anforderungen, sodass Sie neue Vorteile nutzen können Funktionen unter Wiederverwendung vorhandener Fähigkeiten und Intuition.

Die gemeinsame Nutzung und Zusammenarbeit von Data-Science-Experimenten kann über einen regulären Git-Flow (Commits, Branching, Tagging, Pull-Requests) genauso erfolgen, wie es für Softwareentwickler funktioniert. Mit Git und DVC können Data-Science- und ML-Teams Experimente versionieren, große Datensätze verwalten und Projekte reproduzierbar machen.

DVC hat die folgenden Funktionen:

• DVC ist ein kostenlos, Open Source Befehlszeile Werkzeug.
• DVC arbeitet auf Git-Repositories und hat eine ähnliche Befehlszeilenschnittstelle und einen ähnlichen Ablauf wie Git. DVC kann auch Standalone funktionieren, aber ohne Versionierung Funktionen.
• Die Datenversionierung wird ermöglicht, indem große Dateien, Datensatzverzeichnisse, ML-Modelle usw. durch kleine ersetzt werden Metadateien (mit Git einfach zu handhaben). Diese Platzhalter verweisen auf die Originaldaten, die von der Quellcodeverwaltung entkoppelt sind.
• Sie können lokalen oder Cloud-Speicher verwenden, um die Daten des Projekts getrennt von seiner Codebasis zu speichern. So können Data Scientists große Datensätze übertragen oder ein GPU-trainiertes Modell mit anderen teilen.
• DVC macht Data-Science-Projekte reproduzierbar, indem es leichtgewichtig erstellt Pipelines Verwenden von impliziten Abhängigkeitsgraphen und Kodieren der beteiligten Daten und Artefakte.
• DVC ist plattformunabhängig. Es läuft auf allen wichtigen Betriebssystemen (Linux, macOS und Windows) und funktioniert unabhängig von den Programmiersprachen (Python, R, Julia, Shell-Skripte usw.) oder ML-Bibliotheken (Keras, TensorFlow, PyTorch, Scipy usw.). mehr) im Projekt verwendet.
• DVC ist schnell dabei installieren und erfordert keine spezielle Infrastruktur und ist auch nicht von APIs oder externen Diensten abhängig. Es ist ein eigenständiges CLI-Tool.

SageMaker-Experimente und DVC-Beispiel

Folgende GitHub-Beispiel zeigt, wie Sie DVC in der SageMaker-Umgebung verwenden. Insbesondere sehen wir uns an, wie Sie ein benutzerdefiniertes Image mit standardmäßig installierten DVC-Bibliotheken erstellen, um Ihren Data Scientists eine konsistente Entwicklungsumgebung bereitzustellen Amazon SageMaker-Studio, und wie Sie DVC zusammen mit einer von SageMaker verwalteten Infrastruktur für die Verarbeitung und Schulung ausführen. Darüber hinaus zeigen wir, wie Sie SageMaker-Tracking-Informationen mit Datenversionsinformationen aus DVC anreichern und in der Studio-Konsole visualisieren können.

Das folgende Diagramm veranschaulicht die Lösungsarchitektur und den Workflow.

Erstellen Sie ein benutzerdefiniertes Studio-Image mit bereits installiertem DVC

In diesem GitHub-Repository, erklären wir, wie Sie ein benutzerdefiniertes Image für Studio erstellen, auf dem DVC bereits installiert ist. Der Vorteil, ein Image zu erstellen und allen Studio-Benutzern zur Verfügung zu stellen, besteht darin, dass es eine konsistente Umgebung für die Studio-Benutzer schafft, die sie auch lokal ausführen könnten. Obwohl das Beispiel basiert auf AWS Cloud9, können Sie den Container auch auf Ihrem lokalen Computer erstellen, solange Docker installiert ist und ausgeführt wird. Dieses Beispiel basiert auf Folgendem Dockerfile und umwelt.yml. Das resultierende Docker-Image wird in gespeichert Amazon Elastic Container-Registrierung (Amazon EMR) in Ihrem AWS-Konto. Siehe folgenden 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}

Du kannst jetzt Erstellen Sie eine neue Studio-Domain or Aktualisieren Sie eine vorhandene Studio-Domain das Zugriff auf das neu erstellte Docker-Image hat.

Wir verwenden AWS Cloud-Entwicklungskit (AWS CDK), um die folgenden Ressourcen über zu erstellen AWS CloudFormation:

• Eine SageMaker-Ausführungsrolle mit den richtigen Berechtigungen für Ihre neue oder vorhandene Studio-Domain
• Ein SageMaker-Image und eine SageMaker-Image-Version aus dem Docker-Image conda-env-dvc-kernel die wir früher erstellt haben
• An AppImageConfig die angibt, wie das Kernel-Gateway konfiguriert werden soll
• Ein Studio-Benutzer (data-scientist-dvc) mit der richtigen SageMaker-Ausführungsrolle und dem dafür verfügbaren benutzerdefinierten Studio-Image

Detaillierte Anweisungen finden Sie unter Ordnen Sie SageMaker Studio ein benutzerdefiniertes Bild zu.

Führe das Labor aus

Führen Sie die folgenden Schritte aus, um das Lab auszuführen:

1. Starten Sie in der Studio-Domäne Studio für die data-scientist-dvc Benutzer.
2. Wählen Sie das Git-Symbol und wählen Sie dann Klonen Sie ein Repository.
   
3. Geben Sie die URL des Repositorys ein (https://github.com/aws-samples/amazon-sagemaker-experiments-dvc-demo) und wähle Clone.
4. Wählen Sie im Dateibrowser die amazon-sagemaker-experiments-dvc-demo Repository.
5. Öffnen Sie den Microsoft Store auf Ihrem Windows-PC. dvc_sagemaker_script_mode.ipynb Notebook.
6. Aussichten für Benutzerdefiniertes Bild, wählen Sie das Image conda-env-dvc-kernel.
7. Auswählen Auswählen.
   

Konfigurieren Sie DVC für die Datenversionierung

Wir erstellen ein Unterverzeichnis, in dem wir die Daten vorbereiten: sagemaker-dvc-sample. In diesem Unterverzeichnis initialisieren wir ein neues Git-Repository und setzen die Fernbedienung auf ein Repository, in dem wir es erstellen AWS-CodeCommit. Ziel ist es, DVC-Konfigurationen und Dateien für die Datenverfolgung in diesem Repository versioniert zu haben. Git bietet jedoch native Funktionen zum Verwalten von Unterprojekten beispielsweise über Git-Untermodule und Git-Unterbäume, und Sie können dieses Beispiel erweitern, um eines der oben genannten Tools zu verwenden, das am besten zu Ihrem Arbeitsablauf passt.

Der Hauptvorteil der Verwendung von CodeCommit mit SageMaker in unserem Fall ist die Integration mit AWS Identity and Access Management and (IAM) für die Authentifizierung und Autorisierung, was bedeutet, dass wir IAM-Rollen verwenden können, um Daten zu pushen und abzurufen, ohne Anmeldeinformationen (oder SSH-Schlüssel) abrufen zu müssen. Durch Festlegen der entsprechenden Berechtigungen für die SageMaker-Ausführungsrolle können das Studio-Notebook und der SageMaker-Trainings- und -Verarbeitungsauftrag auch sicher mit CodeCommit interagieren.

Obwohl Sie CodeCommit durch jeden anderen Quellcodeverwaltungsdienst wie GitHub, Gitlab oder Bitbucket ersetzen können, müssen Sie überlegen, wie Sie mit den Anmeldeinformationen für Ihr System umgehen. Eine Möglichkeit besteht darin, diese Zugangsdaten zu speichern AWS Secrets Manager und sie zur Laufzeit vom Studio-Notebook sowie von den Verarbeitungs- und Trainingsjobs von SageMaker abrufen.

Verarbeiten und trainieren Sie mit DVC und SageMaker

In diesem Abschnitt untersuchen wir zwei verschiedene Ansätze zur Lösung unseres Problems und wie wir die beiden Tests mithilfe von SageMaker-Experimenten gemäß der oben gezeigten konzeptionellen Architektur auf hoher Ebene verfolgen können.

Richten Sie ein SageMaker-Experiment ein

Um diesen Test in SageMaker nachzuverfolgen, müssen wir ein Experiment erstellen. Wir müssen auch den Versuch innerhalb des Experiments definieren. Der Einfachheit halber betrachten wir nur einen Versuch für das Experiment, aber Sie können innerhalb eines Experiments beliebig viele Versuche haben, wenn Sie beispielsweise verschiedene Algorithmen testen möchten.

Wir erstellen ein Experiment mit dem Namen DEMO-sagemaker-experiments-dvc mit zwei Prüfungen, dvc-trial-single-file und dvc-trial-multi-files, die jeweils eine andere Version des Datasets darstellen.

Lassen Sie uns die erstellen 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: Generieren Sie einzelne Dateien für Training und Validierung

In diesem Abschnitt erstellen wir ein Verarbeitungsskript, das die Rohdaten direkt abruft Amazon Simple Storage-Service (Amazon S3) als Eingabe; verarbeitet es, um die Trainings-, Validierungs- und Testdatensätze zu erstellen; und speichert die Ergebnisse mit DVC zurück in Amazon S3. Darüber hinaus zeigen wir, wie Sie von DVC generierte Ausgabeartefakte mit SageMaker beim Ausführen von Verarbeitungs- und Trainingsjobs und über SageMaker-Experimente nachverfolgen können.

Zuerst erstellen wir die dvc-trial-single-file Testversion und fügen Sie es der hinzu DEMO-sagemaker-experiments-dvc Experiment. Auf diese Weise halten wir alle Studienkomponenten im Zusammenhang mit diesem Test sinnvoll organisiert.

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

Verwenden Sie DVC in einem SageMaker-Verarbeitungsauftrag, um die Einzeldateiversion zu erstellen

In diesem Abschnitt erstellen wir ein Verarbeitungsskript, das die Rohdaten mithilfe der verwalteten Datenladefunktion von SageMaker direkt von Amazon S3 als Eingabe erhält; verarbeitet es, um die Trainings-, Validierungs- und Testdatensätze zu erstellen; und speichert die Ergebnisse mit DVC zurück in Amazon S3. Es ist sehr wichtig zu verstehen, dass wir bei der Verwendung von DVC zum Speichern von Daten in Amazon S3 (oder zum Abrufen von Daten aus Amazon S3) die von SageMaker verwalteten Datenladefunktionen verlieren, was sich potenziell auf die Leistung und die Kosten unserer Verarbeitungs- und Trainingsaufträge auswirken kann , insbesondere bei der Arbeit mit sehr großen Datensätzen. Weitere Informationen zu den verschiedenen Funktionen des nativen Eingabemodus von SageMaker finden Sie unter Greifen Sie auf Trainingsdaten zu.

Schließlich vereinheitlichen wir die DVC-Tracking-Funktionen mit den SageMaker-Tracking-Funktionen, wenn Verarbeitungsaufträge über SageMaker-Experimente ausgeführt werden.

Das Verarbeitungsskript erwartet die Adresse des Git-Repositorys und des Zweigs, den wir erstellen möchten, um die über Umgebungsvariablen übergebenen DVC-Metadaten zu speichern. Die Datensätze selbst werden von DVC in Amazon S3 gespeichert. Obwohl Umgebungsvariablen in SageMaker-Experimenten automatisch nachverfolgt werden und in den Testkomponentenparametern sichtbar sind, möchten wir die Testkomponenten möglicherweise mit weiteren Informationen anreichern, die dann für die Visualisierung in der Studio-Benutzeroberfläche mithilfe eines Tracker-Objekts verfügbar werden. In unserem Fall umfassen die Parameter der Versuchskomponenten Folgendes:

• DVC_REPO_URL
• DVC_BRANCH
• USER
• data_commit_hash
• train_test_split_ratio

Das Vorverarbeitungsskript klont das Git-Repository; generiert die Trainings-, Validierungs- und Testdatensätze; und synchronisiert es mit DVC. Wie bereits erwähnt, können wir bei der Verwendung von DVC die nativen SageMaker-Datenladefunktionen nicht nutzen. Abgesehen von den Leistungseinbußen, die wir bei großen Datensätzen möglicherweise erleiden, verlieren wir auch die automatischen Verfolgungsfunktionen für die Ausgabeartefakte. Dank des Trackers und der DVC-Python-API können wir diese Mängel jedoch ausgleichen, solche Informationen zur Laufzeit abrufen und mit geringem Aufwand in der Testkomponente speichern. Der Mehrwert dabei besteht darin, die Eingabe- und Ausgabeartefakte, die zu diesem bestimmten Verarbeitungsauftrag gehören, in einer einzigen Ansicht zu haben.

Das vollständige Vorverarbeitungs-Python-Skript ist in der verfügbar 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 gibt uns die Möglichkeit, unser Verarbeitungsskript auf von AWS verwalteten Container-Images auszuführen, die für die Ausführung auf der AWS-Infrastruktur optimiert sind. Wenn unser Skript zusätzliche Abhängigkeiten erfordert, können wir eine bereitstellen requirements.txt Datei. Wenn wir den Verarbeitungsauftrag starten, verwendet SageMaker pip-install um alle benötigten Bibliotheken zu installieren (z. B. DVC-bezogene Bibliotheken). Wenn Sie eine strengere Kontrolle über alle auf den Containern installierten Bibliotheken benötigen, können Sie beispielsweise Ihren eigenen Container in SageMaker einbringen Verarbeitung und Training.

Wir haben jetzt alle Zutaten, um unseren SageMaker-Verarbeitungsjob auszuführen:

• Ein Verarbeitungsskript, das mehrere Argumente verarbeiten kann (--train-test-split-ratio) und zwei Umgebungsvariablen (DVC_REPO_URL und DVC_BRANCH)
• A requiremets.txt Datei
• Ein Git-Repository (in CodeCommit)
• Ein SageMaker-Experiment und -Test

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
}

Wir führen dann den Verarbeitungsjob mit dem aus preprocessing-experiment.py Skript, experiment_config, dvc_repo_url und dvc_branch wir haben früher definiert.

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

Der Verarbeitungsauftrag dauert etwa 5 Minuten. Jetzt können Sie die Testdetails für den Einzeldatei-Datensatz anzeigen.

Der folgende Screenshot zeigt, wo Sie die gespeicherten Informationen in Studio finden können. Beachten Sie die Werte für dvc-trial-single-file in DVC_BRANCH, DVC_REPO_URL und data_commit_hash auf die Parameter Tab.

Beachten Sie auch die Ein- und Ausgabedetails auf der Artifacts Tab.

Erstellen Sie einen Schätzer und passen Sie das Modell mit einer Einzeldatei-Datenversion an

Um die DVC-Integration innerhalb eines SageMaker-Schulungsjobs zu verwenden, bestehen wir a dvc_repo_url und dvc_branch als Umgebungsvariablen, wenn Sie das Estimator-Objekt erstellen.

Wir trainieren auf der dvc-trial-single-file zuerst verzweigen.

Beim Abrufen von Daten mit DVC verwenden wir die folgende Datensatzstruktur:

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

Jetzt erstellen wir einen Scikit-learn Estimator mit dem SageMaker Python-SDK. Dadurch können wir Folgendes spezifizieren:

• Der Pfad zur Python-Quelldatei, die als Einstiegspunkt für das Training ausgeführt werden soll.
• Die IAM-Rolle, die Berechtigungen für den Zugriff auf Amazon S3- und CodeCommit-Daten und die Ausführung von SageMaker-Funktionen steuert.
• Eine Liste von Wörterbüchern, die die Metriken definieren, die zur Bewertung der Schulungsjobs verwendet werden.
• Die Anzahl und Art der Trainingsinstanzen. Wir verwenden eine ml.m5.large-Instanz.
• Hyperparameter, die für das Training verwendet werden.
• Umgebungsvariablen, die während des Trainingsjobs verwendet werden sollen. Wir gebrauchen DVC_REPO_URL, DVC_BRANCH und 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
}

Wir rufen die fit-Methode des Estimators mit der zuvor definierten experiment_config auf, um das Training zu starten.

%%time
estimator.fit(experiment_config=experiment_config)

Der Trainingsjob dauert ca. 5 Minuten. Die Protokolle zeigen diese Zeilen, die die von DVC abgerufenen Dateien angeben:

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: Generieren Sie mehrere Dateien für Training und Validierung

Wir schaffen eine neue dvc-trial-multi-files Testversion und fügen Sie sie der aktuellen hinzu 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 als beim ersten Verarbeitungsskript erstellen wir nun aus dem ursprünglichen Datensatz mehrere Dateien für Training und Validierung und speichern die DVC-Metadaten in einem anderen Zweig.

Sie können das zweite Vorverarbeitungs-Python-Skript unter erkunden 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"]
)

Der Verarbeitungsauftrag dauert ca. 5 Minuten. Jetzt können Sie die Testdetails für den Datensatz mit mehreren Dateien anzeigen.

Die folgenden Screenshots zeigen, wo Sie die gespeicherten Informationen innerhalb von SageMaker Experiments in der finden können Testkomponenten Abschnitt innerhalb der Studio-Benutzeroberfläche. Beachten Sie die Werte für dvc-trial-multi-files in DVC_BRANCH, DVC_REPO_URL und data_commit_hash auf die Parameter Tab.

Sie können die Eingabe- und Ausgabedetails auch auf der überprüfen Artifacts Tab.

Wir trainieren jetzt auf der dvc-trial-multi-files Zweig. Beim Abrufen von Daten mit DVC verwenden wir die folgende Datensatzstruktur:

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

Ähnlich wie zuvor erstellen wir einen neuen Scikit-learn Estimator mit dem Testnamen dvc-trial-multi-files und starte den Ausbildungsjob.

%%time

estimator.fit(experiment_config=experiment_config)

Der Trainingsjob dauert ca. 5 Minuten. In den Trainingsjobprotokollen, die an das Notebook ausgegeben werden, können Sie diese Zeilen sehen, die die von DVC abgerufenen Dateien angeben:

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']

Hosten Sie Ihr Modell in SageMaker

Nachdem Sie Ihr ML-Modell trainiert haben, können Sie es mit SageMaker bereitstellen. Um einen dauerhaften Echtzeit-Endpunkt bereitzustellen, der jeweils eine Vorhersage trifft, verwenden wir SageMaker-Echtzeit-Hosting-Dienste.

from sagemaker.serializers import CSVSerializer

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

Zunächst erhalten wir den neuesten Testdatensatz lokal auf dem Entwicklungsnotebook in Studio. Zu diesem Zweck können wir verwenden dvc.api.read() zum Laden der Rohdaten, die vom SageMaker-Verarbeitungsauftrag in Amazon S3 gespeichert wurden.

import io
import dvc.api

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

Dann bereiten wir die Daten mit Pandas auf, laden eine Test-CSV-Datei und rufen an predictor.predict um den zuvor erstellten SageMaker-Endpunkt mit Daten aufzurufen und Vorhersagen zu erhalten.

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

Löschen Sie den Endpunkt

Sie sollten Endpunkte löschen, wenn sie nicht mehr verwendet werden, da sie nach Bereitstellungszeit abgerechnet werden (weitere Informationen finden Sie unter Amazon SageMaker Preise). Achten Sie darauf, den Endpunkt zu löschen, um unerwartete Kosten zu vermeiden.

predictor.delete_endpoint()

Aufräumen

Bevor Sie alle von Ihnen erstellten Ressourcen entfernen, stellen Sie sicher, dass alle Apps aus der gelöscht werden data-scientist-dvc Benutzer, einschließlich aller KernelGateway-Apps sowie der Standard-JupiterServer-App.

Dann können Sie den AWS CDK-Stack zerstören, indem Sie den folgenden Befehl ausführen:

cdk destroy

Wenn Sie eine vorhandene Domäne verwendet haben, führen Sie auch die folgenden Befehle aus:

# 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

Zusammenfassung

In diesem Beitrag haben Sie anhand eines Beispiels gezeigt, wie Sie Ihre Experimente über Code, Daten, Artefakte und Metriken hinweg verfolgen können, indem Sie SageMaker-Experimente und Verarbeitungs- und Trainingsaufträge von SageMaker in Verbindung mit DVC verwenden. Wir haben ein Docker-Image mit DVC erstellt, das für Studio als Entwicklungsnotebook erforderlich war, und gezeigt, wie Sie Verarbeitungs- und Trainingsjobs mit DVC verwenden können. Wir haben zwei Versionen der Daten vorbereitet und DVC verwendet, um sie mit Git zu verwalten. Dann haben Sie SageMaker-Experimente verwendet, um die Verarbeitung und das Training mit den beiden Versionen der Daten zu verfolgen, um eine einheitliche Ansicht von Parametern, Artefakten und Metriken in einem einzigen Fenster zu erhalten. Schließlich haben Sie das Modell auf einem SageMaker-Endpunkt bereitgestellt und ein Testdataset aus der zweiten Dataset-Version verwendet, um den SageMaker-Endpunkt aufzurufen und Vorhersagen zu erhalten.

Als nächsten Schritt können Sie das vorhandene Notebook erweitern und Ihre eigene Feature-Engineering-Strategie einführen und DVC und SageMaker verwenden, um Ihre Experimente durchzuführen. Lass uns bauen gehen!

Weitere Informationen finden Sie in den folgenden Ressourcen:

Über die Autoren

Paolo di Francesco ist Lösungsarchitekt bei AWS. Er hat Erfahrung in der Telekommunikation und im Software-Engineering. Er interessiert sich leidenschaftlich für maschinelles Lernen und konzentriert sich derzeit darauf, seine Erfahrung einzusetzen, um Kunden dabei zu helfen, ihre Ziele auf AWS zu erreichen, insbesondere in Diskussionen über MLOps. Außerhalb der Arbeit spielt er gerne Fußball und liest.

Eitan Sela ist ein Machine Learning Specialist Solutions Architect bei Amazon Web Services. Er arbeitet mit AWS-Kunden zusammen, um Anleitungen und technische Unterstützung bereitzustellen und ihnen dabei zu helfen, Lösungen für maschinelles Lernen auf AWS zu entwickeln und zu betreiben. In seiner Freizeit geht Eitan gerne joggen und liest die neuesten Artikel über maschinelles Lernen.