Reduzieren Sie Kosten und Entwicklungszeit mit dem lokalen Modus von Amazon SageMaker Pipelines

Das Erstellen robuster und wiederverwendbarer Pipelines für maschinelles Lernen (ML) kann ein komplexer und zeitaufwändiger Prozess sein. Entwickler testen ihre Verarbeitungs- und Trainingsskripts normalerweise lokal, aber die Pipelines selbst werden normalerweise in der Cloud getestet. Das Erstellen und Ausführen einer vollständigen Pipeline während des Experimentierens fügt dem Entwicklungslebenszyklus unerwünschte Overheads und Kosten hinzu. In diesem Beitrag beschreiben wir, wie Sie es verwenden können Lokaler Modus von Amazon SageMaker Pipelines ML-Pipelines lokal auszuführen, um sowohl die Pipeline-Entwicklung als auch die Laufzeit zu reduzieren und gleichzeitig die Kosten zu senken. Nachdem die Pipeline vollständig lokal getestet wurde, können Sie sie einfach mit erneut ausführen Amazon Sage Maker verwaltete Ressourcen mit nur wenigen Zeilen Codeänderungen.

Überblick über den ML-Lebenszyklus

Einer der Haupttreiber für neue Innovationen und Anwendungen in ML ist die Verfügbarkeit und Menge von Daten zusammen mit günstigeren Rechenoptionen. In mehreren Bereichen hat sich ML als fähig erwiesen, Probleme zu lösen, die zuvor mit klassischen Big-Data- und Analysetechniken unlösbar waren, und die Nachfrage nach Data Science- und ML-Praktikern steigt stetig. Auf einer sehr hohen Ebene besteht der ML-Lebenszyklus aus vielen verschiedenen Teilen, aber das Erstellen eines ML-Modells besteht normalerweise aus den folgenden allgemeinen Schritten:

1. Datenbereinigung und -aufbereitung (Feature Engineering)
2. Modellbau und Tuning
3. Modellbewertung
4. Modellbereitstellung (oder Batch-Transformation)

Im Datenvorbereitungsschritt werden Daten geladen, massiert und in die Art von Eingaben oder Funktionen umgewandelt, die das ML-Modell erwartet. Das Schreiben der Skripte zum Transformieren der Daten ist in der Regel ein iterativer Prozess, bei dem schnelle Feedbackschleifen wichtig sind, um die Entwicklung zu beschleunigen. Normalerweise ist es nicht erforderlich, den vollständigen Datensatz beim Testen von Feature-Engineering-Skripten zu verwenden, weshalb Sie die verwenden können lokale Modusfunktion der SageMaker-Verarbeitung. Auf diese Weise können Sie lokal ausführen und den Code iterativ aktualisieren, indem Sie ein kleineres Dataset verwenden. Wenn der endgültige Code fertig ist, wird er an den Remote-Verarbeitungsjob übermittelt, der das vollständige Dataset verwendet und auf von SageMaker verwalteten Instanzen ausgeführt wird.

Der Entwicklungsprozess ähnelt dem Datenvorbereitungsschritt sowohl für die Modelltrainings- als auch für die Modellbewertungsschritte. Datenwissenschaftler verwenden die lokale Modusfunktion von SageMaker Training, um schnell mit kleineren Datensätzen lokal zu iterieren, bevor alle Daten in einem von SageMaker verwalteten Cluster von ML-optimierten Instanzen verwendet werden. Dies beschleunigt den Entwicklungsprozess und eliminiert die Kosten für die Ausführung von ML-Instanzen, die von SageMaker verwaltet werden, während Sie experimentieren.

