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. # Definieren einer Pipeline Um Ihre Workflows mit Amazon SageMaker Pipelines zu orchestrieren, müssen Sie ein gerichtetes azyklisches Diagramm (DAG) in Form einer JSON-Pipeline-Definition generieren. Der DAG legt die verschiedenen Schritte Ihres ML-Prozesses fest, wie beispielsweise die Datenvorverarbeitung, das Modelltraining, die Modellbewertung und die Modellbereitstellung, sowie die Abhängigkeiten und den Datenfluss zwischen diesen Schritten. Im folgenden Thema wird gezeigt, wie Sie eine Pipeline-Definition generieren. Sie können Ihre JSON-Pipeline-Definition entweder mit dem SageMaker Python-SDK oder der visuellen Drag-and-Drop-Pipeline Designer-Funktion in Amazon Studio generieren. SageMaker Die folgende Abbildung zeigt die Pipeline-DAG, die Sie in diesem Tutorial erstellen: ![Screenshot der visuellen Drag-and-Drop-Benutzeroberfläche für Pipelines in Studio.](https://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/pipelines/pipelines-studio-overview.png) Die Pipeline, die Sie in den folgenden Abschnitten definieren, löst ein Regressionsproblem, um das Alter einer Abalone anhand ihrer physikalischen Maße zu bestimmen. Ein lauffähiges Jupyter-Notizbuch, das den Inhalt dieses Tutorials enthält, finden Sie [ unter Orchestrieren von Jobs mit Amazon Model Building Pipelines. SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-pipelines/tabular/abalone_build_train_deploy/sagemaker-pipelines-preprocess-train-evaluate-batch-transform.html) **Anmerkung** Sie können den Speicherort des Modells als Eigenschaft des Trainingsschritts referenzieren, wie in der umfassenden Beispielpipeline auf Github gezeigt. [ CustomerChurn ](https://github.com/aws-samples/customer-churn-sagemaker-pipelines-sample/blob/main/pipelines/customerchurn/pipeline.py) **Topics** ## Definieren Sie eine Pipeline (Pipeline Designer) Die folgende exemplarische Vorgehensweise führt Sie durch die Schritte zum Erstellen einer Barebones-Pipeline mithilfe des Pipeline-Designers per Drag-and-Drop. **Wenn Sie Ihre Pipeline-Bearbeitungssitzung im Visual Designer zu einem beliebigen Zeitpunkt unterbrechen oder beenden müssen, klicken Sie auf die Option Exportieren.** Auf diese Weise können Sie die aktuelle Definition Ihrer Pipeline in Ihre lokale Umgebung herunterladen. Später, wenn Sie den Pipeline-Bearbeitungsprozess fortsetzen möchten, können Sie dieselbe JSON-Definitionsdatei in den Visual Designer importieren. ### Erstellen eines Verarbeitungsschritts Gehen Sie wie folgt vor, um einen Datenverarbeitungsauftrag zu erstellen: 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 **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. Um einen Eingabedatensatz **hinzuzufügen**, wählen Sie in der rechten Seitenleiste unter **Daten (Eingabe)** die Option Hinzufügen und wählen Sie einen Datensatz aus. 1. Um einen Speicherort für Ausgabe-Datasets **hinzuzufügen**, wählen Sie in der rechten Seitenleiste unter **Daten (Ausgabe)** die Option Hinzufügen und navigieren Sie zum Ziel. 1. Füllen Sie die verbleibenden Felder in der rechten Seitenleiste 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). ### Erstellen Sie einen Trainingsschritt Gehen Sie zum Einrichten eines Modell-Trainingsschritts wie folgt vor: 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. Um einen Eingabedatensatz **hinzuzufügen**, wählen Sie in der rechten Seitenleiste unter **Daten (Eingabe)** die Option Hinzufügen und wählen Sie einen Datensatz aus. 1. Um einen Speicherort für Ihre Modellartefakte auszuwählen, geben Sie eine Amazon-S3-URI in das Feld **Standort (S3-URI)** ein oder wählen Sie **S3 durchsuchen** aus, um zum Zielort zu navigieren. 1. Füllen Sie die verbleibenden Felder in der rechten Seitenleiste 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. Klicken und ziehen Sie den Cursor aus dem **Prozessdatenschritt**, den Sie im vorherigen Abschnitt hinzugefügt haben, in den Schritt Modell **trainieren**, um eine Kante zu erzeugen, die die beiden Schritte verbindet. ### Erstellen Sie ein Modellpaket mit dem Schritt Modell registrieren Um ein Modellpaket mit einem Modellregistrierungsschritt zu erstellen, führen Sie die folgenden Schritte aus: 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. Um ein Modell für die Registrierung auszuwählen, wählen Sie unter **Modell (Eingabe)** die Option **Hinzufügen** aus. 1. Wählen Sie **Modellgruppe erstellen**, um Ihr Modell zu einer neuen Modellgruppe hinzuzufügen. 1. Füllen Sie die verbleibenden Felder in der rechten Seitenleiste aus. Informationen zu den Feldern in diesen Tabs finden Sie unter [ sagemaker.workflow.step\_collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel). 1. **Klicken und ziehen Sie den Cursor aus dem Schritt **Modell trainieren, den Sie im vorherigen Abschnitt hinzugefügt haben, in den Schritt Modell** registrieren, um eine Kante zu erzeugen, die die beiden Schritte verbindet.** ### Stellen Sie das Modell mit dem Schritt Modell bereitstellen (Endpunkt) auf einem Endpunkt bereit Um Ihr Modell mit einem Modellbereitstellungsschritt bereitzustellen, führen Sie die folgenden Schritte aus: 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. Um ein Modell für die Bereitstellung auszuwählen, wählen Sie unter **Modell (Eingabe)** die Option **Hinzufügen** aus. 1. Wählen Sie das Optionsfeld **Endpunkt erstellen**, um einen neuen Endpunkt zu erstellen. 1. Geben Sie einen **Namen** und eine **Beschreibung** für den Endpunkt ein. 1. Klicken und ziehen Sie den Cursor aus dem Schritt **Modell registrieren**, den Sie im vorherigen Abschnitt hinzugefügt haben, in den Schritt **Modell bereitstellen (Endpunkt)**, um eine Kante zu erstellen, die die beiden Schritte verbindet. 1. Füllen Sie die verbleibenden Felder in der rechten Seitenleiste aus. ### Definieren Sie die Pipeline-Parameter Sie können eine Reihe von Pipeline-Parametern konfigurieren, deren Werte für jede Ausführung aktualisiert werden können. Um die Pipeline-Parameter zu definieren und die Standardwerte festzulegen, klicken Sie auf das Zahnradsymbol unten im Visual Designer. ### Pipeline speichern Nachdem Sie alle erforderlichen Informationen eingegeben haben, um Ihre Pipeline zu erstellen, klicken Sie unten im visuellen Designer auf **Speichern**. Dadurch wird Ihre Pipeline zur Laufzeit auf mögliche Fehler überprüft und Sie werden benachrichtigt. Der **Speichervorgang** ist erst erfolgreich, wenn Sie alle Fehler behoben haben, die durch die automatischen Validierungsprüfungen gekennzeichnet wurden. Wenn Sie die Bearbeitung zu einem späteren Zeitpunkt fortsetzen möchten, können Sie Ihre Pipeline in Bearbeitung als JSON-Definition in Ihrer lokalen Umgebung speichern. Sie können Ihre Pipeline als JSON-Definitionsdatei **exportieren, indem Sie unten im Visual Designer auf die Schaltfläche Exportieren** klicken. Um später mit der Aktualisierung Ihrer Pipeline fortzufahren, laden Sie diese JSON-Definitionsdatei hoch, indem Sie auf die Schaltfläche **Importieren** klicken. ## Definieren Sie eine Pipeline (SageMaker Python SDK) ### Voraussetzungen Zur Ausführung des folgenden Tutorials gehen Sie wie folgt vor: + Richten Sie Ihre Notebook-Instance wie unter [Notebook-Instance erstellen](https://docs.aws.amazon.com/sagemaker/latest/dg/howitworks-create-ws.html) beschrieben ein. Dadurch erhalten Sie für Ihre Rolle die Berechtigung, in Amazon S3 zu lesen und zu schreiben und Schulungs-, Batch-Transformations- und Verarbeitungsjobs in SageMaker KI zu erstellen. + Erteilen Sie Ihrem Notebook Berechtigungen zum Abrufen und Weitergeben seiner eigenen Rolle, wie unter Richtlinie zu [Rollenberechtigungen ändern](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy) beschrieben. Fügen Sie den folgenden JSON-Snippet hinzu, um diese Richtlinie an Ihre Rolle anzuhängen. ``Ersetzen Sie es durch den ARN, der für die Erstellung Ihrer Notebook-Instance verwendet wurde. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:GetRole", "iam:PassRole" ], "Resource": "arn:aws:iam::{{111122223333}}:role/{{role-name}}" } ] } ``` ------ + Vertrauen Sie dem SageMaker AI-Serviceprinzipal, indem Sie die Schritte [ unter Ändern einer Rollenvertrauensrichtlinie befolgen](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-cli.html#roles-managingrole_edit-trust-policy-cli). Fügen Sie das folgende Anweisungsfragment zur Vertrauensstellung Ihrer Rolle hinzu: ``` { "Sid": "", "Effect": "Allow", "Principal": { "Service": "sagemaker.amazonaws.com" }, "Action": "sts:AssumeRole" } ``` #### So richten Sie Ihre Umgebung ein Erstellen Sie eine neue SageMaker AI-Sitzung mit dem folgenden Codeblock. Dies gibt den Rollen-ARN für die Sitzung zurück. Dieser Rollen-ARN sollte der ARN der Ausführungsrolle sein, den Sie als Voraussetzung eingerichtet haben. ``` import boto3 import sagemaker from sagemaker.core.workflow.pipeline_context import PipelineSession from sagemaker.core.helper.session_helper import Session, get_execution_role region = boto3.Session().region_name sagemaker_session = Session() role = get_execution_role() default_bucket = sagemaker_session.default_bucket() pipeline_session = PipelineSession() model_package_group_name = f"AbaloneModelPackageGroupName" ``` ### Erstellen Sie eine Pipeline **Wichtig** Benutzerdefinierte IAM-Richtlinien, die es Amazon SageMaker Studio oder Amazon SageMaker Studio Classic ermöglichen, SageMaker Amazon-Ressourcen zu erstellen, müssen ebenfalls Berechtigungen zum Hinzufügen von Tags zu diesen Ressourcen gewähren. Die Berechtigung zum Hinzufügen von Tags zu Ressourcen ist erforderlich, da Studio und Studio Classic automatisch alle von ihnen erstellten Ressourcen taggen. Wenn eine IAM-Richtlinie Studio und Studio Classic zwar das Erstellen von Ressourcen erlaubt, das Taggen jedoch nicht zulässt, können AccessDenied "“ -Fehler auftreten, wenn versucht wird, Ressourcen zu erstellen. Weitere Informationen finden Sie unter [Stellen Sie Berechtigungen für das Taggen von SageMaker KI-Ressourcen bereit](security_iam_id-based-policy-examples.md#grant-tagging-permissions). [AWS verwaltete Richtlinien für Amazon AI SageMaker](security-iam-awsmanpol.md)die Berechtigungen zum Erstellen von SageMaker Ressourcen gewähren, enthalten bereits Berechtigungen zum Hinzufügen von Tags bei der Erstellung dieser Ressourcen. Führen Sie die folgenden Schritte von Ihrer SageMaker AI-Notebook-Instanz aus, um eine Pipeline zu erstellen, die Schritte für die Vorverarbeitung, das Training, die Bewertung, die bedingte Bewertung und die Modellregistrierung umfasst. **Anmerkung** Sie können die [https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#execution-variables](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#execution-variables) Join-Funktion verwenden [ ExecutionVariables](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#execution-variables), um Ihren Ausgabeort anzugeben. #### Schritt 1: Herunterladen des Datensatzes Dieses Notebook verwendet den UCI Machine Learning Abalone Datensatz. Der Datensatz enthält folgende Merkmale: + `length`– Die längste Schalenmessung der Abalone. + `diameter`– Der Durchmesser der Abalone senkrecht zu ihrer Länge. + `height`– Die Höhe der Abalone mit Fleisch in der Schale. + `whole_weight`– Das Gewicht der ganzen Abalone. + `shucked_weight`– Das Gewicht des aus der Abalone entnommenen Fleisches. + `viscera_weight`– Das Gewicht der Eingeweide der Abalone nach der Blutung. + `shell_weight`– Das Gewicht der Abalone-Schale nach dem Entnehmen und Trocknen des Fleisches. + `sex`– Das Geschlecht der Abalone. Eines von „M“, „F“ oder „I“, wobei „I“ für eine Säuglingsabalone steht. + `rings`– Die Anzahl der Ringe in der Abalone-Schale. Die Anzahl der Ringe in der Abalone-Schale ist anhand der Formel `age=rings + 1.5` eine gute Näherung für ihr Alter. Das Abrufen dieser Zahl ist jedoch eine zeitaufwändige Aufgabe. Sie müssen die Schale durch den Kegel schneiden, den Abschnitt färben und die Anzahl der Ringe durch ein Mikroskop zählen. Die anderen physikalischen Messungen sind jedoch einfacher abzurufen. Dieses Notebook verwendet den Datensatz, um anhand der anderen physikalischen Messungen ein Vorhersagemodell der variablen Ringe zu erstellen. **Zum Herunterladen des Datensatzes** 1. Laden Sie den Datensatz in den standardmäßigen Amazon-S3-Bucket Ihres Kontos herunter. ``` !mkdir -p data local_path = "data/abalone-dataset.csv" s3 = boto3.resource("s3") s3.Bucket(f"sagemaker-servicecatalog-seedcode-{region}").download_file( "dataset/abalone-dataset.csv", local_path ) base_uri = f"s3://{default_bucket}/abalone" input_data_uri = sagemaker.s3.S3Uploader.upload( local_path=local_path, desired_s3_uri=base_uri, ) print(input_data_uri) ``` 1. Laden Sie nach der Erstellung Ihres Modells einen zweiten Datensatz für die Batch-Transformation herunter. ``` local_path = "data/abalone-dataset-batch.csv" s3 = boto3.resource("s3") s3.Bucket(f"sagemaker-servicecatalog-seedcode-{region}").download_file( "dataset/abalone-dataset-batch", local_path ) base_uri = f"s3://{default_bucket}/abalone" batch_data_uri = sagemaker.s3.S3Uploader.upload( local_path=local_path, desired_s3_uri=base_uri, ) print(batch_data_uri) ``` #### Schritt 2: Definieren von Pipeline-Parametern ``` from sagemaker.core.workflow.parameters import ( ParameterInteger, ParameterString, ) processing_instance_count = ParameterInteger(name="ProcessingInstanceCount", default_value=1) model_approval_status = ParameterString(name="ModelApprovalStatus", default_value="PendingManualApproval") input_data = ParameterString(name="InputData", default_value=input_data_uri) batch_data = ParameterString(name="BatchData", default_value=batch_data_uri) ``` #### Schritt 3: Definieren eines Verarbeitungsschritts für Feature Engineering In diesem Abschnitt wird erläutert, wie Sie einen Verarbeitungsschritt erstellen, um die Daten aus dem Datensatz für das Training vorzubereiten. **Um einen Verarbeitungsschritt zu erstellen** 1. Erstellen Sie eine Instanz eines Prozessors, um sie an den Verarbeitungsschritt weiterzuleiten. ``` from sagemaker.core.processing import Processor from sagemaker.core import image_uris framework_version = "0.23-1" sklearn_image_uri = image_uris.retrieve( framework="sklearn", region=region, version=framework_version, instance_type="ml.m5.xlarge" ) sklearn_processor = Processor( image_uri=sklearn_image_uri, instance_type="ml.m5.xlarge", instance_count=processing_instance_count, base_job_name="sklearn-abalone-process", sagemaker_session=pipeline_session, role=role, ) ``` 1. Erstellen Sie einen Verarbeitungsschritt. ``` from sagemaker.core.processing import ProcessingInput, ProcessingOutput from sagemaker.mlops.workflow.steps import ProcessingStep processor_args = sklearn_processor.run( inputs=[ ProcessingInput(source=input_data, destination="/opt/ml/processing/input"), ], outputs=[ ProcessingOutput(output_name="train", source="/opt/ml/processing/train"), ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"), ProcessingOutput(output_name="test", source="/opt/ml/processing/test") ], code="abalone/preprocessing.py", ) step_process = ProcessingStep(name="AbaloneProcess", step_args=processor_args) ``` #### Schritt 4: Definieren eines Trainingsschritts In diesem Abschnitt wird gezeigt, wie der SageMaker AI XGBoost-Algorithmus verwendet wird, um ein Modell anhand der Trainingsdaten zu trainieren, die aus den Verarbeitungsschritten ausgegeben werden. **Um einen Trainingsschritt zu definieren** 1. Geben Sie den Modellpfad an, in dem Sie die Modelle aus dem Training speichern möchten. ``` model_path = f"s3://{default_bucket}/AbaloneTrain" ``` 1. Konfigurieren Sie einen Trainingsschätzer für den XGBoost-Algorithmus und den Eingabedatensatz. ``` from sagemaker.train import ModelTrainer from sagemaker.train.configs import Compute, OutputDataConfig from sagemaker.core import image_uris image_uri = image_uris.retrieve( framework="xgboost", region=region, version="1.0-1", py_version="py3", instance_type="ml.m5.xlarge" ) xgb_train = ModelTrainer( training_image=image_uri, compute=Compute(instance_type="ml.m5.xlarge", instance_count=1), output_data_config=OutputDataConfig(s3_output_path=model_path), hyperparameters={ "objective": "reg:linear", "num_round": "50", "max_depth": "5", "eta": "0.2", "gamma": "4", "min_child_weight": "6", "subsample": "0.7", "silent": "0" }, sagemaker_session=pipeline_session, role=role, ) ``` 1. Erstellen Sie eine `TrainingStep` mithilfe der Trainingsinstanz und der Eigenschaften von. `ProcessingStep` ``` from sagemaker.train.configs import InputData from sagemaker.mlops.workflow.steps import TrainingStep train_args = xgb_train.train( input_data_config=[ InputData( channel_name="train", data_source=step_process.properties.ProcessingOutputConfig.Outputs[ "train" ].S3Output.S3Uri, content_type="text/csv" ), InputData( channel_name="validation", data_source=step_process.properties.ProcessingOutputConfig.Outputs[ "validation" ].S3Output.S3Uri, content_type="text/csv" ) ], ) step_train = TrainingStep(name="AbaloneTrain", step_args=train_args) ``` #### Schritt 5: Definieren eines Verarbeitungsschritts für die Modellbewertung In diesem Abschnitt wird erläutert, wie Sie einen Verarbeitungsschritt erstellen, um die Genauigkeit des Modells zu bewerten. **Um einen Verarbeitungsschritt für die Modellevaluierung zu definieren** 1. Erstellen Sie eine Instanz von a `Processor` zur Auswertung. ``` from sagemaker.core.processing import Processor script_eval = Processor( image_uri=image_uri, command=["python3"], instance_type="ml.m5.xlarge", instance_count=1, base_job_name="script-abalone-eval", sagemaker_session=pipeline_session, role=role, ) ``` 1. Erstellen Sie eine, `ProcessingStep` indem Sie die Prozessorinstanz, die Eingabe- und Ausgabekanäle und das `evaluation.py` Skript verwenden. ``` from sagemaker.core.workflow.properties import PropertyFile evaluation_report = PropertyFile( name="EvaluationReport", output_name="evaluation", path="evaluation.json" ) eval_args = script_eval.run( inputs=[ ProcessingInput( source=step_train.properties.ModelArtifacts.S3ModelArtifacts, destination="/opt/ml/processing/model" ), ProcessingInput( source=step_process.properties.ProcessingOutputConfig.Outputs[ "test" ].S3Output.S3Uri, destination="/opt/ml/processing/test" ) ], outputs=[ ProcessingOutput(output_name="evaluation", source="/opt/ml/processing/evaluation"), ], code="abalone/evaluation.py", ) step_eval = ProcessingStep( name="AbaloneEval", step_args=eval_args, property_files=[evaluation_report], ) ``` #### Schritt 6: Definieren Sie eine CreateModelStep für die Batch-Transformation In diesem Abschnitt wird gezeigt, wie aus der Ausgabe des Trainingsschritts ein SageMaker KI-Modell erstellt wird. **Um eine CreateModelStep für eine Batch-Transformation zu definieren** + Erstellen Sie ein SageMaker KI-Modell und einen Modellschritt. ``` from sagemaker.serve import ModelBuilder from sagemaker.mlops.workflow.model_step import ModelStep model_builder = ModelBuilder( image_uri=image_uri, s3_model_data_url=step_train.properties.ModelArtifacts.S3ModelArtifacts, role_arn=role, sagemaker_session=pipeline_session, ) step_create_model = ModelStep( name="AbaloneCreateModel", step_args=model_builder.build(), ) ``` #### Schritt 7: Definieren Sie eine TransformStep , um eine Batch-Transformation durchzuführen In diesem Abschnitt wird gezeigt, wie ein `TransformStep` erstellt wird, um eine Batch-Transformation an einem Datensatz durchzuführen, nachdem das Modell trainiert wurde. **Um eine zu definieren TransformStep , um eine Batch-Transformation durchzuführen** + Erstellen Sie eine Transformer-Instanz und eine`TransformStep`. ``` from sagemaker.core.transformer import Transformer from sagemaker.mlops.workflow.steps import TransformStep transformer = Transformer( model_name=step_create_model.properties.ModelName, instance_type="ml.m5.xlarge", instance_count=1, output_path=f"s3://{default_bucket}/AbaloneTransform", sagemaker_session=pipeline_session, ) transform_args = transformer.transform(data=batch_data) step_transform = TransformStep( name="AbaloneTransform", step_args=transform_args, ) ``` #### Schritt 8: Definieren Sie einen RegisterModel Schritt zum Erstellen eines Modellpakets In diesem Abschnitt wird gezeigt, wie ein Modell registriert wird. Das Ergebnis ist ein Modellpaket für Inferenz. **Um einen Modellregistrierungsschritt zu definieren, um ein Modellpaket zu erstellen** + Konstruieren Sie einen Schritt zur Modellregistrierung. ``` from sagemaker.core.model_metrics import MetricsSource, ModelMetrics from sagemaker.mlops.workflow.model_step import ModelStep from sagemaker.serve import ModelBuilder model_metrics = ModelMetrics( model_statistics=MetricsSource( s3_uri="{{{}/evaluation.json}}".format( step_eval.arguments["ProcessingOutputConfig"]["Outputs"][0]["S3Output"]["S3Uri"] ), content_type="application/json" ) ) model_builder = ModelBuilder( image_uri=image_uri, s3_model_data_url=step_train.properties.ModelArtifacts.S3ModelArtifacts, role_arn=role, sagemaker_session=pipeline_session, ) register_args = model_builder.register( 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 ) step_register = ModelStep( name="{{AbaloneRegisterModel}}", step_args=register_args, ) ``` #### Schritt 9: Definieren eines Bedingungsschritts zur Überprüfung der Modellgenauigkeit Ein `ConditionStep` ermöglicht es Pipelines, die bedingte Ausführung in Ihrer Pipeline-DAG basierend auf dem Zustand der Schritteigenschaften zu unterstützen. **Um einen Bedingungsschritt zur Überprüfung der Modellgenauigkeit zu definieren** + Definieren Sie eine Bedingung und konstruieren Sie eine`ConditionStep`. ``` from sagemaker.core.workflow.conditions import ConditionLessThanOrEqualTo from sagemaker.mlops.workflow.condition_step import ConditionStep from sagemaker.core.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=[], ) ``` #### Schritt 10: Erstellen einer Pipeline Nachdem Sie nun alle Schritte erstellt haben, kombinieren Sie sie zu einer Pipeline. **So erstellen Sie eine Pipeline** 1. Definieren Sie Folgendes für Ihre Pipeline: `name`, `parameters`, und`steps`. ``` from sagemaker.mlops.workflow.pipeline import Pipeline pipeline_name = f"AbalonePipeline" pipeline = Pipeline( name=pipeline_name, parameters=[ processing_instance_count, model_approval_status, input_data, batch_data, ], steps=[step_process, step_train, step_eval, step_cond], ) ``` 1. (Optional) Untersuchen Sie die JSON-Pipeline-Definition, um sicherzustellen, dass sie korrekt formatiert ist. ``` import json json.loads(pipeline.definition()) ``` Diese Pipeline-Definition kann jetzt an SageMaker AI übermittelt werden. Im nächsten Tutorial senden Sie diese Pipeline an SageMaker AI und starten einen Lauf. ## Definieren Sie eine Pipeline (JSON) Sie können auch [boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_pipeline) oder [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-pipeline.html)zum Erstellen einer Pipeline verwenden. Das Erstellen einer Pipeline erfordert eine Pipeline-Definition, bei der es sich um ein JSON-Objekt handelt, das jeden Schritt der Pipeline definiert. Das SageMaker SDK bietet eine einfache Möglichkeit, die Pipeline-Definition zu erstellen, die Sie mit jeder der zuvor genannten APIs verwenden können, um die Pipeline selbst zu erstellen. Ohne das SDK zu verwenden, müssen Benutzer die unformatierte JSON-Definition schreiben, um die Pipeline ohne die vom SageMaker Python-SDK bereitgestellten Fehlerprüfungen zu erstellen. Das Schema für die Pipeline-JSON-Definition finden Sie unter JSON-Schema für die [ SageMaker AI-Pipeline-Definition](https://aws-sagemaker-mlops.github.io/sagemaker-model-building-pipeline-definition-JSON-schema/). Das folgende Codebeispiel zeigt ein Beispiel für ein JSON-Objekt mit einer SageMaker AI-Pipeline-Definition: ``` {'Version': '2020-12-01', 'Metadata': {}, 'Parameters': [{'Name': 'ProcessingInstanceType', 'Type': 'String', 'DefaultValue': 'ml.m5.xlarge'}, {'Name': 'ProcessingInstanceCount', 'Type': 'Integer', 'DefaultValue': 1}, {'Name': 'TrainingInstanceType', 'Type': 'String', 'DefaultValue': 'ml.m5.xlarge'}, {'Name': 'ModelApprovalStatus', 'Type': 'String', 'DefaultValue': 'PendingManualApproval'}, {'Name': 'ProcessedData', 'Type': 'String', 'DefaultValue': '{{S3_URL}}', {'Name': 'InputDataUrl', 'Type': 'String', 'DefaultValue': '{{S3_URL}}', 'PipelineExperimentConfig': {'ExperimentName': {'Get': 'Execution.PipelineName'}, 'TrialName': {'Get': 'Execution.PipelineExecutionId'}}, 'Steps': [{'Name': 'ReadTrainDataFromFS', 'Type': 'Processing', 'Arguments': {'ProcessingResources': {'ClusterConfig': {'InstanceType': 'ml.m5.4xlarge', 'InstanceCount': 2, 'VolumeSizeInGB': 30}}, 'AppSpecification': {'ImageUri': '{{IMAGE_URI}}', 'ContainerArguments': [....]}, 'RoleArn': '{{ROLE}}', 'ProcessingInputs': [...], 'ProcessingOutputConfig': {'Outputs': [.....]}, 'StoppingCondition': {'MaxRuntimeInSeconds': 86400}}, 'CacheConfig': {'Enabled': True, 'ExpireAfter': '30d'}}, ... ... ... } ``` **Nächster Schritt:** [Ausführen Sie eine Pipeline](run-pipeline.md)