Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Gunakan komponen SageMaker AI
<a name="kubernetes-sagemaker-components-tutorials"></a>

Dalam tutorial ini, Anda menjalankan pipeline menggunakan SageMaker AI Components for Kubeflow Pipelines untuk melatih model klasifikasi menggunakan Kmeans dengan dataset MNIST pada AI. SageMaker Alur kerja menggunakan Pipelines Kubeflow sebagai orkestrator dan SageMaker AI untuk mengeksekusi setiap langkah alur kerja. Contoh diambil dari [contoh SageMaker AI](https://github.com/aws/amazon-sagemaker-examples/blob/8279abfcc78bad091608a4a7135e50a0bd0ec8bb/sagemaker-python-sdk/1P_kmeans_highlevel/kmeans_mnist.ipynb) yang ada dan dimodifikasi untuk bekerja dengan Komponen SageMaker AI untuk Pipelines Kubeflow.

Anda dapat menentukan pipeline Anda dengan Python menggunakan AWS SDK untuk Python (Boto3) kemudian menggunakan dasbor KFP, KFP CLI, atau Boto3 untuk mengkompilasi, menyebarkan, dan menjalankan alur kerja Anda. Kode lengkap untuk contoh pipeline klasifikasi MNIST tersedia di repositori [Kubeflow](https://github.com/kubeflow/pipelines/tree/master/samples/contrib/aws-samples/mnist-kmeans-sagemaker#mnist-classification-with-kmeans) Github. Untuk menggunakannya, kloning file Python ke node gateway Anda.

Anda dapat menemukan contoh [ SageMaker AI Kubeflow Pipelines](https://github.com/kubeflow/pipelines/tree/master/samples/contrib/aws-samples) tambahan di. GitHub Untuk informasi tentang komponen yang digunakan, lihat [ GitHub repositori KubeFlow Pipelines](https://github.com/kubeflow/pipelines/tree/master/components/aws/sagemaker).

Untuk menjalankan contoh pipeline klasifikasi, buat peran eksekusi SageMaker AI IAM yang memberikan izin kepada pekerjaan pelatihan Anda untuk mengakses AWS sumber daya, lalu lanjutkan dengan langkah-langkah yang sesuai dengan opsi penerapan Anda.

## Buat peran eksekusi SageMaker AI
<a name="create-an-amazonsagemaker-execution-role"></a>

Peran `kfp-example-sagemaker-execution-role` IAM adalah peran runtime yang diasumsikan oleh pekerjaan SageMaker AI untuk mengakses AWS sumber daya. Dalam perintah berikut, Anda membuat peran eksekusi IAM bernama`kfp-example-sagemaker-execution-role`, melampirkan dua kebijakan terkelola (AmazonSageMakerFullAccess, AmazonS3FullAccess), dan membuat hubungan kepercayaan dengan SageMaker AI untuk memberikan akses pekerjaan SageMaker AI ke sumber daya tersebut. AWS 

Anda memberikan peran ini sebagai parameter input saat menjalankan pipeline.

Jalankan perintah berikut untuk membuat peran. Perhatikan ARN yang dikembalikan dalam output Anda.

```
SAGEMAKER_EXECUTION_ROLE_NAME=kfp-example-sagemaker-execution-role

TRUST="{ \"Version\": \"2012-10-17		 	 	 \", \"Statement\": [ { \"Effect\": \"Allow\", \"Principal\": { \"Service\": \"sagemaker.amazonaws.com\" }, \"Action\": \"sts:AssumeRole\" } ] }"
aws iam create-role --role-name ${SAGEMAKER_EXECUTION_ROLE_NAME} --assume-role-policy-document "$TRUST"
aws iam attach-role-policy --role-name ${SAGEMAKER_EXECUTION_ROLE_NAME} --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
aws iam attach-role-policy --role-name ${SAGEMAKER_EXECUTION_ROLE_NAME} --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess

aws iam get-role --role-name ${SAGEMAKER_EXECUTION_ROLE_NAME} --output text --query 'Role.Arn'
```

## Kubeflow Penuh pada Deployment AWS
<a name="run-pipelines-on-full-kubeflow-deployment"></a>

Ikuti instruksi [tutorial Pipeline SageMaker Pelatihan untuk Klasifikasi MNIST dengan](https://awslabs.github.io/kubeflow-manifests/docs/amazon-sagemaker-integration/sagemaker-components-for-kubeflow-pipelines/) K-Means.

## Penyebaran Pipa Kubeflow Mandiri
<a name="run-pipelines-on-standalone-kubeflow-pipelines-deployment"></a>

### Siapkan kumpulan data
<a name="prepare-datasets"></a>

Untuk menjalankan pipeline, Anda perlu mengunggah skrip pra-pemrosesan ekstraksi data ke bucket Amazon S3. Bucket ini dan semua sumber daya untuk contoh ini harus berada di `us-east-1` wilayah tersebut. Untuk informasi tentang membuat bucket, lihat [Membuat bucket](https://docs.aws.amazon.com/AmazonS3/latest/gsg/CreatingABucket.html).

Dari `mnist-kmeans-sagemaker` folder repositori Kubeflow yang Anda kloning di node gateway, jalankan perintah berikut untuk mengunggah file ke bucket Amazon S3 `kmeans_preprocessing.py` Anda. Ubah `<bucket-name>` ke nama bucket Amazon S3 Anda.

```
aws s3 cp mnist-kmeans-sagemaker/kmeans_preprocessing.py s3://{{<bucket-name>}}/mnist_kmeans_example/processing_code/kmeans_preprocessing.py
```

### Kompilasi dan terapkan pipeline Anda
<a name="compile-and-deploy-your-pipeline"></a>

Setelah mendefinisikan pipeline, Anda harus mengompilasinya ke representasi perantara sebelum Anda mengirimkannya ke layanan Pipelines Kubeflow di klaster Anda. Representasi perantara adalah spesifikasi alur kerja dalam bentuk file YAMAL yang dikompresi menjadi file tar.gz. Anda memerlukan SDK KFP untuk mengkompilasi pipeline Anda.

#### Instal KFP SDK
<a name="install-kfp-sdk"></a>

Jalankan yang berikut ini dari baris perintah node gateway Anda:

1. Instal SDK KFP mengikuti petunjuk dalam dokumentasi pipeline [Kubeflow](https://www.kubeflow.org/docs/pipelines/sdk/install-sdk/).

1. Verifikasi bahwa KFP SDK diinstal dengan perintah berikut:

   ```
   pip show kfp
   ```

1. Verifikasi bahwa `dsl-compile` telah diinstal dengan benar sebagai berikut:

   ```
   which dsl-compile
   ```

#### Kompilasi pipeline Anda
<a name="compile-your-pipeline"></a>

Anda memiliki tiga opsi untuk berinteraksi dengan Pipelines Kubeflow: KFP UI, KFP CLI, atau KFP SDK. Bagian berikut menggambarkan alur kerja menggunakan UI KFP dan CLI.

Selesaikan langkah-langkah berikut dari node gateway Anda.

1. Ubah file Python Anda dengan nama bucket Amazon S3 dan ARN peran IAM.

1. Gunakan `dsl-compile` perintah dari baris perintah untuk mengkompilasi pipeline Anda sebagai berikut. Ganti `<path-to-python-file>` dengan jalur ke pipeline Anda dan `<path-to-output>` dengan lokasi di mana Anda ingin file tar.gz Anda berada.

   ```
   dsl-compile --py {{<path-to-python-file>}} --output {{<path-to-output>}}
   ```

#### Unggah dan jalankan pipeline menggunakan KFP CLI
<a name="upload-and-run-the-pipeline-using-the-kfp-cli"></a>

Selesaikan langkah-langkah berikut dari baris perintah node gateway Anda. KFP mengatur proses pipa Anda sebagai eksperimen. Anda memiliki opsi untuk menentukan nama eksperimen. Jika Anda tidak menentukannya, proses akan terdaftar di bawah Eksperimen **default**.

1. Unggah pipeline Anda sebagai berikut:

   ```
   kfp pipeline upload --pipeline-name {{<pipeline-name>}} {{<path-to-output-tar.gz>}}
   ```

   Output Anda akan terlihat seperti berikut ini. Catat pipa`ID`.

   ```
   Pipeline 29c3ff21-49f5-4dfe-94f6-618c0e2420fe has been submitted
   
   Pipeline Details
   ------------------
   ID           29c3ff21-49f5-4dfe-94f6-618c0e2420fe
   Name         sm-pipeline
   Description
   Uploaded at  2020-04-30T20:22:39+00:00
   ...
   ...
   ```

1. Buat run menggunakan perintah berikut. Perintah KFP CLI run saat ini tidak mendukung menentukan parameter input saat membuat run. Anda perlu memperbarui parameter Anda di file AWS SDK untuk Python (Boto3) pipeline sebelum dikompilasi. Ganti `<experiment-name>` dan `<job-name>` dengan nama apa pun. Ganti `<pipeline-id>` dengan ID pipeline yang Anda kirimkan. Ganti `<your-role-arn>` dengan ARN dari. `kfp-example-pod-role` Ganti `<your-bucket-name>` dengan nama bucket Amazon S3 yang Anda buat. 

   ```
   kfp run submit --experiment-name {{<experiment-name>}} --run-name {{<job-name>}} --pipeline-id {{<pipeline-id>}} role_arn="{{<your-role-arn>}}" bucket_name="{{<your-bucket-name>}}"
   ```

   Anda juga dapat langsung mengirimkan run menggunakan paket pipeline yang dikompilasi yang dibuat sebagai output dari `dsl-compile` perintah.

   ```
   kfp run submit --experiment-name {{<experiment-name>}} --run-name {{<job-name>}} --package-file {{<path-to-output>}} role_arn="{{<your-role-arn>}}" bucket_name="{{<your-bucket-name>}}"
   ```

   Output Anda akan terlihat seperti berikut:

   ```
   Creating experiment aws.
   Run 95084a2c-f18d-4b77-a9da-eba00bf01e63 is submitted
   +--------------------------------------+--------+----------+---------------------------+
   | run id                               | name   | status   | created at                |
   +======================================+========+==========+===========================+
   | 95084a2c-f18d-4b77-a9da-eba00bf01e63 | sm-job |          | 2020-04-30T20:36:41+00:00 |
   +--------------------------------------+--------+----------+---------------------------+
   ```

1. Arahkan ke UI untuk memeriksa kemajuan pekerjaan.

#### Unggah dan jalankan pipeline menggunakan UI KFP
<a name="upload-and-run-the-pipeline-using-the-kfp-ui"></a>

1. Di panel kiri, pilih tab **Pipelines**. 

1. **Di sudut kanan atas, pilih \+. UploadPipeline** 

1. Masukkan nama dan deskripsi pipa. 

1. Pilih **Unggah file** dan masukkan path ke file tar.gz yang Anda buat menggunakan CLI atau dengan. AWS SDK untuk Python (Boto3)

1. Di panel kiri, pilih tab **Pipelines**.

1. Temukan pipeline yang Anda buat.

1. Pilih **\+ CreateRun**.

1. Masukkan parameter input Anda.

1. Pilih **Jalankan**.

### Jalankan prediksi
<a name="running-predictions"></a>

Setelah pipeline klasifikasi diterapkan, Anda dapat menjalankan prediksi klasifikasi terhadap titik akhir yang dibuat oleh komponen Deploy. Gunakan UI KFP untuk memeriksa artefak keluaran. `sagemaker-deploy-model-endpoint_name` Unduh file.tgz untuk mengekstrak nama titik akhir atau periksa konsol SageMaker AI di wilayah yang Anda gunakan.

#### Konfigurasikan izin untuk menjalankan prediksi
<a name="configure-permissions-to-run-predictions"></a>

Jika Anda ingin menjalankan prediksi dari node gateway Anda, lewati bagian ini.

**Untuk menggunakan mesin lain untuk menjalankan prediksi, tetapkan `sagemaker:InvokeEndpoint` izin ke peran IAM yang digunakan oleh mesin klien.**

1. Di node gateway Anda, jalankan yang berikut ini untuk membuat file kebijakan IAM:

   ```
   cat <<EoF > ./sagemaker-invoke.json
   {
       "Version": "2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "sagemaker:InvokeEndpoint"
               ],
               "Resource": "*"
           }
       ]
   }
   EoF
   ```

1. Lampirkan kebijakan ke peran IAM dari node klien.

   Jalankan perintah berikut. Ganti `<your-instance-IAM-role>` dengan nama peran IAM. Ganti `<path-to-sagemaker-invoke-json>` dengan jalur ke file kebijakan yang Anda buat.

   ```
   aws iam put-role-policy --role-name {{<your-instance-IAM-role>}} --policy-name sagemaker-invoke-for-worker --policy-document file://{{<path-to-sagemaker-invoke-json>}}
   ```

#### Jalankan prediksi
<a name="run-predictions"></a>

1. Buat AWS SDK untuk Python (Boto3) file dari mesin klien Anda bernama `mnist-predictions.py` dengan konten berikut. Ganti `ENDPOINT_NAME` variabel. Skrip memuat dataset MNIST, membuat CSV dari digit tersebut, lalu mengirimkan CSV ke titik akhir untuk prediksi dan mencetak hasilnya.

   ```
   import boto3
   import gzip
   import io
   import json
   import numpy
   import pickle
   
   ENDPOINT_NAME='{{<endpoint-name>}}'
   region = boto3.Session().region_name
   
   # S3 bucket where the original mnist data is downloaded and stored
   downloaded_data_bucket = f"jumpstart-cache-prod-{region}"
   downloaded_data_prefix = "1p-notebooks-datasets/mnist"
   
   # Download the dataset
   s3 = boto3.client("s3")
   s3.download_file(downloaded_data_bucket, f"{downloaded_data_prefix}/mnist.pkl.gz", "mnist.pkl.gz")
   
   # Load the dataset
   with gzip.open('mnist.pkl.gz', 'rb') as f:
       train_set, valid_set, test_set = pickle.load(f, encoding='latin1')
   
   # Simple function to create a csv from our numpy array
   def np2csv(arr):
       csv = io.BytesIO()
       numpy.savetxt(csv, arr, delimiter=',', fmt='%g')
       return csv.getvalue().decode().rstrip()
   
   runtime = boto3.Session(region).client('sagemaker-runtime')
   
   payload = np2csv(train_set[0][30:31])
   
   response = runtime.invoke_endpoint(EndpointName=ENDPOINT_NAME,
                                      ContentType='text/csv',
                                      Body=payload)
   result = json.loads(response['Body'].read().decode())
   print(result)
   ```

1. Jalankan AWS SDK untuk Python (Boto3) file sebagai berikut:

   ```
   python mnist-predictions.py
   ```

### Lihat hasil dan log
<a name="view-results-and-logs"></a>

Saat pipeline berjalan, Anda dapat memilih komponen apa pun untuk memeriksa detail eksekusi, seperti input dan output. Ini mencantumkan nama-nama sumber daya yang dibuat.

Jika permintaan KFP berhasil diproses dan pekerjaan SageMaker AI dibuat, log komponen di UI KFP memberikan tautan ke pekerjaan yang dibuat di AI. SageMaker CloudWatch Log juga disediakan jika pekerjaan berhasil dibuat. 

Jika Anda menjalankan terlalu banyak pekerjaan pipeline pada klaster yang sama, Anda mungkin akan melihat pesan kesalahan yang menunjukkan bahwa Anda tidak memiliki cukup Pod yang tersedia. Untuk memperbaikinya, masuk ke node gateway Anda dan hapus pod yang dibuat oleh pipeline yang tidak Anda gunakan:

```
kubectl get pods -n kubeflow
kubectl delete pods -n kubeflow {{<name-of-pipeline-pod>}}
```

### Pembersihan
<a name="cleanup"></a>

Ketika Anda selesai dengan pipa Anda, Anda perlu membersihkan sumber daya Anda.

1. **Dari dasbor KFP, hentikan proses pipeline Anda jika tidak keluar dengan benar dengan memilih Terminate.**

1. Jika opsi **Terminate** tidak berfungsi, masuk ke node gateway Anda dan hentikan secara manual semua pod yang dibuat oleh pipeline Anda yang dijalankan sebagai berikut: 

   ```
   kubectl get pods -n kubeflow
   kubectl delete pods -n kubeflow {{<name-of-pipeline-pod>}}
   ```

1. Menggunakan AWS akun Anda, masuk ke layanan SageMaker AI. Hentikan semua pelatihan, transformasi batch, dan pekerjaan HPO secara manual. Hapus model, bucket data, dan titik akhir untuk menghindari biaya tambahan. Mengakhiri proses pipa tidak menghentikan pekerjaan di SageMaker AI.