Wenn die ML-Reife einer Organisation zunimmt, können Sie verwenden Amazon SageMaker-Pipelines um ML-Pipelines zu erstellen, die diese Schritte zusammenfügen und komplexere ML-Workflows erstellen, die ML-Modelle verarbeiten, trainieren und bewerten. SageMaker Pipelines ist ein vollständig verwalteter Dienst zur Automatisierung der verschiedenen Schritte des ML-Workflows, einschließlich Datenladen, Datentransformation, Modelltraining und -optimierung sowie Modellbereitstellung. Bis vor kurzem konnten Sie Ihre Skripte lokal entwickeln und testen, mussten Ihre ML-Pipelines jedoch in der Cloud testen. Dies machte die Iteration des Flusses und der Form von ML-Pipelines zu einem langsamen und kostspieligen Prozess. Mit der hinzugefügten Funktion für den lokalen Modus von SageMaker Pipelines können Sie jetzt Ihre ML-Pipelines ähnlich iterieren und testen, wie Sie Ihre Verarbeitungs- und Trainingsskripts testen und iterieren. Sie können Ihre Pipelines auf Ihrem lokalen Computer ausführen und testen, indem Sie eine kleine Teilmenge von Daten verwenden, um die Pipelinesyntax und -funktionen zu validieren.

SageMaker-Pipelines

SageMaker Pipelines bietet eine vollständig automatisierte Möglichkeit, einfache oder komplexe ML-Workflows auszuführen. Mit SageMaker Pipelines können Sie ML-Workflows mit einem benutzerfreundlichen Python-SDK erstellen und Ihren Workflow dann visualisieren und verwalten Amazon SageMaker-Studio. Ihre Data-Science-Teams können effizienter arbeiten und schneller skalieren, indem sie die Workflow-Schritte speichern und wiederverwenden, die Sie in SageMaker-Pipelines erstellen. Sie können auch vorgefertigte Vorlagen verwenden, die die Infrastruktur- und Repository-Erstellung automatisieren, um Modelle in Ihrer ML-Umgebung zu erstellen, zu testen, zu registrieren und bereitzustellen. Diese Vorlagen stehen Ihrer Organisation automatisch zur Verfügung und werden mit bereitgestellt AWS-Servicekatalog Produkte.

SageMaker Pipelines bringt Continuous Integration und Continuous Deployment (CI/CD)-Praktiken in ML, wie z. B. die Aufrechterhaltung der Parität zwischen Entwicklungs- und Produktionsumgebungen, Versionskontrolle, On-Demand-Tests und End-to-End-Automatisierung, was Ihnen hilft, ML in Ihrem gesamten Unternehmen zu skalieren Organisation. DevOps-Praktiker wissen, dass einige der Hauptvorteile der Verwendung von CI/CD-Techniken eine Produktivitätssteigerung durch wiederverwendbare Komponenten und eine Qualitätssteigerung durch automatisierte Tests sind, was zu einem schnelleren ROI für Ihre Geschäftsziele führt. Diese Vorteile stehen MLOps-Praktikern jetzt zur Verfügung, indem sie SageMaker-Pipelines verwenden, um das Training, Testen und Bereitstellen von ML-Modellen zu automatisieren. Mit dem lokalen Modus können Sie jetzt viel schneller iterieren, während Sie Skripts für die Verwendung in einer Pipeline entwickeln. Beachten Sie, dass lokale Pipelineinstanzen in der Studio-IDE nicht angezeigt oder ausgeführt werden können; In Kürze werden jedoch zusätzliche Anzeigeoptionen für lokale Pipelines verfügbar sein.

Das SageMaker SDK bietet einen allgemeinen Zweck Konfiguration im lokalen Modus Damit können Entwickler unterstützte Prozessoren und Schätzfunktionen in ihrer lokalen Umgebung ausführen und testen. Sie können das Training im lokalen Modus mit mehreren von AWS unterstützten Framework-Images (TensorFlow, MXNet, Chainer, PyTorch und Scikit-Learn) sowie mit selbst bereitgestellten Images verwenden.

SageMaker Pipelines, das einen Directed Acyclic Graph (DAG) aus orchestrierten Workflow-Schritten erstellt, unterstützt viele Aktivitäten, die Teil des ML-Lebenszyklus sind. Im lokalen Modus werden die folgenden Schritte unterstützt:

