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.
# 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).