

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

# Terapkan model untuk inferensi waktu nyata


Inferensi waktu nyata ideal untuk beban kerja inferensi di mana Anda memiliki persyaratan waktu nyata, interaktif, dan latensi rendah. Bagian ini menunjukkan bagaimana Anda dapat menggunakan inferensi waktu nyata untuk mendapatkan prediksi secara interaktif dari model Anda.

Untuk menerapkan model yang menghasilkan metrik validasi terbaik dalam eksperimen Autopilot, Anda memiliki beberapa opsi. Misalnya, saat menggunakan Autopilot di SageMaker Studio Classic, Anda dapat menerapkan model secara otomatis atau manual. Anda juga dapat menggunakan SageMaker APIs untuk menyebarkan model Autopilot secara manual. 

Tab berikut menunjukkan tiga opsi untuk menerapkan model Anda. Instruksi ini mengasumsikan bahwa Anda telah membuat model di Autopilot. Jika Anda tidak memiliki model, lihat[Membuat Pekerjaan Regresi atau Klasifikasi untuk Data Tabular Menggunakan AutoML API](autopilot-automate-model-development-create-experiment.md). Untuk melihat contoh untuk setiap opsi, buka setiap tab.

## Terapkan menggunakan Antarmuka Pengguna Autopilot (UI)


UI Autopilot berisi menu tarik-turun yang bermanfaat, sakelar, tooltips, dan lainnya untuk membantu Anda menavigasi penerapan model. Anda dapat menggunakan salah satu dari prosedur berikut: Otomatis atau Manual.
+ **Automatic Deployment**: Untuk secara otomatis menerapkan model terbaik dari eksperimen Autopilot ke titik akhir

  1. [Buat eksperimen](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development-create-experiment.html) di SageMaker Studio Classic. 

  1. **Alihkan nilai **penerapan Otomatis ke Ya**.**
**catatan**  
**Penerapan otomatis akan gagal jika kuota sumber daya default atau kuota pelanggan Anda untuk instans titik akhir di Wilayah terlalu terbatas.** Dalam mode optimasi hyperparameter (HPO), Anda harus memiliki setidaknya dua instance ml.m5.2xlarge. Dalam mode ensembling, Anda harus memiliki setidaknya satu instance ml.m5.12xlarge. Jika Anda mengalami kegagalan terkait kuota, Anda dapat [meminta peningkatan batas layanan untuk instance](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html) titik akhir SageMaker AI.
+ **Penerapan Manual**: Untuk menerapkan model terbaik secara manual dari eksperimen Autopilot ke titik akhir

  1. [Buat eksperimen](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development-create-experiment.html) di SageMaker Studio Classic. 

  1. **Alihkan nilai **Auto deploy ke No**.** 

  1. Pilih model yang ingin Anda gunakan di bawah **Nama model**.

  1. Pilih tombol **Deployment dan pengaturan lanjutan** berwarna oranye yang terletak di sebelah kanan papan peringkat. Ini membuka tab baru.

  1. Konfigurasikan nama titik akhir, jenis instance, dan informasi opsional lainnya.

  1.  Pilih **model Deploy** oranye untuk menyebarkan ke titik akhir.

  1. Periksa kemajuan proses pembuatan titik akhir di bagian [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)dengan menavigasi ke bagian Endpoints. Bagian itu terletak di menu tarik-turun **Inferensi** di panel navigasi. 

  1. Setelah status endpoint berubah dari **Creating** menjadi **InService**, seperti yang ditunjukkan di bawah ini, kembali ke Studio Classic dan panggil endpoint.  