• Verarbeitung von Jobschritten – Eine vereinfachte, verwaltete Erfahrung auf SageMaker zum Ausführen von Datenverarbeitungs-Workloads wie Feature-Engineering, Datenvalidierung, Modellbewertung und Modellinterpretation
• Trainingsjobschritte – Ein iterativer Prozess, der einem Modell beibringt, Vorhersagen zu treffen, indem es Beispiele aus einem Trainingsdatensatz präsentiert
• Hyperparameter-Tuning-Jobs – Eine automatisierte Methode zur Bewertung und Auswahl der Hyperparameter, die das genaueste Modell erzeugen
• Bedingte Ausführungsschritte – Ein Schritt, der eine bedingte Ausführung von Verzweigungen in einer Pipeline bereitstellt
• Modellschritt – Mithilfe von CreateModel-Argumenten kann dieser Schritt ein Modell zur Verwendung in Transformationsschritten oder einer späteren Bereitstellung als Endpunkt erstellen
• Arbeitsschritte umwandeln – Ein Batch-Transformationsjob, der Vorhersagen aus großen Datasets generiert und Inferenzen ausführt, wenn kein persistenter Endpunkt benötigt wird
• Schritte fehlschlagen – Ein Schritt, der eine Pipelineausführung stoppt und die Ausführung als fehlgeschlagen markiert

Lösungsüberblick

Unsere Lösung demonstriert die wesentlichen Schritte zum Erstellen und Ausführen von SageMaker-Pipelines im lokalen Modus, was bedeutet, dass lokale CPU-, RAM- und Festplattenressourcen verwendet werden, um die Workflow-Schritte zu laden und auszuführen. Ihre lokale Umgebung könnte auf einem Laptop ausgeführt werden und beliebte IDEs wie VSCode oder PyCharm verwenden, oder sie könnte von SageMaker unter Verwendung klassischer Notebook-Instances gehostet werden.

Im lokalen Modus können Data Scientists Schritte zusammenfügen, die Verarbeitungs-, Schulungs- und Bewertungsjobs umfassen können, und den gesamten Workflow lokal ausführen. Wenn Sie mit dem lokalen Testen fertig sind, können Sie die Pipeline in einer von SageMaker verwalteten Umgebung erneut ausführen, indem Sie die LocalPipelineSession Objekt mit PipelineSession, was Konsistenz in den ML-Lebenszyklus bringt.

Für dieses Notebook-Beispiel verwenden wir ein öffentlich verfügbares Standard-Dataset, das UCI Machine Learning Abalone-Datensatz. Ziel ist es, ein ML-Modell zu trainieren, um das Alter einer Abalone-Schnecke anhand ihrer physischen Messungen zu bestimmen. Im Kern ist dies ein Regressionsproblem.

Der gesamte Code, der zum Ausführen dieses Notebook-Beispiels erforderlich ist, ist auf GitHub in der amazon-sagemaker-beispiele Repository. In diesem Notebook-Beispiel wird jeder Pipeline-Workflowschritt unabhängig erstellt und dann miteinander verbunden, um die Pipeline zu erstellen. Wir erstellen die folgenden Schritte:

• Verarbeitungsschritt (Feature Engineering)
• Trainingsschritt (Modelltraining)
• Verarbeitungsschritt (Modellbewertung)
• Bedingungsschritt (Modellgenauigkeit)
• Modellschritt erstellen (Modell)
• Transformationsschritt (Stapeltransformation)
• Modellschritt registrieren (Modellpaket)
• Fehlerschritt (Lauf fehlgeschlagen)

Das folgende Diagramm veranschaulicht unsere Pipeline.

Voraussetzungen:

Um diesem Beitrag folgen zu können, benötigen Sie Folgendes:

Nachdem diese Voraussetzungen erfüllt sind, können Sie das Beispielnotebook wie in den folgenden Abschnitten beschrieben ausführen.

Bauen Sie Ihre Pipeline auf

