Definieren einer Pipeline

1. Öffnen Sie die Studio-Konsole, indem Sie den Anweisungen unter Starten Sie Amazon SageMaker Studio folgen.

2. Wählen Sie im linken Navigationsbereich die Option Pipelines aus.

3. Wählen Sie Erstellen aus.

4. Wählen Sie Leer.

5. Wählen Sie in der linken Seitenleiste die Option Daten verarbeiten und ziehen Sie sie auf die Arbeitsfläche.

6. Wählen Sie auf der Arbeitsfläche den Schritt „Daten verarbeiten“ aus, den Sie hinzugefügt haben.

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

8. 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.

9. 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.

1. Wählen Sie in der linken Seitenleiste Train Model und ziehen Sie es auf die Leinwand.

2. Wählen Sie auf der Arbeitsfläche den Schritt Train Model aus, den Sie hinzugefügt haben.

3. 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.

4. 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.

5. 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.

6. 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.

1. Wählen Sie in der linken Seitenleiste Modell registrieren und ziehen Sie es auf die Arbeitsfläche.

2. Wählen Sie auf der Arbeitsfläche den Schritt Modell registrieren aus, den Sie hinzugefügt haben.

3. Um ein Modell für die Registrierung auszuwählen, wählen Sie unter Modell (Eingabe) die Option Hinzufügen aus.

4. Wählen Sie Modellgruppe erstellen, um Ihr Modell zu einer neuen Modellgruppe hinzuzufügen.

5. 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.

6. 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.

1. Wählen Sie in der linken Seitenleiste Modell bereitstellen (Endpunkt) aus und ziehen Sie es auf die Leinwand.

2. Wählen Sie auf der Arbeitsfläche den Schritt Modell bereitstellen (Endpunkt) aus, den Sie hinzugefügt haben.

3. Um ein Modell für die Bereitstellung auszuwählen, wählen Sie unter Modell (Eingabe) die Option Hinzufügen aus.

4. Wählen Sie das Optionsfeld Endpunkt erstellen, um einen neuen Endpunkt zu erstellen.

5. Geben Sie einen Namen und eine Beschreibung für den Endpunkt ein.

6. 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.

7. Füllen Sie die verbleibenden Felder in der rechten Seitenleiste aus.

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)

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

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,
   )

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

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"

2. 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,
   )

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

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,
   )

2. 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],
   )

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(),
  )

Um eine zu definieren TransformStep , um eine Batch-Transformation durchzuführen

• Erstellen Sie eine Transformer-Instanz und eineTransformStep.

  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,
  )

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,
  )

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

• Definieren Sie eine Bedingung und konstruieren Sie eineConditionStep.

  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=[], 
  )

So erstellen Sie eine Pipeline

1. Definieren Sie Folgendes für Ihre Pipeline: name, parameters, undsteps.

   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],
   )

2. (Optional) Untersuchen Sie die JSON-Pipeline-Definition, um sicherzustellen, dass sie korrekt formatiert ist.

   import json
   
   json.loads(pipeline.definition())