Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Langkah-langkah saluran pipa
Pipa terdiri dari langkah-langkah. Langkah-langkah ini menentukan tindakan yang diambil pipeline dan hubungan antara langkah-langkah menggunakan properti. Halaman berikut menjelaskan jenis langkah, propertinya, dan hubungan di antara mereka.
**Topics**
+ [Tambahkan langkah](build-and-manage-steps-types.md)
+ [Tambahkan integrasi](build-and-manage-steps-integration.md)
+ [Properti langkah](#build-and-manage-properties)
+ [Paralelisme langkah](#build-and-manage-parallelism)
+ [Ketergantungan data antar langkah](#build-and-manage-data-dependency)
+ [Ketergantungan khusus antar langkah](#build-and-manage-custom-dependency)
+ [Gambar khusus dalam satu langkah](#build-and-manage-images)
# Tambahkan langkah
Berikut ini menjelaskan persyaratan dari setiap jenis langkah dan memberikan contoh implementasi langkah, serta cara menambahkan langkah ke Pipelines. Ini bukan implementasi yang berfungsi karena mereka tidak menyediakan sumber daya dan input yang dibutuhkan. Untuk tutorial yang mengimplementasikan langkah-langkah ini, lihat[Tindakan saluran pipa](pipelines-build.md).
**catatan**
Anda juga dapat membuat langkah dari kode pembelajaran mesin lokal Anda dengan mengubahnya menjadi langkah Pipelines dengan dekorator. `@step` Untuk informasi selengkapnya, lihat [@step dekorator](#step-type-custom).
Amazon SageMaker Pipelines mendukung jenis langkah berikut:
+ [Jalankan kode](#step-type-executecode)
[Pemrosesan](#step-type-processing)
+ [Pelatihan](#step-type-training)
+ [Tuning](#step-type-tuning)
+ [AutoML](#step-type-automl)
+ [`Model`](#step-type-model)
+ [`Create model`](#step-type-create-model)
+ [`Register model`](#step-type-register-model)
+ [`Deploy model (endpoint)`](#step-type-deploy-model-endpoint)
+ [Transformasi](#step-type-transform)
+ [Kondisi](#step-type-condition)
+ [`Callback`](#step-type-callback)
+ [Lambda](#step-type-lambda)
+ [`ClarifyCheck`](#step-type-clarify-check)
+ [`QualityCheck`](#step-type-quality-check)
+ [EMR](#step-type-emr)
+ [Job Notebook](#step-type-notebook-job)
+ [Gagal](#step-type-fail)
## @step dekorator
Jika Anda ingin mengatur pekerjaan ML khusus yang memanfaatkan fitur SageMaker AI tingkat lanjut atau AWS layanan lain di UI drag-and-drop Pipelines, gunakan. [Jalankan langkah kode](#step-type-executecode)
Anda dapat membuat langkah dari kode pembelajaran mesin lokal menggunakan `@step` dekorator. Setelah menguji kode, Anda dapat mengonversi fungsi menjadi langkah pipeline SageMaker AI dengan membubuhi keterangan dengan dekorator. `@step` Pipelines membuat dan menjalankan pipa ketika Anda melewati output dari fungsi `@step` -decorated sebagai langkah ke pipeline Anda. Anda juga dapat membuat pipeline DAG multi-langkah yang mencakup satu atau lebih fungsi `@step` yang didekorasi serta langkah-langkah pipa SageMaker AI tradisional. Untuk detail selengkapnya tentang cara membuat langkah dengan `@step` dekorator, lihat[Lift-and-shift Kode Python dengan dekorator @step](pipelines-step-decorator.md).
## Jalankan langkah kode
Di drag-and-drop UI Pipelines, Anda dapat menggunakan langkah **kode Execute** untuk menjalankan kode Anda sendiri sebagai langkah pipeline. Anda dapat mengunggah fungsi, skrip, atau buku catatan Python untuk dieksekusi sebagai bagian dari pipeline Anda. Anda harus menggunakan langkah ini jika Anda ingin mengatur pekerjaan HTML khusus yang memanfaatkan fitur SageMaker AI canggih atau layanan lainnya. AWS
Langkah **Execute Code** mengunggah file ke bucket Amazon S3 default Anda untuk Amazon SageMaker AI. Bucket ini mungkin tidak memiliki izin Cross-Origin Resource Sharing (CORS) yang diperlukan. Untuk mempelajari lebih lanjut tentang mengonfigurasi izin CORS, lihat. [Persyaratan CORS untuk Data Gambar Input](sms-cors-update.md)
Langkah **Execute Code** menggunakan pekerjaan SageMaker pelatihan Amazon untuk menjalankan kode Anda. Pastikan peran IAM Anda memiliki izin `sagemaker:CreateTrainingJob` API `sagemaker:DescribeTrainingJob` dan. Untuk mempelajari lebih lanjut tentang semua izin yang diperlukan untuk Amazon SageMaker AI dan cara mengaturnya, lihat[Izin Amazon SageMaker AI API: Tindakan, Izin, dan Referensi Sumber Daya](api-permissions-reference.md).
Untuk menambahkan langkah kode eksekusi ke pipeline menggunakan Pipeline Designer, lakukan hal berikut:
1. Buka konsol Amazon SageMaker Studio dengan mengikuti petunjuk di[Luncurkan Amazon SageMaker Studio](studio-updated-launch.md).
1. Di panel navigasi kiri, pilih **Pipelines**.
1. Pilih **Buat**.
1. Pilih **Kosong**.
1. Di bilah sisi kiri, pilih **Jalankan kode** dan seret ke kanvas.
1. Di kanvas, pilih langkah **Execute code** yang Anda tambahkan.
1. Di bilah sisi kanan, lengkapi formulir di tab **Pengaturan** dan **Detail**.
1. Anda dapat mengunggah satu file untuk mengeksekusi atau mengunggah folder terkompresi yang berisi beberapa artefak.
1. Untuk unggahan file tunggal, Anda dapat memberikan parameter opsional untuk notebook, fungsi python, atau skrip.
1. Saat menyediakan fungsi Python, handler harus disediakan dalam format `file.py:`
1. Untuk unggahan folder terkompresi, jalur relatif ke kode Anda harus disediakan, dan Anda dapat secara opsional memberikan jalur ke `requirements.txt` file atau skrip inisialisasi di dalam folder terkompresi.
1. Jika kanvas menyertakan langkah apa pun yang segera mendahului langkah **Execute code** yang Anda tambahkan, klik dan seret kursor dari langkah ke langkah **Execute code** untuk membuat edge.
1. Jika kanvas menyertakan langkah apa pun yang segera menggantikan langkah **Execute code** yang Anda tambahkan, klik dan seret kursor dari langkah **Execute code** ke langkah untuk membuat edge. Output dari langkah-langkah **kode Execute** dapat direferensikan untuk fungsi Python.
## Langkah pemrosesan
Gunakan langkah pemrosesan untuk membuat pekerjaan pemrosesan untuk pemrosesan data. Untuk informasi selengkapnya tentang pekerjaan pemrosesan, lihat [Memproses Data dan Mengevaluasi Model](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html).
------
#### [ Pipeline Designer ]
Untuk menambahkan langkah pemrosesan ke pipeline menggunakan Pipeline Designer, lakukan hal berikut:
1. Buka konsol Amazon SageMaker Studio dengan mengikuti petunjuk di[Luncurkan Amazon SageMaker Studio](studio-updated-launch.md).
1. Di panel navigasi kiri, pilih **Pipelines**.
1. Pilih **Buat**.
1. Di bilah sisi kiri, pilih **Proses data** dan seret ke kanvas.
1. Di kanvas, pilih langkah **Proses data** yang Anda tambahkan.
1. Di bilah sisi kanan, lengkapi formulir di tab **Pengaturan** dan **Detail**. Untuk informasi tentang bidang di tab ini, lihat [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep).
1. Jika kanvas menyertakan langkah apa pun yang segera mendahului langkah **Proses data** yang Anda tambahkan, klik dan seret kursor dari langkah ke langkah **Proses data** untuk membuat tepi.
1. Jika kanvas menyertakan langkah apa pun yang segera menggantikan langkah **Proses data** yang Anda tambahkan, klik dan seret kursor dari langkah **Proses data** ke langkah untuk membuat tepi.
------
#### [ SageMaker Python SDK ]
Langkah pemrosesan membutuhkan prosesor, skrip Python yang mendefinisikan kode pemrosesan, output untuk pemrosesan, dan argumen pekerjaan. Contoh berikut menunjukkan cara membuat `ProcessingStep` definisi.
```
from sagemaker.sklearn.processing import SKLearnProcessor
sklearn_processor = SKLearnProcessor(framework_version='1.0-1',
role=,
instance_type='ml.m5.xlarge',
instance_count=1)
```
```
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
inputs = [
ProcessingInput(source=, destination="/opt/ml/processing/input"),
]
outputs = [
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
]
step_process = ProcessingStep(
name="AbaloneProcess",
step_args = sklearn_processor.run(inputs=inputs, outputs=outputs,
code="abalone/preprocessing.py")
)
```
**Lulus parameter runtime**
Contoh berikut menunjukkan cara meneruskan parameter runtime dari PySpark prosesor ke file. `ProcessingStep`
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.spark.processing import PySparkProcessor
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
pipeline_session = PipelineSession()
pyspark_processor = PySparkProcessor(
framework_version='2.4',
role=,
instance_type='ml.m5.xlarge',
instance_count=1,
sagemaker_session=pipeline_session,
)
step_args = pyspark_processor.run(
inputs=[ProcessingInput(source=, destination="/opt/ml/processing/input"),],
outputs=[
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
],
code="preprocess.py",
arguments=None,
)
step_process = ProcessingStep(
name="AbaloneProcess",
step_args=step_args,
)
```
Untuk informasi selengkapnya tentang persyaratan langkah pemrosesan, lihat [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep)dokumentasi. Untuk contoh mendalam, lihat buku catatan contoh [Orchestrate Jobs to Train and Evaluate Models with Amazon SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/62de6a1fca74c7e70089d77e36f1356033adbe5f/sagemaker-pipelines/tabular/abalone_build_train_deploy/sagemaker-pipelines-preprocess-train-evaluate-batch-transform.ipynb) Pipelines. Bagian *Tentukan Langkah Pemrosesan untuk Rekayasa Fitur* mencakup informasi lebih lanjut.
------
## Langkah pelatihan
Anda menggunakan langkah pelatihan untuk membuat pekerjaan pelatihan untuk melatih model. Untuk informasi lebih lanjut tentang pekerjaan pelatihan, lihat [Melatih Model dengan Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html).
Langkah pelatihan membutuhkan estimator, serta input data pelatihan dan validasi.
------
#### [ Pipeline Designer ]
Untuk menambahkan langkah pelatihan ke pipeline menggunakan Pipeline Designer, lakukan hal berikut:
1. Buka konsol Amazon SageMaker Studio dengan mengikuti petunjuk di[Luncurkan Amazon SageMaker Studio](studio-updated-launch.md).
1. Di panel navigasi kiri, pilih **Pipelines**.
1. Pilih **Buat**.
1. Pilih **Kosong**.
1. Di sidebar kiri, pilih **Train model** dan seret ke kanvas.
1. Di kanvas, pilih langkah **model Kereta** yang Anda tambahkan.
1. Di bilah sisi kanan, lengkapi formulir di tab **Pengaturan** dan **Detail**. Untuk informasi tentang bidang di tab ini, lihat [sagemaker.workflow.steps. TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep).
1. Jika kanvas menyertakan langkah apa pun yang segera mendahului langkah **model Kereta** yang Anda tambahkan, klik dan seret kursor dari langkah ke langkah **model Kereta** untuk membuat tepi.
1. Jika kanvas menyertakan langkah apa pun yang segera menggantikan langkah **model Kereta** yang Anda tambahkan, klik dan seret kursor dari langkah **model Kereta** ke langkah untuk membuat tepi.
------
#### [ SageMaker Python SDK ]
Contoh berikut menunjukkan cara membuat `TrainingStep` definisi. Untuk informasi selengkapnya tentang persyaratan langkah pelatihan, lihat [sagemaker.workflow.steps. TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep)dokumentasi.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.inputs import TrainingInput
from sagemaker.workflow.steps import TrainingStep
from sagemaker.xgboost.estimator import XGBoost
pipeline_session = PipelineSession()
xgb_estimator = XGBoost(..., sagemaker_session=pipeline_session)
step_args = xgb_estimator.fit(
inputs={
"train": TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"train"
].S3Output.S3Uri,
content_type="text/csv"
),
"validation": TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"validation"
].S3Output.S3Uri,
content_type="text/csv"
)
}
)
step_train = TrainingStep(
name="TrainAbaloneModel",
step_args=step_args,
)
```
------
## Langkah penyetelan
Anda menggunakan langkah tuning untuk membuat pekerjaan tuning hyperparameter, juga dikenal sebagai optimasi hyperparameter (HPO). Pekerjaan tuning hyperparameter menjalankan beberapa pekerjaan pelatihan, dengan setiap pekerjaan menghasilkan versi model. Untuk informasi lebih lanjut tentang penyetelan hyperparameter, lihat. [Penyetelan model otomatis dengan AI SageMaker](automatic-model-tuning.md)
Pekerjaan penyetelan dikaitkan dengan eksperimen SageMaker AI untuk pipa, dengan pekerjaan pelatihan yang dibuat sebagai uji coba. Untuk informasi selengkapnya, lihat [Integrasi Eksperimen](pipelines-experiments.md).
Langkah penyetelan membutuhkan input [HyperparameterTuner](https://sagemaker.readthedocs.io/en/stable/api/training/tuner.html)dan pelatihan. Anda dapat melatih kembali pekerjaan penyetelan sebelumnya dengan menentukan `warm_start_config` parameter. `HyperparameterTuner` Untuk informasi lebih lanjut tentang penyetelan hyperparameter dan start hangat, lihat. [Jalankan Pekerjaan Tuning Hyperparameter Mulai yang Hangat](automatic-model-tuning-warm-start.md)
[Anda menggunakan metode [get\$1top\$1model\$1s3\$1uri dari sagemaker.workflow.steps](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep.get_top_model_s3_uri). TuningStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep)kelas untuk mendapatkan artefak model dari salah satu versi model berkinerja terbaik. Untuk notebook yang menunjukkan cara menggunakan langkah penyetelan dalam pipeline SageMaker AI, lihat [sagemaker-pipelines-tuning-step.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/tuning-step/sagemaker-pipelines-tuning-step.ipynb).
**penting**
Langkah-langkah penyetelan diperkenalkan di Amazon SageMaker Python SDK v2.48.0 dan Amazon Studio Classic v3.8.0. SageMaker Anda harus memperbarui Studio Classic sebelum menggunakan langkah penyetelan atau DAG pipeline tidak ditampilkan. Untuk memperbarui Studio Classic, lihat[Matikan dan Perbarui Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
Contoh berikut menunjukkan cara membuat `TuningStep` definisi.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.tuner import HyperparameterTuner
from sagemaker.inputs import TrainingInput
from sagemaker.workflow.steps import TuningStep
tuner = HyperparameterTuner(..., sagemaker_session=PipelineSession())
step_tuning = TuningStep(
name = "HPTuning",
step_args = tuner.fit(inputs=TrainingInput(s3_data="s3://amzn-s3-demo-bucket/my-data"))
)
```
**Dapatkan versi model terbaik**
Contoh berikut menunjukkan cara mendapatkan versi model terbaik dari pekerjaan penyetelan menggunakan `get_top_model_s3_uri` metode ini. Paling-paling, 50 versi berkinerja teratas tersedia berdasarkan peringkat [HyperParameterTuningJobObjective](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HyperParameterTuningJobObjective.html). `top_k`Argumennya adalah indeks ke dalam versi, di mana `top_k=0` versi berkinerja terbaik dan `top_k=49` merupakan versi berkinerja terburuk.
```
best_model = Model(
image_uri=image_uri,
model_data=step_tuning.get_top_model_s3_uri(
top_k=0,
s3_bucket=sagemaker_session.default_bucket()
),
...
)
```
Untuk informasi selengkapnya tentang persyaratan langkah penyetelan, lihat [sagemaker.workflow.steps. TuningStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep)dokumentasi.
## Langkah fine-tuning
Fine-tuning melatih model fondasi terlatih dari Amazon SageMaker JumpStart pada dataset baru. Proses ini, juga dikenal sebagai pembelajaran transfer, dapat menghasilkan model yang akurat dengan kumpulan data yang lebih kecil dan waktu pelatihan yang lebih sedikit. Saat Anda menyempurnakan model, Anda dapat menggunakan kumpulan data default atau memilih data Anda sendiri. Untuk mempelajari lebih lanjut tentang menyempurnakan model pondasi dari JumpStart, lihat. [Sempurnakan Model](jumpstart-fine-tune.md)
Langkah fine-tuning menggunakan pekerjaan SageMaker pelatihan Amazon untuk menyesuaikan model Anda. Pastikan peran IAM Anda memiliki izin `sagemaker:CreateTrainingJob` API `sagemaker:DescribeTrainingJob` dan untuk menjalankan tugas fine-tuning di pipeline Anda. Untuk mempelajari lebih lanjut tentang izin yang diperlukan untuk Amazon SageMaker AI dan cara mengaturnya, lihat[Izin Amazon SageMaker AI API: Tindakan, Izin, dan Referensi Sumber Daya](api-permissions-reference.md).
Untuk menambahkan langkah **model Fine-tune** ke pipeline Anda menggunakan drag-and-drop editor, ikuti langkah-langkah berikut:
1. Buka konsol Studio dengan mengikuti petunjuk di[Luncurkan Amazon SageMaker Studio](studio-updated-launch.md).
1. Di panel navigasi kiri, pilih **Pipelines**.
1. Pilih **Buat**.
1. Pilih **Kosong**.
1. Di bilah sisi kiri, pilih **Fine-tune model** dan seret ke kanvas.
1. Di kanvas, pilih langkah **model Fine-tune** yang Anda tambahkan.
1. Di bilah sisi kanan, lengkapi formulir di tab **Pengaturan** dan **Detail**.
1. Jika kanvas menyertakan langkah apa pun yang segera mendahului langkah **model Fine-tune** yang Anda tambahkan, klik dan seret kursor dari langkah ke langkah **model Fine-tune** untuk membuat tepi.
1. Jika kanvas menyertakan langkah apa pun yang segera menggantikan langkah **model Fine-tune** yang Anda tambahkan, klik dan seret kursor dari langkah **model Fine-tune** ke langkah untuk membuat tepi.
## Langkah AutoML
Gunakan [AutoML](https://sagemaker.readthedocs.io/en/stable/api/training/automl.html) API untuk membuat pekerjaan AutoML untuk melatih model secara otomatis. Untuk informasi selengkapnya tentang pekerjaan AutoML, lihat [Mengotomatiskan pengembangan model dengan Amazon Autopilot](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development.html). SageMaker
**catatan**
Saat ini, langkah AutoML hanya mendukung mode pelatihan [ensembling](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-model-support-validation.html).
Contoh berikut menunjukkan cara membuat definisi menggunakan`AutoMLStep`.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.workflow.automl_step import AutoMLStep
pipeline_session = PipelineSession()
auto_ml = AutoML(...,
role="",
target_attribute_name="my_target_attribute_name",
mode="ENSEMBLING",
sagemaker_session=pipeline_session)
input_training = AutoMLInput(
inputs="s3://amzn-s3-demo-bucket/my-training-data",
target_attribute_name="my_target_attribute_name",
channel_type="training",
)
input_validation = AutoMLInput(
inputs="s3://amzn-s3-demo-bucket/my-validation-data",
target_attribute_name="my_target_attribute_name",
channel_type="validation",
)
step_args = auto_ml.fit(
inputs=[input_training, input_validation]
)
step_automl = AutoMLStep(
name="AutoMLStep",
step_args=step_args,
)
```
**Dapatkan versi model terbaik**
Langkah AutoML secara otomatis melatih beberapa kandidat model. Dapatkan model dengan metrik objektif terbaik dari pekerjaan AutoML menggunakan `get_best_auto_ml_model` metode sebagai berikut. Anda juga harus menggunakan IAM `role` untuk mengakses artefak model.
```
best_model = step_automl.get_best_auto_ml_model(role=)
```
Untuk informasi selengkapnya, lihat langkah [AutoML](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.automl_step.AutoMLStep) di Python SageMaker SDK.
## Langkah model
Gunakan a `ModelStep` untuk membuat atau mendaftarkan model SageMaker AI. Untuk informasi selengkapnya tentang `ModelStep` persyaratan, lihat [sagemaker.workflow.model\$1step. ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.model_step.ModelStep)dokumentasi.
### Buat model
Anda dapat menggunakan a `ModelStep` untuk membuat model SageMaker AI. A `ModelStep` membutuhkan artefak model dan informasi tentang jenis instance SageMaker AI yang perlu Anda gunakan untuk membuat model. Untuk informasi selengkapnya tentang model SageMaker AI, lihat [Melatih Model dengan Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html).
Contoh berikut menunjukkan cara membuat `ModelStep` definisi.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.model import Model
from sagemaker.workflow.model_step import ModelStep
step_train = TrainingStep(...)
model = Model(
image_uri=pytorch_estimator.training_image_uri(),
model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
sagemaker_session=PipelineSession(),
role=role,
)
step_model_create = ModelStep(
name="MyModelCreationStep",
step_args=model.create(instance_type="ml.m5.xlarge"),
)
```
### Daftarkan model
Anda dapat menggunakan a `ModelStep` untuk mendaftarkan a `sagemaker.model.Model` atau `sagemaker.pipeline.PipelineModel` dengan Amazon SageMaker Model Registry. A `PipelineModel` mewakili pipa inferensi, yang merupakan model yang terdiri dari urutan linier kontainer yang memproses permintaan inferensi. Untuk informasi selengkapnya tentang cara mendaftarkan model, lihat[Penerapan Pendaftaran Model dengan Model Registry](model-registry.md).
Contoh berikut menunjukkan cara membuat `ModelStep` yang mendaftarkan a`PipelineModel`.
```
import time
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.sklearn import SKLearnModel
from sagemaker.xgboost import XGBoostModel
pipeline_session = PipelineSession()
code_location = 's3://{0}/{1}/code'.format(bucket_name, prefix)
sklearn_model = SKLearnModel(
model_data=processing_step.properties.ProcessingOutputConfig.Outputs['model'].S3Output.S3Uri,
entry_point='inference.py',
source_dir='sklearn_source_dir/',
code_location=code_location,
framework_version='1.0-1',
role=role,
sagemaker_session=pipeline_session,
py_version='py3'
)
xgboost_model = XGBoostModel(
model_data=training_step.properties.ModelArtifacts.S3ModelArtifacts,
entry_point='inference.py',
source_dir='xgboost_source_dir/',
code_location=code_location,
framework_version='0.90-2',
py_version='py3',
sagemaker_session=pipeline_session,
role=role
)
from sagemaker.workflow.model_step import ModelStep
from sagemaker import PipelineModel
pipeline_model = PipelineModel(
models=[sklearn_model, xgboost_model],
role=role,sagemaker_session=pipeline_session,
)
register_model_step_args = pipeline_model.register(
content_types=["application/json"],
response_types=["application/json"],
inference_instances=["ml.t2.medium", "ml.m5.xlarge"],
transform_instances=["ml.m5.xlarge"],
model_package_group_name='sipgroup',
)
step_model_registration = ModelStep(
name="AbaloneRegisterModel",
step_args=register_model_step_args,
)
```
## Buat langkah model
Anda menggunakan langkah Buat model untuk membuat model SageMaker AI. Untuk informasi lebih lanjut tentang model SageMaker AI, lihat[Latih Model dengan Amazon SageMaker](how-it-works-training.md).
Langkah membuat model memerlukan artefak model dan informasi tentang jenis instans SageMaker AI yang perlu Anda gunakan untuk membuat model. Contoh berikut menunjukkan cara membuat definisi langkah model Create. Untuk informasi selengkapnya tentang Membuat persyaratan langkah model, lihat [sagemaker.workflow.steps. CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep)dokumentasi.
------
#### [ Pipeline Designer ]
Untuk menambahkan langkah buat model ke pipeline Anda, lakukan hal berikut:
1. Buka konsol Studio dengan mengikuti petunjuk di[Luncurkan Amazon SageMaker Studio](studio-updated-launch.md).
1. Di panel navigasi kiri, pilih **Pipelines**.
1. Pilih **Buat**.
1. Pilih **Kosong**.
1. Di bilah sisi kiri, pilih **Buat model** dan seret ke kanvas.
1. Di kanvas, pilih langkah **Buat model** yang Anda tambahkan.
1. Di bilah sisi kanan, lengkapi formulir di tab **Pengaturan** dan **Detail**. Untuk informasi tentang bidang di tab ini, lihat [sagemaker.workflow.steps. CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep).
1. Jika kanvas menyertakan langkah apa pun yang segera mendahului langkah **Buat model** yang Anda tambahkan, klik dan seret kursor dari langkah ke langkah **Buat model** untuk membuat tepi.
1. Jika kanvas menyertakan langkah apa pun yang segera menggantikan langkah **Buat model** yang Anda tambahkan, klik dan seret kursor dari langkah **Buat model** ke langkah untuk membuat tepi.
------
#### [ SageMaker Python SDK ]
**penting**
Kami merekomendasikan penggunaan [Langkah model](#step-type-model) untuk membuat model pada v2.90.0 dari AI SageMaker Python SDK. `CreateModelStep`akan terus bekerja di versi SDK SageMaker Python sebelumnya, tetapi tidak lagi didukung secara aktif.
```
from sagemaker.workflow.steps import CreateModelStep
step_create_model = CreateModelStep(
name="AbaloneCreateModel",
model=best_model,
inputs=inputs
)
```
------
## Daftarkan langkah model
Langkah model Register mendaftarkan model ke dalam SageMaker Model Registry.
------
#### [ Pipeline Designer ]
Untuk mendaftarkan model dari pipeline menggunakan Pipeline Designer, lakukan hal berikut:
1. Buka konsol Amazon SageMaker Studio dengan mengikuti petunjuk di[Luncurkan Amazon SageMaker Studio](studio-updated-launch.md).
1. Di panel navigasi kiri, pilih **Pipelines**.
1. Pilih **Buat**.
1. Pilih **Kosong**.
1. Di bilah sisi kiri, pilih **Daftar model** dan seret ke kanvas.
1. Di kanvas, pilih langkah **model Daftar** yang Anda tambahkan.
1. Di bilah sisi kanan, lengkapi formulir di tab **Pengaturan** dan **Detail**. Untuk informasi tentang bidang di tab ini, lihat [sagemaker.workflow.step\$1collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel).
1. Jika kanvas menyertakan langkah apa pun yang segera mendahului langkah **model Register** yang Anda tambahkan, klik dan seret kursor dari langkah ke langkah **model Daftar** untuk membuat tepi.
1. Jika kanvas menyertakan langkah apa pun yang segera menggantikan langkah **model Register** yang Anda tambahkan, klik dan seret kursor dari langkah **model Daftar** ke langkah untuk membuat tepi.
------
#### [ SageMaker Python SDK ]
**penting**
Kami merekomendasikan penggunaan [Langkah model](#step-type-model) untuk mendaftarkan model pada v2.90.0 dari AI SageMaker Python SDK. `RegisterModel`akan terus bekerja di versi SDK SageMaker Python sebelumnya, tetapi tidak lagi didukung secara aktif.
[Anda menggunakan `RegisterModel` langkah untuk mendaftarkan [Sagemaker.model.Model atau sagemaker.pipeline.](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html) PipelineModel](https://sagemaker.readthedocs.io/en/stable/api/inference/pipeline.html#pipelinemodel)dengan Registri SageMaker Model Amazon. A `PipelineModel` mewakili pipa inferensi, yang merupakan model yang terdiri dari urutan linier kontainer yang memproses permintaan inferensi.
Untuk informasi selengkapnya tentang cara mendaftarkan model, lihat[Penerapan Pendaftaran Model dengan Model Registry](model-registry.md). Untuk informasi selengkapnya tentang persyaratan `RegisterModel` langkah, lihat [sagemaker.workflow.step\$1collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel)dokumentasi.
Contoh berikut menunjukkan cara membuat `RegisterModel` langkah yang mendaftarkan a`PipelineModel`.
```
import time
from sagemaker.sklearn import SKLearnModel
from sagemaker.xgboost import XGBoostModel
code_location = 's3://{0}/{1}/code'.format(bucket_name, prefix)
sklearn_model = SKLearnModel(model_data=processing_step.properties.ProcessingOutputConfig.Outputs['model'].S3Output.S3Uri,
entry_point='inference.py',
source_dir='sklearn_source_dir/',
code_location=code_location,
framework_version='1.0-1',
role=role,
sagemaker_session=sagemaker_session,
py_version='py3')
xgboost_model = XGBoostModel(model_data=training_step.properties.ModelArtifacts.S3ModelArtifacts,
entry_point='inference.py',
source_dir='xgboost_source_dir/',
code_location=code_location,
framework_version='0.90-2',
py_version='py3',
sagemaker_session=sagemaker_session,
role=role)
from sagemaker.workflow.step_collections import RegisterModel
from sagemaker import PipelineModel
pipeline_model = PipelineModel(models=[sklearn_model,xgboost_model],role=role,sagemaker_session=sagemaker_session)
step_register = RegisterModel(
name="AbaloneRegisterModel",
model=pipeline_model,
content_types=["application/json"],
response_types=["application/json"],
inference_instances=["ml.t2.medium", "ml.m5.xlarge"],
transform_instances=["ml.m5.xlarge"],
model_package_group_name='sipgroup',
)
```
Jika `model` tidak disediakan, langkah model register memerlukan estimator seperti yang ditunjukkan pada contoh berikut.
```
from sagemaker.workflow.step_collections import RegisterModel
step_register = RegisterModel(
name="AbaloneRegisterModel",
estimator=xgb_train,
model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
content_types=["text/csv"],
response_types=["text/csv"],
inference_instances=["ml.t2.medium", "ml.m5.xlarge"],
transform_instances=["ml.m5.xlarge"],
model_package_group_name=model_package_group_name,
approval_status=model_approval_status,
model_metrics=model_metrics
)
```
------
## Terapkan langkah model (titik akhir)
Di Pipeline Designer, gunakan langkah Deploy model (endpoint) untuk menerapkan model Anda ke titik akhir. Anda dapat membuat endpoint baru atau menggunakan endpoint yang sudah ada. Inferensi waktu nyata ideal untuk beban kerja inferensi di mana Anda memiliki persyaratan waktu nyata, interaktif, dan latensi rendah. Anda dapat menerapkan model Anda ke layanan SageMaker AI Hosting dan mendapatkan titik akhir real-time yang dapat digunakan untuk inferensi. Titik akhir ini dikelola sepenuhnya dan mendukung auto-scaling. Untuk mempelajari lebih lanjut tentang inferensi real-time di SageMaker AI, lihat[Inferensi waktu nyata](realtime-endpoints.md).
Sebelum menambahkan langkah model penerapan ke pipeline Anda, pastikan peran IAM Anda memiliki izin berikut:
+ `sagemaker:CreateModel`
+ `sagemaker:CreateEndpointConfig`
+ `sagemaker:CreateEndpoint`
+ `sagemaker:UpdateEndpoint`
+ `sagemaker:DescribeModel`
+ `sagemaker:DescribeEndpointConfig`
+ `sagemaker:DescribeEndpoint`
Untuk mempelajari lebih lanjut tentang semua izin yang diperlukan untuk SageMaker AI dan cara mengaturnya, lihat[Izin Amazon SageMaker AI API: Tindakan, Izin, dan Referensi Sumber Daya](api-permissions-reference.md).
Untuk menambahkan langkah penerapan model ke Pipeline Anda di drag-and-drop editor, selesaikan langkah-langkah berikut:
1. Buka konsol Studio dengan mengikuti petunjuk di[Luncurkan Amazon SageMaker Studio](studio-updated-launch.md).
1. Di panel navigasi kiri, pilih **Pipelines**.
1. Pilih **Buat**.
1. Pilih **Kosong**.
1. Di sidebar kiri, pilih **Deploy model (endpoint)** dan seret ke kanvas.
1. Di kanvas, pilih langkah **Deploy model (endpoint)** yang Anda tambahkan.
1. Di bilah sisi kanan, lengkapi formulir di tab **Pengaturan** dan **Detail**.
1. Jika kanvas menyertakan langkah apa pun yang segera mendahului langkah **Deploy model (endpoint)** yang Anda tambahkan, klik dan seret kursor dari langkah ke langkah **Deploy model (endpoint)** untuk membuat edge.
1. Jika kanvas menyertakan langkah apa pun yang segera menggantikan langkah **Deploy model (endpoint)** yang Anda tambahkan, klik dan seret kursor dari langkah **Deploy model (endpoint)** ke langkah untuk membuat edge.
## Transformasikan langkah
Anda menggunakan langkah transformasi untuk transformasi batch untuk menjalankan inferensi pada seluruh kumpulan data. Untuk informasi selengkapnya tentang transformasi batch, lihat[Batch berubah dengan pipa inferensi](inference-pipeline-batch.md).
Langkah transformasi membutuhkan transformator dan data untuk menjalankan transformasi batch. Contoh berikut menunjukkan cara membuat definisi langkah Transform. Untuk informasi selengkapnya tentang persyaratan langkah Transform, lihat [sagemaker.workflow.steps. TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep)dokumentasi.
------
#### [ Pipeline Designer ]
Untuk menambahkan langkah transformasi batch ke pipeline Anda menggunakan editor drag-and-drop visual, lakukan hal berikut:
1. Buka konsol Studio dengan mengikuti petunjuk di[Luncurkan Amazon SageMaker Studio](studio-updated-launch.md).
1. Di panel navigasi kiri, pilih **Pipelines**.
1. Pilih **Buat**.
1. Pilih **Kosong**.
1. Di sidebar kiri, pilih **Deploy model (batch transform)** dan seret ke kanvas.
1. Di kanvas, pilih langkah **Deploy model (batch transform)** yang Anda tambahkan.
1. Di bilah sisi kanan, lengkapi formulir di tab **Pengaturan** dan **Detail**. Untuk informasi tentang bidang di tab ini, lihat [sagemaker.workflow.steps. TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep).
1. Jika kanvas menyertakan langkah apa pun yang segera mendahului langkah **Deploy model (batch transform)** yang Anda tambahkan, klik dan seret kursor dari langkah ke langkah **Deploy model (batch transform)** untuk membuat edge.
1. Jika kanvas menyertakan langkah apa pun yang segera menggantikan langkah **Deploy model (batch transform)** yang Anda tambahkan, klik dan seret kursor dari langkah **Deploy model (batch transform)** ke langkah untuk membuat edge.
------
#### [ SageMaker Python SDK ]
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.transformer import Transformer
from sagemaker.inputs import TransformInput
from sagemaker.workflow.steps import TransformStep
transformer = Transformer(..., sagemaker_session=PipelineSession())
step_transform = TransformStep(
name="AbaloneTransform",
step_args=transformer.transform(data="s3://amzn-s3-demo-bucket/my-data"),
)
```
------
## Langkah kondisi
Anda menggunakan langkah kondisi untuk mengevaluasi kondisi properti langkah untuk menilai tindakan mana yang harus diambil selanjutnya dalam pipeline.
Langkah kondisi membutuhkan:
+ Daftar kondisi.
+ Daftar langkah-langkah yang harus dijalankan jika kondisi dievaluasi. `true`
+ Daftar langkah-langkah yang harus dijalankan jika kondisi dievaluasi. `false`
------
#### [ Pipeline Designer ]
Untuk menambahkan langkah kondisi ke pipeline menggunakan Pipeline Designer, lakukan hal berikut:
1. Buka konsol Amazon SageMaker Studio dengan mengikuti petunjuk di[Luncurkan Amazon SageMaker Studio](studio-updated-launch.md).
1. Di panel navigasi kiri, pilih **Pipelines**.
1. Pilih **Buat**.
1. Pilih **Kosong**.
1. Di bilah sisi kiri, pilih **Kondisi** dan seret ke kanvas.
1. Di kanvas, pilih langkah **Kondisi** yang Anda tambahkan.
1. Di bilah sisi kanan, lengkapi formulir di tab **Pengaturan** dan **Detail**. Untuk informasi tentang bidang di tab ini, lihat [sagemaker.workflow.condition\$1step. ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.condition_step.ConditionStep).
1. Jika kanvas menyertakan langkah apa pun yang segera mendahului langkah **Kondisi** yang Anda tambahkan, klik dan seret kursor dari langkah ke langkah **Kondisi** untuk membuat tepi.
1. Jika kanvas menyertakan langkah apa pun yang segera menggantikan langkah **Kondisi** yang Anda tambahkan, klik dan seret kursor dari langkah **Kondisi** ke langkah untuk membuat tepi.
------
#### [ SageMaker Python SDK ]
Contoh berikut menunjukkan cara membuat `ConditionStep` definisi.
**Batasan**
+ Pipelines tidak mendukung penggunaan langkah-langkah kondisi bersarang. Anda tidak dapat melewati langkah kondisi sebagai input untuk langkah kondisi lain.
+ Langkah kondisi tidak dapat menggunakan langkah yang identik di kedua cabang. Jika Anda membutuhkan fungsionalitas langkah yang sama di kedua cabang, duplikat langkahnya dan beri nama yang berbeda.
```
from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.functions import JsonGet
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name=step_eval.name,
property_file=evaluation_report,
json_path="regression_metrics.mse.value"
),
right=6.0
)
step_cond = ConditionStep(
name="AbaloneMSECond",
conditions=[cond_lte],
if_steps=[step_register, step_create_model, step_transform],
else_steps=[]
)
```
Untuk informasi selengkapnya tentang `ConditionStep` persyaratan, lihat [sagemaker.workflow.condition\$1step. ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#conditionstep) Referensi API. Untuk informasi selengkapnya tentang kondisi yang didukung, lihat *[Amazon SageMaker Pipelines - Ketentuan](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#conditions)* dalam dokumentasi SageMaker AI Python SDK.
------
## Langkah panggilan balik
Gunakan `Callback` langkah untuk menambahkan proses dan AWS layanan tambahan ke dalam alur kerja Anda yang tidak langsung disediakan oleh Amazon SageMaker Pipelines. Ketika sebuah `Callback` langkah berjalan, prosedur berikut terjadi:
+ Pipelines mengirimkan pesan ke antrean Amazon Simple Queue Service (Amazon SQS) yang ditentukan pelanggan. Pesan tersebut berisi token yang dihasilkan pipeline dan daftar parameter input yang disediakan pelanggan. Setelah mengirim pesan, Pipelines menunggu tanggapan dari pelanggan.
+ Pelanggan mengambil pesan dari antrian Amazon SQS dan memulai proses kustom mereka.
+ Ketika proses selesai, pelanggan memanggil salah satu dari yang berikut APIs dan mengirimkan token yang dihasilkan pipeline:
+ [SendPipelineExecutionStepSuccess](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepSuccess.html), bersama dengan daftar parameter output
+ [SendPipelineExecutionStepFailure](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepFailure.html), bersama dengan alasan kegagalan
+ Panggilan API menyebabkan Pipelines melanjutkan proses pipeline atau gagal dalam proses.
Untuk informasi selengkapnya tentang persyaratan `Callback` langkah, lihat [sagemaker.workflow.callback\$1step. CallbackStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.callback_step.CallbackStep)dokumentasi. Untuk solusi selengkapnya, lihat [Memperluas SageMaker Pipelines untuk menyertakan langkah-langkah kustom menggunakan langkah panggilan balik](https://aws.amazon.com/blogs/machine-learning/extend-amazon-sagemaker-pipelines-to-include-custom-steps-using-callback-steps/).
**penting**
`Callback`langkah-langkah diperkenalkan di Amazon SageMaker Python SDK v2.45.0 dan Amazon Studio Classic v3.6.2. SageMaker Anda harus memperbarui Studio Classic sebelum menggunakan `Callback` langkah atau DAG pipeline tidak ditampilkan. Untuk memperbarui Studio Classic, lihat[Matikan dan Perbarui Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
Contoh berikut menunjukkan implementasi dari prosedur sebelumnya.
```
from sagemaker.workflow.callback_step import CallbackStep
step_callback = CallbackStep(
name="MyCallbackStep",
sqs_queue_url="https://sqs.us-east-2.amazonaws.com/012345678901/MyCallbackQueue",
inputs={...},
outputs=[...]
)
callback_handler_code = '
import boto3
import json
def handler(event, context):
sagemaker_client=boto3.client("sagemaker")
for record in event["Records"]:
payload=json.loads(record["body"])
token=payload["token"]
# Custom processing
# Call SageMaker AI to complete the step
sagemaker_client.send_pipeline_execution_step_success(
CallbackToken=token,
OutputParameters={...}
)
'
```
**catatan**
Parameter keluaran untuk tidak `CallbackStep` boleh bersarang. Misalnya, jika Anda menggunakan kamus bersarang sebagai parameter keluaran Anda, maka kamus diperlakukan sebagai string tunggal (mis. `{"output1": "{\"nested_output1\":\"my-output\"}"}`). Jika Anda memberikan nilai bersarang, maka ketika Anda mencoba merujuk ke parameter keluaran tertentu, SageMaker AI melempar kesalahan klien yang tidak dapat dicoba ulang.
**Menghentikan perilaku**
Proses pipeline tidak berhenti saat `Callback` langkah sedang berjalan.
Saat Anda memanggil [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html)proses pipeline dengan `Callback` langkah yang sedang berjalan, Pipelines mengirimkan pesan Amazon SQS ke antrean SQS. Tubuh pesan SQS berisi bidang **Status**, yang diatur ke`Stopping`. Berikut ini menunjukkan contoh badan pesan SQS.
```
{
"token": "26vcYbeWsZ",
"pipelineExecutionArn": "arn:aws:sagemaker:us-east-2:012345678901:pipeline/callback-pipeline/execution/7pinimwddh3a",
"arguments": {
"number": 5,
"stringArg": "some-arg",
"inputData": "s3://sagemaker-us-west-2-012345678901/abalone/abalone-dataset.csv"
},
"status": "Stopping"
}
```
Anda harus menambahkan logika ke konsumen pesan Amazon SQS Anda untuk mengambil tindakan apa pun yang diperlukan (misalnya, pembersihan sumber daya) setelah menerima pesan. Kemudian tambahkan panggilan ke `SendPipelineExecutionStepSuccess` atau`SendPipelineExecutionStepFailure`.
Hanya ketika Pipelines menerima salah satu panggilan ini barulah ia menghentikan proses pipeline.
## Langkah Lambda
Anda menggunakan langkah Lambda untuk menjalankan fungsi. AWS Lambda Anda dapat menjalankan fungsi Lambda yang ada, atau SageMaker AI dapat membuat dan menjalankan fungsi Lambda baru. Jika Anda memilih untuk menggunakan fungsi Lambda yang ada, itu harus Wilayah AWS sama dengan pipeline SageMaker AI. [Untuk buku catatan yang menunjukkan cara menggunakan langkah Lambda dalam pipeline SageMaker AI, lihat sagemaker-pipelines-lambda-step .ipynb.](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/lambda-step/sagemaker-pipelines-lambda-step.ipynb)
**penting**
Langkah-langkah Lambda diperkenalkan di Amazon SageMaker Python SDK v2.51.0 dan Amazon Studio Classic v3.9.1. SageMaker Anda harus memperbarui Studio Classic sebelum menggunakan langkah Lambda atau DAG pipeline tidak ditampilkan. Untuk memperbarui Studio Classic, lihat[Matikan dan Perbarui Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
SageMaker AI menyediakan [kelas SageMaker.lambda\$1helper.Lambda untuk membuat, memperbarui, memanggil, dan menghapus fungsi Lambda](https://sagemaker.readthedocs.io/en/stable/api/utility/lambda_helper.html). `Lambda`memiliki tanda tangan berikut.
```
Lambda(
function_arn, # Only required argument to invoke an existing Lambda function
# The following arguments are required to create a Lambda function:
function_name,
execution_role_arn,
zipped_code_dir, # Specify either zipped_code_dir and s3_bucket, OR script
s3_bucket, # S3 bucket where zipped_code_dir is uploaded
script, # Path of Lambda function script
handler, # Lambda handler specified as "lambda_script.lambda_handler"
timeout, # Maximum time the Lambda function can run before the lambda step fails
...
)
```
[Sagemaker.workflow.lambda\$1step. LambdaStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.lambda_step.LambdaStep)kelas memiliki `lambda_func` argumen tipe`Lambda`. Untuk menjalankan fungsi Lambda yang ada, satu-satunya persyaratan adalah menyediakan Nama Sumber Daya Amazon (ARN) dari fungsi tersebut. `function_arn` Jika Anda tidak memberikan nilai untuk`function_arn`, Anda harus menentukan `handler` dan salah satu dari berikut ini:
+ `zipped_code_dir`— Jalur fungsi Lambda yang di-zip
`s3_bucket`- Bucket Amazon S3 tempat akan `zipped_code_dir` diunggah
+ `script`— Jalur file skrip fungsi Lambda
Contoh berikut menunjukkan cara membuat definisi `Lambda` langkah yang memanggil fungsi Lambda yang ada.
```
from sagemaker.workflow.lambda_step import LambdaStep
from sagemaker.lambda_helper import Lambda
step_lambda = LambdaStep(
name="ProcessingLambda",
lambda_func=Lambda(
function_arn="arn:aws:lambda:us-west-2:012345678910:function:split-dataset-lambda"
),
inputs={
s3_bucket = s3_bucket,
data_file = data_file
},
outputs=[
"train_file", "test_file"
]
)
```
Contoh berikut menunjukkan cara membuat definisi `Lambda` langkah yang membuat dan memanggil fungsi Lambda menggunakan skrip fungsi Lambda.
```
from sagemaker.workflow.lambda_step import LambdaStep
from sagemaker.lambda_helper import Lambda
step_lambda = LambdaStep(
name="ProcessingLambda",
lambda_func=Lambda(
function_name="split-dataset-lambda",
execution_role_arn=execution_role_arn,
script="lambda_script.py",
handler="lambda_script.lambda_handler",
...
),
inputs={
s3_bucket = s3_bucket,
data_file = data_file
},
outputs=[
"train_file", "test_file"
]
)
```
**Input dan output**
Jika `Lambda` fungsi Anda memiliki input atau output, ini juga harus didefinisikan dalam langkah Anda`Lambda`.
**catatan**
Parameter input dan output tidak boleh bersarang. Misalnya, jika Anda menggunakan kamus bersarang sebagai parameter keluaran Anda, maka kamus diperlakukan sebagai string tunggal (mis. `{"output1": "{\"nested_output1\":\"my-output\"}"}`). Jika Anda memberikan nilai bersarang dan mencoba merujuknya nanti, kesalahan klien yang tidak dapat dicoba ulang akan dilemparkan.
Saat mendefinisikan `Lambda` langkah, `inputs` harus kamus pasangan kunci-nilai. Setiap nilai `inputs` kamus harus berupa tipe primitif (string, integer, atau float). Objek bersarang tidak didukung. Jika dibiarkan tidak terdefinisi, `inputs` nilai default ke. `None`
`outputs`Nilai harus berupa daftar kunci. Kunci-kunci ini mengacu pada kamus yang didefinisikan dalam output `Lambda` fungsi. Seperti`inputs`, kunci ini harus tipe primitif, dan objek bersarang tidak didukung.
**Timeout dan menghentikan perilaku**
`Lambda`Kelas memiliki `timeout` argumen yang menentukan waktu maksimum bahwa fungsi Lambda dapat berjalan. Nilai default adalah 120 detik dengan nilai maksimum 10 menit. Jika fungsi Lambda berjalan saat batas waktu terpenuhi, langkah Lambda gagal; Namun, fungsi Lambda terus berjalan.
Proses pipeline tidak dapat dihentikan saat langkah Lambda berjalan karena fungsi Lambda yang dipanggil oleh langkah Lambda tidak dapat dihentikan. Jika Anda menghentikan proses saat fungsi Lambda sedang berjalan, pipeline menunggu fungsi selesai atau sampai batas waktu tercapai. Ini tergantung pada mana yang terjadi lebih dulu. Prosesnya kemudian berhenti. Jika fungsi Lambda selesai, status proses pipeline adalah. `Stopped` Jika batas waktu tercapai, status proses pipeline adalah`Failed`.
## ClarifyCheck langkah
Anda dapat menggunakan `ClarifyCheck` langkah untuk melakukan pemeriksaan penyimpangan dasar terhadap garis dasar sebelumnya untuk analisis bias dan penjelasan model. Anda kemudian dapat membuat dan [mendaftarkan baseline Anda](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations) dengan `model.register()` metode dan meneruskan output dari metode itu untuk [Langkah model](#step-type-model) digunakan. `[step\$1args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)` Garis dasar untuk pemeriksaan drift ini dapat digunakan oleh Amazon SageMaker Model Monitor untuk titik akhir model Anda. Akibatnya, Anda tidak perlu melakukan saran [dasar](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html) secara terpisah.
`ClarifyCheck`Langkah ini juga dapat menarik garis dasar untuk pemeriksaan drift dari registri model. `ClarifyCheck`Langkah ini menggunakan Container Prebuilt SageMaker Clarify. Wadah ini menyediakan berbagai kemampuan pemantauan model, termasuk saran kendala dan validasi kendala terhadap garis dasar yang diberikan. Untuk informasi selengkapnya, lihat [Kontainer SageMaker Klarifikasi Prebuilt](clarify-processing-job-configure-container.md).
### Mengkonfigurasi langkahnya ClarifyCheck
Anda dapat mengonfigurasi `ClarifyCheck` langkah untuk melakukan hanya satu dari jenis pemeriksaan berikut setiap kali digunakan dalam pipeline.
+ Pemeriksaan bias data
+ Pemeriksaan bias model
+ Pemeriksaan penjelasan model
Untuk melakukan ini, atur `clarify_check_config` parameter dengan salah satu nilai jenis cek berikut:
+ `DataBiasCheckConfig`
+ `ModelBiasCheckConfig`
+ `ModelExplainabilityCheckConfig`
`ClarifyCheck`Langkah ini meluncurkan pekerjaan pemrosesan yang menjalankan wadah prebuilt SageMaker AI Clarify dan memerlukan [konfigurasi khusus untuk pemeriksaan dan](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-configure-processing-jobs.html) pekerjaan pemrosesan. `ClarifyCheckConfig`dan `CheckJobConfig` merupakan fungsi pembantu untuk konfigurasi ini. Fungsi pembantu ini selaras dengan bagaimana pekerjaan pemrosesan SageMaker Clarify menghitung untuk memeriksa bias model, bias data, atau penjelasan model. Untuk informasi selengkapnya, lihat [Jalankan Pekerjaan Pemrosesan SageMaker Klarifikasi untuk Analisis Bias dan Penjelasan](clarify-processing-job-run.md).
### Mengontrol perilaku langkah untuk pemeriksaan drift
`ClarifyCheck`Langkah ini membutuhkan dua flag boolean berikut untuk mengontrol perilakunya:
+ `skip_check`: Parameter ini menunjukkan apakah pemeriksaan drift terhadap baseline sebelumnya dilewati atau tidak. Jika disetel ke`False`, baseline sebelumnya dari jenis pemeriksaan yang dikonfigurasi harus tersedia.
+ `register_new_baseline`: Parameter ini menunjukkan apakah baseline yang baru dihitung dapat diakses melalui properti langkah. `BaselineUsedForDriftCheckConstraints` Jika disetel ke`False`, baseline sebelumnya dari jenis pemeriksaan yang dikonfigurasi juga harus tersedia. Ini dapat diakses melalui `BaselineUsedForDriftCheckConstraints` properti.
Untuk informasi selengkapnya, lihat [Perhitungan dasar, deteksi drift, dan siklus hidup dengan serta langkah-langkah di Amazon Pipelines ClarifyCheck QualityCheck SageMaker](pipelines-quality-clarify-baseline-lifecycle.md).
### Bekerja dengan baseline
Anda dapat secara opsional menentukan `model_package_group_name` untuk menemukan baseline yang ada. Kemudian, `ClarifyCheck` langkah tersebut `DriftCheckBaselines` menarik paket model terbaru yang disetujui dalam grup paket model.
Atau, Anda dapat memberikan baseline sebelumnya melalui parameter. `supplied_baseline_constraints` Jika Anda menentukan kedua `model_package_group_name` dan`supplied_baseline_constraints`, `ClarifyCheck` langkah menggunakan garis dasar yang ditentukan oleh parameter. `supplied_baseline_constraints`
Untuk informasi selengkapnya tentang penggunaan persyaratan `ClarifyCheck` langkah, lihat [sagemaker.workflow.steps. ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.clarify_check_step.ClarifyCheckStep)di *Amazon SageMaker AI SageMaker AI SDK untuk Python*. Untuk notebook Amazon SageMaker Studio Classic yang menunjukkan cara menggunakan `ClarifyCheck` step di Pipelines, lihat [sagemaker-pipeline-model-monitor-clarify-steps.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/model-monitor-clarify-pipelines/sagemaker-pipeline-model-monitor-clarify-steps.ipynb).
**Example Buat `ClarifyCheck` langkah untuk pemeriksaan bias data**
```
from sagemaker.workflow.check_job_config import CheckJobConfig
from sagemaker.workflow.clarify_check_step import DataBiasCheckConfig, ClarifyCheckStep
from sagemaker.workflow.execution_variables import ExecutionVariables
check_job_config = CheckJobConfig(
role=role,
instance_count=1,
instance_type="ml.c5.xlarge",
volume_size_in_gb=120,
sagemaker_session=sagemaker_session,
)
data_bias_data_config = DataConfig(
s3_data_input_path=step_process.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
s3_output_path=Join(on='/', values=['s3:/', your_bucket, base_job_prefix, ExecutionVariables.PIPELINE_EXECUTION_ID, 'databiascheckstep']),
label=0,
dataset_type="text/csv",
s3_analysis_config_output_path=data_bias_analysis_cfg_output_path,
)
data_bias_config = BiasConfig(
label_values_or_threshold=[15.0], facet_name=[8], facet_values_or_threshold=[[0.5]]
)
data_bias_check_config = DataBiasCheckConfig(
data_config=data_bias_data_config,
data_bias_config=data_bias_config,
)h
data_bias_check_step = ClarifyCheckStep(
name="DataBiasCheckStep",
clarify_check_config=data_bias_check_config,
check_job_config=check_job_config,
skip_check=False,
register_new_baseline=False
supplied_baseline_constraints="s3://sagemaker-us-west-2-111122223333/baseline/analysis.json",
model_package_group_name="MyModelPackageGroup"
)
```
## QualityCheck langkah
Gunakan `QualityCheck` langkah untuk melakukan [saran dasar](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html) dan pemeriksaan drift terhadap baseline sebelumnya untuk kualitas data atau kualitas model dalam pipeline. Anda kemudian dapat membuat dan [mendaftarkan baseline Anda](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations) dengan `model.register()` metode dan meneruskan output dari metode itu untuk [Langkah model](#step-type-model) digunakan`[step\$1args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)`.]
Model Monitor dapat menggunakan garis dasar ini untuk pemeriksaan drift untuk titik akhir model Anda sehingga Anda tidak perlu melakukan saran dasar secara terpisah. `QualityCheck`Langkah ini juga dapat menarik garis dasar untuk pemeriksaan drift dari registri model. `QualityCheck`Langkah ini memanfaatkan wadah prebuilt Amazon SageMaker AI Model Monitor. Wadah ini memiliki berbagai kemampuan pemantauan model termasuk saran kendala, pembuatan statistik, dan validasi kendala terhadap baseline. Untuk informasi selengkapnya, lihat [Amazon SageMaker Model Monitor wadah bawaan](model-monitor-pre-built-container.md).
### Mengkonfigurasi langkahnya QualityCheck
Anda dapat mengonfigurasi `QualityCheck` langkah untuk menjalankan hanya satu dari jenis pemeriksaan berikut setiap kali digunakan dalam pipeline.
+ Pemeriksaan kualitas data
+ Pemeriksaan kualitas model
Anda melakukan ini dengan mengatur `quality_check_config` parameter dengan salah satu nilai jenis cek berikut:
+ `DataQualityCheckConfig`
+ `ModelQualityCheckConfig`
`QualityCheck`Langkah ini meluncurkan pekerjaan pemrosesan yang menjalankan wadah bawaan Model Monitor dan memerlukan konfigurasi khusus untuk pemeriksaan dan pekerjaan pemrosesan. Fungsi `QualityCheckConfig` dan `CheckJobConfig` pembantu untuk konfigurasi ini. Fungsi pembantu ini selaras dengan bagaimana Model Monitor membuat garis dasar untuk kualitas model atau pemantauan kualitas data. Untuk informasi selengkapnya tentang saran dasar Model Monitor, lihat [Buat Baseline](model-monitor-create-baseline.md) dan. [Buat baseline kualitas model](model-monitor-model-quality-baseline.md)
### Mengontrol perilaku langkah untuk pemeriksaan drift
`QualityCheck`Langkah ini membutuhkan dua flag Boolean berikut untuk mengontrol perilakunya:
+ `skip_check`: Parameter ini menunjukkan apakah pemeriksaan drift terhadap baseline sebelumnya dilewati atau tidak. Jika disetel ke`False`, baseline sebelumnya dari jenis pemeriksaan yang dikonfigurasi harus tersedia.
+ `register_new_baseline`: Parameter ini menunjukkan apakah baseline yang baru dihitung dapat diakses melalui properti `BaselineUsedForDriftCheckConstraints` langkah dan. `BaselineUsedForDriftCheckStatistics` Jika disetel ke`False`, baseline sebelumnya dari jenis pemeriksaan yang dikonfigurasi juga harus tersedia. Ini dapat diakses melalui `BaselineUsedForDriftCheckConstraints` dan `BaselineUsedForDriftCheckStatistics` properti.
Untuk informasi selengkapnya, lihat [Perhitungan dasar, deteksi drift, dan siklus hidup dengan serta langkah-langkah di Amazon Pipelines ClarifyCheck QualityCheck SageMaker](pipelines-quality-clarify-baseline-lifecycle.md).
### Bekerja dengan baseline
Anda dapat menentukan garis dasar sebelumnya secara langsung melalui parameter `supplied_baseline_statistics` dan`supplied_baseline_constraints`. Anda juga dapat menentukan `model_package_group_name` dan `QualityCheck` langkah menarik paket model terbaru yang disetujui dalam grup paket model. `DriftCheckBaselines`
Saat Anda menentukan yang berikut ini, `QualityCheck` langkah tersebut menggunakan garis dasar yang ditentukan oleh `supplied_baseline_constraints` dan `supplied_baseline_statistics` pada jenis pemeriksaan langkah. `QualityCheck`
+ `model_package_group_name`
+ `supplied_baseline_constraints`
+ `supplied_baseline_statistics`
Untuk informasi selengkapnya tentang penggunaan persyaratan `QualityCheck` langkah, lihat [sagemaker.workflow.steps. QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.quality_check_step.QualityCheckStep)di *Amazon SageMaker AI SageMaker AI SDK untuk Python*. Untuk notebook Amazon SageMaker Studio Classic yang menunjukkan cara menggunakan `QualityCheck` step di Pipelines, lihat [sagemaker-pipeline-model-monitor-clarify-steps.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/model-monitor-clarify-pipelines/sagemaker-pipeline-model-monitor-clarify-steps.ipynb).
**Example Buat `QualityCheck` langkah untuk pemeriksaan kualitas data**
```
from sagemaker.workflow.check_job_config import CheckJobConfig
from sagemaker.workflow.quality_check_step import DataQualityCheckConfig, QualityCheckStep
from sagemaker.workflow.execution_variables import ExecutionVariables
check_job_config = CheckJobConfig(
role=role,
instance_count=1,
instance_type="ml.c5.xlarge",
volume_size_in_gb=120,
sagemaker_session=sagemaker_session,
)
data_quality_check_config = DataQualityCheckConfig(
baseline_dataset=step_process.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
dataset_format=DatasetFormat.csv(header=False, output_columns_position="START"),
output_s3_uri=Join(on='/', values=['s3:/', your_bucket, base_job_prefix, ExecutionVariables.PIPELINE_EXECUTION_ID, 'dataqualitycheckstep'])
)
data_quality_check_step = QualityCheckStep(
name="DataQualityCheckStep",
skip_check=False,
register_new_baseline=False,
quality_check_config=data_quality_check_config,
check_job_config=check_job_config,
supplied_baseline_statistics="s3://sagemaker-us-west-2-555555555555/baseline/statistics.json",
supplied_baseline_constraints="s3://sagemaker-us-west-2-555555555555/baseline/constraints.json",
model_package_group_name="MyModelPackageGroup"
)
```
## Langkah EMR
Gunakan langkah [EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-overview.html) Amazon SageMaker Pipelines untuk:
+ Memproses [langkah-langkah Amazon EMR pada klaster](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-work-with-steps.html) EMR Amazon yang sedang berjalan.
+ Minta pipeline membuat dan mengelola cluster EMR Amazon untuk Anda.
Untuk informasi selengkapnya tentang Amazon EMR, lihat [Memulai dengan Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html).
Langkah EMR mengharuskan `EMRStepConfig` menyertakan lokasi file JAR yang digunakan oleh cluster EMR Amazon dan argumen apa pun yang akan diteruskan. Anda juga memberikan ID cluster EMR Amazon jika Anda ingin menjalankan langkah pada cluster EMR yang sedang berjalan. Anda juga dapat meneruskan konfigurasi cluster untuk menjalankan langkah EMR pada cluster yang dibuat, dikelola, dan diakhiri untuk Anda. Bagian berikut mencakup contoh dan tautan ke notebook sampel yang menunjukkan kedua metode.
**catatan**
Langkah-langkah EMR mengharuskan peran yang diteruskan ke pipeline Anda memiliki izin tambahan. Lampirkan [kebijakan AWS terkelola: `AmazonSageMakerPipelinesIntegrations`](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol-pipelines.html#security-iam-awsmanpol-AmazonSageMakerPipelinesIntegrations) ke peran pipeline Anda, atau pastikan peran tersebut menyertakan izin dalam kebijakan tersebut.
Jika Anda memproses langkah EMR pada cluster yang sedang berjalan, Anda hanya dapat menggunakan cluster yang berada di salah satu status berikut:
`STARTING`
`BOOTSTRAPPING`
`RUNNING`
`WAITING`
Jika Anda memproses langkah-langkah EMR pada cluster yang sedang berjalan, Anda dapat memiliki paling banyak 256 langkah EMR dalam keadaan di cluster EMR. `PENDING` Langkah-langkah EMR yang diajukan di luar batas ini mengakibatkan kegagalan eksekusi pipeline. Anda dapat mempertimbangkan untuk menggunakan[Coba lagi Kebijakan untuk Langkah-langkah Pipa](pipelines-retry-policy.md).
Anda dapat menentukan ID cluster atau konfigurasi cluster, tetapi tidak keduanya.
Langkah EMR bergantung pada Amazon EventBridge untuk memantau perubahan dalam langkah EMR atau status cluster. Jika Anda memproses pekerjaan EMR Amazon di klaster yang sedang berjalan, langkah EMR menggunakan aturan `SageMakerPipelineExecutionEMRStepStatusUpdateRule` untuk memantau status langkah EMR. Jika Anda memproses pekerjaan Anda di klaster yang dibuat oleh langkah EMR, langkah tersebut menggunakan `SageMakerPipelineExecutionEMRClusterStatusRule` aturan untuk memantau perubahan status klaster. Jika Anda melihat salah satu dari EventBridge aturan ini di AWS akun Anda, jangan menghapusnya atau langkah EMR Anda mungkin tidak selesai.
**Tambahkan langkah EMR Amazon ke pipeline Anda**
Untuk menambahkan langkah EMR ke pipeline Anda, lakukan hal berikut:
+ Buka konsol Studio dengan mengikuti petunjuk di [Luncurkan Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
+ Di panel navigasi kiri, pilih **Pipelines**.
+ Pilih **Buat**.
+ Pilih **Kosong**.
+ Di bilah sisi kiri, pilih **Proses data** dan seret ke kanvas.
+ Di kanvas, pilih langkah **Proses data** yang Anda tambahkan.
+ Di sidebar kanan, di bawah mode, pilih **EMR (dikelola)**.
+ Di bilah sisi kanan, lengkapi formulir di tab **Pengaturan dan Detail**. Untuk informasi tentang bidang di tab ini, lihat [sagemaker.workflow.fail\$1step. EMRstep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.emr_step.EMRStep).
**Luncurkan pekerjaan baru di klaster EMR Amazon yang sedang berjalan**
Untuk meluncurkan pekerjaan baru di klaster EMR Amazon yang sedang berjalan, teruskan ID cluster sebagai string ke `cluster_id` argumen. `EMRStep` Contoh berikut menunjukkan prosedur ini.
```
from sagemaker.workflow.emr_step import EMRStep, EMRStepConfig
emr_config = EMRStepConfig(
jar="jar-location", # required, path to jar file used
args=["--verbose", "--force"], # optional list of arguments to pass to the jar
main_class="com.my.Main1", # optional main class, this can be omitted if jar above has a manifest
properties=[ # optional list of Java properties that are set when the step runs
{
"key": "mapred.tasktracker.map.tasks.maximum",
"value": "2"
},
{
"key": "mapreduce.map.sort.spill.percent",
"value": "0.90"
},
{
"key": "mapreduce.tasktracker.reduce.tasks.maximum",
"value": "5"
}
]
)
step_emr = EMRStep (
name="EMRSampleStep", # required
cluster_id="j-1ABCDEFG2HIJK", # include cluster_id to use a running cluster
step_config=emr_config, # required
display_name="My EMR Step",
description="Pipeline step to execute EMR job"
)
```
Untuk contoh buku catatan yang memandu Anda melalui contoh lengkap, lihat [Pipelines EMR Step With Running EMR Cluster](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-running-emr-cluster.ipynb).
**Luncurkan pekerjaan baru di cluster EMR Amazon baru**
Untuk meluncurkan pekerjaan baru di klaster baru yang `EMRStep` membuat untuk Anda, berikan konfigurasi klaster Anda sebagai kamus. Kamus harus memiliki struktur yang sama dengan [RunJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html)permintaan. Namun, jangan sertakan bidang berikut dalam konfigurasi klaster Anda:
+ [`Name`]
+ [`Steps`]
+ [`AutoTerminationPolicy`]
+ [`Instances`][`KeepJobFlowAliveWhenNoSteps`]
+ [`Instances`][`TerminationProtected`]
Semua `RunJobFlow` argumen lain tersedia untuk digunakan dalam konfigurasi cluster Anda. Untuk detail tentang sintaks permintaan, lihat [RunJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html).
Contoh berikut meneruskan konfigurasi cluster ke definisi langkah EMR. Ini mendorong langkah untuk meluncurkan pekerjaan baru di cluster EMR baru. Konfigurasi cluster EMR dalam contoh ini mencakup spesifikasi untuk node cluster EMR primer dan inti. Untuk informasi selengkapnya tentang jenis node EMR Amazon, lihat [Memahami tipe node: node primer, inti, dan tugas](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html).
```
from sagemaker.workflow.emr_step import EMRStep, EMRStepConfig
emr_step_config = EMRStepConfig(
jar="jar-location", # required, path to jar file used
args=["--verbose", "--force"], # optional list of arguments to pass to the jar
main_class="com.my.Main1", # optional main class, this can be omitted if jar above has a manifest
properties=[ # optional list of Java properties that are set when the step runs
{
"key": "mapred.tasktracker.map.tasks.maximum",
"value": "2"
},
{
"key": "mapreduce.map.sort.spill.percent",
"value": "0.90"
},
{
"key": "mapreduce.tasktracker.reduce.tasks.maximum",
"value": "5"
}
]
)
# include your cluster configuration as a dictionary
emr_cluster_config = {
"Applications": [
{
"Name": "Spark",
}
],
"Instances":{
"InstanceGroups":[
{
"InstanceRole": "MASTER",
"InstanceCount": 1,
"InstanceType": "m5.2xlarge"
},
{
"InstanceRole": "CORE",
"InstanceCount": 2,
"InstanceType": "m5.2xlarge"
}
]
},
"BootstrapActions":[],
"ReleaseLabel": "emr-6.6.0",
"JobFlowRole": "job-flow-role",
"ServiceRole": "service-role"
}
emr_step = EMRStep(
name="emr-step",
cluster_id=None,
display_name="emr_step",
description="MyEMRStepDescription",
step_config=emr_step_config,
cluster_config=emr_cluster_config
)
```
Untuk contoh buku catatan yang memandu Anda melalui contoh lengkap, lihat [Pipelines EMR Step With Cluster](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-cluster-lifecycle-management.ipynb) Lifecycle Management.
## Langkah EMR tanpa server
Untuk menambahkan langkah EMR tanpa server ke pipeline Anda, lakukan hal berikut:
+ Buka konsol Studio dengan mengikuti petunjuk di [Luncurkan Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
+ Di panel navigasi kiri, pilih **Pipelines**.
+ Pilih **Buat**.
+ Pilih **Kosong**.
+ Di bilah sisi kiri, pilih **Proses data** dan seret ke kanvas.
+ Di kanvas, pilih langkah **Proses data** yang Anda tambahkan.
+ Di sidebar kanan, di bawah mode, pilih **EMR (tanpa server)**.
+ Di bilah sisi kanan, lengkapi formulir di tab **Pengaturan dan Detail**.
## Langkah pekerjaan notebook
Gunakan a `NotebookJobStep` untuk menjalankan Job SageMaker Notebook Anda secara non-interaktif sebagai langkah pipeline. Jika Anda membangun pipeline di drag-and-drop UI Pipelines, gunakan file [Jalankan langkah kode](#step-type-executecode) untuk menjalankan notebook Anda. Untuk informasi selengkapnya tentang Pekerjaan SageMaker Notebook, lihat[SageMaker Lowongan Notebook](notebook-auto-run.md).
A `NotebookJobStep` membutuhkan minimal notebook input, URI gambar dan nama kernel. Untuk informasi selengkapnya tentang persyaratan langkah Job Notebook dan parameter lain yang dapat Anda atur untuk menyesuaikan langkah, lihat [sagemaker.workflow.steps. NotebookJobStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.notebook_job_step.NotebookJobStep).
Contoh berikut menggunakan argumen minimum untuk mendefinisikan a`NotebookJobStep`.
```
from sagemaker.workflow.notebook_job_step import NotebookJobStep
notebook_job_step = NotebookJobStep(
input_notebook=input_notebook,
image_uri=image_uri,
kernel_name=kernel_name
)
```
Langkah `NotebookJobStep` pipeline Anda diperlakukan sebagai pekerjaan SageMaker notebook. Akibatnya, lacak status eksekusi di dasbor pekerjaan notebook UI Studio Classic dengan menyertakan tag tertentu dengan `tags` argumen. Untuk detail selengkapnya tentang tag yang akan disertakan, lihat[Melihat pekerjaan notebook Anda di dasbor Studio UI](create-notebook-auto-run-sdk.md#create-notebook-auto-run-dash).
Selain itu, jika Anda menjadwalkan pekerjaan notebook menggunakan SageMaker Python SDK, Anda hanya dapat menentukan gambar tertentu untuk menjalankan pekerjaan notebook Anda. Untuk informasi selengkapnya, lihat [Kendala gambar untuk pekerjaan notebook AI SageMaker Python SDK](notebook-auto-run-constraints.md#notebook-auto-run-constraints-image-sdk).
## Langkah gagal
Gunakan langkah Gagal untuk menghentikan eksekusi Amazon SageMaker Pipelines jika kondisi atau status yang diinginkan tidak tercapai. Langkah Gagal juga memungkinkan Anda memasukkan pesan kesalahan khusus, yang menunjukkan penyebab kegagalan eksekusi pipeline.
**catatan**
Ketika langkah Gagal dan langkah pipeline lainnya dijalankan pada saat yang sama, pipeline tidak berakhir sampai semua langkah bersamaan selesai.
### Batasan untuk menggunakan langkah Gagal
+ Anda tidak dapat menambahkan langkah Gagal ke `DependsOn` daftar langkah lainnya. Untuk informasi selengkapnya, lihat [Ketergantungan khusus antar langkah](build-and-manage-steps.md#build-and-manage-custom-dependency).
+ Langkah-langkah lain tidak dapat mereferensikan langkah Gagal. Itu *selalu* merupakan langkah terakhir dalam eksekusi pipeline.
+ Anda tidak dapat mencoba lagi eksekusi pipeline yang diakhiri dengan langkah Gagal.
Anda dapat membuat pesan kesalahan langkah Gagal dalam bentuk string teks statis. Atau, Anda juga dapat menggunakan [Parameter Pipeline](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-parameters.html), operasi [Gabung](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html?highlight=Join#sagemaker.workflow.functions.Join), atau [properti langkah](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#build-and-manage-properties) lainnya untuk membuat pesan kesalahan yang lebih informatif jika Anda menggunakan SDK.
------
#### [ Pipeline Designer ]
Untuk menambahkan langkah Gagal ke pipeline Anda, lakukan hal berikut:
1. Buka konsol Studio dengan mengikuti petunjuk di[Luncurkan Amazon SageMaker Studio](studio-updated-launch.md).
1. Di panel navigasi kiri, pilih **Pipelines**.
1. Pilih **Buat**.
1. Pilih **Kosong**.
1. Di bilah sisi kiri, pilih **Gagal** dan seret ke kanvas.
1. Di kanvas, pilih langkah **Gagal** yang Anda tambahkan.
1. Di bilah sisi kanan, lengkapi formulir di tab **Pengaturan** dan **Detail**. Untuk informasi tentang bidang di tab ini, lihat [sagemaker.workflow.fail\$1step. FailStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.fail_step.FailStep).
1. Jika kanvas menyertakan langkah apa pun yang segera mendahului langkah **Gagal** yang Anda tambahkan, klik dan seret kursor dari langkah ke langkah **Gagal** untuk membuat tepi.
1. Jika kanvas menyertakan langkah apa pun yang segera menggantikan langkah **Gagal** yang Anda tambahkan, klik dan seret kursor dari langkah **Gagal** ke langkah untuk membuat tepi.
------
#### [ SageMaker Python SDK ]
**Example**
Contoh cuplikan kode berikut menggunakan dengan `ErrorMessage` dikonfigurasi `FailStep` dengan Parameter Pipeline dan operasi. `Join`
```
from sagemaker.workflow.fail_step import FailStep
from sagemaker.workflow.functions import Join
from sagemaker.workflow.parameters import ParameterInteger
mse_threshold_param = ParameterInteger(name="MseThreshold", default_value=5)
step_fail = FailStep(
name="AbaloneMSEFail",
error_message=Join(
on=" ", values=["Execution failed due to MSE >", mse_threshold_param]
),
)
```
------
# Tambahkan integrasi
MLflow integrasi memungkinkan Anda untuk menggunakan MLflow dengan pipeline untuk memilih server pelacak atau aplikasi tanpa server, memilih eksperimen, dan mencatat metrik.
## Konsep utama
**Pembuatan aplikasi default** - MLflow Aplikasi default akan dibuat saat Anda memasukkan editor visual pipeline.
**Panel integrasi - Panel** integrasi baru termasuk MLflow, yang dapat Anda pilih dan konfigurasikan.
**Perbarui aplikasi dan eksperimen** - Opsi untuk mengganti aplikasi dan eksperimen yang dipilih selama eksekusi pipeline.
## Cara kerjanya
+ Pergi ke **Pipeline Visual Editor**
+ Pilih **Integrasi** pada toolbar
+ Pilih **MLflow**
+ Konfigurasikan MLflow aplikasi dan eksperimen
## Contoh tangkapan layar
Integrasi panel samping
![\[Deskripsi yang harus dilakukan.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/screenshot-pipeline-1.png)
MLflow konfigurasi
![\[Deskripsi yang harus dilakukan.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/screenshot-pipeline-2.png)
Cara mengganti eksperimen selama eksekusi pipeline
![\[Deskripsi yang harus dilakukan.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/screenshot-pipeline-3.png)
## Properti langkah
Gunakan `properties` atribut untuk menambahkan dependensi data di antara langkah-langkah dalam pipeline. Pipelines menggunakan dependensi data ini untuk membangun DAG dari definisi pipeline. Properti ini dapat direferensikan sebagai nilai placeholder dan diselesaikan saat runtime.
`properties`Atribut langkah Pipelines cocok dengan objek yang dikembalikan oleh `Describe` panggilan untuk jenis pekerjaan SageMaker AI yang sesuai. Untuk setiap jenis pekerjaan, `Describe` panggilan mengembalikan objek respons berikut:
+ `ProcessingStep` – [DescribeProcessingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html)
+ `TrainingStep` – [DescribeTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html)
+ `TransformStep` – [DescribeTransformJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTransformJob.html)
Untuk memeriksa properti mana yang dapat direferensikan untuk setiap tipe langkah selama pembuatan dependensi data, lihat *[Ketergantungan Data - Referensi Properti](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* di Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable) SDK.
## Paralelisme langkah
Ketika sebuah langkah tidak bergantung pada langkah lain, itu berjalan segera setelah eksekusi pipeline. Namun, mengeksekusi terlalu banyak langkah pipeline secara paralel dapat dengan cepat menghabiskan sumber daya yang tersedia. Kontrol jumlah langkah bersamaan untuk eksekusi pipeline dengan`ParallelismConfiguration`.
Contoh berikut digunakan `ParallelismConfiguration` untuk mengatur batas langkah bersamaan ke lima.
```
pipeline.create(
parallelism_config=ParallelismConfiguration(5),
)
```
## Ketergantungan data antar langkah
Anda menentukan struktur DAG Anda dengan menentukan hubungan data antar langkah. Untuk membuat dependensi data antar langkah, berikan properti dari satu langkah sebagai input ke langkah lain dalam pipeline. Langkah menerima input tidak dimulai sampai setelah langkah menyediakan input selesai berjalan.
Ketergantungan data menggunakan JsonPath notasi dalam format berikut. Format ini melintasi file properti JSON. Ini berarti Anda dapat menambahkan sebanyak mungkin ** instance yang diperlukan untuk mencapai properti bersarang yang diinginkan dalam file. Untuk informasi lebih lanjut tentang JsonPath notasi, lihat [JsonPath repo](https://github.com/json-path/JsonPath).
```
.properties..
```
Berikut ini menunjukkan cara menentukan bucket Amazon S3 menggunakan `ProcessingOutputConfig` properti langkah pemrosesan.
```
step_process.properties.ProcessingOutputConfig.Outputs["train_data"].S3Output.S3Uri
```
Untuk membuat ketergantungan data, teruskan bucket ke langkah pelatihan sebagai berikut.
```
from sagemaker.workflow.pipeline_context import PipelineSession
sklearn_train = SKLearn(..., sagemaker_session=PipelineSession())
step_train = TrainingStep(
name="CensusTrain",
step_args=sklearn_train.fit(inputs=TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"train_data"].S3Output.S3Uri
))
)
```
Untuk memeriksa properti mana yang dapat direferensikan untuk setiap tipe langkah selama pembuatan dependensi data, lihat *[Ketergantungan Data - Referensi Properti](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* di Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable) SDK.
## Ketergantungan khusus antar langkah
Saat Anda menentukan ketergantungan data, Pipelines menyediakan koneksi data di antara langkah-langkah tersebut. Atau, satu langkah dapat mengakses data dari langkah sebelumnya tanpa langsung menggunakan Pipelines. Dalam hal ini, Anda dapat membuat dependensi khusus yang memberi tahu Pipelines untuk tidak memulai langkah sampai setelah langkah lain selesai berjalan. Anda membuat dependensi kustom dengan menentukan atribut step. `DependsOn`
Sebagai contoh, berikut ini mendefinisikan langkah `C` yang dimulai hanya setelah kedua langkah `A` dan langkah `B` selesai berjalan.
```
{
'Steps': [
{'Name':'A', ...},
{'Name':'B', ...},
{'Name':'C', 'DependsOn': ['A', 'B']}
]
}
```
Pipelines melempar pengecualian validasi jika ketergantungan akan membuat ketergantungan siklik.
Contoh berikut membuat langkah pelatihan yang dimulai setelah langkah pemrosesan selesai berjalan.
```
processing_step = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step])
```
Contoh berikut membuat langkah pelatihan yang tidak dimulai sampai dua langkah pemrosesan yang berbeda selesai berjalan.
```
processing_step_1 = ProcessingStep(...)
processing_step_2 = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step_1, processing_step_2])
```
Berikut ini menyediakan cara alternatif untuk membuat ketergantungan kustom.
```
training_step.add_depends_on([processing_step_1])
training_step.add_depends_on([processing_step_2])
```
Contoh berikut membuat langkah pelatihan yang menerima masukan dari satu langkah pemrosesan dan menunggu langkah pemrosesan yang berbeda untuk selesai berjalan.
```
processing_step_1 = ProcessingStep(...)
processing_step_2 = ProcessingStep(...)
training_step = TrainingStep(
...,
inputs=TrainingInput(
s3_data=processing_step_1.properties.ProcessingOutputConfig.Outputs[
"train_data"
].S3Output.S3Uri
)
training_step.add_depends_on([processing_step_2])
```
Contoh berikut menunjukkan bagaimana untuk mengambil daftar string dari dependensi kustom langkah.
```
custom_dependencies = training_step.depends_on
```
## Gambar khusus dalam satu langkah
Anda dapat menggunakan salah satu [gambar SageMaker AI Deep Learning Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) yang tersedia saat membuat langkah dalam pipeline.
Anda juga dapat menggunakan wadah Anda sendiri dengan langkah-langkah pipa. Karena Anda tidak dapat membuat gambar dari dalam Studio Classic, Anda harus membuat gambar menggunakan metode lain sebelum menggunakannya dengan Pipelines.
Untuk menggunakan penampung Anda sendiri saat membuat langkah-langkah untuk pipeline Anda, sertakan URI gambar dalam definisi estimator. Untuk informasi selengkapnya tentang penggunaan kontainer Anda sendiri dengan SageMaker AI, lihat [Menggunakan Kontainer Docker dengan SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers.html).