Voraussetzungen Erstellen einer Pipeline

Definieren Sie eine Pipeline

So orchestrieren Sie Ihre Workflows mit Amazon SageMaker Modellbau-Pipelines müssen Sie einen gerichteten azyklischen Graphen (DAG) in Form einer JSON-Pipeline-Definition generieren. Das folgende Bild ist eine Darstellung der Pipeline-DAG, die Sie in diesem Tutorial erstellen:

Sie können Ihre JSON-Pipeline-Definition mithilfe der SageMaker Python-SDK. Das folgende Tutorial zeigt, wie eine Pipeline-Definition für eine Pipeline generiert wird, die ein Regressionsproblem löst, um das Alter einer Abalone basierend auf ihren physikalischen Messungen zu bestimmen. Ein Jupyter-Notizbuch, das den Inhalt in diesem Tutorial enthält, den Sie ausführen können, finden Sie unterOrchestrieren von Jobs mit Amazon SageMaker Pipelines für die Modellerstellungaus.

Themen

Voraussetzungen
Erstellen einer Pipeline

Voraussetzungen

Um das folgende Tutorial ausführen zu können, müssen Sie die folgenden Schritte ausführen:

Richten Sie Ihre Notebook-Instanz wie in beschrieben einErstellen einer Notebook-Instanceaus. Dies gibt Ihrer Rolle Berechtigungen zum Lesen und Schreiben an Amazon S3 und zum Erstellen von Schulungen, Batch-Transformationen und Verarbeitungsaufträgen in SageMaker.
Erteilen Sie Ihrem Notebook Berechtigungen, um seine eigene Rolle zu erhalten und zu übergeben, wie inÄndern einer Rollenberechtigungsrichtlinieaus. Fügen Sie das folgende JSON-Snippet hinzu, um diese Richtlinie an Ihre Rolle anzuhängen. Ersetzen<your-role-arn>mit dem 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>"
        }
    ]
}
```
Vertraue dem SageMaker Service-Prinzipal, indem Sie die Schritte inÄndern einer Rollenvertrauensrichtlinieaus. Fügen Sie der Vertrauensbeziehung Ihrer Rolle das folgende Anweisungsfragment hinzu:
```
{
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "Service": "sagemaker.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
```

Einrichten Ihrer Umgebung

Erstellen eines neuen SageMaker -Sitzung mit dem folgenden Codeblock. Dies gibt die Rolle ARN für die Sitzung zurück. Diese Rolle ARN sollte der ARN der Ausführungsrolle sein, den Sie als Voraussetzung einrichten.


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 Ihrem SageMaker Notebook-Instanz zum Erstellen einer Pipeline mit Schritten für Vorverarbeitung, Schulung, Bewertung, bedingte Auswertung und Modellregistrierung.

Schritt 1: Laden Sie den Datensatz herunter

Dieses Notizbuch verwendet das UCI Machine Learning Abalone Dataset. Der Datensatz enthält die folgenden Funktionen:

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 gesamten Abalone.
shucked_weight— Das Gewicht des Fleisches, das aus der Abalone entfernt wurde.
viscera_weight— Das Gewicht der Abalone-Eingeweide nach der Blutung.
shell_weight— Das Gewicht der Abalone-Schale nach dem Entfernen und Trocknen des Fleisches.
sex— Das Geschlecht der Abalone. Einer von „M“, „F“ oder „I“, wobei „Ich“ ein Säuglings-Abalone ist.
rings— Die Anzahl der Ringe in der Abalone-Schale.

Die Anzahl der Ringe in der Abalone-Schale ist eine gute Annäherung an ihr Alter mit der Formelage=rings + 1.5aus. Es ist jedoch eine zeitaufwändige Aufgabe, diese Zahl zu erhalten. 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 Notizbuch verwendet den Datensatz, um ein Vorhersagemodell der variablen Ringe unter Verwendung der anderen physikalischen Messungen zu erstellen.

So laden Sie den Datensatz herunter

Laden Sie den Datensatz in den standardmäßigen Amazon S3 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 einen zweiten Datensatz für die Batch-Transformation herunter, nachdem Ihr Modell erstellt wurde.


local_path = "data/abalone-dataset-batch"

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: Definition von Pipeline-Parametern

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

processing_instance_type— Dieml.*Instanztyp der Verarbeitungsaufträge.
processing_instance_count— Die Instanzanzahl des Verarbeitungsauftrags.
training_instance_type— Dieml.*Instanztyp der Ausbildungsjobs.
input_data— Der Amazon-S3-Speicherort der Eingabedaten.
batch_data— Der Amazon-S3-Speicherort der Eingabedaten für die Stapeltransformation.
model_approval_status— Der Genehmigungsstatus, bei dem das geschulte Modell für CI/CD registriert werden soll. Weitere Informationen finden Sie unter Automatisieren von MLOPs mit SageMaker Projekte.


from sagemaker.workflow.parameters import (
    ParameterInteger,
    ParameterString,
)


processing_instance_count = ParameterInteger(
    name="ProcessingInstanceCount",
    default_value=1
)
processing_instance_type = ParameterString(
    name="ProcessingInstanceType",
    default_value="ml.m5.xlarge"
)
training_instance_type = ParameterString(
    name="TrainingInstanceType",
    default_value="ml.m5.xlarge"
)
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 Verarbeitungsschritt für Feature Engineering

In diesem Abschnitt wird erläutert, wie ein Verarbeitungsschritt erstellt wird, um die Daten aus dem Datensatz für die Schulung vorzubereiten.

So erstellen Sie einen Verarbeitungsschritt

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

Erstellen Sie eine -Datei im/abaloneVerzeichnis mit dem Namenpreprocessing.pyMit dem folgenden Inhalt. Dieses Vorverarbeitungsskript wird an den Verarbeitungsschritt zur Ausführung der Eingabedaten übergeben. Der Trainingsschritt nutzt dann die vorverarbeiteten Trainingsfunktionen und -beschriftungen, um ein Modell zu trainieren, und der Bewertungsschritt verwendet das geschulte Modell und die vorverarbeiteten Testmerkmale und Etiketten, um das Modell zu bewerten. Das Skript verwendetscikit-learnum Folgendes zu tun:

Ausfüllen fehlendersexkategorische Daten und kodieren sie so, dass es für das Training geeignet ist.
Skalieren und normalisieren Sie alle numerischen Felder mit Ausnahme vonringsundsexaus.
Teilen Sie die Daten in Schulungs-, 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 einer -InstanceSKLearnProcessorum an den Verarbeitungsschritt weiterzugehen.


from sagemaker.sklearn.processing import SKLearnProcessor


framework_version = "0.23-1"

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

Erstellen Sie einen Verarbeitungsschritt. Dieser Schritt führt imSKLearnProcessor, die Ein- und Ausgangskanäle und diepreprocessing.pySkript, das Sie erstellt haben. Dies ist dem einer Prozessorinstanz sehr ähnlichrun-Methode im SageMaker Python SDK. Dieinput_dataParameter übergeben anProcessingStepsind die Eingabedaten des Schrittes selbst. Diese Eingabedaten werden von der Prozessorinstanz verwendet, wenn sie ausgeführt wird.

Beachten Sie die"train,"validation, und"test"benannte Kanäle, die in der Ausgabekonfiguration für den Verarbeitungsauftrag angegeben sind. SchrittPropertieswie diese können in nachfolgenden Schritten verwendet werden und bei der Ausführung auf ihre Laufzeitwerte aufgelöst werden.
```
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 die Option SageMaker XGBoost-Algorithmusum ein logistisches Regressionsmodell für die Trainingsdaten zu trainieren, die aus den Verarbeitungsschritten ausgegeben werden.

So definieren Sie einen Trainingsschritt

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 das Eingabe-Dataset. Dietraining_instance_typewird in den Schätzwert weitergegeben. Ein typisches Trainingsskript lädt Daten aus den Eingangskanälen, konfiguriert das Training mit Hyperparametern, trainiert ein Modell und speichert ein Modell inmodel_dirdamit es später gehostet werden kann. SageMaker lädt das Modell auf Amazon S3 in Form einesmodel.tar.gzam Ende des Ausbildungsauftrags.


from sagemaker.estimator import Estimator


image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.0-1",
    py_version="py3",
    instance_type=training_instance_type,
)
xgb_train = Estimator(
    image_uri=image_uri,
    instance_type=training_instance_type,
    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 einesTrainingStepunter Verwendung der Schätzinstanz und der Eigenschaften desProcessingStep. Geben Sie insbesondere dieS3Urider"train"und"validation"Ausgangskanal zumTrainingStepaus.


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 Bedingungsschritt verwendet, um zu bestimmen, welcher Ausführungspfad verwendet werden soll.

So definieren Sie einen Verarbeitungsschritt für die Modellauswertung

Erstellen Sie eine -Datei im/abaloneVerzeichnis mit dem Namenevaluation.pyaus. Dieses Skript wird in einem Verarbeitungsschritt zur Modellauswertung verwendet. Es benötigt ein geschultes Modell und das Test-Dataset als Eingabe und erstellt dann eine JSON-Datei mit Kennzahlen zur Klassifikationsauswertung.


%%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 Instance vonScriptProcessorDas wird verwendet, umProcessingStepaus.


from sagemaker.processing import ScriptProcessor


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

Erstellen einesProcessingStepunter Verwendung der Prozessorinstanz, der Ein- und Ausgangskanäle sowie dieevaluation.py-Skript. Geben Sie insbesondere dieS3ModelArtifactsEigentum von derstep_trainTrainingsschritt sowie derS3Urider"test"Ausgangskanal desstep_processVerarbeitungsschritt. Dies ist dem einer Prozessorinstanz sehr ähnlichrun-Methode im SageMaker Python SDK.


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 Stapeltransformation

In diesem Abschnitt wird erläutert, wie Sie eine erstellen SageMaker Modell aus dem Output des Trainingsschritts. Dieses Modell wird für die Batch-Transformation für einen neuen Datensatz verwendet. Dieser Schritt wird in den Bedingungsschritt übergeben und nur ausgeführt, wenn der Bedingungsschritt ausgewertet wirdtrueaus.

So definieren Sie einen CreateModelStep für Batch-Transformation

Erstellen eines SageMaker -Modell. Übermitteln Sie dasS3ModelArtifactsEigentum von derstep_trainTrainingsschritt


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 Ihre SageMaker -Modell.


from sagemaker.inputs import CreateModelInput


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

Erstellen SieCreateModelStepVerwendung vonCreateModelInputund SageMaker Modellinstanz, die Sie definiert haben.


from sagemaker.workflow.steps import CreateModelStep


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

Schritt 7: Definieren eines TransformStep so führen Sie eine Stapeltransformation

In diesem Abschnitt wird erläutert, wie Sie eine erstellenTransformStepUm eine Batch-Transformation für einen Datensatz durchzuführen, nachdem das Modell geschult wurde. Dieser Schritt wird in den Bedingungsschritt übergeben und nur ausgeführt, wenn der Bedingungsschritt ausgewertet wirdtrueaus.

So definieren Sie einen TransformStep um Batch-Transformation durchzuführen

Erstellen Sie eine Transformator-Instanz mit dem entsprechenden Compute-Instance-Typ, der Instanzanzahl und dem gewünschten Amazon S3 S3-Bucket-URI. Übermitteln Sie dasModelNameEigentum von derstep_create_model CreateModelSchritt.


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 einesTransformStepunter Verwendung der von Ihnen definierten Transformator-Instanz und derbatch_dataPipeline-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 Schritt zum Erstellen eines Modellpakets

In diesem Abschnitt wird gezeigt, wie Sie eine Instanz vonRegisterModelaus. Das Ergebnis der AusführungRegisterModelIn einer Pipeline befindet sich ein Modellpaket Ein Modellpaket ist eine wiederverwendbare Modellartefakt-Abstraktion, die alle für die Schlussfolgerung notwendigen Zutaten 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 einenModelPackageGroupzum SageMaker Pipelines zum Hinzufügen einer neuen Version und eines neuen Modellpakets zur Gruppe für jede Pipeline-Ausführung. Weitere Informationen zur Modellregistrierung finden Sie unterRegistrieren und Bereitstellen von Modellen mit Modellregistrierungaus.

Dieser Schritt wird in den Bedingungsschritt übergeben und nur ausgeführt, wenn der Bedingungsschritt ausgewertet wirdtrueaus.

So definieren Sie einen RegisterModel Schritt zum Erstellen eines Modellpakets

Konstruieren einesRegisterModelverwenden Sie die Schätzinstanz, die Sie für den Trainingsschritt verwendet haben. Übermitteln Sie dasS3ModelArtifactsEigentum von derstep_trainTrainingsschritt und spezifizieren Sie einModelPackageGroupaus. SageMaker Pipelines schaffen diesModelPackageGroupFür dich.


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 zum Verifizieren

EINConditionSteperlaubt SageMaker Pipelines zur Unterstützung der bedingten Ausführung in Ihrer Pipeline-DAG basierend auf der Bedingung der Schritteigenschaften. In diesem Fall möchten Sie ein Modellpaket nur registrieren, wenn die Genauigkeit dieses Modells, wie durch den Modellauswertungsschritt bestimmt, den erforderlichen Wert überschreitet. Wenn die Genauigkeit den erforderlichen Wert überschreitet, erstellt die Pipeline auch eine SageMaker Modellieren und führen Sie die Batch-Transformation für einen Datensatz aus. In diesem Abschnitt wird gezeigt, wie Sie den Bedingungsschritt definieren.

So definieren Sie einen Bedingungsschritt zur Überprüfung der Modellgenauigkeit

Definieren einesConditionLessThanOrEqualToBedingung unter Verwendung des Genauigkeitswerts, der in der Ausgabe des Verarbeitungsschritts zur Modellbewertung gefunden wurde,step_evalaus. Rufen Sie diese Ausgabe mit der Eigenschaftendatei ab, die Sie im Verarbeitungsschritt indiziert haben, und dem entsprechenden JsonPath des mittleren quadrierten Fehlerwerts,"mse"aus.


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 einesConditionStepaus. Übermitteln Sie dieConditionEqualsBedingung in und legen Sie dann die Schritte zur Modellpaketregistrierung und Batch-Transformation als die nächsten 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 Sie eine Pipeline

Nachdem Sie alle Schritte erstellt haben, kombinieren Sie sie zu einer Pipeline.

So erstellen Sie eine Pipeline

Definieren Sie Folgendes für Ihre Pipeline:name,parameters, undstepsaus. Namen müssen innerhalb einer(account, region)paar.

Anmerkung

Ein Schritt kann nur einmal in der Schrittliste der Pipeline oder in den If/else-Schrittlisten des Bedingungsschritts angezeigt werden. Es kann nicht in beiden erscheinen.


from sagemaker.workflow.pipeline import Pipeline


pipeline_name = f"AbalonePipeline"
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        processing_instance_type, 
        processing_instance_count,
        training_instance_type,
        model_approval_status,
        input_data,
        batch_data,
    ],
    steps=[step_process, step_train, step_eval, step_cond],
)

(Optional) Untersuchen Sie die JSON-Pipeline-Definition, um sicherzustellen, dass sie wohlgeformt ist.
```
import json

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

Diese Pipeline-Definition kann an SageMaker gesendet werden. Im nächsten Tutorial reichen Sie diese Pipeline an SageMaker und beginnen Sie eine Hinrichtung.

Nächster Schritt: Führen Sie eine Pipeline aus

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

Erstellen und Verwalten von Pipelines

Führen Sie eine Pipeline aus