In diesem Notebook-Beispiel verwenden wir SageMaker-Skriptmodus für die meisten ML-Prozesse, was bedeutet, dass wir den eigentlichen Python-Code (Skripts) bereitstellen, um die Aktivität auszuführen, und einen Verweis auf diesen Code übergeben. Der Skriptmodus bietet eine große Flexibilität, um das Verhalten innerhalb der SageMaker-Verarbeitung zu steuern, indem er es Ihnen ermöglicht, Ihren Code anzupassen und gleichzeitig die Vorteile von vorgefertigten SageMaker-Containern wie XGBoost oder Scikit-Learn zu nutzen. Der benutzerdefinierte Code wird mithilfe von Zellen, die mit dem magischen Befehl beginnen, in eine Python-Skriptdatei geschrieben %%writefile, wie folgt:

%%writefile code/evaluation.py

Der primäre Enabler des lokalen Modus ist der LocalPipelineSession -Objekt, das aus dem Python-SDK instanziiert wird. Die folgenden Codesegmente zeigen, wie eine SageMaker-Pipeline im lokalen Modus erstellt wird. Obwohl Sie für viele der lokalen Pipeline-Schritte einen lokalen Datenpfad konfigurieren können, ist Amazon S3 der Standardspeicherort zum Speichern der von der Umwandlung ausgegebenen Daten. Das neue LocalPipelineSession -Objekt wird in vielen der in diesem Beitrag beschriebenen SageMaker-Workflow-API-Aufrufe an das Python-SDK übergeben. Beachten Sie, dass Sie die verwenden können local_pipeline_session -Variable, um Verweise auf den S3-Standard-Bucket und den aktuellen Regionsnamen abzurufen.

from sagemaker.workflow.pipeline_context import LocalPipelineSession

# Create a `LocalPipelineSession` object so that each 
# pipeline step will run locally
# To run this pipeline in the cloud, you must change 
# the `LocalPipelineSession()` to `PipelineSession()`
local_pipeline_session = LocalPipelineSession()
region = local_pipeline_session.boto_region_name

default_bucket = local_pipeline_session.default_bucket()
prefix = "sagemaker-pipelines-local-mode-example"

Bevor wir die einzelnen Pipeline-Schritte erstellen, legen wir einige Parameter fest, die von der Pipeline verwendet werden. Einige dieser Parameter sind Zeichenfolgenliterale, während andere als spezielle Aufzählungstypen erstellt werden, die vom SDK bereitgestellt werden. Die Aufzählungstypisierung stellt sicher, dass gültige Einstellungen für die Pipeline bereitgestellt werden, wie z. B. diese, die an die übergeben wird ConditionLessThanOrEqualTo Schritt weiter nach unten:

mse_threshold = ParameterFloat(name="MseThreshold", default_value=7.0)

Um einen Datenverarbeitungsschritt zu erstellen, der hier verwendet wird, um Feature-Engineering durchzuführen, verwenden wir die SKLearnProcessor um den Datensatz zu laden und zu transformieren. Wir passieren die local_pipeline_session -Variable an den Klassenkonstruktor, der den Arbeitsablaufschritt anweist, im lokalen Modus ausgeführt zu werden:

from sagemaker.sklearn.processing import SKLearnProcessor

framework_version = "1.0-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-abalone-process",
    role=role,
    sagemaker_session=local_pipeline_session,
)

Als Nächstes erstellen wir unseren ersten eigentlichen Pipeline-Schritt, a ProcessingStep -Objekt, wie es aus dem SageMaker SDK importiert wurde. Die Prozessorargumente werden von einem Aufruf an zurückgegeben SKLearnProcessor run()-Methode. Dieser Arbeitsablaufschritt wird gegen Ende des Notizbuchs mit anderen Schritten kombiniert, um die Reihenfolge der Vorgänge innerhalb der Pipeline anzugeben.

from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep

processor_args = sklearn_processor.run(
    inputs=[
        ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
    ],
    outputs=[
        ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
        ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
        ProcessingOutput(output_name="test", source="/opt/ml/processing/test"),
    ],
    code="code/preprocessing.py",
)

step_process = ProcessingStep(name="AbaloneProcess", step_args=processor_args)

