Utilisation AWS Instances Inferentia avec Amazon EKS pour l'apprentissage automatique

Créez un cluster avec des nœuds d'instances Amazon EC2 Inf1. Vous pouvez remplacer inf1.2xlarge par n'importe quel type d'instance Inf1. L'utilitaire eksctl détecte que vous lancez un groupe de nœuds avec un type d'instance Inf1 et démarre vos nœuds à l'aide de l'une des AMI Amazon Linux optimisées et accélérées.

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

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

Lors du lancement d'un groupe de nœuds avec des Inf1 instances, le plug-in de périphérique AWS Neuron Kubernetes est eksctl automatiquement installé. Ce plug-in annonce les appareils Neuron comme une ressource système au planificateur Kubernetes, qui peut être demandé par un conteneur. Outre les stratégies IAM de nœud Amazon EKS par défaut, la stratégie d'accès en lecture seule Amazon S3 est ajoutée afin que l'exemple d'application, traité dans une étape ultérieure, puisse charger un modèle formé à partir d'Amazon S3.

Assurez-vous que tous les pods ont démarré correctement.

kubectl get pods -n kube-system

Sortie abrégée :

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

Ajoutez la politique IAM AmazonS3ReadOnlyAccess au rôle d’instance de nœud créé à l’étape 1 de la section Créer un cluster. Ceci est nécessaire pour que l'application exemple puisse charger un modèle formé à partir de Amazon S3.

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

Créez un fichier nommé rn50_deployment.yaml avec les contenus suivants. Mettez à jour le code régional et le chemin du modèle pour correspondre aux paramètres souhaités. Le nom du modèle est utilisé à des fins d'identification lorsqu'un client adresse une demande au TensorFlow serveur. Cet exemple utilise un nom de modèle correspondant à un exemple de script client de ResNet 50 qui sera utilisé ultérieurement pour envoyer des demandes de prédiction.

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

Déployez le modèle.

kubectl apply -f rn50_deployment.yaml

Créez un fichier nommé rn50_service.yaml avec les contenus suivants. Les ports HTTP et gRPC sont ouverts pour accepter les demandes de prédiction.

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

Créez un service Kubernetes pour votre TensorFlow modèle d'application Serving.

kubectl apply -f rn50_service.yaml

Pour tester localement, transférez le port gRPC au service eks-neuron-test.

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

Créez un script Python appelé tensorflow-model-server-infer.py avec le contenu suivant. Ce script exécute l'inférence via gRPC, qui est un framework de services.

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))

Exécutez le script pour soumettre des prédictions à votre service.

python3 tensorflow-model-server-infer.py

L'exemple qui suit illustre un résultat.

[[(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)]]