![\[SageMaker Konsol AI: Halaman titik akhir untuk membuat titik akhir atau memeriksa status titik akhir.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/autopilot/autopilot-check-progress.PNG)

## Menyebarkan menggunakan SageMaker APIs


Anda juga dapat memperoleh inferensi real-time dengan menerapkan model Anda menggunakan panggilan **API**. Bagian ini menunjukkan lima langkah proses ini menggunakan AWS Command Line Interface (AWS CLI) cuplikan kode. 

Untuk contoh kode lengkap untuk kedua AWS CLI perintah dan AWS SDK untuk Python (boto3), buka tab langsung mengikuti langkah-langkah ini.

1. **Dapatkan definisi kandidat**

   Dapatkan definisi wadah kandidat dari [InferenceContainers](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLCandidate.html#sagemaker-Type-AutoMLCandidate-InferenceContainers). Definisi kandidat ini digunakan untuk membuat model SageMaker AI. 

   Contoh berikut menggunakan [DescribeAutoMLJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeAutoMLJob.html)API untuk mendapatkan definisi kandidat untuk kandidat model terbaik. Lihat AWS CLI perintah berikut sebagai contoh.

   ```
   aws sagemaker describe-auto-ml-job --auto-ml-job-name <job-name> --region <region>
   ```

1. **Daftar kandidat**

   Contoh berikut menggunakan [ListCandidatesForAutoMLJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListCandidatesForAutoMLJob.html)API untuk mencantumkan semua kandidat. Lihat AWS CLI perintah berikut sebagai contoh.

   ```
   aws sagemaker list-candidates-for-auto-ml-job --auto-ml-job-name <job-name> --region <region>
   ```

1. **Buat model SageMaker AI**

   Gunakan definisi container dari langkah sebelumnya untuk membuat model SageMaker AI dengan menggunakan [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API. Lihat AWS CLI perintah berikut sebagai contoh.

   ```
   aws sagemaker create-model --model-name '<your-custom-model-name>' \
                       --containers ['<container-definition1>, <container-definition2>, <container-definition3>]' \
                       --execution-role-arn '<execution-role-arn>' --region '<region>
   ```

1. **Buat konfigurasi titik akhir** 

   Contoh berikut menggunakan [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API untuk membuat konfigurasi endpoint. Lihat AWS CLI perintah berikut sebagai contoh.

   ```
   aws sagemaker create-endpoint-config --endpoint-config-name '<your-custom-endpoint-config-name>' \
                       --production-variants '<list-of-production-variants>' \
                       --region '<region>'
   ```

1. **Buat titik akhir** 

    AWS CLI Contoh berikut menggunakan [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)API untuk membuat titik akhir.

   ```
   aws sagemaker create-endpoint --endpoint-name '<your-custom-endpoint-name>' \
                       --endpoint-config-name '<endpoint-config-name-you-just-created>' \
                       --region '<region>'
   ```

   Periksa kemajuan penerapan titik akhir Anda dengan menggunakan API. [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) Lihat AWS CLI perintah berikut sebagai contoh.

   ```
   aws sagemaker describe-endpoint —endpoint-name '<endpoint-name>' —region <region>
   ```

   Setelah `EndpointStatus` perubahan`InService`, titik akhir siap digunakan untuk inferensi waktu nyata.

1. **Memanggil titik akhir** 

   Struktur perintah berikut memanggil titik akhir untuk inferensi real-time.

   ```
   aws sagemaker invoke-endpoint --endpoint-name '<endpoint-name>' \ 
                     --region '<region>' --body '<your-data>' [--content-type] '<content-type>' <outfile>
   ```

Tab berikut berisi contoh kode lengkap untuk menerapkan model dengan AWS SDK untuk Python (boto3) atau file. AWS CLI

------
#### [ AWS SDK for Python (boto3) ]

1. **Dapatkan definisi kandidat** dengan menggunakan contoh kode berikut.

   ```
   import sagemaker 
   import boto3
   
   session = sagemaker.session.Session()
   
   sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
   job_name = 'test-auto-ml-job'
   
   describe_response = sm_client.describe_auto_ml_job(AutoMLJobName=job_name)
   # extract the best candidate definition from DescribeAutoMLJob response
   best_candidate = describe_response['BestCandidate']
   # extract the InferenceContainers definition from the caandidate definition
   inference_containers = best_candidate['InferenceContainers']
   ```

1. **Buat model** dengan menggunakan contoh kode berikut.

   ```
   # Create Model
   model_name = 'test-model' 
   sagemaker_role = 'arn:aws:iam:444455556666:role/sagemaker-execution-role'
   create_model_response = sagemaker_client.create_model(
      ModelName = model_name,
      ExecutionRoleArn = sagemaker_role,
      Containers = inference_containers 
   )
   ```

1. **Buat konfigurasi endpoint** dengan menggunakan contoh kode berikut.

   ```
   endpoint_config_name = 'test-endpoint-config'
                                                           
   instance_type = 'ml.m5.2xlarge' 
   # for all supported instance types, see 
   # https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html#sagemaker-Type-ProductionVariant-InstanceType    # Create endpoint config
   
   endpoint_config_response = sagemaker_client.create_endpoint_config(
      EndpointConfigName=endpoint_config_name, 
      ProductionVariants=[
          {
              "VariantName": "variant1",
              "ModelName": model_name, 
              "InstanceType": instance_type,
              "InitialInstanceCount": 1
          }
      ]
   )
   
   print(f"Created EndpointConfig: {endpoint_config_response['EndpointConfigArn']}")
   ```

1. **Buat titik akhir** dan gunakan model dengan contoh kode berikut.

   ```
   # create endpoint and deploy the model
   endpoint_name = 'test-endpoint'
   create_endpoint_response = sagemaker_client.create_endpoint(
                                               EndpointName=endpoint_name, 
                                               EndpointConfigName=endpoint_config_name)
   print(create_endpoint_response)
   ```

   **Periksa status pembuatan titik akhir** dengan menggunakan contoh kode berikut.

   ```
   # describe endpoint creation status
   status = sagemaker_client.describe_endpoint(EndpointName=endpoint_name)["EndpointStatus"]
   ```

1. **Memanggil endpoint** untuk inferensi real-time dengan menggunakan struktur perintah berikut.

   ```
   # once endpoint status is InService, you can invoke the endpoint for inferencing
   if status == "InService":
     sm_runtime = boto3.Session().client('sagemaker-runtime')
     inference_result = sm_runtime.invoke_endpoint(EndpointName='test-endpoint', ContentType='text/csv', Body='1,2,3,4,class')
   ```

------
#### [ AWS Command Line Interface (AWS CLI) ]

1. **Dapatkan definisi kandidat** dengan menggunakan contoh kode berikut.

   ```
   aws sagemaker describe-auto-ml-job --auto-ml-job-name 'test-automl-job' --region us-west-2
   ```

1. **Buat model** dengan menggunakan contoh kode berikut.

   ```
   aws sagemaker create-model --model-name 'test-sagemaker-model'
   --containers '[{
       "Image": "348316444620.dkr.ecr.us-west-2.amazonaws.com/sagemaker-sklearn-automl:2.5-1-cpu-py3", amzn-s3-demo-bucket1
       "ModelDataUrl": "s3://amzn-s3-demo-bucket/output/model.tar.gz",
       "Environment": {
           "AUTOML_SPARSE_ENCODE_RECORDIO_PROTOBUF": "1",
           "AUTOML_TRANSFORM_MODE": "feature-transform",
           "SAGEMAKER_DEFAULT_INVOCATIONS_ACCEPT": "application/x-recordio-protobuf",
           "SAGEMAKER_PROGRAM": "sagemaker_serve",
           "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code"
       }
   }, {
       "Image": "348316444620.dkr.ecr.us-west-2.amazonaws.com/sagemaker-xgboost:1.3-1-cpu-py3",
       "ModelDataUrl": "s3://amzn-s3-demo-bucket/output/model.tar.gz",
       "Environment": {
           "MAX_CONTENT_LENGTH": "20971520",
           "SAGEMAKER_DEFAULT_INVOCATIONS_ACCEPT": "text/csv",
           "SAGEMAKER_INFERENCE_OUTPUT": "predicted_label", 
           "SAGEMAKER_INFERENCE_SUPPORTED": "predicted_label,probability,probabilities" 
       }
   }, {
       "Image": "348316444620.dkr.ecr.us-west-2.amazonaws.com/sagemaker-sklearn-automl:2.5-1-cpu-py3", aws-region
       "ModelDataUrl": "s3://amzn-s3-demo-bucket/output/model.tar.gz", 
       "Environment": { 
           "AUTOML_TRANSFORM_MODE": "inverse-label-transform", 
           "SAGEMAKER_DEFAULT_INVOCATIONS_ACCEPT": "text/csv", 
           "SAGEMAKER_INFERENCE_INPUT": "predicted_label", 
           "SAGEMAKER_INFERENCE_OUTPUT": "predicted_label", 
           "SAGEMAKER_INFERENCE_SUPPORTED": "predicted_label,probability,labels,probabilities", 
           "SAGEMAKER_PROGRAM": "sagemaker_serve", 
           "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code"
       } 
   }]' \
   --execution-role-arn 'arn:aws:iam::1234567890:role/sagemaker-execution-role' \ 
   --region 'us-west-2'
   ```

   Untuk detail tambahan, lihat [membuat model](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sagemaker/create-model.html).

   `create model`Perintah akan mengembalikan respons dalam format berikut.

   ```
   {
       "ModelArn": "arn:aws:sagemaker:us-west-2:1234567890:model/test-sagemaker-model"
   }
   ```

1. **Buat konfigurasi endpoint** dengan menggunakan contoh kode berikut.

   ```
   aws sagemaker create-endpoint-config --endpoint-config-name 'test-endpoint-config' \
   --production-variants '[{"VariantName": "variant1", 
                           "ModelName": "test-sagemaker-model",
                           "InitialInstanceCount": 1,
                           "InstanceType": "ml.m5.2xlarge"
                          }]' \
   --region us-west-2
   ```

   Perintah `create endpoint` konfigurasi akan mengembalikan respons dalam format berikut.

   ```
   {
       "EndpointConfigArn": "arn:aws:sagemaker:us-west-2:1234567890:endpoint-config/test-endpoint-config"
   }
   ```

1. **Buat endpoint** dengan menggunakan contoh kode berikut.

   ```
   aws sagemaker create-endpoint --endpoint-name 'test-endpoint' \    
   --endpoint-config-name 'test-endpoint-config' \                 
   --region us-west-2
   ```

   `create endpoint`Perintah akan mengembalikan respons dalam format berikut.

   ```
   {
       "EndpointArn": "arn:aws:sagemaker:us-west-2:1234567890:endpoint/test-endpoint"
   }
   ```

   Periksa kemajuan penerapan titik akhir dengan menggunakan contoh kode CLI [describe-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint.html) berikut.

   ```
   aws sagemaker describe-endpoint --endpoint-name 'test-endpoint' --region us-west-2
   ```

   Pemeriksaan kemajuan sebelumnya akan mengembalikan respons dalam format berikut.

   ```
   {
       "EndpointName": "test-endpoint",
       "EndpointArn": "arn:aws:sagemaker:us-west-2:1234567890:endpoint/test-endpoint",
       "EndpointConfigName": "test-endpoint-config",
       "EndpointStatus": "Creating",
       "CreationTime": 1660251167.595,
       "LastModifiedTime": 1660251167.595
   }
   ```

   Setelah `EndpointStatus` perubahan`InService`, titik akhir siap digunakan dalam inferensi waktu nyata.

1. **Memanggil endpoint** untuk inferensi real-time dengan menggunakan struktur perintah berikut.

   ```
   aws sagemaker-runtime invoke-endpoint --endpoint-name 'test-endpoint' \
   --region 'us-west-2' \
   --body '1,51,3.5,1.4,0.2' \
   --content-type 'text/csv' \
   '/tmp/inference_output'
   ```

   Untuk opsi lainnya, lihat [menjalankan titik akhir](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sagemaker-runtime/invoke-endpoint.html).

------

## Terapkan model dari akun yang berbeda


Anda dapat menerapkan model Autopilot dari akun yang berbeda dari akun asli tempat model dibuat. Untuk menerapkan penerapan model lintas akun, bagian ini menunjukkan cara melakukan hal berikut:   Berikan izin untuk mengambil peran ke akun yang ingin Anda gunakan (akun pembuat).    Lakukan panggilan ke `DescribeAutoMLJob` dari akun penyebaran untuk mendapatkan informasi model.    Berikan hak akses ke artefak model dari akun pembuat.    

1. **Berikan izin ke akun penerapan** 

   Untuk mengambil peran dalam akun pembangkit, Anda harus memberikan izin ke akun penyebaran. Ini memungkinkan akun penyebaran untuk menjelaskan pekerjaan Autopilot di akun pembangkit.

   Contoh berikut menggunakan akun penghasil dengan `sagemaker-role` entitas tepercaya. Contoh menunjukkan cara memberikan akun penerapan dengan izin ID 111122223333 untuk mengambil peran akun pembangkit.

   ```
   "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Service": [
                       "sagemaker.amazonaws.com"
                   ],
                   "AWS": [ "111122223333"]
               },
               "Action": "sts:AssumeRole"
           }
   ```

   Akun baru dengan ID 111122223333 sekarang dapat mengambil peran untuk akun pembangkit. 

   Selanjutnya, panggil `DescribeAutoMLJob` API dari akun penerapan untuk mendapatkan deskripsi pekerjaan yang dibuat oleh akun pembuat. 

   Contoh kode berikut menjelaskan model dari akun penyebaran.

   ```
   import sagemaker 
   import boto3
   session = sagemaker.session.Session()
   
   sts_client = boto3.client('sts')
   sts_client.assume_role
   
   role = 'arn:aws:iam::111122223333:role/sagemaker-role'
   role_session_name = "role-session-name"
   _assumed_role = sts_client.assume_role(RoleArn=role, RoleSessionName=role_session_name)
   
   credentials = _assumed_role["Credentials"]
   access_key = credentials["AccessKeyId"]
   secret_key = credentials["SecretAccessKey"]
   session_token = credentials["SessionToken"]
   
   session = boto3.session.Session()
           
   sm_client = session.client('sagemaker', region_name='us-west-2', 
                              aws_access_key_id=access_key,
                               aws_secret_access_key=secret_key,
                               aws_session_token=session_token)
   
   # now you can call describe automl job created in account A 
   
   job_name = "test-job"
   response= sm_client.describe_auto_ml_job(AutoMLJobName=job_name)
   ```

1. **Berikan akses ke akun penyebaran** ke artefak model di akun pembangkit.

   Akun penerapan hanya memerlukan akses ke artefak model di akun pembuat untuk menerapkannya. Ini terletak di [S3 OutputPath](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLOutputDataConfig.html#sagemaker-Type-AutoMLOutputDataConfig-S3OutputPath) yang ditentukan dalam panggilan `CreateAutoMLJob` API asli selama pembuatan model.

   Untuk memberikan akses akun penyebaran ke artefak model, pilih salah satu opsi berikut:

   1. [Berikan akses](https://aws.amazon.com/premiumsupport/knowledge-center/cross-account-access-s3/) ke `ModelDataUrl` dari akun pembangkit ke akun penyebaran.

      Selanjutnya, Anda perlu memberikan izin akun penerapan untuk mengambil peran tersebut. ikuti langkah-langkah [inferensi waktu nyata](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-deploy-models.html#autopilot-deploy-models-realtime) untuk menerapkan. 

   1. [Salin artefak model](https://aws.amazon.com/premiumsupport/knowledge-center/copy-s3-objects-account/) dari [S3](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLOutputDataConfig.html#sagemaker-Type-AutoMLOutputDataConfig-S3OutputPath) asli akun pembuat OutputPath ke akun pembuat.

      Untuk memberikan akses ke artefak model, Anda harus menentukan `best_candidate` model dan menetapkan ulang wadah model ke akun baru. 

      Contoh berikut menunjukkan bagaimana mendefinisikan `best_candidate` model dan menetapkan kembali. `ModelDataUrl`

      ```
      best_candidate = automl.describe_auto_ml_job()['BestCandidate']
      
      # reassigning ModelDataUrl for best_candidate containers below
      new_model_locations = ['new-container-1-ModelDataUrl', 'new-container-2-ModelDataUrl', 'new-container-3-ModelDataUrl']
      new_model_locations_index = 0
      for container in best_candidate['InferenceContainers']:
          container['ModelDataUrl'] = new_model_locations[new_model_locations_index++]
      ```

      Setelah penugasan kontainer ini, ikuti langkah-langkah [Menyebarkan menggunakan SageMaker APIs](#autopilot-deploy-models-api) untuk menerapkan.

Untuk membuat payload dalam inferensi real-time, lihat contoh notebook untuk [menentukan payload pengujian](https://aws.amazon.com/getting-started/hands-on/machine-learning-tutorial-automatically-create-models). Untuk membuat payload dari file CSV dan menjalankan endpoint, lihat bagian **Predict with your model di [Create a machine](https://aws.amazon.com/getting-started/hands-on/create-machine-learning-model-automatically-sagemaker-autopilot/#autopilot-cr-room) learning model** secara otomatis.