Als Nächstes stellen wir Code bereit, um einen Trainingsschritt einzurichten, indem wir zunächst einen Standardschätzer mit dem SageMaker SDK instanziieren. Wir passieren das gleiche local_pipeline_session Variable an den Schätzer mit dem Namen xgb_train als die sagemaker_session Streit. Da wir ein XGBoost-Modell trainieren möchten, müssen wir einen gültigen Bild-URI generieren, indem wir die folgenden Parameter angeben, einschließlich des Frameworks und mehrerer Versionsparameter:

from sagemaker.estimator import Estimator
from sagemaker.inputs import TrainingInput

model_path = f"s3://{default_bucket}/{prefix}/model"
image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.5-1",
    py_version="py3",
    instance_type=instance_type,
)

xgb_train = Estimator(
    image_uri=image_uri,
    entry_point="code/abalone.py",
    instance_type=instance_type,
    instance_count=training_instance_count,
    output_path=model_path,
    role=role,
    sagemaker_session=local_pipeline_session,
)

Optional können wir zum Beispiel weitere Schätzmethoden aufrufen set_hyperparameters(), um Hyperparametereinstellungen für den Trainingsjob bereitzustellen. Nachdem wir nun einen Estimator konfiguriert haben, können wir den eigentlichen Trainingsschritt erstellen. Auch hier importieren wir die TrainingStep Klasse aus der SageMaker SDK-Bibliothek:

from sagemaker.workflow.steps import TrainingStep

step_train = TrainingStep(name="AbaloneTrain", step_args=train_args)

Als nächstes bauen wir einen weiteren Verarbeitungsschritt auf, um die Modellbewertung durchzuführen. Dies geschieht durch die Erstellung einer ScriptProcessor Instanz und Weitergabe der local_pipeline_session Objekt als Parameter:

from sagemaker.processing import ScriptProcessor

script_eval = ScriptProcessor(
    image_uri=image_uri,
    command=["python3"],
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="script-abalone-eval",
    role=role,
    sagemaker_session=local_pipeline_session,
)

Um die Bereitstellung des trainierten Modells zu ermöglichen, entweder auf a SageMaker-Echtzeitendpunkt oder zu einer Stapeltransformation müssen wir eine erstellen Model -Objekt, indem Sie die Modellartefakte, den richtigen Bild-URI und optional unseren benutzerdefinierten Inferenzcode übergeben. Diese passieren wir dann Model Objekt zu einem ModelStep, die der lokalen Pipeline hinzugefügt wird. Siehe folgenden Code:

from sagemaker.model import Model

model = Model(
    image_uri=image_uri,
    model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
    source_dir="code",
    entry_point="inference.py",
    role=role,
    sagemaker_session=local_pipeline_session,
)

from sagemaker.workflow.model_step import ModelStep

step_create_model = ModelStep(name="AbaloneCreateModel", 
    step_args=model.create(instance_type=instance_type)
)

Als Nächstes erstellen wir einen Batch-Transformationsschritt, in dem wir eine Reihe von Merkmalsvektoren übermitteln und eine Inferenz durchführen. Wir müssen zuerst eine erstellen Transformer Objekt und übergeben Sie die local_pipeline_session Parameter dazu. Dann erstellen wir eine TransformStep, übergeben Sie die erforderlichen Argumente und fügen Sie dies der Pipelinedefinition hinzu:

from sagemaker.transformer import Transformer

transformer = Transformer(
    model_name=step_create_model.properties.ModelName,
    instance_type=instance_type,
    instance_count=transform_instance_count,
    output_path=f"s3://{default_bucket}/{prefix}/transform",
    sagemaker_session=local_pipeline_session,
)

from sagemaker.workflow.steps import TransformStep

transform_args = transformer.transform(transform_data, content_type="text/csv")

step_transform = TransformStep(name="AbaloneTransform", step_args=transform_args)

