Usa le istanze AWS Inferentia con il tuo EKS cluster per il Machine Learning

Crea un cluster con nodi di EC2 istanze Amazon Inf1. Puoi sostituire inf1.2xlarge con qualsiasi tipo di istanza Inf1. L'eksctlutilità rileva che stai avviando un gruppo di nodi con un tipo di Inf1 istanza e avvierà i nodi utilizzando uno degli Amazon Linux accelerati EKS ottimizzati per Amazon. AMIs

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

Quando si avvia un gruppo di nodi con Inf1 istanze, installa eksctl automaticamente Neuron AWS Kubernetes plug-in del dispositivo. Questo plugin pubblicizza i dispositivi Neuron come risorsa di sistema per Kubernetes scheduler, che può essere richiesto da un contenitore. Oltre alle IAM policy predefinite dei EKS nodi Amazon, viene aggiunta la policy di accesso in sola lettura di Amazon S3 in modo che l'applicazione di esempio, trattata in un passaggio successivo, possa caricare un modello addestrato da Amazon S3.

Assicurati che tutto Pods sono iniziati correttamente.

kubectl get pods -n kube-system

Output abbreviato:

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

Aggiungi la AmazonS3ReadOnlyAccess IAM policy al ruolo dell'istanza del nodo creato nel passaggio 1 di Creare un cluster. Ciò è necessario affinché l'applicazione di esempio possa caricare un modello formato da Amazon S3.

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

Crea un file denominato rn50_deployment.yaml con i seguenti contenuti. Aggiornare il codice di Regione e il percorso del modello in modo che corrispondano alle impostazioni desiderate. Il nome del modello serve a scopi di identificazione quando un client effettua una richiesta al TensorFlow server. Questo esempio utilizza un nome di modello che corrisponde a uno script client di esempio di ResNet 50 client che verrà utilizzato in un passaggio successivo per l'invio di richieste di previsione.

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

Implementare il modello.

kubectl apply -f rn50_deployment.yaml

Crea un file denominato rn50_service.yaml con i seguenti contenuti. Le RPC porte HTTP e g vengono aperte per accettare le richieste di previsione.

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

Crea un Kubernetes servizio per la tua applicazione TensorFlow Model Serving.

kubectl apply -f rn50_service.yaml

Per eseguire il test localmente, inoltra la RPC porta g al eks-neuron-test servizio.

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

Creare uno script Python chiamato tensorflow-model-server-infer.py con il seguente contenuto. Questo script esegue l'inferenza tramite gRPC, che è il framework di servizio.

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

Eseguire lo script per inviare previsioni al servizio.

python3 tensorflow-model-server-infer.py

Di seguito viene riportato un output di esempio:

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