Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Tentukan pipa Untuk mengatur alur kerja Anda dengan SageMaker Amazon Pipelines, Anda harus membuat grafik asiklik terarah (DAG) dalam bentuk definisi pipeline JSON. DAG menentukan berbagai langkah yang terlibat dalam proses ML Anda, seperti prapemrosesan data, pelatihan model, evaluasi model, dan penerapan model, serta dependensi dan aliran data di antara langkah-langkah ini. Topik berikut menunjukkan cara menghasilkan definisi pipeline. Anda dapat membuat definisi pipeline JSON menggunakan SageMaker Python SDK atau fitur visual drag-and-drop Pipeline Designer di Amazon Studio. SageMaker Gambar berikut adalah representasi dari pipeline DAG yang Anda buat dalam tutorial ini: ![Tangkapan layar antarmuka drag-and-drop visual untuk Pipelines di Studio.](https://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/pipelines/pipelines-studio-overview.png) Pipa yang Anda tentukan di bagian berikut memecahkan masalah regresi untuk menentukan usia abalon berdasarkan pengukuran fisiknya. Untuk buku catatan Jupyter yang dapat dijalankan yang menyertakan konten dalam tutorial ini, lihat [Mengatur Pekerjaan dengan Pipa Bangunan Model Amazon](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-pipelines/tabular/abalone_build_train_deploy/sagemaker-pipelines-preprocess-train-evaluate-batch-transform.html). SageMaker **catatan** Anda dapat mereferensikan lokasi model sebagai properti dari langkah pelatihan, seperti yang ditunjukkan dalam contoh [CustomerChurn pipeline](https://github.com/aws-samples/customer-churn-sagemaker-pipelines-sample/blob/main/pipelines/customerchurn/pipeline.py) ujung ke ujung di Github. **Topics** ## Tentukan pipa (Pipeline Designer) Panduan berikut memandu Anda melalui langkah-langkah untuk membuat pipa barebone menggunakan Desainer Pipeline drag-and-drop. Jika Anda perlu menjeda atau mengakhiri sesi pengeditan Pipeline Anda di desainer visual kapan saja, klik opsi **Ekspor**. Ini memungkinkan Anda mengunduh definisi Pipeline saat ini ke lingkungan lokal Anda. Kemudian, ketika Anda ingin melanjutkan proses pengeditan Pipeline, Anda dapat mengimpor file definisi JSON yang sama ke desainer visual. ### Buat langkah Pemrosesan Untuk membuat langkah pekerjaan pemrosesan data, 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 **Proses data** dan seret ke kanvas. 1. Di kanvas, pilih langkah **Proses data** yang Anda tambahkan. 1. Untuk menambahkan kumpulan data input, pilih **Tambah** di bawah **Data (input)** di bilah sisi kanan dan pilih kumpulan data. 1. Untuk menambahkan lokasi untuk menyimpan kumpulan data keluaran, pilih **Tambah** di bawah **Data (output)** di bilah sisi kanan dan arahkan ke tujuan. 1. Lengkapi bidang yang tersisa di sidebar kanan. 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). ### Buat langkah Pelatihan Untuk mengatur langkah pelatihan model, lakukan hal berikut: 1. Di sidebar kiri, pilih **Train model** dan seret ke kanvas. 1. Di kanvas, pilih langkah **model Kereta** yang Anda tambahkan. 1. Untuk menambahkan kumpulan data input, pilih **Tambah** di bawah **Data (input)** di bilah sisi kanan dan pilih kumpulan data. 1. Untuk memilih lokasi untuk menyimpan artefak model Anda, masukkan URI Amazon S3 di bidang **Lokasi (URI S3**), atau **pilih Jelajahi** S3 untuk menavigasi ke lokasi tujuan. 1. Lengkapi bidang yang tersisa di sidebar kanan. 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. Klik dan seret kursor dari langkah **Proses data** yang Anda tambahkan di bagian sebelumnya ke langkah **Model kereta** untuk membuat tepi yang menghubungkan dua langkah. ### Buat paket model dengan langkah model Register Untuk membuat paket model dengan langkah pendaftaran model, lakukan hal berikut: 1. Di bilah sisi kiri, pilih **Daftar model** dan seret ke kanvas. 1. Di kanvas, pilih langkah **model Daftar** yang Anda tambahkan. 1. Untuk memilih model yang akan didaftarkan, pilih **Tambah** di bawah **Model (input)**. 1. Pilih **Buat grup model** untuk menambahkan model Anda ke grup model baru. 1. Lengkapi bidang yang tersisa di sidebar kanan. Untuk informasi tentang bidang di tab ini, lihat [sagemaker.workflow.step\_collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel). 1. Klik dan seret kursor dari langkah **model Kereta** yang Anda tambahkan di bagian sebelumnya ke langkah **model Daftar** untuk membuat tepi yang menghubungkan dua langkah. ### Terapkan model ke titik akhir dengan langkah model Deploy (titik akhir) Untuk menerapkan model Anda menggunakan langkah penerapan model, lakukan hal berikut: 1. Di sidebar kiri, pilih **Deploy model (endpoint)** dan seret ke kanvas. 1. Di kanvas, pilih langkah **Deploy model (endpoint)** yang Anda tambahkan. 1. Untuk memilih model yang akan digunakan, pilih **Tambah** di bawah **Model (input)**. 1. Pilih tombol **Create endpoint** radio untuk membuat endpoint baru. 1. Masukkan **Nama** dan **Deskripsi** untuk titik akhir Anda. 1. Klik dan seret kursor dari langkah **model Register** yang Anda tambahkan di bagian sebelumnya ke langkah **Deploy model (endpoint)** untuk membuat tepi yang menghubungkan dua langkah. 1. Lengkapi bidang yang tersisa di sidebar kanan. ### Tentukan parameter Pipeline Anda dapat mengonfigurasi satu set parameter Pipeline yang nilainya dapat diperbarui untuk setiap eksekusi. Untuk menentukan parameter pipa dan mengatur nilai default, klik ikon roda gigi di bagian bawah desainer visual. ### Simpan Pipeline Setelah Anda memasukkan semua informasi yang diperlukan untuk membuat pipeline Anda, klik **Simpan** di bagian bawah desainer visual. Ini memvalidasi pipeline Anda untuk setiap potensi kesalahan saat runtime dan memberi tahu Anda. Operasi **Simpan** tidak akan berhasil sampai Anda mengatasi semua kesalahan yang ditandai oleh pemeriksaan validasi otomatis. Jika Anda ingin melanjutkan pengeditan di lain waktu, Anda dapat menyimpan pipeline yang sedang berlangsung sebagai definisi JSON di lingkungan lokal Anda. Anda dapat mengekspor Pipeline Anda sebagai file definisi JSON dengan mengklik tombol **Ekspor** di bagian bawah desainer visual. Kemudian, untuk melanjutkan memperbarui Pipeline Anda, unggah file definisi JSON itu dengan mengklik tombol **Impor**. ## Tentukan pipeline (SageMaker Python SDK) ### Prasyarat Untuk menjalankan tutorial berikut, lengkapi yang berikut ini: + Siapkan instance notebook Anda seperti yang diuraikan dalam [Buat instance notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/howitworks-create-ws.html). Ini memberi izin peran Anda untuk membaca dan menulis ke Amazon S3, dan membuat pelatihan, transformasi batch, dan pekerjaan SageMaker pemrosesan di AI. + Berikan izin buku catatan Anda untuk mendapatkan dan meneruskan perannya sendiri seperti yang ditunjukkan dalam [Memodifikasi kebijakan izin peran](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy). Tambahkan cuplikan JSON berikut untuk melampirkan kebijakan ini ke peran Anda. Ganti `` dengan ARN yang digunakan untuk membuat instance notebook Anda. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:GetRole", "iam:PassRole" ], "Resource": "arn:aws:iam::{{111122223333}}:role/{{role-name}}" } ] } ``` ------ + Percayai prinsip layanan SageMaker AI dengan mengikuti langkah-langkah dalam [Memodifikasi kebijakan kepercayaan peran](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-cli.html#roles-managingrole_edit-trust-policy-cli). Tambahkan fragmen pernyataan berikut ke hubungan kepercayaan peran Anda: ``` { "Sid": "", "Effect": "Allow", "Principal": { "Service": "sagemaker.amazonaws.com" }, "Action": "sts:AssumeRole" } ``` #### Siapkan lingkungan Anda Buat sesi SageMaker AI baru menggunakan blok kode berikut. Ini mengembalikan peran ARN untuk sesi tersebut. Peran ARN ini harus menjadi peran eksekusi ARN yang Anda tetapkan sebagai prasyarat. ``` import boto3 import sagemaker from sagemaker.core.workflow.pipeline_context import PipelineSession from sagemaker.core.helper.session_helper import Session, get_execution_role region = boto3.Session().region_name sagemaker_session = Session() role = get_execution_role() default_bucket = sagemaker_session.default_bucket() pipeline_session = PipelineSession() model_package_group_name = f"AbaloneModelPackageGroupName" ``` ### Membuat jalur **penting** Kebijakan IAM khusus yang memungkinkan Amazon SageMaker Studio atau Amazon SageMaker Studio Classic membuat SageMaker sumber daya Amazon juga harus memberikan izin untuk menambahkan tag ke sumber daya tersebut. Izin untuk menambahkan tag ke sumber daya diperlukan karena Studio dan Studio Classic secara otomatis menandai sumber daya apa pun yang mereka buat. Jika kebijakan IAM memungkinkan Studio dan Studio Classic membuat sumber daya tetapi tidak mengizinkan penandaan, kesalahan "AccessDenied" dapat terjadi saat mencoba membuat sumber daya. Untuk informasi selengkapnya, lihat [Berikan izin untuk menandai sumber daya AI SageMaker](security_iam_id-based-policy-examples.md#grant-tagging-permissions). [AWS kebijakan terkelola untuk Amazon SageMaker AI](security-iam-awsmanpol.md)yang memberikan izin untuk membuat SageMaker sumber daya sudah menyertakan izin untuk menambahkan tag saat membuat sumber daya tersebut. Jalankan langkah-langkah berikut dari instans notebook SageMaker AI Anda untuk membuat pipeline yang mencakup langkah-langkah untuk pra-pemrosesan, pelatihan, evaluasi, evaluasi bersyarat, dan pendaftaran model. **catatan** Anda dapat menggunakan [ExecutionVariables](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#execution-variables)dan fungsi [Gabung](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#execution-variables) untuk menentukan lokasi output Anda. #### Langkah 1: Unduh dataset Notebook ini menggunakan Dataset Abalone Machine Learning UCI. Dataset berisi fitur-fitur berikut: + `length`— Pengukuran cangkang terpanjang dari abalon. + `diameter`— Diameter abalon tegak lurus dengan panjangnya. + `height`— Ketinggian abalon dengan daging di cangkang. + `whole_weight`— Berat seluruh abalon. + `shucked_weight`— Berat daging dikeluarkan dari abalon. + `viscera_weight`— Berat visera abalon setelah pendarahan. + `shell_weight`— Berat cangkang abalon setelah pengangkatan dan pengeringan daging. + `sex`- Jenis kelamin abalon. Salah satu dari 'M', 'F', atau 'I', di mana 'I' adalah abalon bayi. + `rings`— Jumlah cincin di cangkang abalon. Jumlah cincin dalam cangkang abalon adalah perkiraan yang baik untuk usianya menggunakan rumus. `age=rings + 1.5` Namun, mendapatkan nomor ini adalah tugas yang memakan waktu. Anda harus memotong cangkang melalui kerucut, menodai bagian, dan menghitung jumlah cincin melalui mikroskop. Namun, pengukuran fisik lainnya lebih mudah didapat. Notebook ini menggunakan dataset untuk membangun model prediktif dari cincin variabel menggunakan pengukuran fisik lainnya. **Untuk mengunduh dataset** 1. Unduh kumpulan data ke bucket Amazon S3 default akun Anda. ``` !mkdir -p data local_path = "data/abalone-dataset.csv" s3 = boto3.resource("s3") s3.Bucket(f"sagemaker-servicecatalog-seedcode-{region}").download_file( "dataset/abalone-dataset.csv", local_path ) base_uri = f"s3://{default_bucket}/abalone" input_data_uri = sagemaker.s3.S3Uploader.upload( local_path=local_path, desired_s3_uri=base_uri, ) print(input_data_uri) ``` 1. Unduh kumpulan data kedua untuk transformasi batch setelah model Anda dibuat. ``` local_path = "data/abalone-dataset-batch.csv" s3 = boto3.resource("s3") s3.Bucket(f"sagemaker-servicecatalog-seedcode-{region}").download_file( "dataset/abalone-dataset-batch", local_path ) base_uri = f"s3://{default_bucket}/abalone" batch_data_uri = sagemaker.s3.S3Uploader.upload( local_path=local_path, desired_s3_uri=base_uri, ) print(batch_data_uri) ``` #### Langkah 2: Tentukan parameter pipa ``` from sagemaker.core.workflow.parameters import ( ParameterInteger, ParameterString, ) processing_instance_count = ParameterInteger(name="ProcessingInstanceCount", default_value=1) model_approval_status = ParameterString(name="ModelApprovalStatus", default_value="PendingManualApproval") input_data = ParameterString(name="InputData", default_value=input_data_uri) batch_data = ParameterString(name="BatchData", default_value=batch_data_uri) ``` #### Langkah 3: Tentukan langkah pemrosesan untuk rekayasa fitur Bagian ini menunjukkan cara membuat langkah pemrosesan untuk menyiapkan data dari kumpulan data untuk pelatihan. **Untuk membuat langkah pemrosesan** 1. Buat instance prosesor untuk diteruskan ke langkah pemrosesan. ``` from sagemaker.core.processing import Processor from sagemaker.core import image_uris framework_version = "0.23-1" sklearn_image_uri = image_uris.retrieve( framework="sklearn", region=region, version=framework_version, instance_type="ml.m5.xlarge" ) sklearn_processor = Processor( image_uri=sklearn_image_uri, instance_type="ml.m5.xlarge", instance_count=processing_instance_count, base_job_name="sklearn-abalone-process", sagemaker_session=pipeline_session, role=role, ) ``` 1. Buat langkah pemrosesan. ``` from sagemaker.core.processing import ProcessingInput, ProcessingOutput from sagemaker.mlops.workflow.steps import ProcessingStep processor_args = sklearn_processor.run( inputs=[ ProcessingInput(source=input_data, destination="/opt/ml/processing/input"), ], outputs=[ ProcessingOutput(output_name="train", source="/opt/ml/processing/train"), ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"), ProcessingOutput(output_name="test", source="/opt/ml/processing/test") ], code="abalone/preprocessing.py", ) step_process = ProcessingStep(name="AbaloneProcess", step_args=processor_args) ``` #### Langkah 4: Tentukan langkah pelatihan Bagian ini menunjukkan cara menggunakan Algoritma SageMaker AI XGBoost untuk melatih model pada output data pelatihan dari langkah-langkah pemrosesan. **Untuk menentukan langkah pelatihan** 1. Tentukan jalur model tempat Anda ingin menyimpan model dari pelatihan. ``` model_path = f"s3://{default_bucket}/AbaloneTrain" ``` 1. Konfigurasikan estimator pelatihan untuk algoritme XGBoost dan kumpulan data input. ``` from sagemaker.train import ModelTrainer from sagemaker.train.configs import Compute, OutputDataConfig from sagemaker.core import image_uris image_uri = image_uris.retrieve( framework="xgboost", region=region, version="1.0-1", py_version="py3", instance_type="ml.m5.xlarge" ) xgb_train = ModelTrainer( training_image=image_uri, compute=Compute(instance_type="ml.m5.xlarge", instance_count=1), output_data_config=OutputDataConfig(s3_output_path=model_path), hyperparameters={ "objective": "reg:linear", "num_round": "50", "max_depth": "5", "eta": "0.2", "gamma": "4", "min_child_weight": "6", "subsample": "0.7", "silent": "0" }, sagemaker_session=pipeline_session, role=role, ) ``` 1. Buat `TrainingStep` menggunakan instance pelatihan dan properti dari`ProcessingStep`. ``` from sagemaker.train.configs import InputData from sagemaker.mlops.workflow.steps import TrainingStep train_args = xgb_train.train( input_data_config=[ InputData( channel_name="train", data_source=step_process.properties.ProcessingOutputConfig.Outputs[ "train" ].S3Output.S3Uri, content_type="text/csv" ), InputData( channel_name="validation", data_source=step_process.properties.ProcessingOutputConfig.Outputs[ "validation" ].S3Output.S3Uri, content_type="text/csv" ) ], ) step_train = TrainingStep(name="AbaloneTrain", step_args=train_args) ``` #### Langkah 5: Tentukan langkah pemrosesan untuk evaluasi model Bagian ini menunjukkan cara membuat langkah pemrosesan untuk mengevaluasi keakuratan model. **Untuk menentukan langkah pemrosesan untuk evaluasi model** 1. Buat contoh `Processor` untuk evaluasi. ``` from sagemaker.core.processing import Processor script_eval = Processor( image_uri=image_uri, command=["python3"], instance_type="ml.m5.xlarge", instance_count=1, base_job_name="script-abalone-eval", sagemaker_session=pipeline_session, role=role, ) ``` 1. Buat `ProcessingStep` menggunakan instance prosesor, saluran input dan output, dan `evaluation.py` skrip. ``` from sagemaker.core.workflow.properties import PropertyFile evaluation_report = PropertyFile( name="EvaluationReport", output_name="evaluation", path="evaluation.json" ) eval_args = script_eval.run( inputs=[ ProcessingInput( source=step_train.properties.ModelArtifacts.S3ModelArtifacts, destination="/opt/ml/processing/model" ), ProcessingInput( source=step_process.properties.ProcessingOutputConfig.Outputs[ "test" ].S3Output.S3Uri, destination="/opt/ml/processing/test" ) ], outputs=[ ProcessingOutput(output_name="evaluation", source="/opt/ml/processing/evaluation"), ], code="abalone/evaluation.py", ) step_eval = ProcessingStep( name="AbaloneEval", step_args=eval_args, property_files=[evaluation_report], ) ``` #### Langkah 6: Tentukan CreateModelStep untuk transformasi batch Bagian ini menunjukkan cara membuat model SageMaker AI dari output langkah pelatihan. **Untuk menentukan transformasi CreateModelStep untuk batch** + Buat model SageMaker AI dan langkah model. ``` from sagemaker.serve import ModelBuilder from sagemaker.mlops.workflow.model_step import ModelStep model_builder = ModelBuilder( image_uri=image_uri, s3_model_data_url=step_train.properties.ModelArtifacts.S3ModelArtifacts, role_arn=role, sagemaker_session=pipeline_session, ) step_create_model = ModelStep( name="AbaloneCreateModel", step_args=model_builder.build(), ) ``` #### Langkah 7: Tentukan TransformStep untuk melakukan transformasi batch Bagian ini menunjukkan cara membuat `TransformStep` untuk melakukan transformasi batch pada kumpulan data setelah model dilatih. **Untuk menentukan TransformStep untuk melakukan transformasi batch** + Buat instance transformator dan a`TransformStep`. ``` from sagemaker.core.transformer import Transformer from sagemaker.mlops.workflow.steps import TransformStep transformer = Transformer( model_name=step_create_model.properties.ModelName, instance_type="ml.m5.xlarge", instance_count=1, output_path=f"s3://{default_bucket}/AbaloneTransform", sagemaker_session=pipeline_session, ) transform_args = transformer.transform(data=batch_data) step_transform = TransformStep( name="AbaloneTransform", step_args=transform_args, ) ``` #### Langkah 8: Tentukan RegisterModel langkah untuk membuat paket model Bagian ini menunjukkan cara mendaftarkan model. Hasilnya adalah paket model untuk inferensi. **Untuk menentukan langkah pendaftaran model untuk membuat paket model** + Membangun langkah pendaftaran model. ``` from sagemaker.core.model_metrics import MetricsSource, ModelMetrics from sagemaker.mlops.workflow.model_step import ModelStep from sagemaker.serve import ModelBuilder model_metrics = ModelMetrics( model_statistics=MetricsSource( s3_uri="{{{}/evaluation.json}}".format( step_eval.arguments["ProcessingOutputConfig"]["Outputs"][0]["S3Output"]["S3Uri"] ), content_type="application/json" ) ) model_builder = ModelBuilder( image_uri=image_uri, s3_model_data_url=step_train.properties.ModelArtifacts.S3ModelArtifacts, role_arn=role, sagemaker_session=pipeline_session, ) register_args = model_builder.register( content_types=["text/csv"], response_types=["text/csv"], inference_instances=["{{ml.t2.medium", "ml.m5.xlarge}}"], transform_instances=["{{ml.m5.xlarge}}"], model_package_group_name=model_package_group_name, approval_status=model_approval_status, model_metrics=model_metrics ) step_register = ModelStep( name="{{AbaloneRegisterModel}}", step_args=register_args, ) ``` #### Langkah 9: Tentukan langkah kondisi untuk memverifikasi akurasi model A `ConditionStep` memungkinkan Pipelines untuk mendukung pengoperasian bersyarat di DAG pipeline Anda berdasarkan kondisi properti langkah. **Untuk menentukan langkah kondisi untuk memverifikasi akurasi model** + Tentukan kondisi dan bangun a. `ConditionStep` ``` from sagemaker.core.workflow.conditions import ConditionLessThanOrEqualTo from sagemaker.mlops.workflow.condition_step import ConditionStep from sagemaker.core.workflow.functions import JsonGet cond_lte = ConditionLessThanOrEqualTo( left=JsonGet( step_name=step_eval.name, property_file=evaluation_report, json_path="regression_metrics.mse.value" ), right=6.0 ) step_cond = ConditionStep( name="AbaloneMSECond", conditions=[cond_lte], if_steps=[step_register, step_create_model, step_transform], else_steps=[], ) ``` #### Langkah 10: Buat pipeline Sekarang setelah Anda membuat semua langkah, gabungkan mereka ke dalam pipeline. **Untuk membuat pipa** 1. Tentukan hal berikut untuk pipeline Anda:`name`,`parameters`, dan`steps`. ``` from sagemaker.mlops.workflow.pipeline import Pipeline pipeline_name = f"AbalonePipeline" pipeline = Pipeline( name=pipeline_name, parameters=[ processing_instance_count, model_approval_status, input_data, batch_data, ], steps=[step_process, step_train, step_eval, step_cond], ) ``` 1. (Opsional) Periksa definisi pipa JSON untuk memastikan bahwa itu terbentuk dengan baik. ``` import json json.loads(pipeline.definition()) ``` Definisi pipeline ini siap dikirimkan ke SageMaker AI. Dalam tutorial berikutnya, Anda mengirimkan pipeline ini ke SageMaker AI dan mulai menjalankan. ## Tentukan pipeline (JSON) Anda juga dapat menggunakan [boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_pipeline) atau [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-pipeline.html)untuk membuat pipeline. Membuat pipa memerlukan definisi pipa, yang merupakan objek JSON yang mendefinisikan setiap langkah pipa. SageMaker SDK menawarkan cara sederhana untuk membuat definisi pipeline, yang dapat Anda gunakan dengan salah satu API yang disebutkan sebelumnya untuk membuat pipeline itu sendiri. Tanpa menggunakan SDK, pengguna harus menulis definisi JSON mentah untuk membuat pipeline tanpa pemeriksaan kesalahan yang disediakan oleh Python SageMaker SDK. Untuk melihat skema definisi JSON pipeline, lihat Skema JSON [Definisi Pipeline SageMaker AI](https://aws-sagemaker-mlops.github.io/sagemaker-model-building-pipeline-definition-JSON-schema/). Contoh kode berikut menunjukkan contoh objek JSON definisi pipeline SageMaker AI: ``` {'Version': '2020-12-01', 'Metadata': {}, 'Parameters': [{'Name': 'ProcessingInstanceType', 'Type': 'String', 'DefaultValue': 'ml.m5.xlarge'}, {'Name': 'ProcessingInstanceCount', 'Type': 'Integer', 'DefaultValue': 1}, {'Name': 'TrainingInstanceType', 'Type': 'String', 'DefaultValue': 'ml.m5.xlarge'}, {'Name': 'ModelApprovalStatus', 'Type': 'String', 'DefaultValue': 'PendingManualApproval'}, {'Name': 'ProcessedData', 'Type': 'String', 'DefaultValue': '{{S3_URL}}', {'Name': 'InputDataUrl', 'Type': 'String', 'DefaultValue': '{{S3_URL}}', 'PipelineExperimentConfig': {'ExperimentName': {'Get': 'Execution.PipelineName'}, 'TrialName': {'Get': 'Execution.PipelineExecutionId'}}, 'Steps': [{'Name': 'ReadTrainDataFromFS', 'Type': 'Processing', 'Arguments': {'ProcessingResources': {'ClusterConfig': {'InstanceType': 'ml.m5.4xlarge', 'InstanceCount': 2, 'VolumeSizeInGB': 30}}, 'AppSpecification': {'ImageUri': '{{IMAGE_URI}}', 'ContainerArguments': [....]}, 'RoleArn': '{{ROLE}}', 'ProcessingInputs': [...], 'ProcessingOutputConfig': {'Outputs': [.....]}, 'StoppingCondition': {'MaxRuntimeInSeconds': 86400}}, 'CacheConfig': {'Enabled': True, 'ExpireAfter': '30d'}}, ... ... ... } ``` **Langkah selanjutnya:** [Jalankan pipa](run-pipeline.md)