Abschließend möchten wir dem Workflow eine Verzweigungsbedingung hinzufügen, sodass wir die Stapeltransformation nur ausführen, wenn die Ergebnisse der Modellbewertung unsere Kriterien erfüllen. Wir können diese Bedingung angeben, indem wir a hinzufügen ConditionStep mit einem bestimmten Bedingungstyp, wie z ConditionLessThanOrEqualTo. Dann zählen wir die Schritte für die beiden Zweige auf und definieren im Wesentlichen die if/else- oder true/false-Zweige der Pipeline. Die in der bereitgestellten if_steps ConditionStep (step_create_model, step_transform) werden immer dann ausgeführt, wenn die Bedingung zu ausgewertet wird True.

from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.functions import JsonGet

cond_lte = ConditionLessThanOrEqualTo(
    left=JsonGet(
        step_name=step_eval.name,
        property_file=evaluation_report,
        json_path="regression_metrics.mse.value",),
    right=mse_threshold,
)

step_cond = ConditionStep(
    name="AbaloneMSECond",
    conditions=[cond_lte],
    if_steps=[step_create_model, step_transform],
    else_steps=[step_fail],
)

Das folgende Diagramm veranschaulicht diese bedingte Verzweigung und die zugehörigen if/else-Schritte. Nur eine Verzweigung wird basierend auf dem Ergebnis des Modellauswertungsschritts im Vergleich zum Bedingungsschritt ausgeführt.

Nachdem wir nun alle unsere Schritte definiert und die zugrunde liegenden Klasseninstanzen erstellt haben, können wir sie in einer Pipeline kombinieren. Wir stellen einige Parameter bereit und definieren die Reihenfolge der Operation entscheidend, indem wir einfach die Schritte in der gewünschten Reihenfolge auflisten. Notiere dass der TransformStep wird hier nicht angezeigt, da es das Ziel des bedingten Schritts ist und als Schrittargument für die bereitgestellt wurde ConditionalStep früher.

from sagemaker.workflow.pipeline import Pipeline

pipeline_name = f"LocalModelPipeline"
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        input_data,
        mse_threshold,
    ],
    steps=[step_process, step_train, step_eval, step_cond],
    sagemaker_session=local_pipeline_session,
)

Um die Pipeline auszuführen, müssen Sie zwei Methoden aufrufen: pipeline.upsert(), der die Pipeline in den zugrunde liegenden Dienst hochlädt, und pipeline.start(), wodurch die Ausführung der Pipeline gestartet wird. Sie können verschiedene andere Methoden verwenden, um den Ausführungsstatus abzufragen, die Pipelineschritte aufzulisten und vieles mehr. Da wir die Pipelinesitzung im lokalen Modus verwendet haben, werden diese Schritte alle lokal auf Ihrem Prozessor ausgeführt. Die Zellenausgabe unter der Startmethode zeigt die Ausgabe der Pipeline:

pipeline.upsert(role_arn=role)
execution = pipeline.start()

Unten in der Zellausgabe sollte eine Meldung ähnlich der folgenden angezeigt werden:

Pipeline execution d8c3e172-089e-4e7a-ad6d-6d76caf987b7 SUCCEEDED

Zurück zu verwalteten Ressourcen

Nachdem wir bestätigt haben, dass die Pipeline fehlerfrei ausgeführt wird, und wir mit dem Fluss und der Form der Pipeline zufrieden sind, können wir die Pipeline neu erstellen, aber mit von SageMaker verwalteten Ressourcen, und sie erneut ausführen. Die einzige erforderliche Änderung ist die Verwendung von PipelineSession Objekt statt LocalPipelineSession:

für sagemaker.workflow.pipeline_context importiert LocalPipelineSession
from sagemaker.workflow.pipeline_context import PipelineSession

local_pipeline_session = LocalPipelineSession()
pipeline_session = PipelineSession()

Dadurch wird der Dienst angewiesen, jeden Schritt auszuführen, der auf dieses Sitzungsobjekt auf von SageMaker verwalteten Ressourcen verweist. Angesichts der kleinen Änderung veranschaulichen wir nur die erforderlichen Codeänderungen in der folgenden Codezelle, aber dieselbe Änderung müsste in jeder Zelle mit implementiert werden local_pipeline_session Objekt. Die Änderungen sind jedoch in allen Zellen identisch, da wir nur die ersetzen local_pipeline_session Objekt mit dem pipeline_session Objekt.

