Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# SageMaker KI-Workflows
Wenn Sie Ihre Machine-Learning-Operationen (ML) skalieren, können Sie die vollständig verwalteten Workflow-Services von Amazon SageMaker AI verwenden, um Methoden der kontinuierlichen Integration und Bereitstellung (CI/CD) für Ihren ML-Lebenszyklus zu implementieren. Mit dem Pipelines SDK wählen und integrieren Sie Pipeline-Schritte in eine einheitliche Lösung, die den Modellerstellungsprozess von der Datenvorbereitung bis zur Modellbereitstellung automatisiert. Für Kubernetes-basierte Architekturen können Sie SageMaker KI-Operatoren auf Ihrem Kubernetes-Cluster installieren, um SageMaker KI-Jobs nativ mithilfe der Kubernetes-API und Kubernetes-Befehlszeilentools zu erstellen, wie z. `kubectl` Mit SageMaker KI-Komponenten für Kubeflow-Pipelines können Sie native KI-Jobs von Ihren Kubeflow-Pipelines aus erstellen und überwachen. SageMaker Auf die Jobparameter, den Status und die Ausgaben von SageMaker AI kann über die Benutzeroberfläche von Kubeflow Pipelines zugegriffen werden. Wenn Sie Batch-Jobs planen möchten, können Sie schließlich entweder die AWS Batch Job-Queue-Integration oder den Jupyter-Workflow-Service auf Notebook-Basis verwenden, um eigenständige oder reguläre Läufe nach einem von Ihnen definierten Zeitplan zu initiieren.
Zusammenfassend bietet SageMaker KI die folgenden Workflow-Technologien:
+ [Pipelines](pipelines.md): Tool zum Erstellen und Verwalten von ML-Pipelines.
+ [Kubernetes-Orchestrierung](kubernetes-workflows.md): Benutzerdefinierte SageMaker KI-Operatoren für Ihren Kubernetes-Cluster und Komponenten für Kubeflow-Pipelines.
+ [SageMaker Jobs im Notizbuch](notebook-auto-run.md): Bedarfsgesteuerte oder geplante, nicht interaktive Batchausführungen Ihres Jupyter Notebooks.
Sie können auch andere Dienste nutzen, die in SageMaker KI integriert sind, um Ihren Workflow zu erstellen. Es gibt die folgenden Optionen:
+ [Airflow-Workflows](https://sagemaker.readthedocs.io/en/stable/workflows/airflow/index.html): SageMaker APIs zum Exportieren von Konfigurationen für die Erstellung und Verwaltung von Airflow-Workflows.
+ [AWS Step Functions](https://sagemaker.readthedocs.io/en/stable/workflows/step_functions/index.html): Mehrstufige ML-Workflows in Python, die die SageMaker KI-Infrastruktur orchestrieren, ohne Ihre Ressourcen separat bereitstellen zu müssen.
+ [AWS Batch](https://docs.aws.amazon.com/batch/latest/userguide/getting-started-sagemaker.html): Senden Sie SageMaker KI-Schulungsjobs an eine AWS Batch Job-Warteschlange, in der Sie Jobs für die Ausführung in einer Computerumgebung priorisieren und planen können.
Weitere Informationen zur Verwaltung von SageMaker Schulungen und Inferenzen finden Sie unter [Amazon SageMaker Python SDK-Workflows](https://sagemaker.readthedocs.io/en/stable/workflows/index.html).
**Topics**
+ [Pipelines](pipelines.md)
+ [Kubernetes-Orchestrierung](kubernetes-workflows.md)
+ [SageMaker Jobs im Notizbuch](notebook-auto-run.md)
+ [Planen Sie Ihre ML-Workflows](workflow-scheduling.md)
+ [AWS Batch Unterstützung für SageMaker KI-Ausbildungsjobs](training-job-queues.md)
# Pipelines
Amazon SageMaker Pipelines ist ein speziell entwickelter Workflow-Orchestrierungsservice zur Automatisierung der Entwicklung von maschinellem Lernen (ML).
Pipelines bieten die folgenden Vorteile gegenüber anderen Workflow-Angeboten: AWS
**Automatische Skalierung der serverlosen Infrastruktur** Sie müssen die zugrunde liegende Orchestrierungsinfrastruktur nicht verwalten, um Pipelines auszuführen, sodass Sie sich auf die wichtigsten ML-Aufgaben konzentrieren können. SageMaker KI stellt die Rechenressourcen für die Pipeline-Orchestrierung automatisch bereit, skaliert und heruntergefahren, je nachdem, was Ihr ML-Workload benötigt.
Pipelines für ein **intuitives Benutzererlebnis** können über die Benutzeroberfläche Ihrer Wahl erstellt und verwaltet werden: Visual Editor APIs, SDK oder JSON. Sie können drag-and-drop die verschiedenen ML-Schritte zum Erstellen Ihrer Pipelines in der visuellen Oberfläche von Amazon SageMaker Studio ausführen. Der folgende Screenshot zeigt den Visual Editor für Pipelines in Studio.
![\[Screenshot der visuellen drag-and-drop Oberfläche für Pipelines in Studio.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/pipelines/pipelines-studio-overview.png)
Wenn Sie es vorziehen, Ihre ML-Workflows programmgesteuert zu verwalten, bietet das SageMaker Python-SDK erweiterte Orchestrierungsfunktionen. Weitere Informationen finden Sie unter [Amazon SageMaker Pipelines](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html) in der SageMaker Python SDK-Dokumentation.
**AWS Integrationen** Pipelines bieten eine nahtlose Integration mit allen SageMaker KI-Funktionen und anderen AWS Services zur Automatisierung von Datenverarbeitungs-, Modelltraining-, Feinabstimmungs-, Evaluierungs-, Bereitstellungs- und Überwachungsaufgaben. Sie können die SageMaker KI-Funktionen in Ihre Pipelines integrieren und mithilfe von Deep-Links zwischen ihnen navigieren, um Ihre ML-Workflows in großem Umfang zu erstellen, zu überwachen und zu debuggen.
**Geringere Kosten** Mit Pipelines zahlen Sie nur für die SageMaker Studio-Umgebung und die zugrunde liegenden Jobs, die von Pipelines orchestriert werden (z. B. SageMaker Training, SageMaker Verarbeitung, SageMaker KI Inference und Amazon S3 S3-Datenspeicher).
**Überprüfbarkeit und Herkunftsverfolgung Mit Pipelines können Sie mithilfe der integrierten Versionierung** den Verlauf von Pipeline-Updates und -Ausführungen verfolgen. Amazon SageMaker ML Lineage Tracking hilft Ihnen bei der Analyse der Datenquellen und Datenverbraucher im end-to-end ML-Entwicklungszyklus.
**Topics**
+ [Übersicht über die Pipelines](pipelines-overview.md)
+ [Pipeline-Aktionen](pipelines-build.md)
# Übersicht über die Pipelines
Eine Amazon SageMaker AI-Pipeline besteht aus einer Reihe miteinander verbundener Schritte in einem gerichteten azyklischen Graph (DAG), die mithilfe der drag-and-drop Benutzeroberfläche oder des [Pipelines](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html) SDK definiert werden. Sie können Ihre Pipeline erstellen, indem Sie das [JSON-Schema der Pipeline-Definition](https://aws-sagemaker-mlops.github.io/sagemaker-model-building-pipeline-definition-JSON-schema/) verwenden. Diese DAG-JSON-Definition enthält Informationen zu den Anforderungen und Beziehungen zwischen den einzelnen Schritten Ihrer Pipeline. Die Struktur der DAG einer Pipeline wird durch die Datenabhängigkeiten zwischen den Schritten bestimmt. Diese Datenabhängigkeiten entstehen, wenn die Eigenschaften der Ausgabe eines Schritts als Eingabe an einen anderen Schritt übergeben werden. Die folgende Abbildung ist ein Beispiel für eine Pipeline-DAG:
![\[\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/pipeline-full.png)
**In diesem DAG-Beispiel werden folgende Schritte beschrieben:**
1. `AbaloneProcess`, eine Instance des [Verarbeitungsschritts, führt ein Vorverarbeitungsskript](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing) für die für das Training verwendeten Daten aus. Das Skript könnte beispielsweise fehlende Werte ausfüllen, numerische Daten normalisieren oder Daten in die Datensätze „Train“, „Validation“ und „Test“ aufteilen.
1. `AbaloneTrain`, eine Instance des [Trainingsschritts](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-training), konfiguriert Hyperparameter und trainiert ein Modell anhand der vorverarbeiteten Eingabedaten.
1. `AbaloneEval`, eine weitere Instance des [Verarbeitungsschritts](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing), bewertet das Modell auf seine Genauigkeit. Dieser Schritt veranschaulicht ein Beispiel für eine Datenabhängigkeit – dieser Schritt verwendet die Testdatensatzausgabe von `AbaloneProcess`.
1. `AbaloneMSECond`ist eine Instanz eines [Bedingungsschritts](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-condition), der in diesem Beispiel überprüft, ob das mean-square-error Ergebnis der Modellevaluierung unter einem bestimmten Grenzwert liegt. Wenn das Modell die Kriterien nicht erfüllt, wird der Pipelineverlauf beendet.
1. Der Pipeline-Lauf wird mit den folgenden Schritten fortgesetzt:
1. `AbaloneRegisterModel`, wo SageMaker KI einen [RegisterModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-register-model)Schritt aufruft, um das Modell als versionierte Modellpaketgruppe in der Amazon SageMaker Model Registry zu registrieren.
1. `AbaloneCreateModel`, wobei SageMaker KI einen [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-create-model)Schritt zur Erstellung des Modells zur Vorbereitung der Batch-Transformation aufruft. In ruft SageMaker KI einen [Transformationsschritt](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-transform) auf`AbaloneTransform`, um Modellvorhersagen für einen von Ihnen angegebenen Datensatz zu generieren.
In den folgenden Themen werden die grundlegenden Konzepte von Pipelines beschrieben. Ein Tutorial, das die Implementierung dieser Konzepte beschreibt, finden Sie unter [Pipeline-Aktionen](pipelines-build.md).
**Topics**
+ [Struktur und Ausführung der Pipeline](build-and-manage-pipeline.md)
+ [IAM-Zugriffsverwaltung](build-and-manage-access.md)
+ [Einrichten von kontoübergreifendem Support für Pipelines](build-and-manage-xaccount.md)
+ [Pipeline-Parameter](build-and-manage-parameters.md)
+ [Pipelines-Schritte](build-and-manage-steps.md)
+ [Lift-and-shift Python-Code mit dem @step -Decorator](pipelines-step-decorator.md)
+ [Daten zwischen Schritten weitergeben](build-and-manage-propertyfile.md)
+ [Zwischenspeichern von Pipeline-Schritten](pipelines-caching.md)
+ [Richtlinie für Pipeline-Schritte erneut versuchen](pipelines-retry-policy.md)
+ [Selektive Ausführung von Pipeline-Schritten](pipelines-selective-ex.md)
+ [Basisberechnung, Drifterkennung und Lebenszyklus mit ClarifyCheck und QualityCheck Schritte in Amazon SageMaker Pipelines](pipelines-quality-clarify-baseline-lifecycle.md)
+ [Planen von Pipeline-Läufen](pipeline-eventbridge.md)
+ [Integration von Amazon SageMaker Experiments](pipelines-experiments.md)
+ [Führen Sie Pipelines im lokalen Modus aus](pipelines-local-mode.md)
+ [Fehlerbehebung bei Amazon SageMaker Pipelines](pipelines-troubleshooting.md)
# Struktur und Ausführung der Pipeline
**Topics**
+ [Pipeline-Struktur](#build-and-manage-pipeline-structure)
+ [Pipeline-Ausführung mithilfe der Parallelismus-Konfiguration](#build-and-manage-pipeline-execution)
## Pipeline-Struktur
Eine Amazon SageMaker Pipelines-Instance besteht aus einem `name``parameters`, und`steps`. Phasennamen müssen innerhalb eines `(account, region)`-Paares eindeutig sein. Alle in den Schrittdefinitionen verwendeten Parameter müssen in der Pipeline definiert werden. Die aufgelisteten Pipeline-Schritte bestimmen automatisch ihre Ausführungsreihenfolge anhand ihrer Datenabhängigkeiten voneinander. Der Pipelines-Service löst die Beziehungen zwischen Schritten in der Datenabhängigkeits-DAG auf, um eine Reihe von Schritten zu erstellen, die durch die Ausführung abgeschlossen werden. Im Folgenden finden Sie ein Beispiel für eine Pipeline-Struktur.
**Warnung**
Wenn Sie eine Pipeline mit dem Visual Editor oder dem SageMaker AI Python SDK erstellen, sollten Sie keine vertraulichen Informationen in Pipeline-Parameter oder Schrittdefinitionsfelder (wie Umgebungsvariablen) aufnehmen. Diese Felder werden in future sichtbar sein, wenn sie in einer `DescribePipeline` Anfrage zurückgegeben werden.
```
from sagemaker.workflow.pipeline import Pipeline
pipeline_name = f"AbalonePipeline"
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_type,
processing_instance_count,
training_instance_type,
model_approval_status,
input_data,
batch_data,
],
steps=[step_process, step_train, step_eval, step_cond],
)
```
## Pipeline-Ausführung mithilfe der Parallelismus-Konfiguration
Standardmäßig führt eine Pipeline alle Schritte aus, die parallel ausgeführt werden können. Sie können dieses Verhalten mithilfe der `ParallelismConfiguration` Eigenschaft steuern, wenn Sie eine Pipeline erstellen oder aktualisieren oder wenn Sie eine Pipeline-Ausführung starten oder erneut versuchen.
Parallelitätskonfigurationen werden pro Ausführung angewendet. Wenn beispielsweise zwei Ausführungen gestartet werden, können sie jeweils maximal 50 Schritte gleichzeitig ausführen, was insgesamt 100 gleichzeitig ausgeführten Schritten entspricht. Außerdem haben beim Starten, Wiederholen oder Aktualisieren einer Ausführung angegebene `ParallelismConfiguration`(n) Vorrang vor Parallelitätskonfigurationen, die in der Pipeline definiert wurden.
**Example Erstellen einer Pipeline-Ausführung mit `ParallelismConfiguration`**
```
pipeline = Pipeline(
name="myPipeline",
steps=[step_process, step_train]
)
pipeline.create(role, parallelism_config={"MaxParallelExecutionSteps": 50})
```
# IAM-Zugriffsverwaltung
In den folgenden Abschnitten werden die AWS Identity and Access Management (IAM-) Anforderungen für Amazon SageMaker Pipelines beschrieben. Ein Beispiel dafür, wie Sie diese Berechtigungen implementieren können, finden Sie unter [Voraussetzungen](define-pipeline.md#define-pipeline-prereq).
**Topics**
+ [Berechtigungen für Pipeline-Rollen](#build-and-manage-role-permissions)
+ [Berechtigungen für Pipeline-Schritte](#build-and-manage-step-permissions)
+ [CORS-Konfiguration mit Amazon-S3-Buckets](#build-and-manage-cors-s3)
+ [Anpassen der Zugriffsverwaltung für Pipelines-Aufträge](#build-and-manage-step-permissions-prefix)
+ [Passen Sie den Zugriff auf Pipeline-Versionen an](#build-and-manage-step-permissions-version)
+ [Service-Kontrollrichtlinien mit Pipelines](#build-and-manage-scp)
## Berechtigungen für Pipeline-Rollen
Ihre Pipeline erfordert eine IAM-Pipeline-Ausführungsrolle, die an Pipelines übergeben wird, wenn Sie eine Pipeline erstellen. Die Rolle für die SageMaker AI-Instanz, die Sie zum Erstellen der Pipeline verwenden, muss über eine Richtlinie mit der `iam:PassRole` Berechtigung verfügen, die die Pipeline-Ausführungsrolle spezifiziert. Dies liegt daran, dass die Instanz die Erlaubnis benötigt, Ihre Pipeline-Ausführungsrolle an den Pipeline-Dienst zu übergeben, damit er sie beim Erstellen und Ausführen von Pipelines verwenden kann. Weitere Informationen zu Rollen finden Sie unter [IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
Für Ihre Pipeline-Ausführungsrolle sind die folgenden Berechtigungen erforderlich:
+ Sie können für jeden der SageMaker KI-Auftragsschritte in Ihrer Pipeline eine eindeutige oder benutzerdefinierte Rolle verwenden (anstelle der Pipeline-Ausführungsrolle, die standardmäßig verwendet wird). Stellen Sie sicher, dass Ihrer Pipeline-Ausführungsrolle eine Richtlinie mit der `iam:PassRole` Berechtigung hinzugefügt wurde, die jede dieser Rollen spezifiziert.
+ `Create` und `Describe` Berechtigungen für jeden Jobtyp in der Pipeline.
+ Amazon-S3-Berechtigungen zur Verwendung der `JsonGet` Funktion. Sie können den Zugriff auf Ressourcen mit einer identitätsbasierten oder ressourcenbasierten Richtlinie steuern. Eine ressourcenbasierte Richtlinie wird auf Ihren Amazon-S3-Bucket angewendet und gewährt Pipelines Zugriff auf den Bucket. Eine identitätsbasierte Richtlinie gibt Ihrer Pipeline die Möglichkeit, Amazon-S3-Anrufe von Ihrem Konto aus zu tätigen. Weitere Informationen zu ressourcenbasierten Richtlinien finden Sie unter [Identitätsbasierte und ressourcenbasierte Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html).
```
{
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::/*",
"Effect": "Allow"
}
```
## Berechtigungen für Pipeline-Schritte
Pipelines enthalten Schritte, die SageMaker KI-Jobs ausführen. Damit die Pipeline-Schritte diese Jobs ausführen können, benötigen sie eine IAM-Rolle in Ihrem Konto, die Zugriff auf die benötigte Ressource bietet. Diese Rolle wird von Ihrer Pipeline an den SageMaker AI-Dienstprinzipal übergeben. Weitere Informationen zu Rollen finden Sie unter [IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
Standardmäßig übernimmt jeder Schritt die Rolle der Pipeline-Ausführung. Sie können optional jedem der Schritte in Ihrer Pipeline eine andere Rolle zuweisen. Dadurch wird sichergestellt, dass sich der Code in den einzelnen Schritten nicht auf Ressourcen auswirken kann, die in anderen Schritten verwendet werden, es sei denn, es besteht eine direkte Beziehung zwischen den beiden in der Pipeline-Definition angegebenen Schritten. Sie übergeben diese Rollen, wenn Sie den Prozessor oder den Schätzer für Ihren Schritt definieren. Beispiele dafür, wie diese Rollen in diese Definitionen aufgenommen werden können, finden Sie in der [SageMaker AI Python SDK-Dokumentation](https://sagemaker.readthedocs.io/en/stable/overview.html#using-estimators).
## CORS-Konfiguration mit Amazon-S3-Buckets
Um sicherzustellen, dass Ihre Images auf vorhersehbare Weise aus einem Amazon-S3-Bucket in Ihre Pipelines importiert werden, muss den Amazon-S3-Buckets, aus denen Images importiert werden, eine CORS-Konfiguration hinzugefügt werden. Dieser Abschnitt enthält Anweisungen zum Einrichten der erforderlichen CORS-Konfiguration für Ihren Amazon-S3-Bucket. Die für Pipelines erforderliche XML-`CORSConfiguration` unterscheidet sich von der in [CORS-Anforderung für Eingabebilddaten](sms-cors-update.md). Ansonsten können Sie die dortigen Informationen nutzen, um mehr über die CORS-Anforderungen bei Amazon-S3-Buckets zu erfahren.
Verwenden Sie den folgenden CORS-Konfigurationscode für die Amazon-S3-Buckets, die Ihre Bilder hosten. Anweisungen zum Konfigurieren von CORS finden Sie unter [Konfigurieren von Cross-Origin Resource Sharing (CORS)](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-cors-configuration.html) im Benutzerhandbuch für Amazon Simple Storage Service. Wenn Sie die Amazon S3-Konsole verwenden, um die Richtlinie zu Ihrem Bucket hinzuzufügen, müssen Sie das JSON-Format verwenden.
**JSON**
```
[
{
"AllowedHeaders": [
"*"
],
"AllowedMethods": [
"PUT"
],
"AllowedOrigins": [
"*"
],
"ExposeHeaders": [
"Access-Control-Allow-Origin"
]
}
]
```
**XML**
```
**PUTAccess-Control-Allow-Origin
```
Das folgende GIF zeigt die Anweisungen in der Amazon S3-Dokumentation zum Hinzufügen einer CORS-Header-Richtlinie mithilfe der Amazon S3-Konsole.
![\[Gif zum Hinzufügen einer CORS-Header-Richtlinie mit der Amazon-S3-Konsole.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/sms/gifs/cors-config.gif)
## Anpassen der Zugriffsverwaltung für Pipelines-Aufträge
Sie können Ihre IAM-Richtlinien weiter anpassen, sodass ausgewählte Mitglieder in Ihrer Organisation einzelne oder alle Pipeline-Schritte ausführen können. Sie können beispielsweise bestimmten Benutzern die Berechtigung zum Erstellen von Trainingsaufträgen und einer anderen Benutzergruppe die Berechtigung zum Erstellen von Verarbeitungsaufträgen und all Ihren Benutzern die Erlaubnis erteilen, die verbleibenden Schritte auszuführen. Um diese Funktion zu verwenden, wählen Sie eine benutzerdefinierte Zeichenfolge aus, die Ihrem Jobnamen vorangestellt wird. Ihr Administrator stellt dem Präfix erlaubt ARNs das Präfix voran, während Ihr Datenwissenschaftler dieses Präfix in Pipeline-Instanziierungen einbezieht. Da die IAM-Richtlinie für zugelassene Benutzer einen Job-ARN mit dem angegebenen Präfix enthält, verfügen nachfolgende Jobs Ihres Pipeline-Schritts über die erforderlichen Berechtigungen, um fortzufahren. Das Job-Präfix ist standardmäßig deaktiviert. Sie müssen diese Option in Ihrer `Pipeline` Klasse aktivieren, um sie verwenden zu können.
Bei Jobs mit deaktiviertem Präfix wird der Jobname wie abgebildet formatiert und ist eine Verkettung von Feldern, die in der folgenden Tabelle beschrieben werden:
`pipelines----`
| Feld | Definition |
| --- | --- |
| Pipelines | Eine statische Zeichenfolge wird immer vorangestellt. Diese Zeichenfolge identifiziert den Pipeline-Orchestrierungsdienst als Quelle des Jobs. |
| executionId | Ein zufälliger Puffer für die laufende Instance der Pipeline. |
| stepNamePrefix | Der vom Benutzer angegebene Schrittname (im `name` Argument des Pipeline-Schritts angegeben), begrenzt auf die ersten 20 Zeichen. |
| entityToken | Ein zufälliges Token, um die Idempotenz der Schrittentität sicherzustellen. |
| failureCount | Die aktuelle Anzahl der Versuche, den Job abzuschließen. |
In diesem Fall wird dem Jobnamen kein benutzerdefiniertes Präfix vorangestellt, und die entsprechende IAM-Richtlinie muss mit dieser Zeichenfolge übereinstimmen.
Für Benutzer, die das Job-Präfix aktivieren, hat der zugrunde liegende Jobname die folgende Form, wobei das benutzerdefinierte Präfix wie folgt angegeben ist: `MyBaseJobName`
**-**-**-**
Das benutzerdefinierte Präfix ersetzt die statische `pipelines` Zeichenfolge, sodass Sie die Auswahl der Benutzer einschränken können, die den SageMaker KI-Job als Teil einer Pipeline ausführen können.
**Längenbeschränkungen für das Präfix**
Die Auftragsnamen haben interne Längenbeschränkungen, die für einzelne Pipeline-Schritte spezifisch sind. Diese Einschränkung begrenzt auch die Länge des zulässigen Präfixes. Die Anforderungen an die Präfixlänge lauten wie folgt:
| Pipeline-Schritt | Länge des Präfixes |
| --- | --- |
| `[TrainingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#trainingstep)`, `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)`, `[TransformStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#transformstep)`, `[ProcessingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#processingstep)`, `[ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)`, `[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)`, `[RegisterModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)` | 38 |
| `[TuningStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#tuningstep)`, `[AutoML](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#automlstep)` | 6 |
### Wenden Sie Job-Präfixe auf eine IAM-Richtlinie an
Ihr Administrator erstellt IAM-Richtlinien, die es Benutzern mit bestimmten Präfixen ermöglichen, Jobs zu erstellen. Die folgende Beispielrichtlinie ermöglicht es Datenwissenschaftlern, Trainingsjobs zu erstellen, wenn sie das `MyBaseJobName` Präfix verwenden.
```
{
"Action": "sagemaker:CreateTrainingJob",
"Effect": "Allow",
"Resource": [
"arn:aws:sagemaker:region:account-id:*/MyBaseJobName-*"
]
}
```
### Wenden Sie Job-Präfixe auf Pipeline-Instanziierungen an
Sie geben Ihr Präfix mit dem `*base_job_name` Argument der Job-Instance-Klasse an.
**Anmerkung**
Sie übergeben Ihr Job-Präfix mit dem `*base_job_name` Argument an die Job-Instance, bevor Sie einen Pipeline-Schritt erstellen. Diese Auftrags-Instance enthält die erforderlichen Informationen, damit der Job als Schritt in einer Pipeline ausgeführt werden kann. Dieses Argument hängt von der verwendeten Auftrags-Instance ab. Die folgende Liste zeigt, welches Argument für jeden Pipeline-Schritttyp verwendet werden sollte:
`base_job_name` für die Klassen `[Estimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html)` (`[TrainingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#trainingstep)`), `[Processor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html)` (`[ProcessingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#processingstep)`) und `[AutoML](https://sagemaker.readthedocs.io/en/stable/api/training/automl.html)` (`[AutoMLStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#automlstep)`)
`tuning_base_job_name` für die `[Tuner](https://sagemaker.readthedocs.io/en/stable/api/training/tuner.html)` Klasse (`[TuningStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#tuningstep)`)
`transform_base_job_name` für die `[Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html)` Klasse (`[TransformStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#transformstep)`)
`base_job_name` von `[CheckJobConfig](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#checkjobconfig)` für die Klassen `[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)` (Qualitätsprüfung) und `[ClarifyCheckstep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)` (Klärungsprüfung)
Für die `[Model](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html)` Klasse hängt das verwendete Argument davon ab, ob Sie das Modell ausführen `create` oder ob es `register` sich um Ihr Modell handelt, bevor das Ergebnis an übergeben wird `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)`
Wenn Sie `create` aufrufen, stammt das benutzerdefinierte Präfix aus dem `name` Argument, das Sie bei der Konstruktion Ihres Modells angegeben haben (d. h., `Model(name=)`)
Wenn Sie `register` aufrufen, stammt das benutzerdefinierte Präfix aus dem `model_package_name` Argument Ihres Aufrufs von `register` (d. h., `my_model.register(model_package_name=)`)
Im folgenden Beispiel wird gezeigt, wie Sie ein Präfix für eine neue Trainingsauftrags-Instance angeben:
```
# Create a job instance
xgb_train = Estimator(
image_uri=image_uri,
instance_type="ml.m5.xlarge",
instance_count=1,
output_path=model_path,
role=role,
subnets=["subnet-0ab12c34567de89f0"],
base_job_name="MyBaseJobName"
security_group_ids=["sg-1a2bbcc3bd4444e55"],
tags = [ ... ]
encrypt_inter_container_traffic=True,
)
# Attach your job instance to a pipeline step
step_train = TrainingStep(
name="TestTrainingJob",
estimator=xgb_train,
inputs={
"train": TrainingInput(...),
"validation": TrainingInput(...)
}
)
```
Das Auftrag-Präfix ist standardmäßig deaktiviert. Um sich für diese Funktion zu entscheiden, verwenden Sie die `use_custom_job_prefix` Option von `PipelineDefinitionConfig`, wie im folgenden Codeausschnitt gezeigt:
```
from sagemaker.workflow.pipeline_definition_config import PipelineDefinitionConfig
# Create a definition configuration and toggle on custom prefixing
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=True);
# Create a pipeline with a custom prefix
pipeline = Pipeline(
name="MyJobPrefixedPipeline",
parameters=[...]
steps=[...]
pipeline_definition_config=definition_config
)
```
Erstellen Sie Ihre Pipeline und führen Sie sie aus. Im folgenden Beispiel wird eine Pipeline erstellt und ausgeführt. Außerdem wird veranschaulicht, wie Sie das Auftrag-Präfix deaktivieren und Ihre Pipeline erneut ausführen können.
```
pipeline.create(role_arn=sagemaker.get_execution_role())
# Optionally, call definition() to confirm your prefixed job names are in the built JSON
pipeline.definition()
pipeline.start()
# To run a pipeline without custom-prefixes, toggle off use_custom_job_prefix, update the pipeline
# via upsert() or update(), and start a new run
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=False)
pipeline.pipeline_definition_config = definition_config
pipeline.update()
execution = pipeline.start()
```
In ähnlicher Weise können Sie die Funktion für bestehende Pipelines aktivieren und eine neue Ausführung starten, die Auftragspräfixe verwendet.
```
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=True)
pipeline.pipeline_definition_config = definition_config
pipeline.update()
execution = pipeline.start()
```
Schließlich können Sie Ihren Auftrag mit einem benutzerdefinierten Präfix anzeigen, indem Sie die Pipeline-Ausführung aufrufen`list_steps`.
```
steps = execution.list_steps()
prefixed_training_job_name = steps['PipelineExecutionSteps'][0]['Metadata']['TrainingJob']['Arn']
```
## Passen Sie den Zugriff auf Pipeline-Versionen an
Mithilfe des `sagemaker:PipelineVersionId` Bedingungsschlüssels können Sie benutzerdefinierten Zugriff auf bestimmte Versionen von Amazon SageMaker Pipelines gewähren. Die folgende Richtlinie gewährt beispielsweise Zugriff auf das Starten von Ausführungen oder das Aktualisieren der Pipeline-Version nur für Version 6 und höher.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "AllowStartPipelineExecution",
"Effect": "Allow",
"Action": [
"sagemaker:StartPipelineExecution",
"sagemaker:UpdatePipelineVersion"
],
"Resource": "*",
"Condition": {
"NumericGreaterThanEquals": {
"sagemaker:PipelineVersionId": 6
}
}
}
}
```
------
Weitere Informationen zu unterstützten Bedingungsschlüsseln finden Sie unter [Bedingungsschlüssel für Amazon SageMaker AI](https://docs.aws.amazon.com//service-authorization/latest/reference/list_amazonsagemaker.html#amazonsagemaker-policy-keys).
## Service-Kontrollrichtlinien mit Pipelines
Richtlinien zur Dienstkontrolle (SCPs) sind eine Art von Organisationsrichtlinie, mit der Sie Berechtigungen in Ihrer Organisation verwalten können. SCPs bieten eine zentrale Kontrolle über die maximal verfügbaren Berechtigungen für alle Konten in Ihrer Organisation. Durch die Verwendung von Pipelines innerhalb Ihrer Organisation können Sie sicherstellen, dass Datenwissenschaftler Ihre Pipeline-Ausführungen verwalten, ohne mit der AWS Konsole interagieren zu müssen.
Wenn Sie eine VPC mit Ihrem SCP verwenden, die den Zugriff auf Amazon S3 einschränkt, müssen Sie Maßnahmen ergreifen, damit Ihre Pipeline auf andere Amazon S3-Ressourcen zugreifen kann.
Um Pipelines den Zugriff auf Amazon S3 außerhalb Ihrer VPC mit dieser `JsonGet`-Funktion zu ermöglichen, aktualisieren Sie den SCP Ihres Unternehmens, um sicherzustellen, dass die Rolle, die Pipelines verwendet, auf Amazon S3 zugreifen kann. Erstellen Sie dazu mithilfe eines Principal-Tags und eines Bedingungsschlüssels eine Ausnahme für Rollen, die vom Pipelines-Executor über die Pipeline-Ausführungsrolle verwendet werden.
**So erlauben Sie Pipelines den Zugriff auf Amazon S3 außerhalb Ihrer VPC**
1. Erstellen Sie ein eindeutiges Tag für Ihre Pipeline-Ausführungsrolle, indem Sie die Schritte unter [Taggen von IAM-Benutzern und -Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html) befolgen.
1. Gewähren Sie in Ihrem SCP mithilfe des `Aws:PrincipalTag IAM` Bedingungsschlüssels für das von Ihnen erstellte Tag eine Ausnahme. Weitere Informationen finden Sie unter [Erstellen, Aktualisieren und Löschen von Service-Kontrollrichtlinien](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_create.html).
# Einrichten von kontoübergreifendem Support für Pipelines
Der kontoübergreifende Support für Amazon SageMaker Pipelines ermöglicht es Ihnen, an Machine-Learning-Pipelines mit anderen Teams oder Organisationen zusammenzuarbeiten, die in unterschiedlichen Konten tätig sind. AWS Durch die Einrichtung der kontoübergreifenden Pipeline-Freigabe können Sie kontrollierten Zugriff auf Pipelines gewähren, anderen Konten ermöglichen, Pipeline-Details einzusehen, Ausführungen auszulösen und Läufe zu überwachen. Das folgende Thema behandelt, wie Sie die kontenübergreifende Pipeline-Freigabe einrichten, welche unterschiedlichen Berechtigungsrichtlinien für gemeinsam genutzte Ressourcen verfügbar sind und wie Sie über direkte API-Aufrufe an KI auf gemeinsam genutzte Pipeline-Entitäten zugreifen und mit ihnen interagieren können. SageMaker
## Einrichten der kontoübergreifenden Pipeline-Freigabe
SageMaker KI verwendet [AWS Resource Access Manager](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html) (AWS RAM), um Ihnen zu helfen, Ihre Pipeline-Entitäten sicher für mehrere Konten gemeinsam zu nutzen.
### Erstellen einer Ressourcen-Freigabe
1. Wählen Sie über die [AWS RAM Konsole](https://console.aws.amazon.com/ram/home) **eine Ressourcenfreigabe erstellen** aus.
1. Wenn Sie Details zur Ressourcenfreigabe angeben, wählen Sie den Ressourcentyp „Pipelines“ und anschließend eine oder mehrere Pipelines aus, die Sie gemeinsam nutzen möchten. Wenn Sie eine Pipeline mit einem anderen Konto teilen, werden alle ihre Ausführungen ebenfalls implizit geteilt.
1. Ordnen Sie eine Berechtigung einer Ressourcenfreigabe zu. Wählen Sie entweder die standardmäßige Richtlinie für schreibgeschützte Berechtigungen oder die erweiterte Richtlinie für die Pipeline-Ausführung. Detailliertere Informationen erhalten Sie unter [Berechtigungsrichtlinien für Pipelines-Ressourcen](#build-and-manage-xaccount-permissions).
**Anmerkung**
Wenn Sie die erweiterte Pipeline-Ausführungsrichtlinie auswählen, beachten Sie, dass alle Start-, Stopp- und Wiederholungsbefehle, die von gemeinsam genutzten Konten aufgerufen werden, Ressourcen in dem AWS Konto verwenden, das die Pipeline gemeinsam genutzt hat.
1. Verwenden Sie das AWS Konto IDs , um die Konten anzugeben, denen Sie Zugriff auf Ihre gemeinsam genutzten Ressourcen gewähren möchten.
1. Überprüfen Sie Ihre Konfiguration für die gemeinsame Nutzung Ihrer Ressourcen und wählen Sie **Ressourcenfreigabe erstellen** aus. Es kann einige Minuten dauern, bis die Ressourcenfreigabe und die Hauptverknüpfungen abgeschlossen sind.
Weitere Informationen finden Sie unter [Freigabe Ihrer AWS Ressourcen](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-sharing.html) im *AWS Benutzerhandbuch für den Resource Access Manager*.
### Erhalten Sie Antworten auf Ihre Einladung zur gemeinsamen Nutzung von Ressourcen
Sobald die Ressourcenfreigabe und die Hauptzuordnungen festgelegt sind, erhalten die angegebenen AWS Konten eine Einladung, um der Ressourcenfreigabe beizutreten. Die AWS Konten müssen die Einladung annehmen, um Zugriff auf gemeinsam genutzte Ressourcen zu erhalten.
Weitere Informationen zum Annehmen einer Einladung zur gemeinsamen Nutzung von Ressourcen finden Sie unter [Verwenden von gemeinsam genutzten AWS Ressourcen](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-shared.html) im *AWS Resource Access Manager Manager-Benutzerhandbuch*. AWS RAM
## Berechtigungsrichtlinien für Pipelines-Ressourcen
Wählen Sie bei der Erstellung Ihrer Ressourcenfreigabe eine von zwei unterstützten Berechtigungsrichtlinien aus, die Sie dem Ressourcentyp der SageMaker AI-Pipeline zuordnen möchten. Beide Richtlinien gewähren Zugriff auf jede ausgewählte Pipeline und all ihre Ausführungen.
### Standardmäßige schreibgeschützte Berechtigungen
Die `AWSRAMDefaultPermissionSageMakerPipeline`-Richtlinie erlaubt die folgenden schreibgeschützten Aktionen:
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:Search"
```
### Erweiterte Berechtigungen zur Pipeline-Ausführung
Die `AWSRAMPermissionSageMakerPipelineAllowExecution` Richtlinie umfasst alle Leseberechtigungen der Standardrichtlinie und ermöglicht es gemeinsam genutzten Konten, Pipeline-Ausführungen zu starten, zu beenden und erneut zu versuchen.
**Anmerkung**
Achten Sie bei der Verwendung der Richtlinie für erweiterte Genehmigungen zur Pipeline-Ausführung auf die AWS Ressourcennutzung. Mit dieser Richtlinie können gemeinsam genutzte Konten Pipeline-Ausführungen starten, beenden und erneut versuchen. Alle Ressourcen, die für gemeinsam genutzte Pipeline-Ausführungen verwendet werden, werden vom Besitzerkonto verbraucht.
Die Richtlinie für erweiterte Pipeline-Ausführungsberechtigungen ermöglicht die folgenden Aktionen:
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:StartPipelineExecution"
"sagemaker:StopPipelineExecution"
"sagemaker:RetryPipelineExecution"
"sagemaker:Search"
```
## Greifen Sie über direkte API-Aufrufe auf gemeinsam genutzte Pipeline-Entitäten zu
Sobald die kontoübergreifende Pipeline-Freigabe eingerichtet ist, können Sie die folgenden SageMaker API-Aktionen mithilfe eines Pipeline-ARN aufrufen:
**Anmerkung**
Sie können API-Befehle nur aufrufen, wenn sie in den mit Ihrer Ressourcenfreigabe verknüpften Berechtigungen enthalten sind. Wenn Sie die `AWSRAMPermissionSageMakerPipelineAllowExecution` Richtlinie auswählen, verwenden die Befehle Start, Stop und Retry Ressourcen in dem AWS Konto, das die Pipeline gemeinsam genutzt hat.
+ [DescribePipeline](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipeline.html)
+ [DescribePipelineDefinitionForExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipelineDefinitionForExecution.html)
+ [DescribePipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipelineExecution.html)
+ [ListPipelineExecutions](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineExecutions.html)
+ [ListPipelineExecutionSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineExecutionSteps.html)
+ [ListPipelineParametersForExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineParametersForExecution.html)
+ [StartPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StartPipelineExecution.html)
+ [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html)
+ [RetryPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RetryPipelineExecution.html)
# Pipeline-Parameter
Sie können Variablen mithilfe von Parametern in Ihre Pipeline-Definition aufnehmen. Sie können in Ihrer Pipeline-Definition auf Parameter verweisen, die Sie definieren. Parameter haben einen Standardwert, den Sie überschreiben können, indem Sie beim Starten einer Pipeline-Ausführung Parameterwerte angeben. Der Standardwert muss eine Instance sein, die dem Parametertyp entspricht. Alle in Schrittdefinitionen verwendeten Parameter müssen in Ihrer Pipeline-Definition definiert sein. In diesem Thema werden die Parameter beschrieben, die Sie definieren können, und wie Sie sie implementieren können.
Amazon SageMaker Pipelines unterstützt die folgenden Parametertypen:
+ `ParameterString`– Stellt einen Zeichenkettenparameter dar.
+ `ParameterInteger`– Stellt einen Integer-Parameter dar.
+ `ParameterFloat`– Stellt einen Float-Parameter dar.
+ `ParameterBoolean`– Stellt einen booleschen Python-Typ dar.
Die Parameter haben das folgende Format:
```
= (
name="",
default_value=
)
```
Das folgende Beispiel zeigt eine Beispielimplementierung eines Parameters.
```
from sagemaker.workflow.parameters import (
ParameterInteger,
ParameterString,
ParameterFloat,
ParameterBoolean
)
processing_instance_count = ParameterInteger(
name="ProcessingInstanceCount",
default_value=1
)
```
Sie übergeben den Parameter bei der Erstellung Ihrer Pipeline wie im folgenden Beispiel dargestellt.
```
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_count
],
steps=[step_process]
)
```
Sie können auch einen Parameterwert, der vom Standardwert abweicht, an eine Pipeline-Ausführung übergeben, wie im folgenden Beispiel gezeigt.
```
execution = pipeline.start(
parameters=dict(
ProcessingInstanceCount="2",
ModelApprovalStatus="Approved"
)
)
```
Sie können Parameter mit SageMaker Python-SDK-Funktionen wie manipulieren`[ sagemaker.workflow.functions.Join](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.functions.Join)`. Weitere Informationen zu Parametern finden Sie unter [ SageMaker Pipeline-Parameter](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#parameters).
Bekannte Einschränkungen von Pipeline-Parametern finden Sie unter *[Einschränkungen — Parametrisierung](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#parameterization)* im [Amazon SageMaker ](https://sagemaker.readthedocs.io/en/stable) Python SDK.
# Pipelines-Schritte
Pipelines bestehen aus Schritten. Diese Schritte definieren die Aktionen, die die Pipeline ausführt, und die Beziehungen zwischen den Schritten mithilfe von Eigenschaften. Auf der folgenden Seite werden die Arten von Schritten, ihre Eigenschaften und die Beziehungen zwischen ihnen beschrieben.
**Topics**
+ [Einen Schritt hinzufügen](build-and-manage-steps-types.md)
+ [Integration hinzufügen](build-and-manage-steps-integration.md)
+ [Eigenschaften-Schritt](#build-and-manage-properties)
+ [Schrittparallelität](#build-and-manage-parallelism)
+ [Datenabhängigkeit zwischen Schritten](#build-and-manage-data-dependency)
+ [Benutzerdefinierte Abhängigkeit zwischen Schritten](#build-and-manage-custom-dependency)
+ [Benutzerdefinierte Bilder in einem Schritt](#build-and-manage-images)
# Einen Schritt hinzufügen
Im Folgenden werden die Anforderungen der einzelnen Schritttypen beschrieben und ein Beispiel für die Implementierung des Schritts sowie die Vorgehensweise zum Hinzufügen des Schritts zu einer Pipeline aufgeführt. Dabei handelt es sich nicht um funktionale Implementierungen, da sie nicht die benötigten Ressourcen und Eingaben bereitstellen. Ein Tutorial, das diese Schritte implementiert, finden Sie unter [Pipeline-Aktionen](pipelines-build.md).
**Anmerkung**
Sie können auch einen Schritt aus Ihrem lokalen Machine-Learning-Code erstellen, indem Sie ihn mit dem `@step`-Decorator in einen Pipelines-Schritt konvertieren. Weitere Informationen finden Sie unter [@step Decorator](#step-type-custom).
Amazon SageMaker Pipelines unterstützt die folgenden Schritttypen:
+ [Code ausführen](#step-type-executecode)
[Verarbeitung](#step-type-processing)
+ [Training](#step-type-training)
+ [Optimieren](#step-type-tuning)
+ [AutoML](#step-type-automl)
+ [`Model`](#step-type-model)
+ [`Create model`](#step-type-create-model)
+ [`Register model`](#step-type-register-model)
+ [`Deploy model (endpoint)`](#step-type-deploy-model-endpoint)
+ [Transformieren](#step-type-transform)
+ [Bedingung](#step-type-condition)
+ [`Callback`](#step-type-callback)
+ [Lambda](#step-type-lambda)
+ [`ClarifyCheck`](#step-type-clarify-check)
+ [`QualityCheck`](#step-type-quality-check)
+ [EMR](#step-type-emr)
+ [Notebook-Auftrag](#step-type-notebook-job)
+ [Fehler](#step-type-fail)
## @step Decorator
Wenn Sie einen benutzerdefinierten ML-Job orchestrieren möchten, der erweiterte SageMaker KI-Funktionen oder andere AWS Dienste in der drag-and-drop Pipelines-Benutzeroberfläche nutzt, verwenden Sie den. [Codeschritt ausführen](#step-type-executecode)
Sie können mithilfe des `@step`-Decorators einen Schritt aus lokalem Machine-Learning-Code erstellen. Nachdem Sie Ihren Code getestet haben, können Sie die Funktion in einen SageMaker KI-Pipeline-Schritt konvertieren, indem Sie sie mit dem Decorator kommentieren. `@step` Pipelines erstellt eine Pipeline und führt sie aus, wenn Sie die Ausgabe der mit `@step` -dekorierten Funktion als Schritt an Ihre Pipeline übergeben. Sie können auch eine mehrstufige DAG-Pipeline erstellen, die eine oder mehrere `@step` dekorierte Funktionen sowie herkömmliche SageMaker KI-Pipeline-Schritte umfasst. Weitere Informationen zum Erstellen eines Steps mit `@step`-Decorator finden Sie unter [Lift-and-shift Python-Code mit dem @step -Decorator](pipelines-step-decorator.md).
## Codeschritt ausführen
In der drag-and-drop Pipelines-Benutzeroberfläche können Sie einen Codeschritt **ausführen verwenden, um Ihren eigenen Code** als Pipeline-Schritt auszuführen. Sie können eine Python-Funktion, ein Skript oder ein Notebook hochladen, das als Teil Ihrer Pipeline ausgeführt werden soll. Sie sollten diesen Schritt verwenden, wenn Sie einen benutzerdefinierten ML-Job orchestrieren möchten, der erweiterte SageMaker KI-Funktionen oder andere Dienste nutzt. AWS
Der Schritt **Code ausführen** lädt Dateien in Ihren standardmäßigen Amazon S3 S3-Bucket für Amazon SageMaker AI hoch. Für diesen Bucket sind möglicherweise nicht die erforderlichen Cross-Origin Resource Sharing (CORS) -Berechtigungen festgelegt. Weitere Informationen zum Konfigurieren der CORS-Berechtigungen finden Sie unter [CORS-Anforderung für Eingabebilddaten](sms-cors-update.md).
Der Schritt „**Code ausführen**“ verwendet einen SageMaker Amazon-Schulungsjob, um Ihren Code auszuführen. Stellen Sie sicher, dass Ihre IAM-Rolle über die `sagemaker:DescribeTrainingJob` und `sagemaker:CreateTrainingJob` API-Berechtigungen verfügt. Weitere Informationen zu allen erforderlichen Berechtigungen für Amazon SageMaker AI und deren Einrichtung finden Sie unter[Amazon SageMaker AI API-Berechtigungen: Referenz zu Aktionen, Berechtigungen und Ressourcen](api-permissions-reference.md).
Gehen Sie wie folgt vor, um einer Pipeline mithilfe des Pipeline Designers einen Schritt zum Ausführen von Code hinzuzufügen:
1. Öffnen Sie die Amazon SageMaker Studio-Konsole, indem Sie den Anweisungen unter folgen[Starten Sie Amazon SageMaker Studio](studio-updated-launch.md).
1. Wählen Sie im linken Navigationsbereich die Option **Pipelines** aus.
1. Wählen Sie **Erstellen** aus.
1. **Wählen Sie Leer.**
1. Wählen Sie in der linken Seitenleiste „**Code ausführen**“ und ziehen Sie ihn auf die Arbeitsfläche.
1. Wählen Sie auf der Arbeitsfläche den Schritt **Code ausführen aus**, den Sie hinzugefügt haben.
1. Füllen Sie in der rechten Seitenleiste die Formulare auf den Tabs **Einstellungen** und **Details** aus.
1. Sie können eine einzelne Datei hochladen, um sie auszuführen, oder einen komprimierten Ordner hochladen, der mehrere Artefakte enthält.
1. Für das Hochladen einzelner Dateien können Sie optionale Parameter für Notebooks, Python-Funktionen oder Skripte angeben.
1. Bei der Bereitstellung von Python-Funktionen muss ein Handler im folgenden Format bereitgestellt werden `file.py:`
1. Für komprimierte Ordner-Uploads müssen relative Pfade zu Ihrem Code angegeben werden, und Sie können optional Pfade zu einer `requirements.txt` Datei oder einem Initialisierungsskript innerhalb des komprimierten Ordners angeben.
1. Wenn die Arbeitsfläche einen Schritt enthält, der unmittelbar vor dem von Ihnen hinzugefügten Schritt „**Code ausführen**“ steht, klicken Sie auf den Schritt und ziehen Sie den Cursor von diesem Schritt zum Schritt „**Code ausführen**“, um eine Kante zu erstellen.
1. Wenn die Zeichenfläche einen Schritt enthält, der unmittelbar auf den Schritt „**Code ausführen**“ folgt, klicken Sie auf den Schritt „Code ausführen“ und ziehen Sie den Cursor vom Schritt „**Code ausführen**“ zu dem Schritt, um eine Kante zu erstellen. Ausgaben von **Execute-Codeschritten** können für Python-Funktionen referenziert werden.
## Verarbeitungsschritt
Verwenden Sie einen Verarbeitungsschritt, um einen Verarbeitungsauftrag für die Datenverarbeitung zu erstellen. Weitere Informationen zur Verarbeitung von Auftrags finden Sie unter [Daten verarbeiten und Modelle auswerten](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html).
------
#### [ Pipeline Designer ]
Gehen Sie wie folgt vor, um einer Pipeline mithilfe des Pipeline Designers einen Verarbeitungsschritt hinzuzufügen:
1. Öffnen Sie die Amazon SageMaker Studio-Konsole, indem Sie den Anweisungen unter folgen[Starten Sie Amazon SageMaker Studio](studio-updated-launch.md).
1. Wählen Sie im linken Navigationsbereich die Option **Pipelines** aus.
1. Wählen Sie **Erstellen** aus.
1. Wählen Sie in der linken Seitenleiste die Option **Daten verarbeiten** und ziehen Sie sie auf die Arbeitsfläche.
1. Wählen Sie auf der Arbeitsfläche den Schritt „**Daten verarbeiten**“ aus, den Sie hinzugefügt haben.
1. Füllen Sie in der rechten Seitenleiste die Formulare auf den Tabs **Einstellungen** und **Details** aus. Informationen zu den Feldern in diesen Tabs finden Sie unter [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep).
1. **Wenn die Arbeitsfläche einen Schritt enthält, der dem hinzugefügten **Prozessdatenschritt** unmittelbar vorausgeht, klicken Sie auf den Schritt und ziehen Sie den Cursor von diesem Schritt zum Prozessdatenschritt, um eine Kante zu erstellen.**
1. Wenn die Arbeitsfläche einen Schritt enthält, der unmittelbar auf den von Ihnen hinzugefügten **Prozessdatenschritt** folgt, klicken Sie und ziehen Sie den Cursor vom **Prozessdatenschritt** zu dem Schritt, um eine Kante zu erstellen.
------
#### [ SageMaker Python SDK ]
Ein Verarbeitungsschritt erfordert einen Prozessor, ein Python-Skript, das den Verarbeitungscode definiert, Ausgaben für die Verarbeitung und Auftrag-Argumente. Das folgende Beispiel zeigt, wie man eine `ProcessingStep`-Definition erstellt.
```
from sagemaker.sklearn.processing import SKLearnProcessor
sklearn_processor = SKLearnProcessor(framework_version='1.0-1',
role=,
instance_type='ml.m5.xlarge',
instance_count=1)
```
```
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
inputs = [
ProcessingInput(source=, 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")
]
step_process = ProcessingStep(
name="AbaloneProcess",
step_args = sklearn_processor.run(inputs=inputs, outputs=outputs,
code="abalone/preprocessing.py")
)
```
**Übergeben Sie Laufzeitparameter**
Das folgende Beispiel zeigt, wie Laufzeitparameter von einem PySpark Prozessor an einen übergeben `ProcessingStep` werden.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.spark.processing import PySparkProcessor
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
pipeline_session = PipelineSession()
pyspark_processor = PySparkProcessor(
framework_version='2.4',
role=,
instance_type='ml.m5.xlarge',
instance_count=1,
sagemaker_session=pipeline_session,
)
step_args = pyspark_processor.run(
inputs=[ProcessingInput(source=, 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="preprocess.py",
arguments=None,
)
step_process = ProcessingStep(
name="AbaloneProcess",
step_args=step_args,
)
```
Weitere Informationen zu den Anforderungen für Verarbeitungsschritte finden Sie unter [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep)Dokumentation. Ein ausführliches Beispiel finden Sie im [Beispielnotizbuch Orchestrate Jobs to Train and Evaluate Models with Amazon SageMaker Pipelines](https://github.com/aws/amazon-sagemaker-examples/blob/62de6a1fca74c7e70089d77e36f1356033adbe5f/sagemaker-pipelines/tabular/abalone_build_train_deploy/sagemaker-pipelines-preprocess-train-evaluate-batch-transform.ipynb). Weitere Informationen finden Sie im Abschnitt *Verarbeitungsschritt für Feature Engineering definieren*.
------
## Schritt des Trainings
Sie verwenden einen Trainingsschritt, um einen Trainingsjob zum Trainieren eines Modells zu erstellen. Weitere Informationen zu Schulungsjobs finden Sie unter [Train a Model with Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html).
Ein Trainingsschritt erfordert einen Schätzer sowie Eingaben von Trainings- und Validierungsdaten.
------
#### [ Pipeline Designer ]
Gehen Sie wie folgt vor, um einer Pipeline mithilfe des Pipeline Designers einen Trainingsschritt hinzuzufügen:
1. Öffnen Sie die Amazon SageMaker Studio-Konsole, indem Sie den Anweisungen unter folgen[Starten Sie Amazon SageMaker Studio](studio-updated-launch.md).
1. Wählen Sie im linken Navigationsbereich die Option **Pipelines** aus.
1. Wählen Sie **Erstellen** aus.
1. **Wählen Sie Leer.**
1. Wählen Sie in der linken Seitenleiste **Train Model** und ziehen Sie es auf die Leinwand.
1. Wählen Sie auf der Arbeitsfläche den Schritt **Train Model** aus, den Sie hinzugefügt haben.
1. Füllen Sie in der rechten Seitenleiste die Formulare auf den Tabs **Einstellungen** und **Details** aus. Informationen zu den Feldern in diesen Tabs finden Sie unter [sagemaker.workflow.steps. TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep).
1. **Wenn die Arbeitsfläche einen Schritt enthält, der unmittelbar vor dem Schritt **Modell trainieren**, den Sie hinzugefügt haben, klicken und ziehen Sie den Cursor von dem Schritt zum Schritt Modell trainieren, um eine Kante zu erstellen.**
1. Wenn die Arbeitsfläche einen Schritt enthält, der unmittelbar auf den Schritt **Modell trainieren** folgt, klicken Sie und ziehen Sie den Cursor vom Schritt **Modell trainieren** zu dem Schritt, um eine Kante zu erstellen.
------
#### [ SageMaker Python SDK ]
Das folgende Beispiel zeigt, wie Sie eine `TrainingStep`-Definition erstellen. Weitere Informationen zu den Anforderungen für Trainingsschritte finden Sie unter [sagemaker.workflow.steps. TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep)Dokumentation.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.inputs import TrainingInput
from sagemaker.workflow.steps import TrainingStep
from sagemaker.xgboost.estimator import XGBoost
pipeline_session = PipelineSession()
xgb_estimator = XGBoost(..., sagemaker_session=pipeline_session)
step_args = xgb_estimator.fit(
inputs={
"train": TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"train"
].S3Output.S3Uri,
content_type="text/csv"
),
"validation": TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"validation"
].S3Output.S3Uri,
content_type="text/csv"
)
}
)
step_train = TrainingStep(
name="TrainAbaloneModel",
step_args=step_args,
)
```
------
## Schritt zur Feinabstimmung
Sie verwenden einen Optimierungsschritt, um einen Hyperparameter-Tuning-Auftrag zu erstellen, der auch als Hyperparameter-Optimierung (HPO) bezeichnet wird. Ein Hyperparameter-Optimierungsauftrag führt mehrere Trainingsjobs aus, von denen jeder eine Modellversion erzeugt. Weitere Informationen zur Abstimmung der Hyperparameter finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).
Der Tuning-Job ist mit dem SageMaker KI-Experiment für die Pipeline verknüpft, wobei die Trainingsjobs als Versuche erstellt wurden. Weitere Informationen finden Sie unter [Integration von Experimenten](pipelines-experiments.md).
Ein Optimierungsschritt erfordert Eingaben [HyperparameterTuner](https://sagemaker.readthedocs.io/en/stable/api/training/tuner.html)und Trainingseingaben. Sie können frühere Abstimmungsaufträge erneut trainieren, indem Sie den `warm_start_config`-Parameter des `HyperparameterTuner` angeben. Weitere Informationen zur Hyperparameteroptimierung und zum Warmstart finden Sie unter [Durchführen eines Hyperparameter-Optimierungsauftrags mit Warmstart](automatic-model-tuning-warm-start.md).
[Sie verwenden die Methode [get\$1top\$1model\$1s3\$1uri](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep.get_top_model_s3_uri) der Datei sagemaker.workflow.steps. TuningStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep)Klasse, um das Modellartefakt aus einer der leistungsstärksten Modellversionen abzurufen. [Ein Notizbuch, das zeigt, wie ein Tuning-Schritt in einer SageMaker KI-Pipeline verwendet wird, finden Sie unter sagemaker-pipelines-tuning-step .ipynb.](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/tuning-step/sagemaker-pipelines-tuning-step.ipynb)
**Wichtig**
Optimierungsschritte wurden in Amazon SageMaker Python SDK v2.48.0 und Amazon SageMaker Studio Classic v3.8.0 eingeführt. Sie müssen Studio Classic aktualisieren, bevor Sie einen Optimierungsschritt verwenden, da sonst die Pipeline-DAG nicht angezeigt wird. Informationen zum Aktualisieren von Studio Classic finden Sie unter [Amazon SageMaker Studio Classic herunterfahren und aktualisieren](studio-tasks-update-studio.md).
Das folgende Beispiel zeigt, wie man eine `TuningStep`-Definition erstellt.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.tuner import HyperparameterTuner
from sagemaker.inputs import TrainingInput
from sagemaker.workflow.steps import TuningStep
tuner = HyperparameterTuner(..., sagemaker_session=PipelineSession())
step_tuning = TuningStep(
name = "HPTuning",
step_args = tuner.fit(inputs=TrainingInput(s3_data="s3://amzn-s3-demo-bucket/my-data"))
)
```
**Holen Sie sich die beste Modellversion**
Das folgende Beispiel zeigt, wie Sie mit der `get_top_model_s3_uri` Methode die beste Modellversion aus dem Tuning-Auftrag abrufen können. Es sind höchstens die 50 leistungsstärksten Versionen verfügbar, geordnet nach. [HyperParameterTuningJobObjective](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HyperParameterTuningJobObjective.html) Das Argument `top_k` ist ein Index für die Versionen, wobei `top_k=0` die leistungsstärkste und `top_k=49` die leistungsschwächste Version ist.
```
best_model = Model(
image_uri=image_uri,
model_data=step_tuning.get_top_model_s3_uri(
top_k=0,
s3_bucket=sagemaker_session.default_bucket()
),
...
)
```
Weitere Informationen zu den Anforderungen an die Optimierungsschritte finden Sie unter [sagemaker.workflow.steps. TuningStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep)Dokumentation.
## Feinabstimmungsschritt
Mit der Feinabstimmung wird ein vortrainiertes Fundamentmodell von Amazon SageMaker JumpStart anhand eines neuen Datensatzes trainiert. Dieser Prozess, der auch als Transferlernen bezeichnet wird, kann genaue Modelle mit kleineren Datensätzen und weniger Trainingszeit erzeugen. Bei der Feinabstimmung eines Modells können Sie den Standarddatensatz verwenden oder eigene Daten auswählen. Weitere Informationen zur Feinabstimmung eines Foundation-Modells finden Sie unter JumpStart. [Feinabstimmung eines Modells](jumpstart-fine-tune.md)
Bei der Feinabstimmung wird ein SageMaker Amazon-Schulungsjob verwendet, um Ihr Modell anzupassen. Stellen Sie sicher, dass Ihre IAM-Rolle über die erforderlichen `sagemaker:DescribeTrainingJob` und `sagemaker:CreateTrainingJob` API-Berechtigungen verfügt, um den Feinsteuerungsjob in Ihrer Pipeline auszuführen. Weitere Informationen zu den erforderlichen Berechtigungen für Amazon SageMaker AI und deren Einrichtung finden Sie unter[Amazon SageMaker AI API-Berechtigungen: Referenz zu Aktionen, Berechtigungen und Ressourcen](api-permissions-reference.md).
Gehen Sie wie folgt vor, um Ihrer Pipeline mithilfe des drag-and-drop Editors einen Schritt zur **Feinabstimmung des Modells** hinzuzufügen:
1. Öffnen Sie die Studio-Konsole, indem Sie den Anweisungen unter [Starten Sie Amazon SageMaker Studio](studio-updated-launch.md) folgen.
1. Wählen Sie im linken Navigationsbereich die Option **Pipelines** aus.
1. Wählen Sie **Erstellen** aus.
1. **Wählen Sie Leer.**
1. Wählen Sie in der linken Seitenleiste die Option **Modell feinabstimmen** und ziehen Sie es auf die Leinwand.
1. Wählen Sie auf der Leinwand den hinzugefügten Schritt zur **Feinabstimmung des Modells** aus.
1. Füllen Sie in der rechten Seitenleiste die Formulare auf den Tabs **Einstellungen** und **Details** aus.
1. Wenn die Zeichenfläche einen Schritt enthält, der unmittelbar vor dem Schritt „Modell **feinabstimmen“ liegt, klicken Sie auf den Schritt „Modell** feinabstimmen“ und ziehen Sie den Cursor von diesem Schritt zum Schritt „**Modell feinabstimmen**“, um eine Kante zu erstellen.
1. Wenn die Arbeitsfläche einen Schritt enthält, der unmittelbar auf den Schritt „Modell **feinabstimmen“ folgt, klicken Sie auf den Schritt „Modell** feinabstimmen“ und ziehen Sie den Cursor vom Schritt „**Modell feinabstimmen**“ zu dem Schritt, um eine Kante zu erstellen.
## AutoML-Schritt
Verwenden Sie die [AutoML](https://sagemaker.readthedocs.io/en/stable/api/training/automl.html)-API, um einen AutoML-Auftrag zum automatischen Trainieren eines Modells zu erstellen. Weitere Informationen zu AutoML-Jobs finden Sie unter [Automatisieren der Modellentwicklung mit Amazon SageMaker Autopilot](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development.html).
**Anmerkung**
Derzeit unterstützt der AutoML-Schritt nur den [Ensembling-Trainingsmodus](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-model-support-validation.html).
Das folgende Beispiel zeigt, wie eine Definition mit `AutoMLStep` erstellt werden kann.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.workflow.automl_step import AutoMLStep
pipeline_session = PipelineSession()
auto_ml = AutoML(...,
role="",
target_attribute_name="my_target_attribute_name",
mode="ENSEMBLING",
sagemaker_session=pipeline_session)
input_training = AutoMLInput(
inputs="s3://amzn-s3-demo-bucket/my-training-data",
target_attribute_name="my_target_attribute_name",
channel_type="training",
)
input_validation = AutoMLInput(
inputs="s3://amzn-s3-demo-bucket/my-validation-data",
target_attribute_name="my_target_attribute_name",
channel_type="validation",
)
step_args = auto_ml.fit(
inputs=[input_training, input_validation]
)
step_automl = AutoMLStep(
name="AutoMLStep",
step_args=step_args,
)
```
**Holen Sie sich die beste Modellversion**
Der AutoML-Schritt trainiert automatisch mehrere Modellkandidaten. Rufen Sie das Modell mit der besten Zielmetrik aus dem AutoML-Auftrag ab, indem Sie die `get_best_auto_ml_model`-Methode wie folgt verwenden. Sie müssen auch ein IAM verwenden, `role` um auf Modellartefakte zuzugreifen.
```
best_model = step_automl.get_best_auto_ml_model(role=)
```
Weitere Informationen finden Sie im [AutoML-Schritt](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.automl_step.AutoMLStep) im SageMaker Python-SDK.
## Modellschritt
Verwenden Sie a`ModelStep`, um ein SageMaker KI-Modell zu erstellen oder zu registrieren. Weitere Informationen zu den `ModelStep` Anforderungen finden Sie im Abschnitt [sagemaker.workflow.model\$1step. ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.model_step.ModelStep)Dokumentation.
### Erstellen eines Modells
Sie können a verwenden`ModelStep`, um ein SageMaker KI-Modell zu erstellen. A `ModelStep` benötigt Modellartefakte und Informationen über den SageMaker AI-Instanztyp, den Sie zur Erstellung des Modells verwenden müssen. Weitere Informationen zu SageMaker KI-Modellen finden Sie unter [Train a Model with Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html).
Das folgende Beispiel zeigt, wie man eine `ModelStep`-Definition erstellt.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.model import Model
from sagemaker.workflow.model_step import ModelStep
step_train = TrainingStep(...)
model = Model(
image_uri=pytorch_estimator.training_image_uri(),
model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
sagemaker_session=PipelineSession(),
role=role,
)
step_model_create = ModelStep(
name="MyModelCreationStep",
step_args=model.create(instance_type="ml.m5.xlarge"),
)
```
### Registrieren eines Modells
Sie können a verwenden`ModelStep`, um ein `sagemaker.model.Model` oder a `sagemaker.pipeline.PipelineModel` bei der Amazon SageMaker Model Registry zu registrieren. Ein `PipelineModel` stellt eine Inferenzpipeline dar, ein Modell, das aus einer linearen Abfolge von Containern besteht, die Inferenzanforderungen verarbeiten. Weitere Informationen über die Registrierung eines Modells finden Sie unter [Bereitstellung von Modellregistrierung mit Model Registry](model-registry.md).
Das folgende Beispiel zeigt, wie Sie eine `ModelStep` erstellen, die eine `PipelineModel` registriert.
```
import time
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.sklearn import SKLearnModel
from sagemaker.xgboost import XGBoostModel
pipeline_session = PipelineSession()
code_location = 's3://{0}/{1}/code'.format(bucket_name, prefix)
sklearn_model = SKLearnModel(
model_data=processing_step.properties.ProcessingOutputConfig.Outputs['model'].S3Output.S3Uri,
entry_point='inference.py',
source_dir='sklearn_source_dir/',
code_location=code_location,
framework_version='1.0-1',
role=role,
sagemaker_session=pipeline_session,
py_version='py3'
)
xgboost_model = XGBoostModel(
model_data=training_step.properties.ModelArtifacts.S3ModelArtifacts,
entry_point='inference.py',
source_dir='xgboost_source_dir/',
code_location=code_location,
framework_version='0.90-2',
py_version='py3',
sagemaker_session=pipeline_session,
role=role
)
from sagemaker.workflow.model_step import ModelStep
from sagemaker import PipelineModel
pipeline_model = PipelineModel(
models=[sklearn_model, xgboost_model],
role=role,sagemaker_session=pipeline_session,
)
register_model_step_args = pipeline_model.register(
content_types=["application/json"],
response_types=["application/json"],
inference_instances=["ml.t2.medium", "ml.m5.xlarge"],
transform_instances=["ml.m5.xlarge"],
model_package_group_name='sipgroup',
)
step_model_registration = ModelStep(
name="AbaloneRegisterModel",
step_args=register_model_step_args,
)
```
## Schritt „Modell erstellen“
Sie verwenden den Schritt Modell erstellen, um ein SageMaker KI-Modell zu erstellen. Weitere Informationen zu SageMaker KI-Modellen finden Sie unter[Trainiere ein Modell mit Amazon SageMaker](how-it-works-training.md).
Ein Schritt zum Erstellen eines Modells erfordert Modellartefakte und Informationen über den SageMaker AI-Instanztyp, den Sie zur Erstellung des Modells verwenden müssen. Die folgenden Beispiele zeigen, wie Sie eine Schrittdefinition für das Erstellen eines Modells erstellen. Weitere Informationen zu den Anforderungen für den Schritt Modell erstellen finden Sie unter [sagemaker.workflow.steps. CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep)Dokumentation.
------
#### [ Pipeline Designer ]
Gehen Sie wie folgt vor, um zu Ihrer Pipeline einen Schritt zum Erstellen eines Modells hinzuzufügen:
1. Öffnen Sie die Studio-Konsole, indem Sie den Anweisungen unter [Starten Sie Amazon SageMaker Studio](studio-updated-launch.md) folgen.
1. Wählen Sie im linken Navigationsbereich die Option **Pipelines** aus.
1. Wählen Sie **Erstellen** aus.
1. **Wählen Sie Leer.**
1. Wählen Sie in der linken Seitenleiste „**Modell erstellen**“ und ziehen Sie es auf die Leinwand.
1. Wählen Sie auf der Leinwand den Schritt **Modell erstellen** aus, den Sie hinzugefügt haben.
1. Füllen Sie in der rechten Seitenleiste die Formulare auf den Tabs **Einstellungen** und **Details** aus. Informationen zu den Feldern in diesen Tabs finden Sie unter [sagemaker.workflow.steps. CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep).
1. **Wenn die Arbeitsfläche einen Schritt enthält, der unmittelbar vor dem Schritt Modell erstellen liegt, den Sie hinzugefügt haben, klicken Sie auf den Schritt **Modell erstellen** und ziehen Sie den Cursor von diesem Schritt zum Schritt Modell erstellen, um eine Kante zu erstellen.**
1. Wenn die Leinwand einen Schritt enthält, der unmittelbar auf den Schritt **Modell erstellen folgt, klicken Sie auf den Schritt Modell erstellen** und ziehen Sie den Cursor vom Schritt **Modell erstellen** zu dem Schritt, um eine Kante zu erstellen.
------
#### [ SageMaker Python SDK ]
**Wichtig**
Wir empfehlen [Modellschritt](#step-type-model) die Verwendung zum Erstellen von Modellen ab Version 2.90.0 des SageMaker AI Python SDK. `CreateModelStep`funktioniert weiterhin in früheren Versionen des SageMaker Python-SDK, wird aber nicht mehr aktiv unterstützt.
```
from sagemaker.workflow.steps import CreateModelStep
step_create_model = CreateModelStep(
name="AbaloneCreateModel",
model=best_model,
inputs=inputs
)
```
------
## Schritt „Modell registrieren“
Der Schritt Modell registrieren registriert ein Modell in der SageMaker Model Registry.
------
#### [ Pipeline Designer ]
Gehen Sie wie folgt vor, um ein Modell aus einer Pipeline mit dem Pipeline Designer zu registrieren:
1. Öffnen Sie die Amazon SageMaker Studio-Konsole, indem Sie den Anweisungen unter folgen[Starten Sie Amazon SageMaker Studio](studio-updated-launch.md).
1. Wählen Sie im linken Navigationsbereich die Option **Pipelines** aus.
1. Wählen Sie **Erstellen** aus.
1. **Wählen Sie Leer.**
1. Wählen Sie in der linken Seitenleiste **Modell registrieren** und ziehen Sie es auf die Arbeitsfläche.
1. Wählen Sie auf der Arbeitsfläche den Schritt **Modell registrieren** aus, den Sie hinzugefügt haben.
1. Füllen Sie in der rechten Seitenleiste die Formulare auf den Tabs **Einstellungen** und **Details** aus. Informationen zu den Feldern in diesen Tabs finden Sie unter [sagemaker.workflow.step\$1collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel).
1. **Wenn die Arbeitsfläche einen Schritt enthält, der dem Schritt Modell registrieren, den Sie hinzugefügt haben, unmittelbar vorausgeht, klicken Sie auf den Schritt **Modell registrieren** und ziehen Sie den Cursor von diesem Schritt zum Schritt Modell registrieren, um eine Kante zu erstellen.**
1. Wenn die Zeichenfläche einen Schritt enthält, der unmittelbar auf den Schritt **Modell registrieren folgt, klicken Sie auf den Schritt Modell registrieren** und ziehen Sie den Cursor vom Schritt **Modell registrieren** zu dem Schritt, um eine Kante zu erstellen.
------
#### [ SageMaker Python SDK ]
**Wichtig**
Wir empfehlen [Modellschritt](#step-type-model) die Verwendung zur Registrierung von Modellen ab Version 2.90.0 des SageMaker AI Python SDK. `RegisterModel`funktioniert weiterhin in früheren Versionen des SageMaker Python-SDK, wird aber nicht mehr aktiv unterstützt.
[Sie verwenden einen `RegisterModel` Schritt, um ein [SageMaker.Model.Model oder eine Sagemaker.Pipeline](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html) zu registrieren. PipelineModel](https://sagemaker.readthedocs.io/en/stable/api/inference/pipeline.html#pipelinemodel)mit der Amazon SageMaker Model Registry. Ein `PipelineModel` stellt eine Inferenzpipeline dar, ein Modell, das aus einer linearen Abfolge von Containern besteht, die Inferenzanforderungen verarbeiten.
Weitere Informationen über die Registrierung eines Modells finden Sie unter [Bereitstellung von Modellregistrierung mit Model Registry](model-registry.md). Weitere Informationen zu den `RegisterModel` Schrittanforderungen finden Sie unter [sagemaker.workflow.step\$1collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel)Dokumentation.
Das folgende Beispiel zeigt, wie Sie einen Schritt `RegisterModel` erstellen, der eine `PipelineModel` registriert.
```
import time
from sagemaker.sklearn import SKLearnModel
from sagemaker.xgboost import XGBoostModel
code_location = 's3://{0}/{1}/code'.format(bucket_name, prefix)
sklearn_model = SKLearnModel(model_data=processing_step.properties.ProcessingOutputConfig.Outputs['model'].S3Output.S3Uri,
entry_point='inference.py',
source_dir='sklearn_source_dir/',
code_location=code_location,
framework_version='1.0-1',
role=role,
sagemaker_session=sagemaker_session,
py_version='py3')
xgboost_model = XGBoostModel(model_data=training_step.properties.ModelArtifacts.S3ModelArtifacts,
entry_point='inference.py',
source_dir='xgboost_source_dir/',
code_location=code_location,
framework_version='0.90-2',
py_version='py3',
sagemaker_session=sagemaker_session,
role=role)
from sagemaker.workflow.step_collections import RegisterModel
from sagemaker import PipelineModel
pipeline_model = PipelineModel(models=[sklearn_model,xgboost_model],role=role,sagemaker_session=sagemaker_session)
step_register = RegisterModel(
name="AbaloneRegisterModel",
model=pipeline_model,
content_types=["application/json"],
response_types=["application/json"],
inference_instances=["ml.t2.medium", "ml.m5.xlarge"],
transform_instances=["ml.m5.xlarge"],
model_package_group_name='sipgroup',
)
```
Wenn `model` nicht angegeben, benötigt der Registermodellschritt einen Schätzer, wie im folgenden Beispiel gezeigt.
```
from sagemaker.workflow.step_collections import RegisterModel
step_register = RegisterModel(
name="AbaloneRegisterModel",
estimator=xgb_train,
model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
content_types=["text/csv"],
response_types=["text/csv"],
inference_instances=["ml.t2.medium", "ml.m5.xlarge"],
transform_instances=["ml.m5.xlarge"],
model_package_group_name=model_package_group_name,
approval_status=model_approval_status,
model_metrics=model_metrics
)
```
------
## Schritte zum Bereitstellen von Modellen (Endpunkte)
Gehen Sie im Pipeline Designer mithilfe des Schritts Modell bereitstellen (Endpunkt) vor, um Ihr Modell auf einem Endpunkt bereitzustellen. Sie können einen neuen Endpunkt erstellen oder einen vorhandenen Endpunkt verwenden. Inferenz in Echtzeit ist ideal für Inferenz-Workloads, bei denen interaktive Echtzeitanforderungen mit geringer Latenz erfüllt werden müssen. Sie können Ihr Modell für SageMaker KI-Hosting-Dienste bereitstellen und erhalten einen Echtzeit-Endpunkt, der für Inferenzen verwendet werden kann. Diese Endgeräte werden vollständig verwaltet und unterstützen Auto Scaling. Weitere Informationen über Echtzeit-Inferenz in SageMaker KI finden Sie unter. [Echtzeit-Inferenz](realtime-endpoints.md)
Bevor Sie Ihrer Pipeline einen Schritt zum Bereitstellen eines Modells hinzufügen, vergewissern Sie sich, dass Ihre IAM-Rolle über die folgenden Berechtigungen verfügt:
+ `sagemaker:CreateModel`
+ `sagemaker:CreateEndpointConfig`
+ `sagemaker:CreateEndpoint`
+ `sagemaker:UpdateEndpoint`
+ `sagemaker:DescribeModel`
+ `sagemaker:DescribeEndpointConfig`
+ `sagemaker:DescribeEndpoint`
Weitere Informationen zu allen erforderlichen Berechtigungen für SageMaker KI und deren Einrichtung finden Sie unter[Amazon SageMaker AI API-Berechtigungen: Referenz zu Aktionen, Berechtigungen und Ressourcen](api-permissions-reference.md).
Gehen Sie wie folgt vor, um Ihrer Pipeline im drag-and-drop Editor einen Schritt zur Modellbereitstellung hinzuzufügen:
1. Öffnen Sie die Studio-Konsole, indem Sie den Anweisungen unter [Starten Sie Amazon SageMaker Studio](studio-updated-launch.md) folgen.
1. Wählen Sie im linken Navigationsbereich die Option **Pipelines** aus.
1. Wählen Sie **Erstellen** aus.
1. **Wählen Sie Leer.**
1. Wählen Sie in der linken Seitenleiste **Modell bereitstellen (Endpunkt)** aus und ziehen Sie es auf die Leinwand.
1. Wählen Sie auf der Arbeitsfläche den Schritt **Modell bereitstellen (Endpunkt)** aus, den Sie hinzugefügt haben.
1. Füllen Sie in der rechten Seitenleiste die Formulare auf den Tabs **Einstellungen** und **Details** aus.
1. Wenn die Arbeitsfläche einen Schritt enthält, der unmittelbar vor dem von Ihnen hinzugefügten Schritt **Modell bereitstellen (Endpunkt)** liegt, klicken Sie auf den Schritt und ziehen Sie den Cursor von diesem Schritt zum Schritt **Modell bereitstellen (Endpunkt)**, um eine Kante zu erstellen.
1. Wenn die Arbeitsfläche einen Schritt enthält, der unmittelbar auf den Schritt **Modell bereitstellen (Endpunkt)** folgt, klicken Sie auf den Schritt Modell bereitstellen (Endpunkt) und ziehen Sie den Cursor vom Schritt **Modell bereitstellen (Endpunkt)** auf den Schritt zum Erstellen einer Kante.
## Schritt Transformieren
Sie verwenden einen Transformationsschritt für die Batch-Transformation, um die Inferenz für einen gesamten Datensatz durchzuführen. Weitere Informationen zur Batch-Transformation finden Sie unter [Stapeltransformationen mit Inferenz-Pipelines](inference-pipeline-batch.md).
Ein Transformationsschritt erfordert einen Transformator und die Daten, für die die Batch-Transformation ausgeführt werden soll. Das folgende Beispiel zeigt, wie Sie eine Transform-Schrittdefinition erstellen. Weitere Informationen zu den Anforderungen für Transformationsschritte finden Sie unter [sagemaker.workflow.steps. TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep)Dokumentation.
------
#### [ Pipeline Designer ]
Gehen Sie wie folgt vor, um Ihrer Pipeline mithilfe des drag-and-drop visuellen Editors einen Batch-Transformationsschritt hinzuzufügen:
1. Öffnen Sie die Studio-Konsole, indem Sie den Anweisungen unter [Starten Sie Amazon SageMaker Studio](studio-updated-launch.md) folgen.
1. Wählen Sie im linken Navigationsbereich die Option **Pipelines** aus.
1. Wählen Sie **Erstellen** aus.
1. **Wählen Sie Leer.**
1. Wählen Sie in der linken Seitenleiste **Modell bereitstellen (Batch-Transformation)** und ziehen Sie es auf die Leinwand.
1. Wählen Sie auf der Arbeitsfläche den Schritt **Modell bereitstellen (Batch-Transformation)** aus, den Sie hinzugefügt haben.
1. Füllen Sie in der rechten Seitenleiste die Formulare auf den Tabs **Einstellungen** und **Details** aus. Informationen zu den Feldern in diesen Tabs finden Sie unter [sagemaker.workflow.steps. TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep).
1. Wenn die Arbeitsfläche einen Schritt enthält, der unmittelbar vor dem von Ihnen hinzugefügten Schritt **Modell bereitstellen (Batch-Transformation)** liegt, klicken Sie auf den Schritt und ziehen Sie den Cursor von diesem Schritt zum Schritt Modell **bereitstellen** (Batch-Transformation), um eine Kante zu erstellen.
1. Wenn die Arbeitsfläche einen Schritt enthält, der unmittelbar auf den Schritt **Modell bereitstellen (Batch-Transformation)** folgt, klicken Sie auf den Schritt Modell bereitstellen (Batch-Transformation) und ziehen Sie den Cursor vom Schritt **Modell bereitstellen (Batch-Transformation)** zu dem Schritt, um eine Kante zu erstellen.
------
#### [ SageMaker Python SDK ]
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.transformer import Transformer
from sagemaker.inputs import TransformInput
from sagemaker.workflow.steps import TransformStep
transformer = Transformer(..., sagemaker_session=PipelineSession())
step_transform = TransformStep(
name="AbaloneTransform",
step_args=transformer.transform(data="s3://amzn-s3-demo-bucket/my-data"),
)
```
------
## Bedingungsschritt
Sie verwenden einen Bedingungsschritt, um den Zustand der Schritteigenschaften zu bewerten, um zu beurteilen, welche Maßnahme als Nächstes in der Pipeline ergriffen werden sollte.
Ein Bedingungsschritt erfordert:
+ Eine Liste der Bedingungen.
+ Eine Liste von Schritten, die ausgeführt werden sollen, wenn die Bedingung `true` ist.
+ Eine Liste von Schritten, die ausgeführt werden sollen, wenn die Bedingung `false` ist.
------
#### [ Pipeline Designer ]
Gehen Sie wie folgt vor, um einer Pipeline mithilfe des Pipeline-Designers einen Bedingungsschritt hinzuzufügen:
1. Öffnen Sie die Amazon SageMaker Studio-Konsole, indem Sie den Anweisungen unter folgen[Starten Sie Amazon SageMaker Studio](studio-updated-launch.md).
1. Wählen Sie im linken Navigationsbereich die Option **Pipelines** aus.
1. Wählen Sie **Erstellen** aus.
1. **Wählen Sie Leer.**
1. Wählen Sie in der linken Seitenleiste die Option **Bedingung** aus und ziehen Sie sie auf die Leinwand.
1. Wählen Sie auf der Leinwand den Schritt „**Bedingung**“ aus, den Sie hinzugefügt haben.
1. Füllen Sie in der rechten Seitenleiste die Formulare auf den Tabs **Einstellungen** und **Details** aus. Informationen zu den Feldern in diesen Tabs finden Sie unter [sagemaker.workflow.condition\$1step. ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.condition_step.ConditionStep).
1. **Wenn die Arbeitsfläche einen Schritt enthält, der unmittelbar vor dem Schritt „Bedingung“ liegt, den Sie hinzugefügt haben, klicken Sie auf den Schritt und ziehen Sie den Cursor von diesem Schritt zum Schritt „**Bedingung**“, um eine Kante zu erstellen.**
1. Wenn die Zeichenfläche einen Schritt enthält, der unmittelbar auf den Schritt „**Bedingung**“ folgt, klicken Sie auf den Schritt „Bedingung“ und ziehen Sie den Cursor vom Schritt „**Bedingung**“ zu dem Schritt, um eine Kante zu erstellen.
------
#### [ SageMaker Python SDK ]
Das folgende Beispiel zeigt, wie Sie eine `ConditionStep`-Definition erstellen.
**Einschränkungen**
+ Pipelines unterstützt die Verwendung von verschachtelten Bedingungsschritten nicht. Sie können einen Bedingungsschritt nicht als Eingabe für einen anderen Bedingungsschritt übergeben.
+ Ein Bedingungsschritt kann nicht identische Schritte in beiden Zweigen verwenden. Wenn Sie in beiden Zweigen dieselbe Schrittfunktionalität benötigen, duplizieren Sie den Schritt und geben Sie ihm einen anderen Namen.
```
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=6.0
)
step_cond = ConditionStep(
name="AbaloneMSECond",
conditions=[cond_lte],
if_steps=[step_register, step_create_model, step_transform],
else_steps=[]
)
```
Weitere Informationen zu den `ConditionStep` Anforderungen finden Sie unter [sagemaker.workflow.condition\$1step. ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#conditionstep) API-Referenz. Weitere Informationen zu unterstützten Bedingungen finden Sie unter *[Amazon SageMaker Pipelines — Conditions](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#conditions)* in der SageMaker AI Python SDK-Dokumentation.
------
## Rückrufschritt
Verwenden Sie einen `Callback` Schritt, um Ihrem Workflow zusätzliche Prozesse und AWS Services hinzuzufügen, die nicht direkt von Amazon SageMaker Pipelines bereitgestellt werden. Wenn ein `Callback` Schritt ausgeführt wird, erfolgt das folgende Verfahren:
+ Pipelines sendet eine Nachricht an eine vom Kunden angegebene Warteschlange von Amazon Simple Queue Service (Amazon SQS). Die Nachricht enthält ein von Pipelines generiertes Token und eine vom Kunden bereitgestellte Liste von Eingabeparametern. Nach dem Absenden der Nachricht wartet Pipelines auf eine Antwort des Kunden.
+ Der Kunde ruft die Nachricht aus der Amazon-SQS-Warteschlange ab und startet seinen benutzerdefinierten Prozess.
+ Wenn der Vorgang abgeschlossen ist, ruft der Kunde eine der folgenden Adressen an APIs und übermittelt das von Pipelines generierte Token:
+ [SendPipelineExecutionStepSuccess](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepSuccess.html), zusammen mit einer Liste von Ausgabeparametern
+ [SendPipelineExecutionStepFailure](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepFailure.html), zusammen mit einem Fehlergrund
+ Der API-Aufruf veranlasst Pipelines, entweder den Pipeline-Prozess fortzusetzen oder den Prozess fehlschlagen zu lassen.
Weitere Informationen zu den `Callback` Schrittanforderungen finden Sie unter [sagemaker.workflow.callback\$1step. CallbackStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.callback_step.CallbackStep)Dokumentation. Eine vollständige Lösung finden Sie unter [Erweitern von SageMaker Pipelines um benutzerdefinierte Schritte mithilfe von Callback-Schritten](https://aws.amazon.com/blogs/machine-learning/extend-amazon-sagemaker-pipelines-to-include-custom-steps-using-callback-steps/).
**Wichtig**
`Callback`Schritte wurden in Amazon SageMaker Python SDK v2.45.0 und Amazon SageMaker Studio Classic v3.6.2 eingeführt. Sie müssen Studio Classic aktualisieren, bevor Sie einen `Callback`-Schritt verwenden, sonst wird die Pipeline-DAG nicht angezeigt. Informationen zum Aktualisieren von Studio Classic finden Sie unter [Amazon SageMaker Studio Classic herunterfahren und aktualisieren](studio-tasks-update-studio.md).
Das folgende Beispiel zeigt eine Implementierung des vorherigen Verfahrens.
```
from sagemaker.workflow.callback_step import CallbackStep
step_callback = CallbackStep(
name="MyCallbackStep",
sqs_queue_url="https://sqs.us-east-2.amazonaws.com/012345678901/MyCallbackQueue",
inputs={...},
outputs=[...]
)
callback_handler_code = '
import boto3
import json
def handler(event, context):
sagemaker_client=boto3.client("sagemaker")
for record in event["Records"]:
payload=json.loads(record["body"])
token=payload["token"]
# Custom processing
# Call SageMaker AI to complete the step
sagemaker_client.send_pipeline_execution_step_success(
CallbackToken=token,
OutputParameters={...}
)
'
```
**Anmerkung**
Die Ausgabeparameter für `CallbackStep` sollten nicht verschachtelt sein. Wenn Sie beispielsweise ein verschachteltes Wörterbuch als Ausgabeparameter verwenden, wird das Wörterbuch als eine einzelne Zeichenfolge behandelt (z. B. `{"output1": "{\"nested_output1\":\"my-output\"}"}`). Wenn Sie einen verschachtelten Wert angeben und versuchen, auf einen bestimmten Ausgabeparameter zu verweisen, gibt SageMaker AI einen Client-Fehler aus, der nicht erneut versucht werden kann.
**Verhalten wird gestoppt**
Ein Pipelineprozess wird nicht gestoppt, während ein `Callback` Schritt ausgeführt wird.
Wenn Sie einen Pipeline-Prozess mit einem laufenden `Callback` Schritt aufrufen [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html), sendet Pipelines eine Amazon SQS SQS-Nachricht an die SQS-Warteschlange. Der Hauptteil der SQS-Nachricht enthält ein **Statusfeld**, das auf `Stopping` gesetzt ist. Im Folgenden wird ein Beispiel für einen SQS-Nachrichtenkörper gezeigt.
```
{
"token": "26vcYbeWsZ",
"pipelineExecutionArn": "arn:aws:sagemaker:us-east-2:012345678901:pipeline/callback-pipeline/execution/7pinimwddh3a",
"arguments": {
"number": 5,
"stringArg": "some-arg",
"inputData": "s3://sagemaker-us-west-2-012345678901/abalone/abalone-dataset.csv"
},
"status": "Stopping"
}
```
Es wird empfohlen, Ihrem Amazon-SQS-Nachrichtenempfänger eine Logik hinzuzufügen, um bei Empfang der Nachricht alle erforderlichen Maßnahmen (z. B. Ressourcenbereinigung) zu ergreifen. Fügen Sie dann einen Anruf zu `SendPipelineExecutionStepSuccess` oder hinzu`SendPipelineExecutionStepFailure`.
Erst wenn Pipelines einen dieser Aufrufe erhält, stoppt es den Pipeline-Prozess.
## Lambda-Schritt
Sie verwenden einen Lambda-Schritt, um eine AWS Lambda Funktion auszuführen. Sie können eine bestehende Lambda-Funktion ausführen, oder SageMaker KI kann eine neue Lambda-Funktion erstellen und ausführen. Wenn Sie sich dafür entscheiden, eine vorhandene Lambda-Funktion zu verwenden, muss sie sich in derselben AWS-Region wie die SageMaker AI-Pipeline befinden. Ein Notizbuch, das zeigt, wie ein Lambda-Schritt in einer SageMaker KI-Pipeline verwendet wird, finden Sie unter [sagemaker-pipelines-lambda-step.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/lambda-step/sagemaker-pipelines-lambda-step.ipynb).
**Wichtig**
Lambda-Schritte wurden in Amazon SageMaker Python SDK v2.51.0 und Amazon SageMaker Studio Classic v3.9.1 eingeführt. Sie müssen Studio Classic aktualisieren, bevor Sie einen Lambda-Schritt verwenden, da sonst die Pipeline-DAG nicht angezeigt wird. Informationen zum Aktualisieren von Studio Classic finden Sie unter [Amazon SageMaker Studio Classic herunterfahren und aktualisieren](studio-tasks-update-studio.md).
SageMaker AI stellt die Klasse [SageMaker.Lambda\$1Helper.Lambda bereit, um Lambda-Funktionen zu erstellen, zu aktualisieren, aufzurufen](https://sagemaker.readthedocs.io/en/stable/api/utility/lambda_helper.html) und zu löschen. `Lambda`hat die folgende Signatur.
```
Lambda(
function_arn, # Only required argument to invoke an existing Lambda function
# The following arguments are required to create a Lambda function:
function_name,
execution_role_arn,
zipped_code_dir, # Specify either zipped_code_dir and s3_bucket, OR script
s3_bucket, # S3 bucket where zipped_code_dir is uploaded
script, # Path of Lambda function script
handler, # Lambda handler specified as "lambda_script.lambda_handler"
timeout, # Maximum time the Lambda function can run before the lambda step fails
...
)
```
Der [sagemaker.workflow.lambda\$1step. LambdaStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.lambda_step.LambdaStep)Die Klasse hat ein Argument vom Typ. `lambda_func` `Lambda` Um eine bestehende Lambda-Funktion aufzurufen, muss nur der Amazon Resource Name (ARN) der Funktion an `function_arn` übergeben werden. Wenn Sie keinen Wert für `function_arn` angeben, müssen Sie `handler` und eine der folgenden Angaben machen:
+ `zipped_code_dir`– Der Pfad der komprimierten Lambda-Funktion
`s3_bucket`– Amazon-S3-Bucket, wo `zipped_code_dir` hochgeladen werden soll
+ `script`– Der Pfad der Lambda-Funktionsskriptdatei
Das folgende Beispiel zeigt, wie eine `Lambda` Schrittdefinition erstellt wird, die eine vorhandene Lambda-Funktion aufruft.
```
from sagemaker.workflow.lambda_step import LambdaStep
from sagemaker.lambda_helper import Lambda
step_lambda = LambdaStep(
name="ProcessingLambda",
lambda_func=Lambda(
function_arn="arn:aws:lambda:us-west-2:012345678910:function:split-dataset-lambda"
),
inputs={
s3_bucket = s3_bucket,
data_file = data_file
},
outputs=[
"train_file", "test_file"
]
)
```
Das folgende Beispiel zeigt, wie Sie eine `Lambda` Schrittdefinition erstellen, die mithilfe eines Lambda-Funktionsskripts eine Lambda-Funktion erstellt und aufruft.
```
from sagemaker.workflow.lambda_step import LambdaStep
from sagemaker.lambda_helper import Lambda
step_lambda = LambdaStep(
name="ProcessingLambda",
lambda_func=Lambda(
function_name="split-dataset-lambda",
execution_role_arn=execution_role_arn,
script="lambda_script.py",
handler="lambda_script.lambda_handler",
...
),
inputs={
s3_bucket = s3_bucket,
data_file = data_file
},
outputs=[
"train_file", "test_file"
]
)
```
**Eingaben und Ausgaben**
Wenn Ihre `Lambda` Funktion Eingaben oder Ausgaben hat, müssen diese ebenfalls in Ihrem Schritt definiert werden. `Lambda`
**Anmerkung**
Eingabe- und Ausgabeparameter sollten nicht verschachtelt sein. Wenn Sie beispielsweise ein verschachteltes Wörterbuch als Ausgabeparameter verwenden, wird das Wörterbuch als eine einzelne Zeichenfolge behandelt (z. B. `{"output1": "{\"nested_output1\":\"my-output\"}"}`). Wenn Sie einen verschachtelten Wert angeben und später versuchen, darauf zu verweisen, wird ein Client-Fehler ausgegeben, der nicht erneut versucht werden kann.
Bei der Definition des `Lambda` Schritts `inputs` muss es sich um ein Wörterbuch mit Schlüssel-Wert-Paaren handeln. Jeder Wert des `inputs` Wörterbuchs muss ein primitiver Typ sein (Zeichenfolge, Ganzzahl oder Gleitkommazahl). Verschachtelte Objekte werden nicht unterstützt. Bleibt der Wert für `inputs` undefiniert, wird der Wert für `None` verwendet.
Der `outputs` Wert muss eine Liste von Schlüsseln sein. Diese Schlüssel beziehen sich auf ein Wörterbuch, das in der Ausgabe der `Lambda` Funktion definiert ist. Wie bei `inputs` müssen diese Schlüssel primitive Typen sein, und verschachtelte Objekte werden nicht unterstützt.
**Timeout und Verhalten beim Stoppen**
Die `Lambda` Klasse hat ein `timeout` Argument, das die maximale Zeit angibt, während der die Lambda-Funktion ausgeführt werden kann. Der Standardwert ist 120 Sekunden und der Höchstwert 10 Minuten. Wenn die Lambda-Funktion ausgeführt wird, wenn das Timeout erreicht ist, schlägt der Lambda-Schritt fehl. Die Lambda-Funktion wird jedoch weiterhin ausgeführt.
Ein Pipelineprozess kann nicht gestoppt werden, während ein Lambda-Schritt ausgeführt wird, da die durch den Lambda-Schritt aufgerufene Lambda-Funktion nicht gestoppt werden kann. Wenn Sie den Prozess unterbrechen, während die Lambda-Funktion ausgeführt wird, wartet die Pipeline, bis die Funktion beendet ist oder bis das Zeitlimit erreicht ist. Das hängt davon ab, was zuerst eintritt. Der Vorgang wird dann gestoppt. Wenn die Lambda-Funktion beendet wird, lautet der Status des Pipeline-Prozesses `Stopped`. Wenn die Zeitüberschreitung erreicht ist, lautet der Status des Pipeline-Prozesses `Failed`.
## ClarifyCheck Schritt
Sie können diesen `ClarifyCheck` Schritt verwenden, um die Ausgangsabweichung anhand früherer Basislinien zu überprüfen, um die Verzerrungsanalyse und die Erklärbarkeit des Modells zu verbessern. Mit der `model.register()` Methode können Sie dann Ihre [Baselines erstellen und registrieren](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations) und die Ausgabe dieser Methode mit [Modellschritt](#step-type-model) an `[step\$1args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)` übergeben. Diese Basislinien für die Driftprüfung können von Amazon SageMaker Model Monitor für Ihre Modellendpunkte verwendet werden. Daher müssen Sie einen [Basisvorschlag](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html) nicht separat erstellen.
Bei diesem `ClarifyCheck` Schritt können auch Basiswerte für die Driftprüfung aus der Modellregistrierung abgerufen werden. In diesem `ClarifyCheck` Schritt wird der vorgefertigte SageMaker Clarify-Container verwendet. Dieser Container bietet eine Reihe von Features zur Modellüberwachung, darunter Vorschläge für Einschränkungen und Beschränkungsvalidierung anhand einer bestimmten Baseline. Weitere Informationen finden Sie unter [Vorgefertigte SageMaker Clarify-Container](clarify-processing-job-configure-container.md).
### Konfiguration des Schritts ClarifyCheck
Sie können den `ClarifyCheck` Schritt so konfigurieren, dass bei jeder Verwendung in einer Pipeline nur einer der folgenden Prüftypen durchgeführt wird.
+ Prüfung auf Datenverzerrung
+ Überprüfung der Modellverzerrung
+ Überprüfung der Erklärbarkeit des Modells
Dazu setzen Sie den `clarify_check_config`-Parameter mit einem der folgenden Prüftypwerte:
+ `DataBiasCheckConfig`
+ `ModelBiasCheckConfig`
+ `ModelExplainabilityCheckConfig`
In diesem `ClarifyCheck` Schritt wird ein Verarbeitungsjob gestartet, der den SageMaker vorgefertigten AI Clarif-Container ausführt und spezielle [Konfigurationen für die Prüfung und den Verarbeitungsjob](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-configure-processing-jobs.html) erfordert. `ClarifyCheckConfig`und `CheckJobConfig` sind Hilfsfunktionen für diese Konfigurationen. Diese Hilfsfunktionen sind darauf abgestimmt, wie der Verarbeitungsjob SageMaker Clarify Berechnungen durchführt, um Modellverzerrungen, Datenverzerrungen oder Modellerklärbarkeit zu überprüfen. Weitere Informationen finden Sie unter [Führen Sie SageMaker Clarify Processing Jobs aus, um Verzerrungen zu analysieren und zu erklären](clarify-processing-job-run.md).
### Steuerung des Schrittverhaltens bei der Drift-Prüfung
Für diesen `ClarifyCheck` Schritt sind die folgenden zwei booleschen Flags erforderlich, um sein Verhalten zu steuern:
+ `skip_check`: Dieser Parameter gibt an, ob die Driftprüfung gegenüber der vorherigen Basislinie übersprungen wurde oder nicht. Wenn `False` auf gesetzt ist, muss die vorherige Basislinie des konfigurierten Prüftyps verfügbar sein.
+ `register_new_baseline`: Dieser Parameter gibt an, ob über die Schritteigenschaft `BaselineUsedForDriftCheckConstraints` auf eine neu berechnete Basislinie zugegriffen werden kann. Wenn `False` auf gesetzt ist, muss auch die vorherige Basislinie des konfigurierten Prüftyps verfügbar sein. Darauf kann über die `BaselineUsedForDriftCheckConstraints` Eigenschaft zugegriffen werden.
Weitere Informationen finden Sie unter [Basisberechnung, Drifterkennung und Lebenszyklus mit ClarifyCheck und QualityCheck Schritte in Amazon SageMaker Pipelines](pipelines-quality-clarify-baseline-lifecycle.md).
### Arbeiten mit Baselines
Optional können Sie angeben`model_package_group_name`, um die vorhandene Baseline zu finden. Anschließend ruft der `ClarifyCheck`-Schritt `DriftCheckBaselines` auf dem zuletzt genehmigten Modellpaket aus der Modellpaketgruppe ab.
Oder Sie können über den `supplied_baseline_constraints` Parameter eine vorherige Basislinie angeben. Wenn Sie sowohl `model_package_group_name` als auch `supplied_baseline_constraints` angeben, verwendet der Schritt `ClarifyCheck` die durch den `supplied_baseline_constraints` Parameter angegebene Basislinie.
[Weitere Informationen zur Verwendung der `ClarifyCheck` Schrittanforderungen finden Sie unter sagemaker.workflow.steps. ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.clarify_check_step.ClarifyCheckStep)im *Amazon SageMaker AI SageMaker AI SDK für Python*. Ein Amazon SageMaker Studio Classic-Notizbuch, das zeigt, wie `ClarifyCheck` Step in Pipelines verwendet wird, finden Sie unter [sagemaker-pipeline-model-monitor-clarify-steps.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/model-monitor-clarify-pipelines/sagemaker-pipeline-model-monitor-clarify-steps.ipynb).
**Example Erstellen eines `ClarifyCheck`-Schrittes zur Prüfung der Datenverzerrung**
```
from sagemaker.workflow.check_job_config import CheckJobConfig
from sagemaker.workflow.clarify_check_step import DataBiasCheckConfig, ClarifyCheckStep
from sagemaker.workflow.execution_variables import ExecutionVariables
check_job_config = CheckJobConfig(
role=role,
instance_count=1,
instance_type="ml.c5.xlarge",
volume_size_in_gb=120,
sagemaker_session=sagemaker_session,
)
data_bias_data_config = DataConfig(
s3_data_input_path=step_process.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
s3_output_path=Join(on='/', values=['s3:/', your_bucket, base_job_prefix, ExecutionVariables.PIPELINE_EXECUTION_ID, 'databiascheckstep']),
label=0,
dataset_type="text/csv",
s3_analysis_config_output_path=data_bias_analysis_cfg_output_path,
)
data_bias_config = BiasConfig(
label_values_or_threshold=[15.0], facet_name=[8], facet_values_or_threshold=[[0.5]]
)
data_bias_check_config = DataBiasCheckConfig(
data_config=data_bias_data_config,
data_bias_config=data_bias_config,
)h
data_bias_check_step = ClarifyCheckStep(
name="DataBiasCheckStep",
clarify_check_config=data_bias_check_config,
check_job_config=check_job_config,
skip_check=False,
register_new_baseline=False
supplied_baseline_constraints="s3://sagemaker-us-west-2-111122223333/baseline/analysis.json",
model_package_group_name="MyModelPackageGroup"
)
```
## QualityCheck Schritt
Mit dem Schritt `QualityCheck` können Sie [Baseline-Vorschläge](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html) und Drift-Checks gegen eine frühere Baseline für die Datenqualität oder die Modellqualität in einer Pipeline durchführen. Sie können dann Ihre [Baselines mit der `model.register()`-Methode erzeugen und registrieren](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations) und die Ausgabe dieser Methode mit [Modellschritt](#step-type-model) an `[step\$1args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)` übergeben.
Model Monitor kann diese Basislinien für die Drift-Prüfung Ihrer Modellendpunkte verwenden, sodass Sie einen Basisvorschlag nicht separat erstellen müssen. Bei diesem `QualityCheck` Schritt können auch Basiswerte für die Driftprüfung aus der Modellregistrierung abgerufen werden. Dieser `QualityCheck` Schritt nutzt den vorgefertigten Container von Amazon SageMaker AI Model Monitor. Dieser Container verfügt über eine Reihe von Modellüberwachungsfunktionen, darunter Vorschläge für Einschränkungen, Erstellung von Statistiken und Validierung von Einschränkungen anhand einer Baseline. Weitere Informationen finden Sie unter [Vorgefertigter Amazon SageMaker Model Monitor-Container](model-monitor-pre-built-container.md).
### Konfiguration des Schritts QualityCheck
Sie können den `QualityCheck`-Schritt so konfigurieren, dass bei jeder Verwendung in einer Pipeline nur einer der folgenden Prüftypen durchgeführt wird.
+ Überprüfung der Datenqualität
+ Modellqualitätsprüfung
Dazu setzen Sie den `quality_check_config` Parameter mit einem der folgenden Prüftypwerte:
+ `DataQualityCheckConfig`
+ `ModelQualityCheckConfig`
In diesem `QualityCheck` Schritt wird ein Verarbeitungsauftrag gestartet, der den vorgefertigten Container von Model Monitor ausführt und spezielle Konfigurationen für die Prüfung und den Verarbeitungsauftrag erfordert. Die `QualityCheckConfig` und `CheckJobConfig` sind Hilfsfunktionen für diese Konfigurationen. Diese Hilfsfunktionen sind darauf abgestimmt, wie Model Monitor eine Baseline für die Überwachung der Modell- oder Datenqualität erstellt. Weitere Informationen zu den Basisvorschlägen von Model Monitor finden Sie unter [Erstellen einer Baseline](model-monitor-create-baseline.md) und[Erstellen einer Baseline für die Modellqualität](model-monitor-model-quality-baseline.md).
### Steuern des Schrittverhaltens bei der Drift-Prüfung
Für diesen `QualityCheck` Schritt sind die folgenden zwei booleschen Flags erforderlich, um sein Verhalten zu steuern:
+ `skip_check`: Dieser Parameter gibt an, ob die Driftprüfung gegenüber der vorherigen Basislinie übersprungen wurde oder nicht. Wenn `False` auf gesetzt ist, muss die vorherige Basislinie des konfigurierten Prüftyps verfügbar sein.
+ `register_new_baseline`: Dieser Parameter gibt an, ob auf eine neu berechnete Basislinie über die Schritteigenschaften `BaselineUsedForDriftCheckConstraints` und `BaselineUsedForDriftCheckStatistics`. Ist sie auf `False` eingestellt, muss auch die vorherige Baseline der konfigurierten Prüfart verfügbar sein. Auf diese kann über die Eigenschaften `BaselineUsedForDriftCheckConstraints` und `BaselineUsedForDriftCheckStatistics` zugegriffen werden.
Weitere Informationen finden Sie unter [Basisberechnung, Drifterkennung und Lebenszyklus mit ClarifyCheck und QualityCheck Schritte in Amazon SageMaker Pipelines](pipelines-quality-clarify-baseline-lifecycle.md).
### Arbeiten mit Baselines
Sie können eine vorherige Baseline direkt über die `supplied_baseline_constraints` Parameter `supplied_baseline_statistics` und angeben. Sie können auch `model_package_group_name` und den `QualityCheck`-Schritt angeben, der das zuletzt genehmigte Modellpaket in der Modellpaketgruppe abruft.
Wenn Sie Folgendes angeben, verwendet der `QualityCheck`-Schritt die durch `supplied_baseline_constraints` und `supplied_baseline_statistics` auf dem Prüftyp des Schritts `QualityCheck` angegebene Baseline.
+ `model_package_group_name`
+ `supplied_baseline_constraints`
+ `supplied_baseline_statistics`
Weitere Informationen zur Verwendung der `QualityCheck` Schrittanforderungen finden Sie unter [sagemaker.workflow.steps. QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.quality_check_step.QualityCheckStep)im *Amazon SageMaker AI SageMaker AI SDK für Python*. Ein Amazon SageMaker Studio Classic-Notizbuch, das zeigt, wie `QualityCheck` Step in Pipelines verwendet wird, finden Sie unter [sagemaker-pipeline-model-monitor-clarify-steps.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/model-monitor-clarify-pipelines/sagemaker-pipeline-model-monitor-clarify-steps.ipynb).
**Example Erstellen eines `QualityCheck`-Schrittes zur Prüfung der Datenqualität**
```
from sagemaker.workflow.check_job_config import CheckJobConfig
from sagemaker.workflow.quality_check_step import DataQualityCheckConfig, QualityCheckStep
from sagemaker.workflow.execution_variables import ExecutionVariables
check_job_config = CheckJobConfig(
role=role,
instance_count=1,
instance_type="ml.c5.xlarge",
volume_size_in_gb=120,
sagemaker_session=sagemaker_session,
)
data_quality_check_config = DataQualityCheckConfig(
baseline_dataset=step_process.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
dataset_format=DatasetFormat.csv(header=False, output_columns_position="START"),
output_s3_uri=Join(on='/', values=['s3:/', your_bucket, base_job_prefix, ExecutionVariables.PIPELINE_EXECUTION_ID, 'dataqualitycheckstep'])
)
data_quality_check_step = QualityCheckStep(
name="DataQualityCheckStep",
skip_check=False,
register_new_baseline=False,
quality_check_config=data_quality_check_config,
check_job_config=check_job_config,
supplied_baseline_statistics="s3://sagemaker-us-west-2-555555555555/baseline/statistics.json",
supplied_baseline_constraints="s3://sagemaker-us-west-2-555555555555/baseline/constraints.json",
model_package_group_name="MyModelPackageGroup"
)
```
## EMR-Schritt
Verwenden Sie den [EMR-Schritt](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-overview.html) Amazon SageMaker Pipelines, um:
+ Verarbeiten Sie [Amazon EMR-Schritte](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-work-with-steps.html) auf einem laufenden Amazon EMR-Cluster.
+ Lassen Sie die Pipeline einen Amazon EMR-Cluster für Sie erstellen und verwalten.
Weitere Informationen über Amazon EMR finden Sie unter [Erste Schritte mit Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html).
Der EMR-Schritt erfordert, dass `EMRStepConfig` den Speicherort der JAR-Datei, die vom Amazon-EMR-Cluster verwendet werden soll, und alle zu übergebenden Argumente enthält. Sie geben auch die Amazon EMR-Cluster-ID an, wenn Sie den Schritt auf einem laufenden EMR-Cluster ausführen möchten. Sie können auch die Cluster-Konfiguration übergeben, um den EMR-Schritt auf einem Cluster auszuführen, den er für Sie erstellt, verwaltet und beendet. Die folgenden Abschnitte enthalten Beispiele und Links zu Beispiel-Notebooks, die beide Methoden demonstrieren.
**Anmerkung**
EMR-Schritte erfordern, dass die an Ihre Pipeline übergebene Rolle über zusätzliche Berechtigungen verfügt. Sie sollten die [AWS verwaltete Richtlinie: `AmazonSageMakerPipelinesIntegrations`](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol-pipelines.html#security-iam-awsmanpol-AmazonSageMakerPipelinesIntegrations) an Ihre Pipeline-Rolle anfügen oder sicherstellen, dass die Rolle die in dieser Richtlinie enthaltenen Berechtigungen umfasst.
Wenn Sie einen EMR-Schritt auf einem laufenden Cluster verarbeiten, können Sie nur einen Cluster verwenden, der sich in einem der folgenden Zustände befindet:
`STARTING`
`BOOTSTRAPPING`
`RUNNING`
`WAITING`
Wenn Sie EMR-Schritte in einem laufenden Cluster verarbeiten, können Sie maximal 256 EMR-Schritte in einem `PENDING` Status auf einem EMR-Cluster haben. EMR-Schritte, die über diesen Grenzwert hinaus eingereicht werden, führen zu einem Fehler bei der Pipeline-Ausführung. Sie können auch [Richtlinie für Pipeline-Schritte erneut versuchen](pipelines-retry-policy.md) verwenden.
Sie können entweder Cluster-ID oder Cluster-Konfiguration angeben, aber nicht beides.
Der EMR-Schritt stützt sich darauf EventBridge , dass Amazon Änderungen im EMR-Schritt oder Cluster-Status überwacht. Wenn Sie Ihren Amazon EMR-Auftrag auf einem laufenden Cluster verarbeiten, verwendet der EMR-Schritt die `SageMakerPipelineExecutionEMRStepStatusUpdateRule` Regel zur Überwachung des EMR-Schrittstatus. Wenn Sie Ihren Auftrag auf einem Cluster verarbeiten, den der EMR-Schritt für Sie erstellt, verwendet der Schritt die `SageMakerPipelineExecutionEMRClusterStatusRule`-Regel, um Änderungen im Clusterstatus zu überwachen. Wenn Sie eine dieser EventBridge Regeln in Ihrem AWS Konto sehen, löschen Sie sie nicht, da sonst Ihr EMR-Schritt möglicherweise nicht abgeschlossen werden kann.
**Fügen Sie Ihrer Pipeline einen Amazon EMR-Schritt hinzu**
Gehen Sie wie folgt vor, um Ihrer Pipeline einen EMR-Schritt hinzuzufügen:
+ Öffnen Sie die Studio-Konsole, indem Sie den Anweisungen unter [Amazon SageMaker Studio starten](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html) folgen.
+ Wählen Sie im linken Navigationsbereich die Option **Pipelines** aus.
+ Wählen Sie **Erstellen** aus.
+ **Wählen Sie Leer.**
+ Wählen Sie in der linken Seitenleiste die Option **Daten verarbeiten** und ziehen Sie sie auf die Arbeitsfläche.
+ Wählen Sie auf der Arbeitsfläche den Schritt „**Daten verarbeiten**“ aus, den Sie hinzugefügt haben.
+ Wählen Sie in der rechten Seitenleiste unter Modus die Option **EMR (verwaltet)** aus.
+ Füllen Sie in der rechten Seitenleiste die Formulare auf den Tabs **Einstellungen und Details** aus. Informationen zu den Feldern in diesen Tabs finden Sie unter [sagemaker.workflow.fail\$1step. EMRstep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.emr_step.EMRStep).
**Starten Sie einen neuen Auftrag auf einem laufenden Amazon EMR-Cluster**
Wenn Sie einen neuen Auftrag auf einem laufenden Amazon-EMR-Cluster starten möchten, übergeben Sie die Cluster-ID als Zeichenfolge an das `cluster_id` Argument von `EMRStep`. Das folgende Beispiel veranschaulicht diese Vorgehensweise.
```
from sagemaker.workflow.emr_step import EMRStep, EMRStepConfig
emr_config = EMRStepConfig(
jar="jar-location", # required, path to jar file used
args=["--verbose", "--force"], # optional list of arguments to pass to the jar
main_class="com.my.Main1", # optional main class, this can be omitted if jar above has a manifest
properties=[ # optional list of Java properties that are set when the step runs
{
"key": "mapred.tasktracker.map.tasks.maximum",
"value": "2"
},
{
"key": "mapreduce.map.sort.spill.percent",
"value": "0.90"
},
{
"key": "mapreduce.tasktracker.reduce.tasks.maximum",
"value": "5"
}
]
)
step_emr = EMRStep (
name="EMRSampleStep", # required
cluster_id="j-1ABCDEFG2HIJK", # include cluster_id to use a running cluster
step_config=emr_config, # required
display_name="My EMR Step",
description="Pipeline step to execute EMR job"
)
```
Ein Beispiel-Notebook, das Sie durch ein vollständiges Beispiel führt, finden Sie unter [Pipelines EMR-Schritt mit laufendem EMR-Cluster](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-running-emr-cluster.ipynb).
**Starten Sie einen neuen Auftrag in einem neuen Amazon EMR-Cluster**
Um einen neuen Auftrag auf einem neuen Cluster zu starten, der `EMRStep` für Sie erstellt wird, geben Sie Ihre Clusterkonfiguration als Wörterbuch an. Das Wörterbuch muss dieselbe Struktur wie eine [RunJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html)Anfrage haben. Nehmen Sie jedoch nicht die folgenden Felder in Ihre Clusterkonfiguration auf:
+ [`Name`]
+ [`Steps`]
+ [`AutoTerminationPolicy`]
+ [`Instances`][`KeepJobFlowAliveWhenNoSteps`]
+ [`Instances`][`TerminationProtected`]
Alle anderen `RunJobFlow` Argumente können in Ihrer Clusterkonfiguration verwendet werden. Einzelheiten zur Anforderungssyntax finden Sie unter [RunJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html).
Im folgenden Beispiel wird eine Cluster-Konfiguration an eine EMR-Schrittdefinition übergeben. Dies führt zu dem Schritt, einen neuen Auftrag auf einem neuen EMR-Cluster zu starten. Die EMR-Clusterkonfiguration in diesem Beispiel umfasst Spezifikationen für primäre und zentrale EMR-Clusterknoten. Weitere Informationen zu Amazon EMR-Knotentypen finden Sie unter [Grundlegendes zu Knotentypen: Primär-, Kern- und Aufgabenknoten](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html).
```
from sagemaker.workflow.emr_step import EMRStep, EMRStepConfig
emr_step_config = EMRStepConfig(
jar="jar-location", # required, path to jar file used
args=["--verbose", "--force"], # optional list of arguments to pass to the jar
main_class="com.my.Main1", # optional main class, this can be omitted if jar above has a manifest
properties=[ # optional list of Java properties that are set when the step runs
{
"key": "mapred.tasktracker.map.tasks.maximum",
"value": "2"
},
{
"key": "mapreduce.map.sort.spill.percent",
"value": "0.90"
},
{
"key": "mapreduce.tasktracker.reduce.tasks.maximum",
"value": "5"
}
]
)
# include your cluster configuration as a dictionary
emr_cluster_config = {
"Applications": [
{
"Name": "Spark",
}
],
"Instances":{
"InstanceGroups":[
{
"InstanceRole": "MASTER",
"InstanceCount": 1,
"InstanceType": "m5.2xlarge"
},
{
"InstanceRole": "CORE",
"InstanceCount": 2,
"InstanceType": "m5.2xlarge"
}
]
},
"BootstrapActions":[],
"ReleaseLabel": "emr-6.6.0",
"JobFlowRole": "job-flow-role",
"ServiceRole": "service-role"
}
emr_step = EMRStep(
name="emr-step",
cluster_id=None,
display_name="emr_step",
description="MyEMRStepDescription",
step_config=emr_step_config,
cluster_config=emr_cluster_config
)
```
Ein Beispiel-Notebook, das Sie durch ein vollständiges Beispiel führt, finden Sie unter [Pipelines EMR-Schritt mit Cluster-Lebenszyklusmanagement](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-cluster-lifecycle-management.ipynb).
## Serverloser EMR-Schritt
Gehen Sie wie folgt vor, um Ihrer Pipeline einen serverlosen EMR-Schritt hinzuzufügen:
+ Öffnen Sie die Studio-Konsole, indem Sie den Anweisungen unter [Amazon SageMaker Studio starten](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html) folgen.
+ Wählen Sie im linken Navigationsbereich die Option **Pipelines** aus.
+ Wählen Sie **Erstellen** aus.
+ **Wählen Sie Leer.**
+ Wählen Sie in der linken Seitenleiste die Option **Daten verarbeiten** und ziehen Sie sie auf die Arbeitsfläche.
+ Wählen Sie auf der Arbeitsfläche den Schritt „**Daten verarbeiten**“ aus, den Sie hinzugefügt haben.
+ Wählen Sie in der rechten Seitenleiste unter Modus die Option **EMR (serverlos**) aus.
+ Füllen Sie in der rechten Seitenleiste die Formulare auf den Tabs **Einstellungen** und Details aus.
## Schritt für Notebook-Aufträge
Verwenden Sie a`NotebookJobStep`, um Ihren SageMaker Notebook-Job nicht interaktiv als Pipeline-Schritt auszuführen. Wenn Sie Ihre Pipeline in der drag-and-drop Pipelines-Benutzeroberfläche erstellen, verwenden Sie die, [Codeschritt ausführen](#step-type-executecode) um Ihr Notizbuch auszuführen. Weitere Informationen zu SageMaker Notebook-Jobs finden Sie unter[SageMaker Jobs im Notizbuch](notebook-auto-run.md).
A `NotebookJobStep` erfordert mindestens ein Eingabe-Notebook, eine Image-URI und einen Kernelnamen. Weitere Informationen zu den Anforderungen an die Notebook-Job-Schritte und anderen Parametern, die Sie zur Anpassung Ihres Schritts festlegen können, finden Sie unter [sagemaker.workflow.steps. NotebookJobStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.notebook_job_step.NotebookJobStep).
Im folgenden Beispiel werden `NotebookJobStep` Minimalargumente verwendet, um a zu definieren.
```
from sagemaker.workflow.notebook_job_step import NotebookJobStep
notebook_job_step = NotebookJobStep(
input_notebook=input_notebook,
image_uri=image_uri,
kernel_name=kernel_name
)
```
Ihr `NotebookJobStep` Pipeline-Schritt wird wie ein SageMaker Notebook-Job behandelt. Verfolgen Sie daher den Ausführungsstatus im Dashboard für Notebook-Jobs auf der Benutzeroberfläche von Studio Classic, indem Sie dem `tags` Argument bestimmte Tags hinzufügen. Weitere Informationen zu den einzufügenden Tags finden Sie unter [Sehen Sie sich Ihre Notebook-Jobs im Studio-UI-Dashboard an](create-notebook-auto-run-sdk.md#create-notebook-auto-run-dash).
Wenn Sie Ihren Notebook-Job mit dem SageMaker Python-SDK planen, können Sie außerdem nur bestimmte Images angeben, um Ihren Notebook-Job auszuführen. Weitere Informationen finden Sie unter [Bildeinschränkungen für SageMaker AI Python SDK-Notebook-Jobs](notebook-auto-run-constraints.md#notebook-auto-run-constraints-image-sdk).
## Schritt „Fehlschlagen“
Verwenden Sie einen Fail-Schritt, um die Ausführung von Amazon SageMaker Pipelines zu beenden, wenn eine gewünschte Bedingung oder ein gewünschter Status nicht erreicht wird. Im Schritt „Fehlschlagen“ können Sie auch eine benutzerdefinierte Fehlermeldung eingeben, die die Ursache für den Ausführungsfehler der Pipeline angibt.
**Anmerkung**
Wenn ein Schritt „Fehlschlagen“ und andere Pipeline-Schritte gleichzeitig ausgeführt werden, wird die Pipeline erst beendet, wenn alle gleichzeitigen Schritte abgeschlossen sind.
### Einschränkungen bei der Verwendung von Fail Step
+ Sie können ein Schritt „Fehlschlagen“ nicht in die `DependsOn`-Liste anderer Schritte aufnehmen. Weitere Informationen finden Sie unter [Benutzerdefinierte Abhängigkeit zwischen Schritten](build-and-manage-steps.md#build-and-manage-custom-dependency).
+ Andere Schritte können sich nicht auf den Schritt „Fehlschlagen“ beziehen. Dies ist *immer* der letzte Schritt bei der Ausführung einer Pipeline.
+ Sie können eine Pipeline-Ausführung, die mit einem Schritt „Fehlschlagen“ endet, nicht wiederholen.
Sie können die Fehlermeldung zum Schritt „Fehlschlagen“ in Form einer statischen Textzeichenfolge erstellen. Alternativ können Sie auch [Pipeline-Parameter](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-parameters.html), eine [Join](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html?highlight=Join#sagemaker.workflow.functions.Join)-Operation oder andere [Schritteigenschaften](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#build-and-manage-properties) verwenden, um eine aussagekräftigere Fehlermeldung zu erstellen, wenn Sie das SDK verwenden.
------
#### [ Pipeline Designer ]
Gehen Sie wie folgt vor, um Ihrer Pipeline einen Fail-Schritt hinzuzufügen:
1. Öffnen Sie die Studio-Konsole, indem Sie den Anweisungen unter [Starten Sie Amazon SageMaker Studio](studio-updated-launch.md) folgen.
1. Wählen Sie im linken Navigationsbereich die Option **Pipelines** aus.
1. Wählen Sie **Erstellen** aus.
1. **Wählen Sie Leer.**
1. Wählen Sie in der linken Seitenleiste die Option **Fehlgeschlagen** aus und ziehen Sie den Vorgang auf die Leinwand.
1. Wählen Sie auf der Leinwand den hinzugefügten Schritt „**Fehlgeschlagen**“ aus.
1. Füllen Sie in der rechten Seitenleiste die Formulare auf den Tabs **Einstellungen** und **Details** aus. Informationen zu den Feldern in diesen Tabs finden Sie unter [sagemaker.workflow.fail\$1step. FailStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.fail_step.FailStep).
1. **Wenn die Arbeitsfläche einen Schritt enthält, der dem hinzugefügten Schritt „**Fehler**“ unmittelbar vorausgeht, klicken Sie auf den Schritt und ziehen Sie den Cursor von dem Schritt zum Schritt „Fehler“, um eine Kante zu erstellen.**
1. Wenn die Arbeitsfläche einen Schritt enthält, der unmittelbar auf den von Ihnen hinzugefügten Schritt „**Fehler**“ folgt, klicken Sie auf den Schritt und ziehen Sie den Cursor vom **Fail-Schritt** zu dem Schritt, um eine Kante zu erstellen.
------
#### [ SageMaker Python SDK ]
**Example**
Der folgende Beispielcodeausschnitt verwendet eine `FailStep` mit Pipelineparametern `ErrorMessage` konfigurierte Option und eine `Join` Operation.
```
from sagemaker.workflow.fail_step import FailStep
from sagemaker.workflow.functions import Join
from sagemaker.workflow.parameters import ParameterInteger
mse_threshold_param = ParameterInteger(name="MseThreshold", default_value=5)
step_fail = FailStep(
name="AbaloneMSEFail",
error_message=Join(
on=" ", values=["Execution failed due to MSE >", mse_threshold_param]
),
)
```
------
# Integration hinzufügen
MLflow Durch die Integration können Sie Pipelines verwenden MLflow , um einen Tracking-Server oder eine serverlose Anwendung auszuwählen, ein Experiment auszuwählen und Metriken zu protokollieren.
## Die wichtigsten Konzepte
**Erstellung von Standard-Apps** — Eine MLflow Standardanwendung wird erstellt, wenn Sie den visuellen Pipeline-Editor aufrufen.
**Integrationspanel** — Es enthält ein neues Integrationsfenster MLflow, das Sie auswählen und konfigurieren können.
**App aktualisieren und testen** — Die Option, die ausgewählte Anwendung zu überschreiben und während der Pipeline-Ausführung zu experimentieren.
## Funktionsweise
+ Gehen Sie zum **Pipeline Visual Editor**
+ Wählen Sie **in der Werkzeugleiste Integration**
+ Wählen Sie **MLflow** aus.
+ Konfiguriere die MLflow App und experimentiere
## Beispiel-Screenshots
Seitenbereich für Integrationen
![\[Die Beschreibung der Aufgaben.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/screenshot-pipeline-1.png)
MLflow Konfiguration
![\[Die Beschreibung der Aufgaben.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/screenshot-pipeline-2.png)
Wie überschreibt man das Experiment während der Pipeline-Ausführung
![\[Die Beschreibung der zu erledigenden Aufgaben.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/screenshot-pipeline-3.png)
## Eigenschaften-Schritt
Verwenden Sie das `properties`-Attribut, um Datenabhängigkeiten zwischen Schritten in der Pipeline hinzuzufügen. Pipelines verwenden diese Datenabhängigkeiten, um aus der Pipeline-Definition den DAG zu erstellen. Diese Eigenschaften können als Platzhalterwerte referenziert werden und werden zur Laufzeit aufgelöst.
Das `properties` Attribut eines Pipelines-Schritts entspricht dem Objekt, das von einem `Describe` Aufruf für den entsprechenden SageMaker AI-Jobtyp zurückgegeben wurde. Für jeden Auftragstyp gibt der `Describe` Aufruf das folgende Antwortobjekt zurück:
+ `ProcessingStep` – [DescribeProcessingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html)
+ `TrainingStep` – [DescribeTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html)
+ `TransformStep` – [DescribeTransformJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTransformJob.html)
Informationen dazu, welche Eigenschaften für jeden Schritttyp bei der Erstellung von Datenabhängigkeiten referenzierbar sind, finden Sie unter *[Datenabhängigkeit — Eigenschaftsreferenz](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
## Schrittparallelität
Wenn ein Schritt nicht von einem anderen Schritt abhängt, wird er sofort nach der Ausführung der Pipeline ausgeführt. Die parallel Ausführung zu vieler Pipeline-Schritte kann jedoch schnell die verfügbaren Ressourcen erschöpfen. Steuern Sie die Anzahl der gleichzeitigen Schritte für eine Pipeline-Ausführung mit `ParallelismConfiguration`.
Im folgenden Beispiel wird `ParallelismConfiguration` verwendet, um die Grenze für gleichzeitige Schritte auf fünf zu setzen.
```
pipeline.create(
parallelism_config=ParallelismConfiguration(5),
)
```
## Datenabhängigkeit zwischen Schritten
Sie definieren die Struktur Ihrer DAG, indem Sie die Datenbeziehungen zwischen den Schritten angeben. Um Datenabhängigkeiten zwischen Schritten herzustellen, übergeben Sie die Eigenschaften eines Schritts als Eingabe an einen anderen Schritt in der Pipeline. Der Schritt, der die Eingabe empfängt, wird erst gestartet, nachdem der Schritt, der die Eingabe bereitstellt, abgeschlossen ist.
Eine Datenabhängigkeit verwendet die JsonPath Notation im folgenden Format. Dieses Format durchläuft die JSON-Eigenschaftendatei. Das bedeutet, dass Sie so viele ** Instanzen wie nötig anhängen können, um die gewünschte verschachtelte Eigenschaft in der Datei zu erreichen. [Weitere Informationen zur JsonPath Notation finden Sie im JsonPath Repo.](https://github.com/json-path/JsonPath)
```
.properties..
```
Im Folgenden wird gezeigt, wie ein Amazon-S3-Bucket mithilfe der `ProcessingOutputConfig` Eigenschaft eines Verarbeitungsschritts angegeben wird.
```
step_process.properties.ProcessingOutputConfig.Outputs["train_data"].S3Output.S3Uri
```
Um die Datenabhängigkeit zu erstellen, übergeben Sie den Bucket wie folgt an einen Trainingsschritt.
```
from sagemaker.workflow.pipeline_context import PipelineSession
sklearn_train = SKLearn(..., sagemaker_session=PipelineSession())
step_train = TrainingStep(
name="CensusTrain",
step_args=sklearn_train.fit(inputs=TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"train_data"].S3Output.S3Uri
))
)
```
Informationen dazu, welche Eigenschaften für jeden Schritttyp bei der Erstellung von Datenabhängigkeiten referenzierbar sind, finden Sie unter *[Datenabhängigkeit — Eigenschaftsreferenz](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
## Benutzerdefinierte Abhängigkeit zwischen Schritten
Wenn Sie eine Datenabhängigkeit angeben, stellt Pipelines die Datenverbindung zwischen den Schritten bereit. Alternativ kann ein Schritt auf die Daten aus einem vorherigen Schritt zugreifen, ohne Pipelines direkt zu verwenden. In diesem Fall können Sie eine benutzerdefinierte Abhängigkeit erstellen, die Pipelines anweist, einen Schritt erst zu starten, nachdem ein anderer Schritt abgeschlossen ist. Sie erstellen eine benutzerdefinierte Abhängigkeit, indem Sie `DependsOn` -Attribut eines Schritts angeben.
Im Folgenden wird beispielsweise ein Schritt `C` definiert, der erst beginnt, wenn sowohl der Schritt `A` als auch der Schritt `B` abgeschlossen sind.
```
{
'Steps': [
{'Name':'A', ...},
{'Name':'B', ...},
{'Name':'C', 'DependsOn': ['A', 'B']}
]
}
```
Pipelines löst eine Validierungsausnahme aus, wenn die Abhängigkeit eine zyklische Abhängigkeit erzeugen würde.
Im folgenden Beispiel wird ein Trainingsschritt erstellt, der beginnt, nachdem ein Verarbeitungsschritt abgeschlossen ist.
```
processing_step = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step])
```
Im folgenden Beispiel wird ein Trainingsschritt erstellt, der erst beginnt, wenn zwei verschiedene Verarbeitungsschritte abgeschlossen sind.
```
processing_step_1 = ProcessingStep(...)
processing_step_2 = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step_1, processing_step_2])
```
Im Folgenden wird eine alternative Methode zum Erstellen der benutzerdefinierten Abhängigkeit beschrieben.
```
training_step.add_depends_on([processing_step_1])
training_step.add_depends_on([processing_step_2])
```
Im folgenden Beispiel wird ein Trainingsschritt erstellt, der Eingaben von einem Verarbeitungsschritt empfängt und darauf wartet, dass ein anderer Verarbeitungsschritt abgeschlossen ist.
```
processing_step_1 = ProcessingStep(...)
processing_step_2 = ProcessingStep(...)
training_step = TrainingStep(
...,
inputs=TrainingInput(
s3_data=processing_step_1.properties.ProcessingOutputConfig.Outputs[
"train_data"
].S3Output.S3Uri
)
training_step.add_depends_on([processing_step_2])
```
Das folgende Beispiel zeigt, wie eine Stringliste der benutzerdefinierten Abhängigkeiten eines Schritts abgerufen wird.
```
custom_dependencies = training_step.depends_on
```
## Benutzerdefinierte Bilder in einem Schritt
Sie können jedes der verfügbaren SageMaker AI [Deep Learning Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) verwenden, wenn Sie einen Schritt in Ihrer Pipeline erstellen.
Sie können auch Ihren eigenen -Container mit Pipeline-Schritten verwenden. Da Sie in Studio Classic kein Image erstellen können, müssen Sie Ihr Image mit einer anderen Methode erstellen, bevor Sie es mit Pipelines verwenden können.
Um bei der Erstellung der Schritte für Ihre Pipeline Ihren eigenen Container zu verwenden, fügen Sie den Bild-URI in die Estimator-Definition ein. Weitere Informationen zur Verwendung Ihres eigenen Containers mit SageMaker KI finden Sie unter [Docker-Container mit SageMaker KI verwenden](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers.html).
# Lift-and-shift Python-Code mit dem @step -Decorator
Der `@step` Decorator ist eine Funktion, die Ihren lokalen ML-Code (Machine Learning) in einen oder mehrere Pipeline-Schritte umwandelt. Sie können Ihre ML-Funktion so schreiben, wie Sie es für jedes ML-Projekt tun würden. Nachdem Sie die Funktion lokal oder als Trainingsaufgabe mit dem `@remote` Decorator getestet haben, können Sie sie in einen SageMaker KI-Pipeline-Schritt umwandeln, indem Sie einen Decorator hinzufügen. `@step` Anschließend können Sie die Ausgabe des mit `@step` -dekorierten Funktionen versehenen Funktionsaufrufs als Schritt an Pipelines übergeben, um eine Pipeline zu erstellen und auszuführen. Sie können eine Reihe von Funktionen mit dem `@step` Decorator verketten, um auch eine mehrstufige DAG-Pipeline (Directed Acyclic Graph) zu erstellen.
Die Konfiguration für die Verwendung des `@step`-Decorators entspricht der Konfiguration für die Verwendung des `@remote`-Decorators. Einzelheiten zur [Einrichtung der Umgebung und zur [Verwendung einer Konfigurationsdatei](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-config.html) zum Festlegen von Standardeinstellungen finden Sie in der](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator.html#train-remote-decorator-env) Dokumentation zur Remote-Funktion. [Weitere Informationen zum `@step` Decorator finden Sie unter sagemaker.workflow.function\$1step.step.](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.step)
Um Beispiel-Notebooks anzuzeigen, die die Verwendung von `@step`-Decorator veranschaulichen, siehe [@step decorator sample notebooks](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-pipelines/step-decorator).
In den folgenden Abschnitten wird erklärt, wie Sie Ihren lokalen ML-Code mit einem `@step` Decorator annotieren können, um einen Schritt zu erstellen, mithilfe des Schritts eine Pipeline zu erstellen und auszuführen und das Erlebnis an Ihren Anwendungsfall anzupassen.
**Topics**
+ [Erstellen Sie eine Pipeline mit `@step` -dekorierten Funktionen](pipelines-step-decorator-create-pipeline.md)
+ [Ausführen Sie eine Pipeline](pipelines-step-decorator-run-pipeline.md)
+ [Konfigurieren Ihrer Pipeline](pipelines-step-decorator-cfg-pipeline.md)
+ [Bewährte Methoden](pipelines-step-decorator-best.md)
+ [Einschränkungen](pipelines-step-decorator-limit.md)
# Erstellen Sie eine Pipeline mit `@step` -dekorierten Funktionen
Sie können eine Pipeline erstellen, indem Sie Python-Funktionen mithilfe des `@step` Decorators in Pipeline-Schritte konvertieren, Abhängigkeiten zwischen diesen Funktionen erstellen, um einen Pipeline-Graphen (oder einen gerichteten azyklischen Graphen (DAG)) zu erstellen, und die Blattknoten dieses Graphen als Liste von Schritten an die Pipeline übergeben. In den folgenden Abschnitten wird dieses Verfahren anhand von Beispielen ausführlich erläutert.
**Topics**
+ [Konvertiert eine Funktion in einen Schritt](#pipelines-step-decorator-run-pipeline-convert)
+ [Erstellen Sie Abhängigkeiten zwischen den Schritten](#pipelines-step-decorator-run-pipeline-link)
+ [Wird `ConditionStep` zusammen mit Schritten verwendet, die mit `@step` -verziert sind](#pipelines-step-decorator-condition)
+ [Definieren Sie eine Pipeline anhand der `DelayedReturn` Ausgabe von Schritten](#pipelines-step-define-delayed)
+ [Erstellen Sie eine Pipeline](#pipelines-step-decorator-pipeline-create)
## Konvertiert eine Funktion in einen Schritt
Um einen Schritt mit dem `@step`-Decorator zu erstellen, kommentieren Sie die Funktion mit `@step`. Das folgende Beispiel zeigt eine `@step` mit -dekorierte Funktion zur Vorverarbeitung der Daten.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
step_process_result = preprocess(raw_data)
```
Wenn Sie eine `@step` mit -dekorierte Funktion aufrufen, gibt SageMaker AI eine `DelayedReturn` Instanz zurück, anstatt die Funktion auszuführen. Eine `DelayedReturn` Instance ist ein Proxy für die tatsächliche Rückgabe dieser Funktion. Die `DelayedReturn` Instance kann als Argument an eine andere Funktion oder als Schritt direkt an eine Pipeline-Instance übergeben werden. [Informationen zur `DelayedReturn` Klasse finden Sie unter sagemaker.workflow.function\$1step. DelayedReturn](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.DelayedReturn).
## Erstellen Sie Abhängigkeiten zwischen den Schritten
Wenn Sie eine Abhängigkeit zwischen zwei Schritten erstellen, stellen Sie eine Verbindung zwischen den Schritten in Ihrem Pipeline-Diagramm her. In den folgenden Abschnitten werden mehrere Möglichkeiten vorgestellt, wie Sie eine Abhängigkeit zwischen Ihren Pipeline-Schritten herstellen können.
### Datenabhängigkeiten durch Eingabeargumente
Wenn die `DelayedReturn` Ausgabe einer Funktion als Eingabe an eine andere Funktion übergeben wird, entsteht automatisch eine Datenabhängigkeit in der Pipeline-DAG. Im folgenden Beispiel wird durch die Übergabe der `DelayedReturn` Ausgabe der `preprocess` Funktion an die `train` Funktion eine Abhängigkeit zwischen `preprocess` und erzeugt`train`.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
@step
def train(training_data):
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train(step_process_result)
```
Das vorherige Beispiel definiert eine Trainingsfunktion, die mit ausgestattet ist`@step`. Wenn diese Funktion aufgerufen wird, erhält sie die `DelayedReturn` Ausgabe des Vorverarbeitungs-Pipeline-Schritts als Eingabe. Beim Aufrufen der Trainingsfunktion wird eine weitere `DelayedReturn`-Instance zurückgegeben. Diese Instance enthält die Informationen zu allen zuvor in dieser Funktion definierten Schritten (d. h. dem `preprocess`-Schritt in diesem Beispiel), die die Pipeline-DAG bilden.
Im vorherigen Beispiel gibt die `preprocess` Funktion einen einzelnen Wert zurück. Für komplexere Rückgabetypen wie Listen oder Tupel, siehe [Einschränkungen](pipelines-step-decorator-limit.md).
### Definieren von benutzerdefinierten Abhängigkeiten
Im vorherigen Beispiel hat die `train` Funktion die `DelayedReturn` Ausgabe von empfangen `preprocess` und eine Abhängigkeit erstellt. Wenn Sie die Abhängigkeit explizit definieren möchten, ohne die Ausgabe des vorherigen Schritts zu übergeben, verwenden Sie die `add_depends_on` Funktion mit dem Schritt. Sie können die `get_step()` Funktion verwenden, um den zugrunde liegenden Schritt aus seiner `DelayedReturn` Instance abzurufen, und dann `add_depends_on` \$1on mit der Abhängigkeit als Eingabe aufrufen. Die `get_step()` Funktionsdefinition finden Sie unter [sagemaker.workflow.step\$1outputs.get\$1step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_outputs.get_step). Das folgende Beispiel zeigt, wie Sie eine Abhängigkeit zwischen `preprocess` und `train` mithilfe von `get_step()` und erstellen`add_depends_on()`.
```
from sagemaker.workflow.step_outputs import get_step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
processed_data = ..
return s3.upload(processed_data)
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train()
get_step(step_train_result).add_depends_on([step_process_result])
```
### Übergeben Sie Daten an und von einer `@step` mit -dekorierten Funktion an einen herkömmlichen Pipeline-Schritt
Sie können eine Pipeline erstellen, die einen Schritt mit einer `@step` Markierung und einen herkömmlichen Pipeline-Schritt umfasst und Daten zwischen diesen weiterleitet. Sie können sie beispielsweise verwenden, um die Daten `ProcessingStep` zu verarbeiten und das Ergebnis an die Trainingsfunktion `@step` mit -dekoriertem Dekor weiterzuleiten. Im folgenden Beispiel verweist ein `@step` mit -dekorierter Trainingsschritt auf die Ausgabe eines Verarbeitungsschritts.
```
# Define processing step
from sagemaker.sklearn.processing import SKLearnProcessor
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
sklearn_processor = SKLearnProcessor(
framework_version='1.2-1',
role='arn:aws:iam::123456789012:role/SagemakerExecutionRole',
instance_type='ml.m5.large',
instance_count='1',
)
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")
]
process_step = ProcessingStep(
name="MyProcessStep",
step_args=sklearn_processor.run(inputs=inputs, outputs=outputs,code='preprocessing.py'),
)
```
```
# Define a @step-decorated train step which references the
# output of a processing step
@step
def train(train_data_path, test_data_path):
...
return trained_model
step_train_result = train(
process_step.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
process_step.properties.ProcessingOutputConfig.Outputs["test"].S3Output.S3Uri,
)
```
## Wird `ConditionStep` zusammen mit Schritten verwendet, die mit `@step` -verziert sind
Pipelines unterstützt eine `ConditionStep` Klasse, die die Ergebnisse der vorherigen Schritte auswertet, um zu entscheiden, welche Maßnahmen in der Pipeline ergriffen werden sollen. Sie können es auch `ConditionStep` mit einem Schritt verwenden, der mit `@step` einem Symbol versehen ist. Um die Ausgabe eines mit `@step`-dekorierten Schritts mit zu verwenden, geben Sie die Ausgabe dieses Schritts als Argument für `ConditionStep` ein. Im folgenden Beispiel erhält der Bedingungsschritt die Ausgabe des Bewertungsschritts für das `@step` mit -dekorierte Modell.
```
# Define steps
@step(name="evaluate")
def evaluate_model():
# code to evaluate the model
return {
"rmse":rmse_value
}
@step(name="register")
def register_model():
# code to register the model
...
```
```
# Define ConditionStep
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.conditions import ConditionGreaterThanOrEqualTo
from sagemaker.workflow.fail_step import FailStep
conditionally_register = ConditionStep(
name="conditional_register",
conditions=[
ConditionGreaterThanOrEqualTo(
# Output of the evaluate step must be json serializable
left=evaluate_model()["rmse"], #
right=5,
)
],
if_steps=[FailStep(name="Fail", error_message="Model performance is not good enough")],
else_steps=[register_model()],
)
```
## Definieren Sie eine Pipeline anhand der `DelayedReturn` Ausgabe von Schritten
Sie definieren eine Pipeline auf die gleiche Weise, unabhängig davon, ob Sie einen `@step` Decorator verwenden oder nicht. Wenn Sie eine `DelayedReturn` Instance an Ihre Pipeline übergeben, müssen Sie keine vollständige Liste der Schritte zum Erstellen der Pipeline übergeben. Das SDK leitet anhand der von Ihnen definierten Abhängigkeiten automatisch die vorherigen Schritte ab. Alle vorherigen Schritte der `Step` Objekte, die Sie an die Pipeline übergeben haben, oder der `DelayedReturn` Objekte, sind im Pipeline-Diagramm enthalten. Im folgenden Beispiel empfängt die Pipeline das `DelayedReturn` Objekt für die `train` Funktion. SageMaker AI fügt den `preprocess` Schritt als vorherigen Schritt von `train` zum Pipeline-Diagramm hinzu.
```
from sagemaker.workflow.pipeline import Pipeline
pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=,
)
```
Wenn zwischen den Schritten keine Daten oder benutzerdefinierten Abhängigkeiten bestehen und Sie mehrere Schritte parallel ausführen, hat das Pipeline-Diagramm mehr als einen Blattknoten. Übergeben Sie all diese Blattknoten in einer Liste an das `steps` Argument in Ihrer Pipeline-Definition, wie im folgenden Beispiel gezeigt:
```
@step
def process1():
...
return data
@step
def process2():
...
return data
step_process1_result = process1()
step_process2_result = process2()
pipeline = Pipeline(
name="",
steps=[step_process1_result, step_process2_result],
sagemaker_session=sagemaker-session,
)
```
Wenn die Pipeline läuft, laufen beide Schritte parallel.
Sie übergeben nur die Blattknoten des Diagramms an die Pipeline, da die Blattknoten Informationen über alle vorherigen Schritte enthalten, die durch Daten oder benutzerdefinierte Abhängigkeiten definiert wurden. Beim Kompilieren der Pipeline leitet SageMaker KI auch von allen nachfolgenden Schritten ab, die den Pipeline-Graphen bilden, und fügt jeden von ihnen als separaten Schritt zur Pipeline hinzu.
## Erstellen Sie eine Pipeline
Erstellen Sie eine Pipeline durch Aufrufen`pipeline.create()`, wie im folgenden Ausschnitt gezeigt. [Einzelheiten dazu finden Sie unter `create()` SageMaker.Workflow.Pipeline.Pipeline.Create.](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.create)
```
role = "pipeline-role"
pipeline.create(role)
```
Wenn Sie aufrufen`pipeline.create()`, kompiliert SageMaker AI alle Schritte, die als Teil der Pipeline-Instanz definiert sind. SageMaker KI lädt die serialisierte Funktion, die Argumente und alle anderen schrittbezogenen Artefakte auf Amazon S3 hoch.
Die Daten befinden sich im S3-Bucket gemäß der folgenden Struktur:
```
s3_root_uri/
pipeline_name/
sm_rf_user_ws/
workspace.zip # archive of the current working directory (workdir)
step_name/
timestamp/
arguments/ # serialized function arguments
function/ # serialized function
pre_train_dependencies/ # any dependencies and pre_execution scripts provided for the step
execution_id/
step_name/
results # returned output from the serialized function including the model
```
`s3_root_uri`ist in der SageMaker AI-Konfigurationsdatei definiert und gilt für die gesamte Pipeline. Wenn nicht definiert, wird der SageMaker Standard-AI-Bucket verwendet.
**Anmerkung**
Jedes Mal, wenn SageMaker AI eine Pipeline kompiliert, speichert SageMaker AI die serialisierten Funktionen, Argumente und Abhängigkeiten der Schritte in einem Ordner, der mit der aktuellen Uhrzeit versehen ist. Dies geschieht jedes Mal, wenn Sie `pipeline.create()`, `pipeline.update()`, `pipeline.upsert()` oder `pipeline.definition()` ausführen.
# Ausführen Sie eine Pipeline
Auf der folgenden Seite wird beschrieben, wie Sie eine Pipeline mit Amazon SageMaker Pipelines ausführen, entweder mit SageMaker KI-Ressourcen oder lokal.
Starten Sie einen neuen Pipeline-Lauf mit der `pipeline.start()` Funktion wie bei einem herkömmlichen SageMaker KI-Pipeline-Lauf. [Informationen zu der `start()` Funktion finden Sie unter SageMaker.Workflow.Pipeline.Pipeline.Start.](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.start)
**Anmerkung**
Ein mit dem `@step` Decorateur definierter Schritt wird als Trainingsjob ausgeführt. Beachten Sie daher folgende Einschränkungen:
Limits für Instances und Trainingsjobs in Ihren Konten. Aktualisieren Sie Ihre Limits entsprechend, um Probleme mit der Drosselung oder dem Ressourcenlimit zu vermeiden.
Die monetären Kosten, die mit jedem anstehenden Trainingsschritt verbunden sind. Weitere Informationen finden Sie unter [ SageMaker Amazon-Preise](https://aws.amazon.com/sagemaker/pricing/).
## Rufen Sie die Ergebnisse einer lokal ausgeführten Pipeline ab
Um das Ergebnis eines beliebigen Schritts eines Pipeline-Laufs anzuzeigen, verwenden Sie [execution.result ()](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline._PipelineExecution.result ), wie im folgenden Codeausschnitt gezeigt:
```
execution = pipeline.start()
execution.result(step_name="train")
```
**Anmerkung**
Pipelines unterstützt `execution.result()` im lokalen Modus nicht.
Sie können nur jeweils Ergebnisse für einen Schritt abrufen. Wenn der Schrittname von SageMaker AI generiert wurde, können Sie den Schrittnamen abrufen, indem Sie `list_steps` wie folgt aufrufen:
```
execution.list_step()
```
## Ausführen Sie eine Pipeline lokal
Sie können eine Pipeline mit mit `@step` -dekorierten Schritten wie bei herkömmlichen Pipeline-Schritten lokal ausführen. Einzelheiten zu Pipeline-Läufen im lokalen Modus finden Sie unter[Führen Sie Pipelines im lokalen Modus aus](pipelines-local-mode.md). Um den lokalen Modus zu verwenden, fügen Sie Ihrer Pipeline-Definition `LocalPipelineSession` statt a ein `SageMakerSession` hinzu, wie im folgenden Beispiel gezeigt:
```
from sagemaker.workflow.function_step import step
from sagemaker.workflow.pipeline import Pipeline
from sagemaker.workflow.pipeline_context import LocalPipelineSession
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_train_result = train()
local_pipeline_session = LocalPipelineSession()
local_pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=local_pipeline_session # needed for local mode
)
local_pipeline.create(role_arn="role_arn")
# pipeline runs locally
execution = local_pipeline.start()
```
# Konfigurieren Ihrer Pipeline
Es wird empfohlen, die SageMaker AI-Konfigurationsdatei zu verwenden, um die Standardeinstellungen für die Pipeline festzulegen. Informationen zur SageMaker AI-Konfigurationsdatei finden Sie unter [Konfiguration und Verwendung von Standardwerten mit dem SageMaker Python-SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#configuring-and-using-defaults-with-the-sagemaker-python-sdk). Jede Konfiguration, die der Konfigurationsdatei hinzugefügt wird, gilt für alle Schritte in der Pipeline. Wenn Sie die Optionen für einen der Schritte überschreiben möchten, geben Sie neue Werte in den `@step` Decorator-Argumenten an. Das folgende Thema beschreibt, wie eine Konfigurationsdatei eingerichtet wird.
Die Konfiguration des `@step` Decorators in der Konfigurationsdatei ist identisch mit der Konfiguration des `@remote` Decorators. Verwenden Sie den `Pipeline` Abschnitt im folgenden Ausschnitt, um den ARN der Pipeline-Rolle und die Pipeline-Tags in der Konfigurationsdatei einzurichten:
```
SchemaVersion: '1.0'
SageMaker:
Pipeline:
RoleArn: 'arn:aws:iam::555555555555:role/IMRole'
Tags:
- Key: 'tag_key'
Value: 'tag_value'
```
Die meisten Standardeinstellungen, die Sie in der Konfigurationsdatei festlegen können, können Sie auch überschreiben, indem Sie dem `@step`-Decorator neue Werte übergeben. Sie können beispielsweise den Instance-Typ überschreiben, den Sie in der Konfigurationsdatei für Ihren Vorverarbeitungsschritt festgelegt haben, wie im folgenden Beispiel dargestellt:
```
@step(instance_type="ml.m5.large")
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
```
Einige Argumente sind nicht Teil der `@step` Decorator-Parameterliste — sie können nur über die AI-Konfigurationsdatei für die gesamte Pipeline konfiguriert werden. SageMaker Sie sind wie folgt aufgeführt:
+ `sagemaker_session`(`sagemaker.session.Session`): Die zugrunde liegende SageMaker KI-Sitzung, an die SageMaker KI Serviceanrufe delegiert. Falls nicht angegeben, wird eine Sitzung mit einer Standardkonfiguration wie folgt erstellt:
```
SageMaker:
PythonSDK:
Modules:
Session:
DefaultS3Bucket: 'default_s3_bucket'
DefaultS3ObjectKeyPrefix: 'key_prefix'
```
+ `custom_file_filter`(`CustomFileFilter)`: Ein `CustomFileFilter` Objekt, das die lokalen Verzeichnisse und Dateien angibt, die in den Pipeline-Schritt aufgenommen werden sollen. Falls nicht angegeben, ist dieser Wert standardmäßig `None`. Damit `custom_file_filter` wirksam wird, müssen Sie `IncludeLocalWorkdir` auf `True` festlegen. Das folgende Beispiel zeigt eine Konfiguration, die alle Notebookdateien sowie die genannten `data` Dateien und Verzeichnisse ignoriert.
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
IncludeLocalWorkDir: true
CustomFileFilter:
IgnoreNamePatterns: # files or directories to ignore
- "*.ipynb" # all notebook files
- "data" # folder or file named "data"
```
Weitere Informationen zur Verwendung von `IncludeLocalWorkdir` mit finden Sie `CustomFileFilter` unter[Verwendung von modularem Code mit dem @remote Decorator](train-remote-decorator-modular.md).
+ `s3_root_uri (str)`: Der Amazon S3 S3-Stammordner, in den SageMaker AI die Codearchive und Daten hochlädt. Falls nicht angegeben, wird der SageMaker Standard-AI-Bucket verwendet.
+ `s3_kms_key (str)`: Der Schlüssel, der zum Verschlüsseln der Eingabe- und Ausgabedaten verwendet wird. Sie können dieses Argument nur in der SageMaker AI-Konfigurationsdatei konfigurieren und das Argument gilt für alle in der Pipeline definierten Schritte. Wenn keine Angabe erfolgt, lautet der Standardwert `None`. Im folgenden Codeausschnitt finden Sie ein Beispiel für eine S3-KMS-Schlüsselkonfiguration:
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
S3KmsKeyId: 's3kmskeyid'
S3RootUri: 's3://amzn-s3-demo-bucket/my-project
```
# Bewährte Methoden
In den folgenden Abschnitten finden Sie bewährte Methoden für die Verwendung des `@step` Decorators für Ihre Pipeline-Schritte.
## Verwenden Sie Warm-Pools
Verwenden Sie für schnellere Pipeline-Step-Läufe die Funktion zum Warmpooling, die für Trainingsaufgaben bereitgestellt wird. Sie können die Warm-Pool-Funktionalität aktivieren, indem Sie dem `@step` Decorator das `keep_alive_period_in_seconds` Argument zur Verfügung stellen, wie im folgenden Codeausschnitt gezeigt:
```
@step(
keep_alive_period_in_seconds=900
)
```
Weitere Informationen zu Warm-Pools finden Sie unter [SageMaker KI-verwaltete warme Pools](train-warm-pools.md).
## Strukturieren Ihres Verzeichnisses
Es wird empfohlen, bei der Verwendung des `@step` Decorators Codemodule zu verwenden. Platzieren Sie das `pipeline.py` Modul, in dem Sie die Schrittfunktionen aufrufen und die Pipeline definieren, im Stammverzeichnis des Workspace. Die empfohlene Struktur sieht wie folgt aus:
```
.
├── config.yaml # the configuration file that define the infra settings
├── requirements.txt # dependencies
├── pipeline.py # invoke @step-decorated functions and define the pipeline here
├── steps/
| ├── processing.py
| ├── train.py
├── data/
├── test/
```
# Einschränkungen
In den folgenden Abschnitten werden die Einschränkungen beschrieben, die Sie beachten sollten, wenn Sie den `@step` Decorator für Ihre Pipeline-Schritte verwenden.
## Einschränkungen von Funktionsargumenten
Wenn Sie ein Eingabeargument an die `@step` mit -dekorierte Funktion übergeben, gelten die folgenden Einschränkungen:
+ Sie können die Objekte`DelayedReturn`, `Properties` (von Schritten anderer Typen) und `ExecutionVariable` -Objekte als `Parameter` Argumente an `@step` mit -dekorierte Funktionen übergeben. Mit `@step` -dekorierten Funktionen werden `Join` Objekte jedoch nicht als `JsonGet` Argumente unterstützt.
+ Sie können von einer `@step` Funktion aus nicht direkt auf eine Pipeline-Variable zugreifen. Das folgende Beispiel erzeugt einen Fehler:
```
param = ParameterInteger(name="", default_value=10)
@step
def func():
print(param)
func() # this raises a SerializationError
```
+ Sie können eine Pipeline-Variable nicht in einem anderen Objekt verschachteln und an eine `@step` Funktion übergeben. Das folgende Beispiel erzeugt einen Fehler:
```
param = ParameterInteger(name="", default_value=10)
@step
def func(arg):
print(arg)
func(arg=(param,)) # this raises a SerializationError because param is nested in a tuple
```
+ Da die Ein- und Ausgaben einer Funktion serialisiert sind, gibt es Einschränkungen hinsichtlich der Art der Daten, die als Eingabe oder Ausgabe von einer Funktion übergeben werden können. Weitere Informationen finden Sie im Abschnitt *Datenserialisierung und Deserialisierung* von[Aufrufen einer Remote-Funktion](train-remote-decorator-invocation.md). Die gleichen Einschränkungen gelten für `@step`-dekorierte Funktionen.
+ Objekte, die einen Boto-Client enthalten, können nicht serialisiert werden. Daher können Sie solche Objekte nicht als Eingabe an eine mit `@step`-dekorierte Funktion übergeben oder als Ausgabe von einer solchen Funktion erhalten. Beispielsweise `Processor` können SageMaker Python-SDK-Clientklassen wie `Estimator``Predictor`, und nicht serialisiert werden.
## Funktionsimporte
Sie sollten die Bibliotheken importieren, die für den Schritt innerhalb und nicht außerhalb der Funktion erforderlich sind. Wenn Sie sie auf globaler Ebene importieren, riskieren Sie bei der Serialisierung der Funktion eine Importkollision. `sklearn.pipeline.Pipeline` könnte beispielsweise mit `sagemaker.workflow.pipeline.Pipeline` überschrieben werden.
## Verweisen auf untergeordnete Elemente des Funktionsrückgabewerts
Wenn Sie auf untergeordnete Elemente des Rückgabewerts einer `@step` mit -dekorierten Funktion verweisen, gelten die folgenden Einschränkungen:
+ Sie können auf die untergeordneten Elemente verweisen, `[]` wenn das `DelayedReturn` Objekt ein Tupel, eine Liste oder ein Diktat darstellt, wie im folgenden Beispiel gezeigt:
```
delayed_return[0]
delayed_return["a_key"]
delayed_return[1]["a_key"]
```
+ Sie können eine Tupel- oder Listenausgabe nicht entpacken, da die genaue Länge des zugrunde liegenden Tupels oder der zugrunde liegenden Liste nicht bekannt sein kann, wenn Sie die Funktion aufrufen. Das folgende Beispiel erzeugt einen Fehler:
```
a, b, c = func() # this raises ValueError
```
+ Sie können nicht über ein `DelayedReturn`-Objekt iterieren. Das folgende Beispiel löst einen Fehler aus:
```
for item in func(): # this raises a NotImplementedError
```
+ Sie können nicht mit '`.`' auf beliebige untergeordnete Elemente verweisen. Das folgende Beispiel erzeugt einen Fehler:
```
delayed_return.a_child # raises AttributeError
```
## Bestehende Pipeline-Funktionen, die nicht unterstützt werden
Sie können den `@step` Decorator nicht mit den folgenden Pipeline-Funktionen verwenden:
+ [Zwischenspeichern eines Pipeline-Schritts](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-caching.html)
+ [Eigenschaftendatei](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-propertyfile.html#build-and-manage-propertyfile-property)
# Daten zwischen Schritten weitergeben
Beim Erstellen von Pipelines mit Amazon SageMaker Pipelines müssen Sie möglicherweise Daten von einem Schritt zum nächsten weitergeben. Beispielsweise möchten Sie möglicherweise die durch einen Trainingsschritt generierten Modellartefakte als Eingabe für einen Schritt zur Modellbewertung oder -bereitstellung verwenden. Sie können diese Funktionalität verwenden, um voneinander abhängige Pipeline-Schritte zu erstellen und Ihre ML-Workflows zu erstellen.
Wenn Sie Informationen aus der Ausgabe eines Pipeline-Schritts abrufen müssen, können Sie `JsonGet` verwenden. `JsonGet` unterstützt Sie beim Extrahieren von Informationen aus Amazon S3 oder Eigenschaftsdateien. In den folgenden Abschnitten werden Methoden beschrieben, mit denen Sie Schrittausgaben extrahieren können`JsonGet`.
## Übergeben Sie Daten zwischen Schritten mit Amazon S3
Sie können `JsonGet` in a verwenden`ConditionStep`, um die JSON-Ausgabe direkt von Amazon S3 abzurufen. Der Amazon-S3-URI kann eine `Std:Join`-Funktion sein, die primitive Zeichenketten, Pipeline-Ausführungsvariablen oder Pipeline-Parameter enthält. Das folgende Beispiel zeigt, wie Sie `JsonGet` in einem `ConditionStep` verwenden können.
```
# Example json file in s3 bucket generated by a processing_step
{
"Output": [5, 10]
}
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name="",
s3_uri="",
json_path="Output[1]"
),
right=6.0
)
```
Wenn Sie `JsonGet` mit einem Amazon-S3-Pfad im Bedingungsschritt verwenden, müssen Sie explizit eine Abhängigkeit zwischen dem Bedingungsschritt und dem Schritt, der die JSON-Ausgabe generiert, hinzufügen. Im folgenden Beispiel wird der Bedingungsschritt mit einer Abhängigkeit vom Verarbeitungsschritt erstellt:
```
cond_step = ConditionStep(
name="",
conditions=[cond_lte],
if_steps=[fail_step],
else_steps=[register_model_step],
depends_on=[processing_step],
)
```
## Übergeben Sie Daten mit Eigenschaftendateien zwischen Schritten
Verwenden Sie Eigenschaftendateien, um Informationen aus der Ausgabe eines Verarbeitungsschritts zu speichern. Dies ist besonders nützlich, wenn die Ergebnisse eines Verarbeitungsschritts analysiert werden, um zu entscheiden, wie ein bedingter Schritt ausgeführt werden soll. Die `JsonGet` Funktion verarbeitet eine Eigenschaftendatei und ermöglicht es Ihnen, die Eigenschaften-JSON-Datei mithilfe der JsonPath Notation abzufragen. Weitere Informationen zur JsonPath Notation finden Sie im [JsonPath Repo](https://github.com/json-path/JsonPath).
Um eine Eigenschaftendatei für die spätere Verwendung zu speichern, müssen Sie zunächst eine `PropertyFile` Instance mit dem folgenden Format erstellen. Der `path` Parameter ist der Name der JSON-Datei, in der die Eigenschaftendatei gespeichert wird. Jedes `output_name` muss mit dem `output_name` des `ProcessingOutput` übereinstimmen, das Sie in Ihrem Verarbeitungsschritt definieren. Dadurch kann die Eigenschaftendatei die `ProcessingOutput` in dem Schritt erfassen.
```
from sagemaker.workflow.properties import PropertyFile
= PropertyFile(
name="",
output_name="",
path=""
)
```
Wenn Sie Ihre `ProcessingStep` Instance erstellen, fügen Sie den `property_files` Parameter hinzu, um alle Parameterdateien aufzulisten, die der Amazon SageMaker Pipelines-Service indizieren muss. Dadurch wird die Eigenschaftendatei für die spätere Verwendung gespeichert.
```
property_files=[]
```
Um Ihre Eigenschaftsdatei in einem Bedingungsschritt zu verwenden, fügen Sie `property_file` zu der Bedingung hinzu, die Sie an Ihren Bedingungsschritt übergeben, wie im folgenden Beispiel gezeigt, um die JSON-Datei mit dem Parameter `json_path` nach der gewünschten Eigenschaft abzufragen.
```
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name=step_eval.name,
property_file=,
json_path="mse"
),
right=6.0
)
```
Ausführlichere Beispiele finden Sie unter *[Property File](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#property-file)* im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
# Zwischenspeichern von Pipeline-Schritten
In Amazon SageMaker Pipelines können Sie Step-Caching verwenden, um beim erneuten Ausführen von Pipelines Zeit und Ressourcen zu sparen. Beim Step-Caching wird die Ausgabe einer vorherigen erfolgreichen Ausführung eines Schritts wiederverwendet (anstatt sie erneut zu berechnen), wenn der Schritt dieselbe Konfiguration und dieselben Eingaben hat. Auf diese Weise können Sie bei Pipeline-Wiederholungen mit identischen Parametern konsistente Ergebnisse erzielen. Im folgenden Thema erfahren Sie, wie Sie das Step-Caching für Ihre Pipelines konfigurieren und aktivieren.
Wenn Sie das Zwischenspeichern von Schrittsignaturen verwenden, versucht Pipelines, eine frühere Ausführung Ihres aktuellen Pipeline-Schritts mit denselben Werten für bestimmte Attribute zu finden. Falls gefunden, überträgt Pipelines die Ausgaben der vorherigen Ausführung, anstatt den Schritt erneut zu berechnen. Die geprüften Attribute sind spezifisch für den Schritttyp und werden in [Standard-Cache-Schlüsselattribute nach Pipeline-Schritttyp](pipelines-default-keys.md) aufgeführt.
Sie müssen sich für das Step-Caching entscheiden – es ist standardmäßig deaktiviert. Wenn Sie das Step-Caching aktivieren, müssen Sie auch ein Timeout definieren. Dieses Timeout definiert, wie alt ein früherer Lauf sein kann, damit er als Kandidat für die Wiederverwendung in Frage kommt.
Beim Step-Caching werden nur erfolgreiche Läufe berücksichtigt – fehlgeschlagene Läufe werden niemals wiederverwendet. Wenn innerhalb des Timeout-Zeitraums mehrere erfolgreiche Ausführungen existieren, verwendet Pipelines das Ergebnis für die letzte erfolgreiche Ausführung. Wenn im Timeout-Zeitraum keine erfolgreichen Ausführungen übereinstimmen, führt Pipelines den Schritt erneut aus. Wenn der Executor eine vorherige Ausführung findet, die die Kriterien erfüllt, aber noch läuft, werden beide Schritte weiter ausgeführt und der Cache wird aktualisiert, wenn sie erfolgreich sind.
Das Zwischenspeichern von Schritten ist nur für einzelne Pipelines vorgesehen, sodass Sie einen Schritt aus einer anderen Pipeline nicht wiederverwenden können, selbst wenn eine Übereinstimmung mit der Schrittsignatur vorliegt.
Das Zwischenspeichern von Schritten ist für die folgenden Schritttypen verfügbar:
+ [Verarbeitung](build-and-manage-steps-types.md#step-type-processing)
+ [Training](build-and-manage-steps-types.md#step-type-training)
+ [Optimieren](build-and-manage-steps-types.md#step-type-tuning)
+ [AutoML](build-and-manage-steps-types.md#step-type-automl)
+ [Transformieren](build-and-manage-steps-types.md#step-type-transform)
+ [`ClarifyCheck`](build-and-manage-steps-types.md#step-type-clarify-check)
+ [`QualityCheck`](build-and-manage-steps-types.md#step-type-quality-check)
+ [EMR](build-and-manage-steps-types.md#step-type-emr)
**Topics**
+ [Schalten Sie das Step-Caching ein](pipelines-caching-enabling.md)
+ [Deaktivieren des Schritt-Caching](pipelines-caching-disabling.md)
+ [Standard-Cache-Schlüsselattribute nach Pipeline-Schritttyp](pipelines-default-keys.md)
+ [Zugriffskontrolle für zwischengespeicherte Daten](pipelines-access-control.md)
# Schalten Sie das Step-Caching ein
Um das Schritt-Caching zu aktivieren, müssen Sie der Schrittdefinition eine `CacheConfig`-Eigenschaft hinzufügen. `CacheConfig`-Eigenschaften verwenden in der Pipeline-Definitionsdatei das folgende Format:
```
{
"CacheConfig": {
"Enabled": false,
"ExpireAfter": "