Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# SageMaker Alur Kerja AI
Saat Anda menskalakan operasi pembelajaran mesin (ML), Anda dapat menggunakan layanan alur kerja yang dikelola sepenuhnya Amazon SageMaker AI untuk menerapkan praktik integrasi dan penerapan berkelanjutan (CI/CD) untuk siklus hidup ML Anda. Dengan Pipelines SDK, Anda memilih dan mengintegrasikan langkah-langkah pipeline ke dalam solusi terpadu yang mengotomatiskan proses pembuatan model dari persiapan data hingga penerapan model. Untuk arsitektur berbasis Kubernetes, Anda dapat menginstal Operator SageMaker AI di klaster Kubernetes Anda untuk membuat pekerjaan SageMaker AI secara native menggunakan API Kubernetes dan alat Kubernetes baris perintah seperti. `kubectl` Dengan komponen SageMaker AI untuk pipeline Kubeflow, Anda dapat membuat dan memantau pekerjaan SageMaker AI asli dari Pipelines Kubeflow Anda. Parameter pekerjaan, status, dan output dari SageMaker AI dapat diakses dari UI Pipelines Kubeflow. Terakhir, jika Anda ingin menjadwalkan pekerjaan batch, Anda dapat menggunakan integrasi antrian AWS Batch pekerjaan atau layanan alur kerja berbasis notebook Jupyter untuk memulai proses mandiri atau reguler pada jadwal yang Anda tentukan.
Singkatnya, SageMaker AI menawarkan teknologi alur kerja berikut:
+ [Pipeline](pipelines.md): Alat untuk membangun dan mengelola jaringan pipa ML.
+ [Orkestrasi Kubernetes](kubernetes-workflows.md): Operator kustom SageMaker AI untuk klaster Kubernetes Anda dan komponen untuk Pipelines Kubeflow.
+ [SageMaker Lowongan Notebook](notebook-auto-run.md): Sesuai permintaan atau batch non-interaktif terjadwal dari notebook Jupyter Anda.
Anda juga dapat memanfaatkan layanan lain yang terintegrasi dengan SageMaker AI untuk membangun alur kerja Anda. Opsi termasuk layanan berikut:
+ [Alur Kerja Alur Udara](https://sagemaker.readthedocs.io/en/stable/workflows/airflow/index.html): SageMaker APIs untuk mengekspor konfigurasi untuk membuat dan mengelola alur kerja Alur Udara.
+ [AWS Step Functions](https://sagemaker.readthedocs.io/en/stable/workflows/step_functions/index.html): Alur kerja MLM multi-langkah dengan Python yang mengatur infrastruktur SageMaker AI tanpa harus menyediakan sumber daya Anda secara terpisah.
+ [AWS Batch](https://docs.aws.amazon.com/batch/latest/userguide/getting-started-sagemaker.html): Kirim pekerjaan pelatihan SageMaker AI ke antrian AWS Batch pekerjaan, di mana Anda dapat memprioritaskan dan menjadwalkan pekerjaan untuk dijalankan di lingkungan komputasi.
Untuk informasi selengkapnya tentang mengelola SageMaker pelatihan dan inferensi, lihat Alur Kerja SDK [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/workflows/index.html).
**Topics**
+ [Pipeline](pipelines.md)
+ [Orkestrasi Kubernetes](kubernetes-workflows.md)
+ [SageMaker Lowongan Notebook](notebook-auto-run.md)
+ [Jadwalkan alur kerja ML Anda](workflow-scheduling.md)
+ [AWS Batch dukungan untuk pekerjaan pelatihan SageMaker AI](training-job-queues.md)
# Pipeline
Amazon SageMaker Pipelines adalah layanan orkestrasi alur kerja yang dibuat khusus untuk mengotomatiskan pengembangan machine learning (ML).
Pipelines memberikan keuntungan sebagai berikut dibandingkan penawaran AWS alur kerja lainnya:
**Infrastruktur tanpa server penskalaan otomatis Anda tidak perlu mengelola infrastruktur** orkestrasi yang mendasarinya untuk menjalankan Pipelines, yang memungkinkan Anda untuk fokus pada tugas-tugas inti HTML. SageMaker AI secara otomatis menyediakan, menskalakan, dan mematikan sumber daya komputasi orkestrasi pipeline sesuai tuntutan beban kerja ML Anda.
**Pengalaman pengguna yang intuitif** Pipelines dapat dibuat dan dikelola melalui antarmuka pilihan Anda: editor visual, SDK APIs, atau JSON. Anda dapat drag-and-drop melakukan berbagai langkah ML untuk membuat pipeline Anda di antarmuka visual Amazon SageMaker Studio. Tangkapan layar berikut menunjukkan editor visual Studio untuk saluran pipa.
![\[Tangkapan layar drag-and-drop antarmuka visual untuk Pipelines di Studio.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/pipelines/pipelines-studio-overview.png)
Jika Anda lebih suka mengelola alur kerja ML Anda secara terprogram, SageMaker Python SDK menawarkan fitur orkestrasi lanjutan. Untuk informasi selengkapnya, lihat [Amazon SageMaker Pipelines](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html) dalam dokumentasi SageMaker Python SDK.
**AWS integrasi** Pipelines menyediakan integrasi tanpa batas dengan semua fitur SageMaker AI dan AWS layanan lainnya untuk mengotomatiskan pemrosesan data, pelatihan model, fine-tuning, evaluasi, penyebaran, dan pekerjaan pemantauan. Anda dapat menggabungkan fitur SageMaker AI di Pipelines Anda dan menavigasi mereka menggunakan deep link untuk membuat, memantau, dan men-debug alur kerja ML Anda dalam skala besar.
**Mengurangi biaya** Dengan Pipelines, Anda hanya membayar untuk lingkungan SageMaker Studio dan pekerjaan dasar yang diatur oleh Pipelines (misalnya, SageMaker Pelatihan, SageMaker Pemrosesan, Inferensi SageMaker AI, dan penyimpanan data Amazon S3).
**Auditabilitas dan pelacakan garis keturunan** Dengan Pipelines, Anda dapat melacak riwayat pembaruan dan eksekusi pipeline menggunakan versi bawaan. Amazon SageMaker ML Lineage Tracking membantu Anda menganalisis sumber data dan konsumen data dalam siklus hidup pengembangan end-to-end ML.
**Topics**
+ [Ikhtisar jaringan pipa](pipelines-overview.md)
+ [Tindakan saluran pipa](pipelines-build.md)
# Ikhtisar jaringan pipa
[Pipeline Amazon SageMaker AI adalah serangkaian langkah yang saling berhubungan dalam grafik asiklik terarah (DAG) yang didefinisikan menggunakan drag-and-drop UI atau Pipelines SDK.](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html) Anda juga dapat membangun pipeline menggunakan [skema JSON definisi pipeline](https://aws-sagemaker-mlops.github.io/sagemaker-model-building-pipeline-definition-JSON-schema/). Definisi DAG JSON ini memberikan informasi tentang persyaratan dan hubungan antara setiap langkah pipa Anda. Struktur DAG pipa ditentukan oleh dependensi data antar langkah. Dependensi data ini dibuat ketika properti output langkah diteruskan sebagai input ke langkah lain. Gambar berikut adalah contoh dari pipa DAG:
![\[\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/pipeline-full.png)
**Contoh DAG mencakup langkah-langkah berikut:**
1. `AbaloneProcess`, contoh dari langkah [Processing](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing), menjalankan skrip preprocessing pada data yang digunakan untuk pelatihan. Misalnya, skrip dapat mengisi nilai yang hilang, menormalkan data numerik, atau membagi data ke dalam kumpulan data kereta, validasi, dan pengujian.
1. `AbaloneTrain`, contoh dari langkah [Pelatihan](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-training), mengonfigurasi hiperparameter dan melatih model dari data input yang telah diproses sebelumnya.
1. `AbaloneEval`, contoh lain dari langkah [Pemrosesan](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing), mengevaluasi model untuk akurasi. Langkah ini menunjukkan contoh ketergantungan data—langkah ini menggunakan keluaran dataset pengujian dari. `AbaloneProcess`
1. `AbaloneMSECond`adalah contoh dari langkah [Kondisi](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-condition) yang, dalam contoh ini, memeriksa untuk memastikan mean-square-error hasil evaluasi model di bawah batas tertentu. Jika model tidak memenuhi kriteria, proses pipa berhenti.
1. Proses pipeline berjalan dengan langkah-langkah berikut:
1. `AbaloneRegisterModel`, di mana SageMaker AI memanggil [RegisterModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-register-model)langkah untuk mendaftarkan model sebagai grup paket model berversi ke dalam Amazon SageMaker Model Registry.
1. `AbaloneCreateModel`, di mana SageMaker AI memanggil [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-create-model)langkah untuk membuat model dalam persiapan untuk transformasi batch. Di`AbaloneTransform`, SageMaker AI memanggil langkah [Transform](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-transform) untuk menghasilkan prediksi model pada kumpulan data yang Anda tentukan.
Topik berikut menjelaskan konsep dasar Pipelines. Untuk tutorial yang menjelaskan implementasi konsep-konsep ini, lihat[Tindakan saluran pipa](pipelines-build.md).
**Topics**
+ [Struktur dan Eksekusi Pipa](build-and-manage-pipeline.md)
+ [Manajemen Akses IAM](build-and-manage-access.md)
+ [Menyiapkan dukungan lintas akun untuk Pipelines](build-and-manage-xaccount.md)
+ [Parameter pipa](build-and-manage-parameters.md)
+ [Langkah-langkah saluran pipa](build-and-manage-steps.md)
+ [Lift-and-shift Kode Python dengan dekorator @step](pipelines-step-decorator.md)
+ [Lulus Data Antar Langkah](build-and-manage-propertyfile.md)
+ [Langkah-langkah pipa cache](pipelines-caching.md)
+ [Coba lagi Kebijakan untuk Langkah-langkah Pipa](pipelines-retry-policy.md)
+ [Eksekusi selektif dari langkah-langkah pipa](pipelines-selective-ex.md)
+ [Perhitungan dasar, deteksi drift, dan siklus hidup dengan serta langkah-langkah di Amazon Pipelines ClarifyCheck QualityCheck SageMaker](pipelines-quality-clarify-baseline-lifecycle.md)
+ [Jadwalkan Pipeline Runs](pipeline-eventbridge.md)
+ [Integrasi SageMaker Eksperimen Amazon](pipelines-experiments.md)
+ [Jalankan saluran pipa menggunakan mode lokal](pipelines-local-mode.md)
+ [Memecahkan Masalah Pipa Amazon SageMaker](pipelines-troubleshooting.md)
# Struktur dan Eksekusi Pipa
**Topics**
+ [Struktur Pipa](#build-and-manage-pipeline-structure)
+ [Eksekusi Pipeline menggunakan Konfigurasi Paralelisme](#build-and-manage-pipeline-execution)
## Struktur Pipa
Instans Amazon SageMaker Pipelines terdiri dari`name`,`parameters`, dan`steps`. Nama pipa harus unik dalam `(account, region)` pasangan. Semua parameter yang digunakan dalam definisi langkah harus didefinisikan dalam pipeline. Langkah-langkah pipeline yang tercantum secara otomatis menentukan urutan eksekusi mereka berdasarkan dependensi data mereka satu sama lain. Layanan Pipelines menyelesaikan hubungan antara langkah-langkah dalam dependensi data DAG untuk membuat serangkaian langkah yang diselesaikan eksekusi. Berikut ini adalah contoh struktur pipa.
**Awas**
Saat membangun pipeline melalui editor visual atau SageMaker AI Python SDK, jangan sertakan informasi sensitif dalam parameter pipeline atau bidang definisi langkah apa pun (seperti variabel lingkungan). Bidang ini akan terlihat di masa depan saat dikembalikan dalam `DescribePipeline` permintaan.
```
from sagemaker.workflow.pipeline import Pipeline
pipeline_name = f"AbalonePipeline"
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_type,
processing_instance_count,
training_instance_type,
model_approval_status,
input_data,
batch_data,
],
steps=[step_process, step_train, step_eval, step_cond],
)
```
## Eksekusi Pipeline menggunakan Konfigurasi Paralelisme
Secara default, pipeline melakukan semua langkah yang tersedia untuk dijalankan secara paralel. Anda dapat mengontrol perilaku ini dengan menggunakan `ParallelismConfiguration` properti saat membuat atau memperbarui pipeline, serta saat memulai atau mencoba ulang eksekusi pipeline.
Konfigurasi paralelisme diterapkan per eksekusi. Misalnya, jika dua eksekusi dimulai, mereka masing-masing dapat menjalankan maksimum 50 langkah secara bersamaan, dengan total 100 langkah yang berjalan secara bersamaan. Juga, `ParallelismConfiguration` yang ditentukan saat memulai, mencoba kembali, atau memperbarui eksekusi lebih diutamakan daripada konfigurasi paralelisme yang ditentukan dalam pipeline.
**Example Membuat eksekusi pipeline dengan `ParallelismConfiguration`**
```
pipeline = Pipeline(
name="myPipeline",
steps=[step_process, step_train]
)
pipeline.create(role, parallelism_config={"MaxParallelExecutionSteps": 50})
```
# Manajemen Akses IAM
Bagian berikut menjelaskan persyaratan AWS Identity and Access Management (IAM) untuk Amazon SageMaker Pipelines. Untuk contoh bagaimana Anda dapat menerapkan izin ini, lihat[Prasyarat](define-pipeline.md#define-pipeline-prereq).
**Topics**
+ [Izin Peran Pipeline](#build-and-manage-role-permissions)
+ [Izin Langkah Pipeline](#build-and-manage-step-permissions)
+ [Konfigurasi CORS dengan bucket Amazon S3](#build-and-manage-cors-s3)
+ [Sesuaikan manajemen akses untuk pekerjaan Pipelines](#build-and-manage-step-permissions-prefix)
+ [Sesuaikan akses ke versi pipeline](#build-and-manage-step-permissions-version)
+ [Kebijakan Kontrol Layanan dengan Pipa](#build-and-manage-scp)
## Izin Peran Pipeline
Pipeline Anda memerlukan peran eksekusi pipeline IAM yang diteruskan ke Pipelines saat Anda membuat pipeline. Peran instans SageMaker AI yang Anda gunakan untuk membuat pipeline harus memiliki kebijakan dengan `iam:PassRole` izin yang menentukan peran eksekusi pipeline. Ini karena instans memerlukan izin untuk meneruskan peran eksekusi pipeline Anda ke layanan Pipelines untuk digunakan dalam membuat dan menjalankan pipeline. Untuk informasi selengkapnya tentang peran IAM, lihat Peran [IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
Peran eksekusi pipeline Anda memerlukan izin berikut:
+ Anda dapat menggunakan peran unik atau khusus untuk setiap langkah pekerjaan SageMaker AI di pipeline Anda (bukan peran eksekusi pipeline, yang digunakan secara default). Pastikan peran eksekusi pipeline Anda telah menambahkan kebijakan dengan `iam:PassRole` izin yang menentukan masing-masing peran ini.
+ `Create`dan `Describe` izin untuk masing-masing jenis pekerjaan di pipeline.
+ Izin Amazon S3 untuk menggunakan fungsi tersebut. `JsonGet` Anda mengontrol akses ke sumber daya Amazon S3 menggunakan kebijakan berbasis sumber daya dan kebijakan berbasis identitas. Kebijakan berbasis sumber daya diterapkan pada bucket Amazon S3 Anda dan memberikan akses Pipelines ke bucket. Kebijakan berbasis identitas memberi pipeline kemampuan untuk melakukan panggilan Amazon S3 dari akun Anda. [Untuk informasi selengkapnya tentang kebijakan berbasis sumber daya dan kebijakan berbasis identitas, lihat Kebijakan berbasis identitas dan kebijakan berbasis sumber daya.](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html)
```
{
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::/*",
"Effect": "Allow"
}
```
## Izin Langkah Pipeline
Pipelines mencakup langkah-langkah yang menjalankan pekerjaan SageMaker AI. Agar langkah pipeline dapat menjalankan pekerjaan ini, mereka memerlukan peran IAM di akun Anda yang menyediakan akses untuk sumber daya yang dibutuhkan. Peran ini diteruskan ke kepala layanan SageMaker AI oleh pipeline Anda. Untuk informasi selengkapnya tentang peran IAM, lihat Peran [IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
Secara default, setiap langkah mengambil peran eksekusi pipeline. Anda secara opsional dapat meneruskan peran yang berbeda ke salah satu langkah dalam pipeline Anda. Ini memastikan bahwa kode di setiap langkah tidak memiliki kemampuan untuk memengaruhi sumber daya yang digunakan dalam langkah lain kecuali ada hubungan langsung antara dua langkah yang ditentukan dalam definisi pipeline. Anda melewati peran ini saat mendefinisikan prosesor atau estimator untuk langkah Anda. Untuk contoh cara memasukkan peran ini dalam definisi ini, lihat dokumentasi [SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#using-estimators).
## Konfigurasi CORS dengan bucket Amazon S3
Untuk memastikan gambar Anda diimpor ke Pipelines dari bucket Amazon S3 dengan cara yang dapat diprediksi, konfigurasi CORS harus ditambahkan ke bucket Amazon S3 tempat gambar diimpor. Bagian ini memberikan petunjuk tentang cara menyetel konfigurasi CORS yang diperlukan ke bucket Amazon S3 Anda. XHTML yang `CORSConfiguration` diperlukan untuk Pipelines berbeda dari yang ada di[Persyaratan CORS untuk Data Gambar Input](sms-cors-update.md), jika tidak, Anda dapat menggunakan informasi di sana untuk mempelajari lebih lanjut tentang persyaratan CORS dengan bucket Amazon S3.
Gunakan kode konfigurasi CORS berikut untuk bucket Amazon S3 yang meng-host gambar Anda. Untuk petunjuk cara mengonfigurasi CORS, lihat [Mengonfigurasi berbagi sumber daya lintas asal (CORS) di Panduan Pengguna Layanan](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-cors-configuration.html) Penyimpanan Sederhana Amazon. Jika Anda menggunakan konsol Amazon S3 untuk menambahkan kebijakan ke bucket, Anda harus menggunakan format JSON.
**JSON**
```
[
{
"AllowedHeaders": [
"*"
],
"AllowedMethods": [
"PUT"
],
"AllowedOrigins": [
"*"
],
"ExposeHeaders": [
"Access-Control-Allow-Origin"
]
}
]
```
**XML-XM**
```
**PUTAccess-Control-Allow-Origin
```
GIF berikut menunjukkan petunjuk yang ditemukan dalam dokumentasi Amazon S3 untuk menambahkan kebijakan header CORS menggunakan konsol Amazon S3.
![\[Gif tentang cara menambahkan kebijakan header CORS menggunakan konsol Amazon S3.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/sms/gifs/cors-config.gif)
## Sesuaikan manajemen akses untuk pekerjaan Pipelines
Anda dapat menyesuaikan kebijakan IAM lebih lanjut sehingga anggota yang dipilih di organisasi Anda dapat menjalankan salah satu atau semua langkah pipeline. Misalnya, Anda dapat memberikan izin kepada pengguna tertentu untuk membuat pekerjaan pelatihan, dan grup pengguna lain izin untuk membuat pekerjaan pemrosesan, dan semua pengguna Anda mengizinkan untuk menjalankan langkah-langkah yang tersisa. Untuk menggunakan fitur ini, Anda memilih string kustom yang awalan nama pekerjaan Anda. Admin Anda menambahkan awalan yang diizinkan ARNs dengan awalan sementara ilmuwan data Anda menyertakan awalan ini dalam instantiasi pipeline. Karena kebijakan IAM untuk pengguna yang diizinkan berisi ARN pekerjaan dengan awalan yang ditentukan, pekerjaan berikutnya dari langkah pipeline Anda memiliki izin yang diperlukan untuk melanjutkan. Awalan Job tidak aktif secara default—Anda harus mengaktifkan opsi ini di kelas Anda untuk menggunakannya. `Pipeline`
Untuk pekerjaan dengan awalan dimatikan, nama pekerjaan diformat seperti yang ditunjukkan dan merupakan rangkaian bidang yang dijelaskan dalam tabel berikut:
`pipelines----`
| Bidang | Definisi |
| --- | --- |
| jaringan pipa | String statis selalu diawali. String ini mengidentifikasi layanan orkestrasi pipeline sebagai sumber pekerjaan. |
| ExecutionID | Buffer acak untuk instance pipeline yang sedang berjalan. |
| stepNamePrefix | Nama langkah yang ditentukan pengguna (diberikan dalam `name` argumen langkah pipeline), terbatas pada 20 karakter pertama. |
| EntityToken | Token acak untuk memastikan idempotensi entitas langkah. |
| FailureCount | Jumlah percobaan ulang saat ini berusaha menyelesaikan pekerjaan. |
Dalam hal ini, tidak ada awalan khusus yang ditambahkan ke nama pekerjaan, dan kebijakan IAM yang sesuai harus cocok dengan string ini.
Untuk pengguna yang mengaktifkan awalan pekerjaan, nama pekerjaan yang mendasarinya mengambil formulir berikut, dengan awalan kustom ditentukan sebagai: `MyBaseJobName`
**-**-**-**
Awalan kustom menggantikan `pipelines` string statis untuk membantu Anda mempersempit pilihan pengguna yang dapat menjalankan pekerjaan SageMaker AI sebagai bagian dari pipeline.
**Pembatasan panjang awalan**
Nama pekerjaan memiliki batasan panjang internal khusus untuk masing-masing langkah pipa. Kendala ini juga membatasi panjang awalan yang diizinkan. Persyaratan panjang awalan adalah sebagai berikut:
| Langkah pipa | Panjang awalan |
| --- | --- |
| `[TrainingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#trainingstep)`, `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)`, `[TransformStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#transformstep)`, `[ProcessingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#processingstep)`, `[ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)`, `[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)`, `[RegisterModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)` | 38 |
| `[TuningStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#tuningstep)`, `[AutoML](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#automlstep)` | 6 |
### Terapkan awalan pekerjaan ke kebijakan IAM
Admin Anda membuat kebijakan IAM yang memungkinkan pengguna awalan tertentu untuk membuat pekerjaan. Contoh kebijakan berikut memungkinkan ilmuwan data untuk membuat pekerjaan pelatihan jika mereka menggunakan `MyBaseJobName` awalan.
```
{
"Action": "sagemaker:CreateTrainingJob",
"Effect": "Allow",
"Resource": [
"arn:aws:sagemaker:region:account-id:*/MyBaseJobName-*"
]
}
```
### Terapkan awalan pekerjaan ke instantiasi pipeline
Anda menentukan awalan Anda dengan `*base_job_name` argumen kelas instance pekerjaan.
**catatan**
Anda meneruskan awalan pekerjaan Anda dengan `*base_job_name` argumen ke instance pekerjaan sebelum membuat langkah pipeline. Contoh pekerjaan ini berisi informasi yang diperlukan agar pekerjaan dapat dijalankan sebagai langkah dalam pipeline. Argumen ini bervariasi tergantung pada instance pekerjaan yang digunakan. Daftar berikut menunjukkan argumen mana yang akan digunakan untuk setiap jenis langkah pipeline:
`base_job_name`untuk kelas `[Estimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html)` (`[TrainingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#trainingstep)`), `[Processor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html)` (`[ProcessingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#processingstep)`), dan `[AutoML](https://sagemaker.readthedocs.io/en/stable/api/training/automl.html)` (`[AutoMLStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#automlstep)`)
`tuning_base_job_name`untuk `[Tuner](https://sagemaker.readthedocs.io/en/stable/api/training/tuner.html)` kelas (`[TuningStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#tuningstep)`)
`transform_base_job_name`untuk `[Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html)` kelas (`[TransformStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#transformstep)`)
`base_job_name``[CheckJobConfig](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#checkjobconfig)`untuk kelas `[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)` (Quality Check) dan `[ClarifyCheckstep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)` (Clarify Check)
Untuk `[Model](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html)` kelas, argumen yang digunakan tergantung pada apakah Anda menjalankan `create` atau `register` pada model Anda sebelum meneruskan hasilnya ke `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)`
Jika Anda memanggil`create`, awalan kustom berasal dari `name` argumen saat Anda membuat model Anda (yaitu,) `Model(name=)`
Jika Anda menelepon`register`, awalan kustom berasal dari `model_package_name` argumen panggilan Anda ke `register` (yaitu,`my_model.register(model_package_name=)`)
Contoh berikut menunjukkan cara menentukan awalan untuk instance pekerjaan pelatihan baru.
```
# Create a job instance
xgb_train = Estimator(
image_uri=image_uri,
instance_type="ml.m5.xlarge",
instance_count=1,
output_path=model_path,
role=role,
subnets=["subnet-0ab12c34567de89f0"],
base_job_name="MyBaseJobName"
security_group_ids=["sg-1a2bbcc3bd4444e55"],
tags = [ ... ]
encrypt_inter_container_traffic=True,
)
# Attach your job instance to a pipeline step
step_train = TrainingStep(
name="TestTrainingJob",
estimator=xgb_train,
inputs={
"train": TrainingInput(...),
"validation": TrainingInput(...)
}
)
```
Awalan Job tidak aktif secara default. Untuk memilih fitur ini, gunakan `use_custom_job_prefix` opsi `PipelineDefinitionConfig` seperti yang ditunjukkan pada cuplikan berikut:
```
from sagemaker.workflow.pipeline_definition_config import PipelineDefinitionConfig
# Create a definition configuration and toggle on custom prefixing
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=True);
# Create a pipeline with a custom prefix
pipeline = Pipeline(
name="MyJobPrefixedPipeline",
parameters=[...]
steps=[...]
pipeline_definition_config=definition_config
)
```
Buat dan jalankan pipeline Anda. Contoh berikut membuat dan menjalankan pipeline, dan juga menunjukkan bagaimana Anda dapat mematikan awalan pekerjaan dan menjalankan kembali pipeline Anda.
```
pipeline.create(role_arn=sagemaker.get_execution_role())
# Optionally, call definition() to confirm your prefixed job names are in the built JSON
pipeline.definition()
pipeline.start()
# To run a pipeline without custom-prefixes, toggle off use_custom_job_prefix, update the pipeline
# via upsert() or update(), and start a new run
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=False)
pipeline.pipeline_definition_config = definition_config
pipeline.update()
execution = pipeline.start()
```
Demikian pula, Anda dapat mengaktifkan fitur untuk pipeline yang ada dan memulai proses baru yang menggunakan awalan pekerjaan.
```
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=True)
pipeline.pipeline_definition_config = definition_config
pipeline.update()
execution = pipeline.start()
```
Terakhir, Anda dapat melihat pekerjaan yang diawali khusus dengan memanggil eksekusi `list_steps` pipeline.
```
steps = execution.list_steps()
prefixed_training_job_name = steps['PipelineExecutionSteps'][0]['Metadata']['TrainingJob']['Arn']
```
## Sesuaikan akses ke versi pipeline
Anda dapat memberikan akses khusus ke versi Amazon SageMaker Pipelines tertentu dengan menggunakan kunci `sagemaker:PipelineVersionId` kondisi. Misalnya, kebijakan di bawah ini memberikan akses untuk memulai eksekusi atau memperbarui versi pipeline hanya untuk ID versi 6 ke atas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "AllowStartPipelineExecution",
"Effect": "Allow",
"Action": [
"sagemaker:StartPipelineExecution",
"sagemaker:UpdatePipelineVersion"
],
"Resource": "*",
"Condition": {
"NumericGreaterThanEquals": {
"sagemaker:PipelineVersionId": 6
}
}
}
}
```
------
Untuk informasi selengkapnya tentang kunci kondisi yang didukung, lihat [Kunci kondisi untuk Amazon SageMaker AI](https://docs.aws.amazon.com//service-authorization/latest/reference/list_amazonsagemaker.html#amazonsagemaker-policy-keys).
## Kebijakan Kontrol Layanan dengan Pipa
Kebijakan kontrol layanan (SCPs) adalah jenis kebijakan organisasi yang dapat Anda gunakan untuk mengelola izin di organisasi Anda. SCPs menawarkan kontrol pusat atas izin maksimum yang tersedia untuk semua akun di organisasi Anda. Dengan menggunakan Pipelines dalam organisasi Anda, Anda dapat memastikan bahwa ilmuwan data mengelola eksekusi pipeline Anda tanpa harus berinteraksi dengan konsol. AWS
Jika Anda menggunakan VPC dengan SCP yang membatasi akses ke Amazon S3, Anda perlu mengambil langkah-langkah untuk mengizinkan pipeline mengakses sumber daya Amazon S3 lainnya.
Untuk mengizinkan Pipelines mengakses Amazon S3 di luar VPC Anda dengan fungsi `JsonGet` tersebut, perbarui SCP organisasi Anda untuk memastikan bahwa peran yang menggunakan Pipelines dapat mengakses Amazon S3. Untuk melakukan ini, buat pengecualian untuk peran yang digunakan oleh pelaksana Pipelines melalui peran eksekusi pipeline menggunakan tag utama dan kunci kondisi.
**Untuk mengizinkan Pipelines mengakses Amazon S3 di luar VPC Anda**
1. Buat tag unik untuk peran eksekusi pipeline Anda mengikuti langkah-langkah dalam [Menandai pengguna dan peran IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html).
1. Berikan pengecualian di SCP Anda menggunakan kunci `Aws:PrincipalTag IAM` kondisi untuk tag yang Anda buat. Untuk informasi selengkapnya, lihat [Membuat, memperbarui, dan menghapus kebijakan kontrol layanan](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_create.html).
# Menyiapkan dukungan lintas akun untuk Pipelines
Dukungan lintas akun untuk Amazon SageMaker Pipelines memungkinkan Anda berkolaborasi dalam pipeline pembelajaran mesin dengan tim atau organisasi lain yang beroperasi di akun berbeda. AWS Dengan menyiapkan berbagi pipeline lintas akun, Anda dapat memberikan akses terkontrol ke pipeline, mengizinkan akun lain untuk melihat detail pipeline, memicu eksekusi, dan memantau proses. Topik berikut mencakup cara mengatur berbagi pipeline lintas akun, berbagai kebijakan izin yang tersedia untuk sumber daya bersama, dan cara mengakses dan berinteraksi dengan entitas pipeline bersama melalui panggilan API langsung ke SageMaker AI.
## Siapkan berbagi saluran lintas akun
SageMaker AI menggunakan [AWS Resource Access Manager](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html) (AWS RAM) untuk membantu Anda berbagi entitas pipeline dengan aman di seluruh akun.
### Buat berbagi sumber daya
1. Pilih **Buat berbagi sumber daya** melalui [AWS RAM konsol](https://console.aws.amazon.com/ram/home).
1. Saat menentukan detail berbagi sumber daya, pilih jenis sumber daya Pipelines dan pilih satu atau beberapa saluran pipa yang ingin Anda bagikan. Saat Anda berbagi pipeline dengan akun lain, semua eksekusinya juga dibagikan secara implisit.
1. Kaitkan izin dengan pembagian sumber daya Anda. Pilih kebijakan izin hanya-baca default atau kebijakan izin eksekusi pipeline yang diperluas. Untuk informasi selengkapnya, lihat [Kebijakan izin untuk sumber daya Pipelines](#build-and-manage-xaccount-permissions).
**catatan**
Jika Anda memilih kebijakan eksekusi pipeline yang diperluas, perhatikan bahwa perintah start, stop, dan retry yang dipanggil oleh akun bersama menggunakan sumber daya di AWS akun yang berbagi pipeline.
1. Gunakan AWS akun IDs untuk menentukan akun yang ingin Anda berikan akses ke sumber daya bersama Anda.
1. Tinjau konfigurasi berbagi sumber daya Anda dan pilih **Buat berbagi sumber daya**. Mungkin diperlukan beberapa menit untuk pembagian sumber daya dan asosiasi utama untuk menyelesaikannya.
Untuk informasi selengkapnya, lihat [Berbagi AWS sumber daya Anda](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-sharing.html) di *Panduan Pengguna AWS Resource Access Manager*.
### Dapatkan tanggapan atas undangan berbagi sumber daya Anda
Setelah pembagian sumber daya dan asosiasi utama ditetapkan, AWS akun yang ditentukan menerima undangan untuk bergabung dengan pembagian sumber daya. AWS Akun harus menerima undangan untuk mendapatkan akses ke sumber daya bersama.
Untuk informasi selengkapnya tentang menerima undangan berbagi sumber daya AWS RAM, lihat [Menggunakan AWS sumber daya bersama](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-shared.html) di *Panduan Pengguna AWS Resource Access Manager*.
## Kebijakan izin untuk sumber daya Pipelines
Saat membuat pembagian sumber daya, pilih salah satu dari dua kebijakan izin yang didukung untuk dikaitkan dengan jenis sumber daya saluran SageMaker AI. Kedua kebijakan tersebut memberikan akses ke saluran pipa yang dipilih dan semua pelaksanaannya.
### Izin hanya-baca default
`AWSRAMDefaultPermissionSageMakerPipeline`Kebijakan ini memungkinkan tindakan hanya-baca berikut:
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:Search"
```
### Izin eksekusi pipa yang diperluas
`AWSRAMPermissionSageMakerPipelineAllowExecution`Kebijakan ini mencakup semua izin hanya-baca dari kebijakan default dan juga memungkinkan akun bersama untuk memulai, menghentikan, dan mencoba lagi eksekusi pipeline.
**catatan**
Perhatikan penggunaan AWS sumber daya saat menggunakan kebijakan izin eksekusi pipeline yang diperluas. Dengan kebijakan ini, akun bersama diizinkan untuk memulai, menghentikan, dan mencoba lagi eksekusi pipeline. Sumber daya apa pun yang digunakan untuk eksekusi pipa bersama dikonsumsi oleh akun pemilik.
Kebijakan izin eksekusi pipeline yang diperluas memungkinkan tindakan berikut:
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:StartPipelineExecution"
"sagemaker:StopPipelineExecution"
"sagemaker:RetryPipelineExecution"
"sagemaker:Search"
```
## Akses entitas pipeline bersama melalui panggilan API langsung
Setelah berbagi pipeline lintas akun disiapkan, Anda dapat memanggil tindakan SageMaker API berikut menggunakan ARN pipeline:
**catatan**
Anda hanya dapat memanggil perintah API jika perintah tersebut disertakan dalam izin yang terkait dengan pembagian sumber daya Anda. Jika Anda memilih `AWSRAMPermissionSageMakerPipelineAllowExecution` kebijakan, perintah mulai, berhenti, dan coba lagi menggunakan sumber daya di AWS akun yang membagikan pipeline.
+ [DescribePipeline](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipeline.html)
+ [DescribePipelineDefinitionForExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipelineDefinitionForExecution.html)
+ [DescribePipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipelineExecution.html)
+ [ListPipelineExecutions](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineExecutions.html)
+ [ListPipelineExecutionSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineExecutionSteps.html)
+ [ListPipelineParametersForExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineParametersForExecution.html)
+ [StartPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StartPipelineExecution.html)
+ [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html)
+ [RetryPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RetryPipelineExecution.html)
# Parameter pipa
Anda dapat memasukkan variabel ke dalam definisi pipeline Anda menggunakan parameter. Anda dapat mereferensikan parameter yang Anda tentukan di seluruh definisi pipeline Anda. Parameter memiliki nilai default, yang dapat Anda timpa dengan menentukan nilai parameter saat memulai eksekusi pipeline. Nilai default harus berupa instance yang cocok dengan tipe parameter. Semua parameter yang digunakan dalam definisi langkah harus didefinisikan dalam definisi pipeline Anda. Topik ini menjelaskan parameter yang dapat Anda tentukan dan cara menerapkannya.
Amazon SageMaker Pipelines mendukung jenis parameter berikut:
+ `ParameterString`— Mewakili parameter string.
+ `ParameterInteger`— Mewakili parameter integer.
+ `ParameterFloat`— Mewakili parameter float.
+ `ParameterBoolean`— Mewakili tipe Boolean Python.
Parameter mengambil format berikut:
```
= (
name="",
default_value=
)
```
Contoh berikut menunjukkan implementasi parameter sampel.
```
from sagemaker.workflow.parameters import (
ParameterInteger,
ParameterString,
ParameterFloat,
ParameterBoolean
)
processing_instance_count = ParameterInteger(
name="ProcessingInstanceCount",
default_value=1
)
```
Anda meneruskan parameter saat membuat pipeline Anda seperti yang ditunjukkan pada contoh berikut.
```
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_count
],
steps=[step_process]
)
```
Anda juga dapat meneruskan nilai parameter yang berbeda dari nilai default ke eksekusi pipeline, seperti yang ditunjukkan pada contoh berikut.
```
execution = pipeline.start(
parameters=dict(
ProcessingInstanceCount="2",
ModelApprovalStatus="Approved"
)
)
```
Anda dapat memanipulasi parameter dengan fungsi SageMaker Python SDK seperti. `[ sagemaker.workflow.functions.Join](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.functions.Join)` Untuk informasi selengkapnya tentang parameter, lihat [Parameter SageMaker Pipelines](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#parameters).
Untuk batasan Parameter Pipelines yang diketahui, lihat *[Batasan - Parameterisasi](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#parameterization)* di Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable) SDK.
# 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).
# Lift-and-shift Kode Python dengan dekorator @step
`@step`Dekorator adalah fitur yang mengubah kode machine learning (ML) lokal Anda menjadi satu atau beberapa langkah pipeline. Anda dapat menulis fungsi ML Anda seperti yang Anda lakukan untuk setiap proyek ML. Setelah diuji secara lokal atau sebagai pekerjaan pelatihan menggunakan `@remote` dekorator, Anda dapat mengonversi fungsi menjadi langkah pipa SageMaker AI dengan menambahkan dekorator. `@step` Anda kemudian dapat meneruskan output dari panggilan fungsi `@step` -decorated sebagai langkah ke Pipelines untuk membuat dan menjalankan pipeline. Anda dapat menghubungkan serangkaian fungsi dengan `@step` dekorator untuk membuat pipa grafik asiklik terarah (DAG) multi-langkah juga.
Pengaturan untuk menggunakan `@step` dekorator sama dengan pengaturan untuk menggunakan `@remote` dekorator. Anda dapat merujuk ke dokumentasi fungsi jarak jauh untuk detail tentang cara [mengatur lingkungan](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator.html#train-remote-decorator-env) dan [menggunakan file konfigurasi](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-config.html) untuk mengatur default. Untuk informasi selengkapnya tentang `@step` dekorator, lihat [sagemaker.workflow.function\$1step.step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.step).
Untuk melihat contoh buku catatan yang menunjukkan penggunaan `@step` dekorator, lihat contoh notebook [@step decorator](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-pipelines/step-decorator).
Bagian berikut menjelaskan bagaimana Anda dapat membuat anotasi kode HTML lokal Anda dengan `@step` dekorator untuk membuat langkah, membuat dan menjalankan pipeline menggunakan langkah, dan menyesuaikan pengalaman untuk kasus penggunaan Anda.
**Topics**
+ [Buat pipa dengan fungsi yang `@step` didekorasi](pipelines-step-decorator-create-pipeline.md)
+ [Jalankan pipa](pipelines-step-decorator-run-pipeline.md)
+ [Konfigurasikan pipeline Anda](pipelines-step-decorator-cfg-pipeline.md)
+ [Praktik Terbaik](pipelines-step-decorator-best.md)
+ [Batasan](pipelines-step-decorator-limit.md)
# Buat pipa dengan fungsi yang `@step` didekorasi
Anda dapat membuat pipeline dengan mengubah fungsi Python menjadi langkah-langkah pipeline menggunakan dekorator, membuat dependensi `@step` di antara fungsi-fungsi tersebut untuk membuat grafik pipeline (atau grafik asiklik terarah (DAG)), dan meneruskan simpul daun grafik itu sebagai daftar langkah ke pipeline. Bagian berikut menjelaskan prosedur ini secara rinci dengan contoh.
**Topics**
+ [Ubah fungsi menjadi langkah](#pipelines-step-decorator-run-pipeline-convert)
+ [Buat dependensi di antara langkah-langkah](#pipelines-step-decorator-run-pipeline-link)
+ [Gunakan `ConditionStep` dengan langkah-langkah `@step` yang didekorasi](#pipelines-step-decorator-condition)
+ [Tentukan pipeline menggunakan `DelayedReturn` output dari langkah-langkah](#pipelines-step-define-delayed)
+ [Membuat jalur](#pipelines-step-decorator-pipeline-create)
## Ubah fungsi menjadi langkah
Untuk membuat langkah menggunakan `@step` dekorator, beri anotasi fungsi dengan. `@step` Contoh berikut menunjukkan fungsi `@step` -decorated yang memproses data sebelumnya.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
step_process_result = preprocess(raw_data)
```
Saat Anda menjalankan fungsi `@step` -decorated, SageMaker AI mengembalikan `DelayedReturn` instance alih-alih menjalankan fungsi. Sebuah `DelayedReturn` instance adalah proxy untuk pengembalian aktual dari fungsi itu. `DelayedReturn`Instance dapat diteruskan ke fungsi lain sebagai argumen atau langsung ke instance pipeline sebagai langkah. Untuk informasi tentang `DelayedReturn` kelas, lihat [sagemaker.workflow.function\$1step. DelayedReturn](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.DelayedReturn).
## Buat dependensi di antara langkah-langkah
Saat Anda membuat dependensi di antara dua langkah, Anda membuat koneksi antara langkah-langkah dalam grafik pipeline Anda. Bagian berikut memperkenalkan beberapa cara Anda dapat membuat ketergantungan di antara langkah-langkah pipeline Anda.
### Dependensi data melalui argumen masukan
Melewati `DelayedReturn` output dari satu fungsi sebagai input ke fungsi lain secara otomatis menciptakan ketergantungan data dalam pipeline DAG. Dalam contoh berikut, meneruskan `DelayedReturn` output fungsi ke `preprocess` `train` fungsi menciptakan ketergantungan antara `preprocess` dan`train`.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
@step
def train(training_data):
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train(step_process_result)
```
Contoh sebelumnya mendefinisikan fungsi pelatihan yang dihiasi dengan`@step`. Ketika fungsi ini dipanggil, ia menerima `DelayedReturn` output dari langkah pipa preprocessing sebagai input. Memanggil fungsi pelatihan mengembalikan `DelayedReturn` instance lain. Instance ini menyimpan informasi tentang semua langkah sebelumnya yang didefinisikan dalam fungsi itu (yaitu, `preprocess` langkah dalam contoh ini) yang membentuk saluran DAG.
Pada contoh sebelumnya, `preprocess` fungsi mengembalikan nilai tunggal. Untuk jenis pengembalian yang lebih kompleks seperti daftar atau tupel, lihat. [Batasan](pipelines-step-decorator-limit.md)
### Tentukan dependensi khusus
Pada contoh sebelumnya, `train` fungsi menerima `DelayedReturn` output `preprocess` dan menciptakan ketergantungan. Jika Anda ingin mendefinisikan ketergantungan secara eksplisit tanpa melewatkan output langkah sebelumnya, gunakan `add_depends_on` fungsi dengan langkah. Anda dapat menggunakan `get_step()` fungsi untuk mengambil langkah yang mendasari dari `DelayedReturn` instance-nya, dan kemudian memanggil `add_depends_on` \$1on dengan ketergantungan sebagai input. Untuk melihat definisi `get_step()` fungsi, lihat [sagemaker.workflow.step\$1outputs.get\$1step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_outputs.get_step). Contoh berikut menunjukkan cara membuat ketergantungan antara `preprocess` dan `train` menggunakan `get_step()` dan`add_depends_on()`.
```
from sagemaker.workflow.step_outputs import get_step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
processed_data = ..
return s3.upload(processed_data)
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train()
get_step(step_train_result).add_depends_on([step_process_result])
```
### Meneruskan data ke dan dari fungsi `@step` yang didekorasi ke langkah pipa tradisional
Anda dapat membuat pipa yang mencakup langkah yang `@step` didekorasi dan langkah pipa tradisional dan meneruskan data di antara mereka. Misalnya, Anda dapat menggunakan `ProcessingStep` untuk memproses data dan meneruskan hasilnya ke fungsi pelatihan `@step` yang didekorasi. Dalam contoh berikut, langkah pelatihan yang `@step` didekorasi mereferensikan output dari langkah pemrosesan.
```
# Define processing step
from sagemaker.sklearn.processing import SKLearnProcessor
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
sklearn_processor = SKLearnProcessor(
framework_version='1.2-1',
role='arn:aws:iam::123456789012:role/SagemakerExecutionRole',
instance_type='ml.m5.large',
instance_count='1',
)
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")
]
process_step = ProcessingStep(
name="MyProcessStep",
step_args=sklearn_processor.run(inputs=inputs, outputs=outputs,code='preprocessing.py'),
)
```
```
# Define a @step-decorated train step which references the
# output of a processing step
@step
def train(train_data_path, test_data_path):
...
return trained_model
step_train_result = train(
process_step.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
process_step.properties.ProcessingOutputConfig.Outputs["test"].S3Output.S3Uri,
)
```
## Gunakan `ConditionStep` dengan langkah-langkah `@step` yang didekorasi
Pipelines mendukung `ConditionStep` kelas yang mengevaluasi hasil dari langkah-langkah sebelumnya untuk memutuskan tindakan apa yang harus diambil dalam pipeline. Anda dapat menggunakan `ConditionStep` dengan langkah `@step` yang didekorasi juga. Untuk menggunakan output dari setiap langkah `@step` yang didekorasi dengan`ConditionStep`, masukkan output dari langkah itu sebagai argumen untuk`ConditionStep`. Dalam contoh berikut, langkah kondisi menerima output dari langkah evaluasi model `@step` yang didekorasi.
```
# Define steps
@step(name="evaluate")
def evaluate_model():
# code to evaluate the model
return {
"rmse":rmse_value
}
@step(name="register")
def register_model():
# code to register the model
...
```
```
# Define ConditionStep
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.conditions import ConditionGreaterThanOrEqualTo
from sagemaker.workflow.fail_step import FailStep
conditionally_register = ConditionStep(
name="conditional_register",
conditions=[
ConditionGreaterThanOrEqualTo(
# Output of the evaluate step must be json serializable
left=evaluate_model()["rmse"], #
right=5,
)
],
if_steps=[FailStep(name="Fail", error_message="Model performance is not good enough")],
else_steps=[register_model()],
)
```
## Tentukan pipeline menggunakan `DelayedReturn` output dari langkah-langkah
Anda mendefinisikan pipeline dengan cara yang sama apakah Anda menggunakan `@step` dekorator atau tidak. Ketika Anda meneruskan `DelayedReturn` instance ke pipeline Anda, Anda tidak perlu melewati daftar lengkap langkah-langkah untuk membangun pipeline. SDK secara otomatis menyimpulkan langkah-langkah sebelumnya berdasarkan dependensi yang Anda tetapkan. Semua langkah sebelumnya dari `Step` objek yang Anda lewatkan ke pipa atau `DelayedReturn` objek termasuk dalam grafik pipa. Dalam contoh berikut, pipa menerima `DelayedReturn` objek untuk `train` fungsi tersebut. SageMaker AI menambahkan `preprocess` langkah, sebagai langkah sebelumnya`train`, ke grafik pipeline.
```
from sagemaker.workflow.pipeline import Pipeline
pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=,
)
```
Jika tidak ada data atau dependensi khusus di antara langkah-langkah dan Anda menjalankan beberapa langkah secara paralel, grafik pipeline memiliki lebih dari satu simpul daun. Berikan semua node daun ini dalam daftar ke `steps` argumen dalam definisi pipeline Anda, seperti yang ditunjukkan pada contoh berikut:
```
@step
def process1():
...
return data
@step
def process2():
...
return data
step_process1_result = process1()
step_process2_result = process2()
pipeline = Pipeline(
name="",
steps=[step_process1_result, step_process2_result],
sagemaker_session=sagemaker-session,
)
```
Saat pipeline berjalan, kedua langkah berjalan secara paralel.
Anda hanya meneruskan simpul daun grafik ke pipeline karena simpul daun berisi informasi tentang semua langkah sebelumnya yang ditentukan melalui data atau dependensi khusus. Saat mengkompilasi pipeline, SageMaker AI juga menyimpulkan semua langkah selanjutnya yang membentuk grafik pipa dan menambahkan masing-masing sebagai langkah terpisah ke pipa.
## Membuat jalur
Buat pipeline dengan memanggil`pipeline.create()`, seperti yang ditunjukkan pada cuplikan berikut. Untuk detailnya`create()`, lihat [SageMaker.Workflow.Pipeline.Pipeline.Create](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.create).
```
role = "pipeline-role"
pipeline.create(role)
```
Saat Anda menelepon`pipeline.create()`, SageMaker AI mengkompilasi semua langkah yang didefinisikan sebagai bagian dari instance pipeline. SageMaker AI mengunggah fungsi serial, argumen, dan semua artefak terkait langkah lainnya ke Amazon S3.
Data berada di bucket S3 sesuai dengan struktur berikut:
```
s3_root_uri/
pipeline_name/
sm_rf_user_ws/
workspace.zip # archive of the current working directory (workdir)
step_name/
timestamp/
arguments/ # serialized function arguments
function/ # serialized function
pre_train_dependencies/ # any dependencies and pre_execution scripts provided for the step
execution_id/
step_name/
results # returned output from the serialized function including the model
```
`s3_root_uri`didefinisikan dalam file konfigurasi SageMaker AI dan berlaku untuk seluruh pipeline. Jika tidak ditentukan, bucket SageMaker AI default digunakan.
**catatan**
Setiap kali SageMaker AI mengkompilasi pipeline, SageMaker AI menyimpan fungsi, argumen, dan dependensi serial langkah-langkah dalam folder yang diberi cap waktu dengan waktu saat ini. Ini terjadi setiap kali Anda berlari`pipeline.create()`,`pipeline.update()`, `pipeline.upsert()` atau`pipeline.definition()`.
# Jalankan pipa
Halaman berikut menjelaskan cara menjalankan pipeline dengan Amazon SageMaker Pipelines, baik dengan sumber daya SageMaker AI atau lokal.
Mulai proses pipeline baru dengan `pipeline.start()` fungsi seperti yang Anda lakukan untuk menjalankan pipeline SageMaker AI tradisional. Untuk informasi tentang `start()` fungsi, lihat [SageMaker.workflow.pipeline.pipeline.pipeline.start](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.start).
**catatan**
Langkah yang didefinisikan menggunakan `@step` dekorator berjalan sebagai pekerjaan pelatihan. Karena itu, waspadai batas-batas berikut:
Batas instans dan batas pekerjaan pelatihan di akun Anda. Perbarui batas Anda untuk menghindari masalah pembatasan atau batas sumber daya.
Biaya moneter yang terkait dengan setiap langkah pelatihan dalam pipa. Untuk detail selengkapnya, lihat [ SageMaker Harga Amazon](https://aws.amazon.com/sagemaker/pricing/).
## Mengambil hasil dari pipeline yang dijalankan secara lokal
Untuk melihat hasil dari setiap langkah dari pipeline run, gunakan [execution.result ()](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline._PipelineExecution.result ), seperti yang ditunjukkan pada cuplikan berikut:
```
execution = pipeline.start()
execution.result(step_name="train")
```
**catatan**
Pipelines tidak mendukung `execution.result()` dalam mode lokal.
Anda hanya dapat mengambil hasil untuk satu langkah pada satu waktu. Jika nama langkah dihasilkan oleh SageMaker AI, Anda dapat mengambil nama langkah dengan memanggil `list_steps` sebagai berikut:
```
execution.list_step()
```
## Jalankan pipeline secara lokal
Anda dapat menjalankan pipa dengan langkah-langkah yang `@step` didekorasi secara lokal seperti yang Anda lakukan untuk langkah-langkah pipa tradisional. Untuk detail tentang proses pipeline mode lokal, lihat[Jalankan saluran pipa menggunakan mode lokal](pipelines-local-mode.md). Untuk menggunakan mode lokal, berikan definisi pipeline sebagai `LocalPipelineSession` pengganti a`SageMakerSession`, seperti yang ditunjukkan pada contoh berikut:
```
from sagemaker.workflow.function_step import step
from sagemaker.workflow.pipeline import Pipeline
from sagemaker.workflow.pipeline_context import LocalPipelineSession
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_train_result = train()
local_pipeline_session = LocalPipelineSession()
local_pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=local_pipeline_session # needed for local mode
)
local_pipeline.create(role_arn="role_arn")
# pipeline runs locally
execution = local_pipeline.start()
```
# Konfigurasikan pipeline Anda
Anda disarankan untuk menggunakan file konfigurasi SageMaker AI untuk mengatur default untuk pipeline. Untuk informasi tentang file konfigurasi SageMaker AI, lihat [Mengonfigurasi dan menggunakan default dengan Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#configuring-and-using-defaults-with-the-sagemaker-python-sdk). SageMaker Konfigurasi apa pun yang ditambahkan ke file konfigurasi berlaku untuk semua langkah dalam pipeline. Jika Anda ingin mengganti opsi untuk salah satu langkah, berikan nilai baru dalam argumen `@step` dekorator. Topik berikut menjelaskan cara menyiapkan file konfigurasi.
Konfigurasi `@step` dekorator dalam file konfigurasi identik dengan konfigurasi `@remote` dekorator. Untuk menyiapkan ARN peran pipeline dan tag pipeline di file konfigurasi, gunakan `Pipeline` bagian yang ditunjukkan dalam cuplikan berikut:
```
SchemaVersion: '1.0'
SageMaker:
Pipeline:
RoleArn: 'arn:aws:iam::555555555555:role/IMRole'
Tags:
- Key: 'tag_key'
Value: 'tag_value'
```
Untuk sebagian besar default yang dapat Anda atur dalam file konfigurasi, Anda juga dapat mengganti dengan meneruskan nilai baru ke dekorator. `@step` Misalnya, Anda dapat mengganti jenis instance yang disetel dalam file konfigurasi untuk langkah preprocessing Anda, seperti yang ditunjukkan pada contoh berikut:
```
@step(instance_type="ml.m5.large")
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
```
Beberapa argumen bukan bagian dari daftar parameter `@step` dekorator — ini dapat dikonfigurasi untuk seluruh pipeline hanya melalui file konfigurasi SageMaker AI. Mereka terdaftar sebagai berikut:
+ `sagemaker_session`(`sagemaker.session.Session`): Sesi SageMaker AI yang mendasari panggilan layanan SageMaker AI mendelegasikan. Jika tidak ditentukan, sesi dibuat menggunakan konfigurasi default sebagai berikut:
```
SageMaker:
PythonSDK:
Modules:
Session:
DefaultS3Bucket: 'default_s3_bucket'
DefaultS3ObjectKeyPrefix: 'key_prefix'
```
+ `custom_file_filter`(`CustomFileFilter)`: `CustomFileFilter` Objek yang menentukan direktori dan file lokal untuk disertakan dalam langkah pipeline. Jika tidak ditentukan, nilai ini default ke. `None` `custom_file_filter`Agar berlaku, Anda harus mengatur `IncludeLocalWorkdir` ke`True`. Contoh berikut menunjukkan konfigurasi yang mengabaikan semua file notebook, dan file dan direktori bernama. `data`
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
IncludeLocalWorkDir: true
CustomFileFilter:
IgnoreNamePatterns: # files or directories to ignore
- "*.ipynb" # all notebook files
- "data" # folder or file named "data"
```
Untuk detail selengkapnya tentang cara menggunakannya `IncludeLocalWorkdir``CustomFileFilter`, lihat[Menggunakan kode modular dengan dekorator @remote](train-remote-decorator-modular.md).
+ `s3_root_uri (str)`: Folder root Amazon S3 tempat SageMaker AI mengunggah arsip kode dan data. Jika tidak ditentukan, bucket SageMaker AI default digunakan.
+ `s3_kms_key (str)`: Kunci yang digunakan untuk mengenkripsi data input dan output. Anda hanya dapat mengonfigurasi argumen ini di file konfigurasi SageMaker AI dan argumen tersebut berlaku untuk semua langkah yang ditentukan dalam pipeline. Jika tidak ditentukan, nilai default ke. `None` Lihat cuplikan berikut untuk contoh konfigurasi kunci S3 KMS:
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
S3KmsKeyId: 's3kmskeyid'
S3RootUri: 's3://amzn-s3-demo-bucket/my-project
```
# Praktik Terbaik
Bagian berikut menyarankan praktik terbaik untuk diikuti ketika Anda menggunakan `@step` dekorator untuk langkah-langkah pipeline Anda.
## Gunakan kolam hangat
Untuk langkah pipa yang lebih cepat berjalan, gunakan fungsionalitas penyatuan hangat yang disediakan untuk pekerjaan pelatihan. Anda dapat mengaktifkan fungsionalitas kolam hangat dengan memberikan `keep_alive_period_in_seconds` argumen kepada `@step` dekorator seperti yang ditunjukkan dalam cuplikan berikut:
```
@step(
keep_alive_period_in_seconds=900
)
```
Untuk informasi lebih lanjut tentang kolam hangat, lihat[SageMaker Kolam Hangat yang Dikelola AI](train-warm-pools.md).
## Struktur direktori Anda
Anda disarankan untuk menggunakan modul kode saat menggunakan `@step` dekorator. Letakkan `pipeline.py` modul, di mana Anda menjalankan fungsi langkah dan menentukan pipeline, di root ruang kerja. Struktur yang direkomendasikan ditunjukkan sebagai berikut:
```
.
├── config.yaml # the configuration file that define the infra settings
├── requirements.txt # dependencies
├── pipeline.py # invoke @step-decorated functions and define the pipeline here
├── steps/
| ├── processing.py
| ├── train.py
├── data/
├── test/
```
# Batasan
Bagian berikut menguraikan batasan yang harus Anda waspadai ketika Anda menggunakan `@step` dekorator untuk langkah-langkah pipa Anda.
## Keterbatasan argumen fungsi
Saat Anda meneruskan argumen input ke fungsi `@step` -decorated, batasan berikut berlaku:
+ Anda dapat meneruskan`DelayedReturn`, `Properties` (langkah dari jenis lain),`Parameter`, dan `ExecutionVariable` objek ke fungsi `@step` -decorated sebagai argumen. Tapi fungsi `@step` yang didekorasi tidak mendukung `JsonGet` dan `Join` objek sebagai argumen.
+ Anda tidak dapat langsung mengakses variabel pipeline dari suatu `@step` fungsi. Contoh berikut menghasilkan kesalahan:
```
param = ParameterInteger(name="", default_value=10)
@step
def func():
print(param)
func() # this raises a SerializationError
```
+ Anda tidak dapat membuat sarang variabel pipeline di objek lain dan meneruskannya ke `@step` fungsi. Contoh berikut menghasilkan kesalahan:
```
param = ParameterInteger(name="", default_value=10)
@step
def func(arg):
print(arg)
func(arg=(param,)) # this raises a SerializationError because param is nested in a tuple
```
+ Karena input dan output dari suatu fungsi diserialisasi, ada batasan pada jenis data yang dapat diteruskan sebagai input atau output dari suatu fungsi. Lihat bagian *Serialisasi dan deserialisasi data* [Memanggil fungsi jarak jauh](train-remote-decorator-invocation.md) untuk detail selengkapnya. Pembatasan yang sama berlaku untuk fungsi `@step` yang didekorasi.
+ Objek apa pun yang memiliki klien boto tidak dapat diserialisasi, oleh karena itu Anda tidak dapat meneruskan objek seperti input ke atau output dari fungsi `@step` -decorated. Misalnya, kelas klien SDK SageMaker Python seperti`Estimator`,`Predictor`, dan tidak `Processor` dapat diserialisasi.
## Impor fungsi
Anda harus mengimpor pustaka yang diperlukan oleh langkah di dalam daripada di luar fungsi. Jika Anda mengimpornya di lingkup global, Anda berisiko mengalami tabrakan impor saat membuat serial fungsi. Misalnya, `sklearn.pipeline.Pipeline` bisa diganti dengan. `sagemaker.workflow.pipeline.Pipeline`
## Mereferensikan anggota anak dari nilai pengembalian fungsi
Jika Anda mereferensikan anggota turunan dari nilai pengembalian fungsi `@step` -decorated, batasan berikut berlaku:
+ Anda dapat mereferensikan anggota anak dengan `[]` jika `DelayedReturn` objek mewakili Tuple, list atau dict, seperti yang ditunjukkan pada contoh berikut:
```
delayed_return[0]
delayed_return["a_key"]
delayed_return[1]["a_key"]
```
+ Anda tidak dapat membongkar keluaran tuple atau daftar karena panjang yang tepat dari tupel atau daftar yang mendasarinya tidak dapat diketahui saat Anda menjalankan fungsi tersebut. Contoh berikut menghasilkan kesalahan:
```
a, b, c = func() # this raises ValueError
```
+ Anda tidak dapat mengulangi `DelayedReturn` objek. Contoh berikut menimbulkan kesalahan:
```
for item in func(): # this raises a NotImplementedError
```
+ Anda tidak dapat mereferensikan anggota anak yang sewenang-wenang dengan '`.`'. Contoh berikut menghasilkan kesalahan:
```
delayed_return.a_child # raises AttributeError
```
## Fitur pipeline yang ada yang tidak didukung
Anda tidak dapat menggunakan `@step` dekorator dengan fitur pipeline berikut:
+ [Caching langkah pipa](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-caching.html)
+ [File properti](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-propertyfile.html#build-and-manage-propertyfile-property)
# Lulus Data Antar Langkah
Saat membangun jaringan pipa dengan Amazon SageMaker Pipelines, Anda mungkin perlu meneruskan data dari satu langkah ke langkah berikutnya. Misalnya, Anda mungkin ingin menggunakan artefak model yang dihasilkan oleh langkah pelatihan sebagai masukan ke evaluasi model atau langkah penerapan. Anda dapat menggunakan fungsionalitas ini untuk membuat langkah pipeline yang saling bergantung dan membangun alur kerja ML Anda.
Ketika Anda perlu mengambil informasi dari output dari langkah pipa, Anda dapat menggunakannya`JsonGet`. `JsonGet`membantu Anda mengekstrak informasi dari Amazon S3 atau file properti. Bagian berikut menjelaskan metode yang dapat Anda gunakan untuk mengekstrak output langkah dengan`JsonGet`.
## Lulus data antar langkah dengan Amazon S3
Anda dapat menggunakan `JsonGet` dalam `ConditionStep` untuk mengambil output JSON langsung dari Amazon S3. URI Amazon S3 dapat berupa `Std:Join` fungsi yang berisi string primitif, variabel pipeline run, atau parameter pipeline. Contoh berikut menunjukkan bagaimana Anda dapat menggunakan `JsonGet` dalam`ConditionStep`:
```
# Example json file in s3 bucket generated by a processing_step
{
"Output": [5, 10]
}
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name="",
s3_uri="",
json_path="Output[1]"
),
right=6.0
)
```
Jika Anda menggunakan `JsonGet` jalur Amazon S3 di langkah kondisi, Anda harus secara eksplisit menambahkan ketergantungan antara langkah kondisi dan langkah yang menghasilkan output JSON. Dalam contoh berikut, langkah kondisi dibuat dengan ketergantungan pada langkah pemrosesan:
```
cond_step = ConditionStep(
name="",
conditions=[cond_lte],
if_steps=[fail_step],
else_steps=[register_model_step],
depends_on=[processing_step],
)
```
## Lulus data antar langkah dengan file properti
Gunakan file properti untuk menyimpan informasi dari output dari langkah pemrosesan. Ini sangat berguna ketika menganalisis hasil dari langkah pemrosesan untuk memutuskan bagaimana langkah bersyarat harus dijalankan. `JsonGet`Fungsi memproses file properti dan memungkinkan Anda untuk menggunakan JsonPath notasi untuk query file JSON properti. Untuk informasi lebih lanjut tentang JsonPath notasi, lihat [JsonPath repo](https://github.com/json-path/JsonPath).
Untuk menyimpan file properti untuk digunakan nanti, Anda harus terlebih dahulu membuat `PropertyFile` instance dengan format berikut. `path`Parameter adalah nama file JSON tempat file properti disimpan. Setiap `output_name` harus cocok dengan `output_name` `ProcessingOutput` yang Anda tentukan dalam langkah pemrosesan Anda. Hal ini memungkinkan file properti untuk menangkap `ProcessingOutput` dalam langkah.
```
from sagemaker.workflow.properties import PropertyFile
= PropertyFile(
name="",
output_name="",
path=""
)
```
Saat membuat `ProcessingStep` instance, tambahkan `property_files` parameter untuk mencantumkan semua file parameter yang harus diindeks oleh layanan Amazon SageMaker Pipelines. Ini menyimpan file properti untuk digunakan nanti.
```
property_files=[]
```
Untuk menggunakan file properti Anda dalam langkah kondisi, tambahkan `property_file` ke kondisi yang Anda teruskan ke langkah kondisi Anda seperti yang ditunjukkan pada contoh berikut untuk menanyakan file JSON untuk properti yang Anda inginkan menggunakan `json_path` parameter.
```
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name=step_eval.name,
property_file=,
json_path="mse"
),
right=6.0
)
```
Untuk contoh lebih mendalam, lihat *[File properti](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#property-file)* di [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
# Langkah-langkah pipa cache
Di Amazon SageMaker Pipelines, Anda dapat menggunakan caching langkah untuk menghemat waktu dan sumber daya saat menjalankan ulang pipeline. Step caching menggunakan kembali output dari langkah yang berhasil sebelumnya (bukan mengkomputernya ulang) ketika langkah memiliki konfigurasi dan input yang sama. Ini membantu Anda mencapai hasil yang konsisten di seluruh tayangan ulang pipeline dengan parameter yang identik. Topik berikut menunjukkan cara mengkonfigurasi dan mengaktifkan caching langkah untuk pipeline Anda.
Saat Anda menggunakan caching tanda tangan langkah, Pipelines mencoba menemukan langkah pipeline Anda yang berjalan sebelumnya dengan nilai yang sama untuk atribut tertentu. Jika ditemukan, Pipelines menyebarkan output dari proses sebelumnya daripada menghitung ulang langkah. Atribut yang dicentang khusus untuk jenis langkah, dan tercantum dalam[Atribut kunci cache default berdasarkan tipe langkah pipa](pipelines-default-keys.md).
Anda harus memilih untuk melakukan caching langkah — ini tidak aktif secara default. Saat Anda mengaktifkan caching langkah, Anda juga harus menentukan batas waktu. Batas waktu ini menentukan berapa umur lari sebelumnya untuk tetap menjadi kandidat untuk digunakan kembali.
Step caching hanya mempertimbangkan proses yang berhasil - tidak pernah menggunakan kembali proses yang gagal. Ketika beberapa proses yang berhasil ada dalam periode batas waktu, Pipelines menggunakan hasilnya untuk menjalankan sukses terbaru. Jika tidak ada pertandingan berjalan yang berhasil dalam periode batas waktu, Pipelines menjalankan ulang langkahnya. Jika pelaksana menemukan proses sebelumnya yang memenuhi kriteria tetapi masih dalam proses, kedua langkah terus berjalan dan memperbarui cache jika berhasil.
Step caching hanya dicakup untuk pipeline individu, jadi Anda tidak dapat menggunakan kembali langkah dari pipeline lain meskipun ada kecocokan tanda tangan langkah.
Langkah caching tersedia untuk jenis langkah berikut:
+ [Pemrosesan](build-and-manage-steps-types.md#step-type-processing)
+ [Pelatihan](build-and-manage-steps-types.md#step-type-training)
+ [Tuning](build-and-manage-steps-types.md#step-type-tuning)
+ [AutoML](build-and-manage-steps-types.md#step-type-automl)
+ [Transformasi](build-and-manage-steps-types.md#step-type-transform)
+ [`ClarifyCheck`](build-and-manage-steps-types.md#step-type-clarify-check)
+ [`QualityCheck`](build-and-manage-steps-types.md#step-type-quality-check)
+ [EMR](build-and-manage-steps-types.md#step-type-emr)
**Topics**
+ [Aktifkan caching langkah](pipelines-caching-enabling.md)
+ [Matikan caching langkah](pipelines-caching-disabling.md)
+ [Atribut kunci cache default berdasarkan tipe langkah pipa](pipelines-default-keys.md)
+ [Kontrol akses data cache](pipelines-access-control.md)
# Aktifkan caching langkah
Untuk mengaktifkan caching langkah, Anda harus menambahkan `CacheConfig` properti ke definisi langkah. `CacheConfig`properti menggunakan format berikut dalam file definisi pipeline:
```
{
"CacheConfig": {
"Enabled": false,
"ExpireAfter": "