from sagemaker.sklearn.processing import SKLearnProcessor

framework_version = "1.0-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-abalone-process",
    role=role,
    sagemaker_session=pipeline_session,  # non-local session
)

Nachdem das lokale Sitzungsobjekt überall ersetzt wurde, erstellen wir die Pipeline neu und führen sie mit von SageMaker verwalteten Ressourcen aus:

from sagemaker.workflow.pipeline import Pipeline

pipeline_name = f"LocalModelPipeline"
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        input_data,
        mse_threshold,
    ],
    steps=[step_process, step_train, step_eval, step_cond],
    sagemaker_session=pipeline_session, # non-local session
)

pipeline.upsert(role_arn=role)
execution = pipeline.start()

Aufräumen

Wenn Sie die Studio-Umgebung aufgeräumt halten möchten, können Sie die SageMaker-Pipeline und das Modell mit den folgenden Methoden löschen. Den vollständigen Code finden Sie im Beispiel Notizbuch.

# delete models 
sm_client = boto3.client("sagemaker")
model_prefix="AbaloneCreateModel"
delete_models(sm_client, model_prefix)

# delete managed pipeline
pipeline_to_delete = 'SM-Managed-Pipeline'
delete_sagemaker_pipeline(sm_client, pipeline_to_delete)

Zusammenfassung

Bis vor kurzem konnten Sie die lokale Modusfunktion von SageMaker Processing und SageMaker Training verwenden, um Ihre Verarbeitungs- und Trainingsskripts lokal zu durchlaufen, bevor Sie sie auf allen Daten mit von SageMaker verwalteten Ressourcen ausführen. Mit der neuen Funktion für den lokalen Modus von SageMaker Pipelines können ML-Experten jetzt beim Iterieren ihrer ML-Pipelines dieselbe Methode anwenden und die verschiedenen ML-Workflows zusammenfügen. Wenn die Pipeline für die Produktion bereit ist, sind für ihre Ausführung mit von SageMaker verwalteten Ressourcen nur wenige Zeilen Codeänderungen erforderlich. Dies reduziert die Pipeline-Laufzeit während der Entwicklung, was zu einer schnelleren Pipeline-Entwicklung mit kürzeren Entwicklungszyklen führt und gleichzeitig die Kosten für von SageMaker verwaltete Ressourcen senkt.

Um mehr zu erfahren, besuchen Sie Amazon SageMaker-Pipelines or Verwenden Sie SageMaker-Pipelines, um Ihre Jobs lokal auszuführen.

Über die Autoren

Paul Hargis hat seine Bemühungen auf maschinelles Lernen bei mehreren Unternehmen konzentriert, darunter AWS, Amazon und Hortonworks. Es macht ihm Spaß, technische Lösungen zu entwickeln und Menschen beizubringen, wie sie das Beste daraus machen können. Vor seiner Rolle bei AWS war er leitender Architekt für Amazon Exports and Expansions und half amazon.com dabei, das Erlebnis für internationale Käufer zu verbessern. Paul hilft Kunden gerne, ihre maschinellen Lerninitiativen zu erweitern, um reale Probleme zu lösen.

Niklas Palme ist ein Lösungsarchitekt bei AWS in Stockholm, Schweden, wo er Kunden in den nordischen Ländern hilft, in der Cloud erfolgreich zu sein. Er interessiert sich besonders für serverlose Technologien sowie für IoT und maschinelles Lernen. Außerhalb der Arbeit ist Niklas ein begeisterter Langläufer und Snowboarder sowie ein Meister-Eierkessel.

Kirit Thadaka ist ein ML Solutions Architect, der im Team von SageMaker Service SA arbeitet. Bevor er zu AWS kam, arbeitete Kirit in KI-Startups in der Frühphase, gefolgt von einer Zeit als Beraterin in verschiedenen Rollen in den Bereichen KI-Forschung, MLOps und technische Führung.