Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # 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)