

 **Bantu meningkatkan 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 GitHub ** tautan ** Edit halaman ini di 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.

# Gunakan AWS Instans Inferentia dengan Amazon EKS untuk Pembelajaran Mesin
<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 ](https://aws.amazon.com/machine-learning/inferentia/)AWS Inferentia, yang dibuat khusus AWS untuk memberikan kinerja tinggi dan inferensi biaya terendah di cloud. Model pembelajaran mesin diterapkan 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 pembuatan 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 ID logis harus berdekatan. Jika Pod yang meminta beberapa perangkat Neuron dijadwalkan pada jenis `inf1.24xlarge` instans `inf1.6xlarge` atau (yang memiliki lebih dari satu perangkat Neuron), Pod tersebut akan gagal memulai jika penjadwal Kubernetes memilih ID perangkat yang tidak bersebelahan. Untuk informasi selengkapnya, lihat ID logis [ perangkat 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 [ Instal `eksctl` asi ](https://eksctl.io/installation) di dokumentasi.
+ Miliki `kubectl` yang ter-install pada komputer Anda. Untuk informasi selengkapnya, lihat [Siapkan `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 ](https://aws.amazon.com/ec2/instance-types/inf1/) Inf1 apa pun. `eksctl`Utilitas mendeteksi bahwa Anda meluncurkan grup node dengan tipe `Inf1` instance dan akan memulai node Anda menggunakan salah satu AMI Amazon Linux yang dioptimalkan yang dioptimalkan Amazon EKS.
**catatan**  
Anda tidak dapat menggunakan peran [ IAM untuk akun layanan ](iam-roles-for-service-accounts.md) dengan Serving TensorFlow .

   ```
   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 pada 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 telah 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 TensorFlow gambar aplikasi Serving
<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 ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html) Neuron 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 mengkompilasi model Neuron, lihat [ Chip AWS Inferentia With DLAM ](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-inferentia.html) I di Panduan Pengembang AMI Pembelajaran AWS Mendalam.

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 Kontainer Pembelajaran Mendalam yang telah dibuat sebelumnya yang dioptimalkan untuk Neuron disimpan di GitHub bawah Gambar [ yang ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-inference-containers) Tersedia. Saat start-up, DLC akan mengambil model Anda dari Amazon S3, meluncurkan Neuron Serving TensorFlow 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 [ 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 naskah klien sampel 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 Pel TensorFlow ayanan 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_neuron'
      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)]]
   ```