

 **Bantu tingkatkan halaman ini** 

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

Untuk berkontribusi pada panduan pengguna ini, pilih **Edit halaman ini pada GitHub** tautan yang terletak di panel kanan setiap halaman.

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

# Menggunakan instans AWS Inferentia dengan Amazon EKS untuk Machine Learning
<a name="inferentia-support"></a>

Topik ini menjelaskan cara membuat klaster Amazon EKS dengan simpul yang berjalan [Inf1 Amazon EC2](https://aws.amazon.com/ec2/instance-types/inf1/) instans dan (opsional) men-deploy aplikasi sampel. Instans Amazon EC2 Inf1 didukung oleh chip [AWS Inferentia](https://aws.amazon.com/machine-learning/inferentia/), yang dibuat khusus AWS untuk memberikan kinerja tinggi dan inferensi biaya terendah di cloud. Model pembelajaran mesin digunakan ke wadah menggunakan [AWS Neuron](https://aws.amazon.com/machine-learning/neuron/), kit pengembangan perangkat lunak khusus (SDK) yang terdiri dari kompiler, runtime, dan alat profil yang mengoptimalkan kinerja inferensi pembelajaran mesin chip Inferentia. AWS Neuron mendukung kerangka kerja pembelajaran mesin populer seperti TensorFlow, PyTorch, dan MXNet.

**catatan**  
Perangkat neuron logis IDs harus bersebelahan. Jika sebuah Pod yang meminta beberapa perangkat Neuron dijadwalkan pada tipe `inf1.6xlarge` atau `inf1.24xlarge` instance (yang memiliki lebih dari satu perangkat Neuron), Pod tersebut akan gagal untuk memulai jika penjadwal Kubernetes memilih perangkat yang tidak bersebelahan. IDs Untuk informasi selengkapnya, lihat [Logika perangkat IDs harus bersebelahan](https://github.com/aws/aws-neuron-sdk/issues/110). GitHub

## Prasyarat
<a name="inferentia-prerequisites"></a>
+ Miliki `eksctl` yang terinstal pada komputer Anda. Jika Anda belum menginstalnya, lihat [Instalasi](https://eksctl.io/installation) di `eksctl` dokumentasi.
+ Miliki `kubectl` yang ter-install pada komputer Anda. Untuk informasi selengkapnya, lihat [Mengatur `kubectl` dan `eksctl`](install-kubectl.md).
+ (Opsional) Miliki `python3` yang ter-install pada komputer Anda. Jika Anda belum menginstalnya, lihat [unduhan Python](https://www.python.org/downloads/) untuk petunjuk penginstalan.

## Buat klaster
<a name="create-cluster-inferentia"></a>

1. Membuat klaster dengan simpul instans Inf1 Amazon EC2. Anda dapat mengganti {{inf1.2xlarge}} dengan [jenis instans Inf1](https://aws.amazon.com/ec2/instance-types/inf1/) apa pun. `eksctl`Utilitas mendeteksi bahwa Anda meluncurkan grup node dengan tipe `Inf1` instans dan akan memulai node Anda menggunakan salah satu Amazon EKS yang dioptimalkan Amazon Linux AMIs yang dipercepat.
**catatan**  
Anda tidak dapat menggunakan [peran IAM untuk akun layanan](iam-roles-for-service-accounts.md) dengan TensorFlow Serving.

   ```
   eksctl create cluster \
       --name inferentia \
       --region region-code \
       --nodegroup-name ng-inf1 \
       --node-type inf1.2xlarge \
       --nodes 2 \
       --nodes-min 1 \
       --nodes-max 4 \
       --ssh-access \
       --ssh-public-key your-key \
       --with-oidc
   ```
**catatan**  
Perhatikan nilai baris output berikut. Ini digunakan dalam langkah selanjutnya (opsional).

   ```
   [9]  adding identity "arn:aws: iam::111122223333:role/eksctl-inferentia-nodegroup-ng-in-NodeInstanceRole-FI7HIYS3BS09" to auth ConfigMap
   ```

   Saat meluncurkan grup node dengan `Inf1` instance, `eksctl` secara otomatis menginstal plugin perangkat AWS Neuron Kubernetes. Plugin ini mengiklankan perangkat Neuron sebagai sumber daya sistem ke penjadwal Kubernetes, yang dapat diminta oleh kontainer. Sebagai tambahan untuk kebijakan IAM simpul Amazon EKS default, Amazon S3 hanya membaca kebijakan akses yang ditambahkan sehingga aplikasi sampel, dibahas dalam langkah berikutnya, dapat memuat model terlatih dari Amazon S3.

1. Pastikan semua Pod sudah dimulai dengan benar.

   ```
   kubectl get pods -n kube-system
   ```

   Output yang disingkat:

   ```
   NAME                                   READY   STATUS    RESTARTS   AGE
   [...]
   neuron-device-plugin-daemonset-6djhp   1/1     Running   0          5m
   neuron-device-plugin-daemonset-hwjsj   1/1     Running   0          5m
   ```

## (Opsional) Menyebarkan gambar aplikasi TensorFlow Penyajian
<a name="deploy-tensorflow-serving-application"></a>

Sebuah model terlatih harus dikompilasikan ke target Inferentia sebelum dapat di-deploy pada instans Inferentia. Untuk melanjutkan, Anda memerlukan TensorFlow model yang [dioptimalkan Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html) yang disimpan di Amazon S3. Jika Anda belum memilikinya SavedModel, ikuti tutorial untuk [membuat model ResNet 50 yang kompatibel dengan Neuron](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-inferentia-tf-neuron.html) dan unggah hasilnya SavedModel ke S3. ResNet-50 adalah model pembelajaran mesin populer yang digunakan untuk tugas pengenalan gambar. Untuk informasi lebih lanjut tentang menyusun model Neuron, lihat [Chip AWS Inferentia Dengan DLAMI di Panduan Pengembang Pembelajaran](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-inferentia.html) Mendalam. AWS AMIs 

Manifes penerapan sampel mengelola wadah penyajian inferensi bawaan yang TensorFlow disediakan oleh AWS Deep Learning Containers. Di dalam wadah adalah AWS Neuron Runtime dan aplikasi TensorFlow Serving. Daftar lengkap Deep Learning Containers pra-bangun yang dioptimalkan untuk Neuron dipertahankan di GitHub bawah [Gambar yang Tersedia](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-inference-containers). Saat start-up, DLC akan mengambil model Anda dari Amazon S3, meluncurkan Neuron TensorFlow Serving dengan model yang disimpan, dan menunggu permintaan prediksi.

Jumlah perangkat Neuron yang dialokasikan untuk aplikasi penyajian Anda agar dapat disesuaikan dengan mengubah sumber daya `aws.amazon.com/neuron` dalam deployment yaml. Harap dicatat bahwa komunikasi antara TensorFlow Serving dan runtime Neuron terjadi melalui GRPC, yang membutuhkan penerusan `IPC_LOCK` kemampuan ke wadah.

1. Tambahkan kebijakan `AmazonS3ReadOnlyAccess` IAM ke peran instance node yang dibuat pada langkah 1 dari [Buat cluster](#create-cluster-inferentia). Hal ini diperlukan agar aplikasi sampel dapat memuat model terlatih dari Amazon S3.

   ```
   aws iam attach-role-policy \
       --policy-arn arn:aws: iam::aws:policy/AmazonS3ReadOnlyAccess \
       --role-name eksctl-inferentia-nodegroup-ng-in-NodeInstanceRole-FI7HIYS3BS09
   ```

1. Buat file bernama `rn50_deployment.yaml` dengan isi berikut ini. Memperbarui kode wilayah dan jalur model agar sesuai dengan pengaturan yang Anda inginkan. Nama model adalah untuk tujuan identifikasi ketika klien membuat permintaan ke TensorFlow server. Contoh ini menggunakan nama model untuk mencocokkan contoh skrip klien ResNet 50 yang akan digunakan pada langkah selanjutnya untuk mengirim permintaan prediksi.

   ```
   aws ecr list-images --repository-name neuron-rtd --registry-id 790709498068 --region us-west-2
   ```

   ```
   kind: Deployment
   apiVersion: apps/v1
   metadata:
     name: eks-neuron-test
     labels:
       app: eks-neuron-test
       role: master
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: eks-neuron-test
         role: master
     template:
       metadata:
         labels:
           app: eks-neuron-test
           role: master
       spec:
         containers:
           - name: eks-neuron-test
             image: 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-neuron:1.15.4-neuron-py37-ubuntu18.04
             command:
               - /usr/local/bin/entrypoint.sh
             args:
               - --port=8500
               - --rest_api_port=9000
               - --model_name=resnet50_neuron
               - --model_base_path=s3://${your-bucket-of-models}/resnet50_neuron/
             ports:
               - containerPort: 8500
               - containerPort: 9000
             imagePullPolicy: IfNotPresent
             env:
               - name: AWS_REGION
                 value: "us-east-1"
               - name: S3_USE_HTTPS
                 value: "1"
               - name: S3_VERIFY_SSL
                 value: "0"
               - name: S3_ENDPOINT
                 value: s3.us-east-1.amazonaws.com
               - name: AWS_LOG_LEVEL
                 value: "3"
             resources:
               limits:
                 cpu: 4
                 memory: 4Gi
                 aws.amazon.com/neuron: 1
               requests:
                 cpu: "1"
                 memory: 1Gi
             securityContext:
               capabilities:
                 add:
                   - IPC_LOCK
   ```

1. Men-deploy model.

   ```
   kubectl apply -f rn50_deployment.yaml
   ```

1. Membuat file bernama `rn50_service.yaml` dengan konten berikut. Port HTTP dan gRPC dibuka untuk menerima permintaan prediksi.

   ```
   kind: Service
   apiVersion: v1
   metadata:
     name: eks-neuron-test
     labels:
       app: eks-neuron-test
   spec:
     type: ClusterIP
     ports:
       - name: http-tf-serving
         port: 8500
         targetPort: 8500
       - name: grpc-tf-serving
         port: 9000
         targetPort: 9000
     selector:
       app: eks-neuron-test
       role: master
   ```

1. Buat layanan Kubernetes untuk aplikasi Serving TensorFlow model Anda.

   ```
   kubectl apply -f rn50_service.yaml
   ```

## (Opsional) Buat prediksi terhadap layanan TensorFlow Serving Anda
<a name="make-predictions-against-tensorflow-service"></a>

1. Untuk menguji secara lokal, meneruskan port gRPC ke layanan `eks-neuron-test`.

   ```
   kubectl port-forward service/eks-neuron-test 8500:8500 &
   ```

1. Membuat skrip Python yang disebut `tensorflow-model-server-infer.py` dengan konten berikut. Skrip ini menjalankan inferensi melalui gRPC, yang merupakan kerangka kerja layanan.

   ```
   import numpy as np
   import grpc
   import tensorflow as tf
   from tensorflow.keras.preprocessing import image
   from tensorflow.keras.applications.resnet50 import preprocess_input
   from tensorflow_serving.apis import predict_pb2
   from tensorflow_serving.apis import prediction_service_pb2_grpc
   from tensorflow.keras.applications.resnet50 import decode_predictions
   
   if __name__ == '__main__':
      channel = grpc.insecure_channel('localhost:8500')
      stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
      img_file = tf.keras.utils.get_file(
          "./kitten_small.jpg",
          "https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg")
      img = image.load_img(img_file, target_size=(224, 224))
      img_array = preprocess_input(image.img_to_array(img)[None, ...])
      request = predict_pb2.PredictRequest()
      request.model_spec.name = 'resnet50_inf1'
      request.inputs['input'].CopyFrom(
          tf.make_tensor_proto(img_array, shape=img_array.shape))
      result = stub.Predict(request)
      prediction = tf.make_ndarray(result.outputs['output'])
      print(decode_predictions(prediction))
   ```

1. Menjalankan penulisan untuk mengirimkan prediksi ke layanan Anda.

   ```
   python3 tensorflow-model-server-infer.py
   ```

   Contoh output adalah sebagai berikut.

   ```
   [[(u'n02123045', u'tabby', 0.68817204), (u'n02127052', u'lynx', 0.12701613), (u'n02123159', u'tiger_cat', 0.08736559), (u'n02124075', u'Egyptian_cat', 0.063844085), (u'n02128757', u'snow_leopard', 0.009240591)]]
   ```