Voraussetzungen Erstellen einer Pipeline

Definieren einer Pipeline

Um Ihre Workflows mit Amazon SageMaker Model Building Pipelines zu orchestrieren, müssen Sie ein gerichtetes azyklisches Diagramm (DAG) in Form einer JSON-Pipeline-Definition generieren. Die folgende Abbildung ist eine Darstellung der Pipeline-DAG, die Sie in diesem Tutorial erstellen:

Sie können Ihre JSON-Pipeline-Definition mit dem SageMaker Python SDK generieren. Das folgende Tutorial zeigt, wie Sie eine Pipeline-Definition für eine Pipeline generieren, die ein Regressionsproblem löst, um das Alter einer Abalone basierend auf ihren physischen Messungen zu bestimmen. Ein Jupyter-Notebook, das den Inhalt dieses Tutorials enthält, den Sie ausführen können, finden Sie unter Orchestrieren von Aufträgen mit Amazon SageMaker Model Building Pipelines.

Voraussetzungen

Zur Ausführung des folgenden Tutorials gehen Sie wie folgt vor:

Richten Sie Ihre Notebook-Instanz wie unter Notebook-Instanz erstellen beschrieben ein. Dadurch erhält Ihre Rolle Berechtigungen zum Lesen und Schreiben in Amazon S3 sowie zum Erstellen von Trainings-, Batch-Transformations- und Verarbeitungsaufträgen in SageMaker.
Erteilen Sie Ihrem Notebook Berechtigungen zum Abrufen und Weitergeben seiner eigenen Rolle, wie unter Richtlinie zu Rollenberechtigungen ändern beschrieben. Fügen Sie den folgenden JSON-Snippet hinzu, um diese Richtlinie an Ihre Rolle anzuhängen. Ersetzen Sie <your-role-arn> durch den ARN, der zum Erstellen Ihrer Notebook-Instanz verwendet wurde.
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "iam:GetRole",
                "iam:PassRole"
            ],
            "Resource": "<your-role-arn>"
        }
    ]
}
```
Vertrauen Sie dem SageMaker Service-Prinzipal, indem Sie die Schritte unter Ändern einer Rollenvertrauensrichtlinie befolgen. Fügen Sie das folgende Anweisungsfragment zur Vertrauensstellung Ihrer Rolle hinzu:
```
{
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "Service": "sagemaker.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
```

Einrichten Ihrer Umgebung

Erstellen Sie eine neue SageMaker Sitzung mit dem folgenden Codeblock. Dadurch wird der Rollen-ARN für die Sitzung zurückgegeben. Bei diesem Rollen-ARN sollte es sich um den ARN für die Ausführungsrolle handeln, den Sie als Voraussetzung eingerichtet haben.


import boto3
import sagemaker
import sagemaker.session


region = boto3.Session().region_name
sagemaker_session = sagemaker.session.Session()
role = sagemaker.get_execution_role()
default_bucket = sagemaker_session.default_bucket()
model_package_group_name = f"AbaloneModelPackageGroupName"

Erstellen einer Pipeline

Führen Sie die folgenden Schritte von Ihrer SageMaker Notebook-Instance aus, um eine Pipeline zu erstellen, die Schritte für Vorverarbeitung, Training, Auswertung, bedingte Auswertung und Modellregistrierung enthält.

Schritt 1: Herunterladen des Datensatzes

Dieses Notebook verwendet den UCI Machine Learning Abalone Dataset. 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 Ermitteln 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 zu bestimmen. Dieses Notebook verwendet den Datensatz, um anhand der anderen physikalischen Messungen ein Vorhersagemodell der variablen Ringe zu erstellen.

Zum Herunterladen des Datensatzes

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)

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: Pipeline-Parameter definieren

Dieser Codeblock definiert die folgenden Parameter für Ihre Pipeline:

processing_instance_count – Die Anzahl der Instanzen des Verarbeitungsjobs.
input_data – Der Amazon S3-Speicherort der Eingabedaten..
batch_data – Der Amazon-S3-Speicherort der Eingabedaten für die Batch-Transformation.
model_approval_status – Der Genehmigungsstatus, mit dem das trainierte Modell für CI/CD registriert werden soll. Weitere Informationen finden Sie unter Automatisieren von MLOps mit - SageMaker Projekten.


from sagemaker.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 Sie einen Verarbeitungsschritt 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

Erstellen Sie ein Verzeichnis für das Verarbeitungsskript.
```
!mkdir -p abalone
```

Erstellen Sie im Verzeichnis /abalone eine Datei namens preprocessing.py mit folgendem Inhalt. Dieses Vorverarbeitungsskript wird an den Verarbeitungsschritt zur Ausführung der Eingabedaten übergeben. Der Trainingsschritt verwendet dann die vorverarbeiteten Trainingsmerkmale und Labels, um ein Modell zu trainieren, und der Bewertungsschritt verwendet das trainierte Modell und die vorverarbeiteten Testmerkmale und Labels, um das Modell zu evaluieren. Das Skript verwendet scikit-learn für die folgenden Aufgaben:

Füllen Sie fehlende sex kategoriale Daten aus und codieren Sie sie so, dass sie für das Training geeignet sind.
Skalieren und normalisieren Sie alle numerischen Felder außer rings und sex.
Teilen Sie die Daten in Trainings-, Test- und Validierungsdatensätze auf.


%%writefile abalone/preprocessing.py
import argparse
import os
import requests
import tempfile
import numpy as np
import pandas as pd


from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder


# Because this is a headerless CSV file, specify the column names here.
feature_columns_names = [
    "sex",
    "length",
    "diameter",
    "height",
    "whole_weight",
    "shucked_weight",
    "viscera_weight",
    "shell_weight",
]
label_column = "rings"

feature_columns_dtype = {
    "sex": str,
    "length": np.float64,
    "diameter": np.float64,
    "height": np.float64,
    "whole_weight": np.float64,
    "shucked_weight": np.float64,
    "viscera_weight": np.float64,
    "shell_weight": np.float64
}
label_column_dtype = {"rings": np.float64}


def merge_two_dicts(x, y):
    z = x.copy()
    z.update(y)
    return z


if __name__ == "__main__":
    base_dir = "/opt/ml/processing"

    df = pd.read_csv(
        f"{base_dir}/input/abalone-dataset.csv",
        header=None, 
        names=feature_columns_names + [label_column],
        dtype=merge_two_dicts(feature_columns_dtype, label_column_dtype)
    )
    numeric_features = list(feature_columns_names)
    numeric_features.remove("sex")
    numeric_transformer = Pipeline(
        steps=[
            ("imputer", SimpleImputer(strategy="median")),
            ("scaler", StandardScaler())
        ]
    )

    categorical_features = ["sex"]
    categorical_transformer = Pipeline(
        steps=[
            ("imputer", SimpleImputer(strategy="constant", fill_value="missing")),
            ("onehot", OneHotEncoder(handle_unknown="ignore"))
        ]
    )

    preprocess = ColumnTransformer(
        transformers=[
            ("num", numeric_transformer, numeric_features),
            ("cat", categorical_transformer, categorical_features)
        ]
    )
    
    y = df.pop("rings")
    X_pre = preprocess.fit_transform(df)
    y_pre = y.to_numpy().reshape(len(y), 1)
    
    X = np.concatenate((y_pre, X_pre), axis=1)
    
    np.random.shuffle(X)
    train, validation, test = np.split(X, [int(.7*len(X)), int(.85*len(X))])

    
    pd.DataFrame(train).to_csv(f"{base_dir}/train/train.csv", header=False, index=False)
    pd.DataFrame(validation).to_csv(f"{base_dir}/validation/validation.csv", header=False, index=False)
    pd.DataFrame(test).to_csv(f"{base_dir}/test/test.csv", header=False, index=False)

Erstellen Sie eine Instanz von SKLearnProcessor, die an den Verarbeitungsschritt übergeben werden soll.


from sagemaker.sklearn.processing import SKLearnProcessor


framework_version = "0.23-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type="ml.m5.xlarge",
    instance_count=processing_instance_count,
    base_job_name="sklearn-abalone-process",
    role=role,
)

Erstellen Sie einen Verarbeitungsschritt. In diesem Schritt werden die SKLearnProcessor Eingabe- und Ausgabekanäle sowie das von Ihnen erstellte preprocessing.py Skript berücksichtigt. Dies ist der Methode einer Prozessor-runInstance im SageMaker Python-SDK sehr ähnlich. Der Parameter input_data, der an ProcessingStep übergeben wird, sind die Eingabedaten des Schrittes selbst. Diese Eingabedaten werden von der Prozessorinstanz verwendet, wenn sie ausgeführt wird.

Beachten Sie die in der Ausgabekonfiguration für den Verarbeitungsauftrag angegebenen "train, "validation, und "test" benannten Kanäle. Schritte Properties wie diese können in nachfolgenden Schritten verwendet werden und werden bei der Ausführung in ihre Laufzeitwerte umgewandelt.
```
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
    

step_process = ProcessingStep(
    name="AbaloneProcess",
    processor=sklearn_processor,
    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",
)
```

Schritt 4: Definieren Sie einen Trainingsschritt

In diesem Abschnitt wird gezeigt, wie Sie mit dem SageMaker XGBoost-Algorithmus ein Modell anhand der Trainingsdaten trainieren, die aus den Verarbeitungsschritten ausgegeben wurden.

Um einen Trainingsschritt zu definieren

Geben Sie den Modellpfad an, in dem Sie die Modelle aus dem Training speichern möchten.
```
model_path = f"s3://{default_bucket}/AbaloneTrain"
```

Konfigurieren Sie einen Schätzer für den XGBoost-Algorithmus und den Eingabedatensatz. Der Typ der Trainingsinstanz wird an den Schätzer übergeben. Ein typisches Trainingsskript lädt Daten aus den Eingabekanälen, konfiguriert das Training mit Hyperparametern, trainiert ein Modell und speichert ein Modell inmodel_dir , sodass es später gehostet werden kann. SageMaker lädt das Modell in Form einesmodel.tar.gz am Ende des Trainingsauftrags in Amazon S3.


from sagemaker.estimator import Estimator


image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.0-1",
    py_version="py3",
    instance_type="ml.m5.xlarge"
)
xgb_train = Estimator(
    image_uri=image_uri,
    instance_type="ml.m5.xlarge",
    instance_count=1,
    output_path=model_path,
    role=role,
)
xgb_train.set_hyperparameters(
    objective="reg:linear",
    num_round=50,
    max_depth=5,
    eta=0.2,
    gamma=4,
    min_child_weight=6,
    subsample=0.7,
    silent=0
)

Erstellen Sie ein TrainingStep unter Verwendung der Schätzer-Instanz und der Eigenschaften der ProcessingStep. Insbesondere ist der S3Uri des "train"- und "validation"-Ausgangskanals an den TrainingStep weiterzuleiten.


from sagemaker.inputs import TrainingInput
from sagemaker.workflow.steps import TrainingStep


step_train = TrainingStep(
    name="AbaloneTrain",
    estimator=xgb_train,
    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"
        )
    },
)

Schritt 5: Definieren Sie einen Verarbeitungsschritt für die Modellbewertung

In diesem Abschnitt wird erläutert, wie Sie einen Verarbeitungsschritt erstellen, um die Genauigkeit des Modells zu bewerten. Das Ergebnis dieser Modellauswertung wird im Schritt „Bedingung“ verwendet, um zu bestimmen, welcher Ausführungspfad gewählt werden soll.

Um einen Verarbeitungsschritt für die Modellevaluierung zu definieren

Erstellen Sie im Verzeichnis /abalone eine Datei mit dem Namen evaluation.py. Dieses Skript wird in einem Verarbeitungsschritt zur Durchführung der Modellevaluierung verwendet. Es verwendet ein trainiertes Modell und den Testdatensatz als Eingabe und erstellt dann eine JSON-Datei mit Bewertungsmetriken für die Klassifizierung.


%%writefile abalone/evaluation.py
import json
import pathlib
import pickle
import tarfile
import joblib
import numpy as np
import pandas as pd
import xgboost


from sklearn.metrics import mean_squared_error


if __name__ == "__main__":
    model_path = f"/opt/ml/processing/model/model.tar.gz"
    with tarfile.open(model_path) as tar:
        tar.extractall(path=".")
    
    model = pickle.load(open("xgboost-model", "rb"))

    test_path = "/opt/ml/processing/test/test.csv"
    df = pd.read_csv(test_path, header=None)
    
    y_test = df.iloc[:, 0].to_numpy()
    df.drop(df.columns[0], axis=1, inplace=True)
    
    X_test = xgboost.DMatrix(df.values)
    
    predictions = model.predict(X_test)

    mse = mean_squared_error(y_test, predictions)
    std = np.std(y_test - predictions)
    report_dict = {
        "regression_metrics": {
            "mse": {
                "value": mse,
                "standard_deviation": std
            },
        },
    }

    output_dir = "/opt/ml/processing/evaluation"
    pathlib.Path(output_dir).mkdir(parents=True, exist_ok=True)
    
    evaluation_path = f"{output_dir}/evaluation.json"
    with open(evaluation_path, "w") as f:
        f.write(json.dumps(report_dict))

Erstellen Sie eine Instanz von ScriptProcessor, die verwendet wird, um eine ProcessingStep zu erstellen.


from sagemaker.processing import ScriptProcessor


script_eval = ScriptProcessor(
    image_uri=image_uri,
    command=["python3"],
    instance_type="ml.m5.xlarge",
    instance_count=1,
    base_job_name="script-abalone-eval",
    role=role,
)

Erstellen Sie eineProcessingStep mit der Prozessor-Instance, den Eingabe- und Ausgabekanälen und dem evaluation.pySkript. Übergeben Sie insbesondere die -S3ModelArtifactsEigenschaft aus dem step_train Trainingsschritt sowie die S3Uri des "test" Ausgabekanals des step_process Verarbeitungsschrittsrun. Dies ist der Methode einer Prozessor-Instance im SageMaker Python SDK sehr ähnlich.


from sagemaker.workflow.properties import PropertyFile


evaluation_report = PropertyFile(
    name="EvaluationReport",
    output_name="evaluation",
    path="evaluation.json"
)
step_eval = ProcessingStep(
    name="AbaloneEval",
    processor=script_eval,
    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",
    property_files=[evaluation_report],
)

Schritt 6: Definieren eines CreateModelStep für die Batch-Transformation

Wichtig

Wir empfehlen die Verwendung von Modell Schritt, um Modelle ab v2.90.0 des SageMaker Python SDK zu erstellen. funktioniert CreateModelStep weiterhin in früheren Versionen des SageMaker Python SDK, wird aber nicht mehr aktiv unterstützt.

In diesem Abschnitt wird gezeigt, wie Sie ein SageMaker Modell aus der Ausgabe des Trainingsschritts erstellen. Dieses Modell wird für die Batch-Transformation eines neuen Datensatzes verwendet. Dieser Schritt wird an den Bedingungsschritt übergeben und nur ausgeführt, wenn der Bedingungsschritt den Wert true ergibt.

So definieren Sie einen CreateModelStep für die Batch-Transformation

Erstellen Sie ein SageMaker Modell. Übergeben Sie die S3ModelArtifacts Eigenschaft aus dem step_train Trainingsschritt.


from sagemaker.model import Model


model = Model(
    image_uri=image_uri,
    model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
    sagemaker_session=sagemaker_session,
    role=role,
)

Definieren Sie die Modelleingabe für Ihr SageMaker Modell.


from sagemaker.inputs import CreateModelInput


inputs = CreateModelInput(
    instance_type="ml.m5.large",
    accelerator_type="ml.eia1.medium",
)

Erstellen Sie Ihre CreateModelStep mit der von Ihnen definierten CreateModelInput und SageMaker Modell-Instance.


from sagemaker.workflow.steps import CreateModelStep


step_create_model = CreateModelStep(
    name="AbaloneCreateModel",
    model=model,
    inputs=inputs,
)

Schritt 7: Definieren eines TransformStep zur Durchführung einer Batch-Transformation

In diesem Abschnitt wird gezeigt, wie ein TransformStep erstellt wird, um eine Batch-Transformation an einem Datensatz durchzuführen, nachdem das Modell trainiert wurde. Dieser Schritt wird an den Bedingungsschritt übergeben und wird nur ausgeführt, wenn der Bedingungsschritt true ergibt.

So definieren Sie einen TransformStep für die Batch-Transformation

Erstellen Sie eine Transformer-Instance mit dem entsprechenden Compute-Instance-Typ, der Instance-Anzahl und der gewünschten Amazon S3-Output-Bucket-URI. Übergeben Sie die ModelName Eigenschaft aus dem step_create_model CreateModel Schritt.


from sagemaker.transformer import Transformer


transformer = Transformer(
    model_name=step_create_model.properties.ModelName,
    instance_type="ml.m5.xlarge",
    instance_count=1,
    output_path=f"s3://{default_bucket}/AbaloneTransform"
)

Erstellen Sie eine TransformStep mit der Transformer-Instanz, die Sie definiert haben, und dem batch_data Pipeline-Parameter.


from sagemaker.inputs import TransformInput
from sagemaker.workflow.steps import TransformStep


step_transform = TransformStep(
    name="AbaloneTransform",
    transformer=transformer,
    inputs=TransformInput(data=batch_data)
)

Schritt 8: Definieren eines RegisterModel Schritts zum Erstellen eines Modellpakets

Wichtig

Wir empfehlen, zu verwendenModell Schritt, um Modelle ab v2.90.0 des SageMaker Python SDK zu registrieren. funktioniert RegisterModel weiterhin in früheren Versionen des SageMaker Python SDK, wird aber nicht mehr aktiv unterstützt.

In diesem Abschnitt wird erläutert, wie eine Instanz von RegisterModel erstellt wird. Das Ergebnis der Ausführung von RegisterModel in einer Pipeline ist ein Modellpaket. Ein Modellpaket ist eine wiederverwendbare Abstraktion von Modellartefakten, die alle für die Inferenz erforderlichen Bestandteile verpackt. Es besteht aus einer Inferenzspezifikation, die das zu verwendende Inferenzbild zusammen mit einer optionalen Position der Modellgewichte definiert. Eine Modellpaketgruppe ist eine Sammlung von Modellpaketen. Sie können eine ModelPackageGroup für SageMaker Pipelines verwenden, um der Gruppe für jede Pipeline-Ausführung ein neues Versions- und Modellpaket hinzuzufügen. Weitere Informationen zur Modellregistrierung finden Sie unter Modelle mit Model Registry registrieren und bereitstellen.

Dieser Schritt wird an den Bedingungsschritt übergeben und nur ausgeführt, wenn der Bedingungsschritt den Wert true ergibt.

So definieren Sie einen RegisterModel Schritt zum Erstellen eines Modellpakets

Konstruieren Sie einen RegisterModel Schritt mit der Estimator-Instanz, die Sie für den Trainingsschritt verwendet haben. Übergeben Sie die S3ModelArtifacts Eigenschaft aus dem step_train Trainingsschritt und geben Sie ModelPackageGroup an. SageMaker Pipelines erstellt dies ModelPackageGroup für Sie.


from sagemaker.model_metrics import MetricsSource, ModelMetrics 
from sagemaker.workflow.step_collections import RegisterModel


model_metrics = ModelMetrics(
    model_statistics=MetricsSource(
        s3_uri="{}/evaluation.json".format(
            step_eval.arguments["ProcessingOutputConfig"]["Outputs"][0]["S3Output"]["S3Uri"]
        ),
        content_type="application/json"
    )
)
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
)

Schritt 9: Definieren Sie einen Bedingungsschritt zur Überprüfung der Modellgenauigkeit

Ein ConditionStep ermöglicht es SageMaker Pipelines, die bedingte Ausführung in Ihrer Pipeline-DAG basierend auf der Bedingung der Schritteigenschaften zu unterstützen. In diesem Fall möchten Sie ein Modellpaket nur registrieren, wenn die Genauigkeit dieses Modells, wie sie im Schritt der Modellbewertung bestimmt wurde, den erforderlichen Wert übersteigt. Wenn die Genauigkeit den erforderlichen Wert überschreitet, erstellt die Pipeline auch ein SageMaker Modell und führt eine Batch-Transformation für einen Datensatz durch. In diesem Abschnitt wird erläutert, wie der Schritt Bedingung definiert wird.

Um einen Bedingungsschritt zur Überprüfung der Modellgenauigkeit zu definieren

Definieren Sie eine ConditionLessThanOrEqualTo Bedingung anhand des Genauigkeitswerts, der in der Ausgabe des Verarbeitungsschritts der Modellbewertung ermittelt wurde, step_eval. Verwenden Sie für diese Ausgabe die Eigenschaftendatei, die Sie im Verarbeitungsschritt indexiert haben, und den entsprechenden JSONPath des mittleren quadratischen Fehlerwerts, "mse".


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
)

Konstruieren Sie ein ConditionStep. Übergeben Sie die ConditionEquals Bedingung und legen Sie dann die Schritte zur Registrierung des Modellpakets und zur Batch-Transformation als nächste Schritte fest, wenn die Bedingung erfüllt ist.
```
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, können Sie sie zu einer Pipeline zusammenfassen.

So erstellen Sie eine Pipeline

Definieren Sie Folgendes für Ihre Pipeline: name, parameters, undsteps. Die Namen müssen innerhalb eines (account, region)-Paares eindeutig sein.

Anmerkung
Ein Schritt kann entweder in der Schrittliste der Pipeline oder in den if/else-Schrittlisten des Bedingungsschritts nur einmal vorkommen. Er kann nicht in beiden vorkommen.
```
from sagemaker.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],
)
```
(Optional) Untersuchen Sie die JSON-Pipeline-Definition, um sicherzustellen, dass sie korrekt formatiert ist.
```
import json

json.loads(pipeline.definition())
```

Diese Pipeline-Definition kann an gesendet werden SageMaker. Im nächsten Tutorial übermitteln Sie diese Pipeline an SageMaker und starten eine Ausführung.

Nächster Schritt: Ausführen Sie eine Pipeline

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Pipelines erstellen und verwalten

Ausführen Sie eine Pipeline

Definieren einer Pipeline

Themen

Voraussetzungen

Einrichten Ihrer Umgebung

Erstellen einer Pipeline

Schritt 1: Herunterladen des Datensatzes

Zum Herunterladen des Datensatzes

Schritt 2: Pipeline-Parameter definieren

Schritt 3: Definieren Sie einen Verarbeitungsschritt für Feature Engineering

Um einen Verarbeitungsschritt zu erstellen

Schritt 4: Definieren Sie einen Trainingsschritt

Um einen Trainingsschritt zu definieren

Schritt 5: Definieren Sie einen Verarbeitungsschritt für die Modellbewertung

Um einen Verarbeitungsschritt für die Modellevaluierung zu definieren

Schritt 6: Definieren eines CreateModelStep für die Batch-Transformation

Wichtig

So definieren Sie einen CreateModelStep für die Batch-Transformation

Schritt 7: Definieren eines TransformStep zur Durchführung einer Batch-Transformation

So definieren Sie einen TransformStep für die Batch-Transformation

Schritt 8: Definieren eines RegisterModel Schritts zum Erstellen eines Modellpakets

Wichtig

So definieren Sie einen RegisterModel Schritt zum Erstellen eines Modellpakets

Schritt 9: Definieren Sie einen Bedingungsschritt zur Überprüfung der Modellgenauigkeit

Um einen Bedingungsschritt zur Überprüfung der Modellgenauigkeit zu definieren

Schritt 10: Erstellen einer Pipeline

So erstellen Sie eine Pipeline

Anmerkung