Implantar workloads de inferência de ML com o AWSInferentia no Amazon EKS

Para criar um cluster com os nós da instância Inf1 do Amazon EC2

1. Crie um cluster com os nós da instância Inf1 do Amazon EC2. É possível substituir inf1.2xlarge por qualquer tipo de instância Inf1. O utilitário eksctl detecta que você está iniciando um grupo de nós com um tipo de instância Inf1 e iniciará seus nós utilizando uma das AMIs aceleradas do Amazon Linux otimizadas para Amazon EKS.

   nota

   Você não pode usar funções do IAM para contas de serviço com o 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
   

   nota

   Observe o valor da seguinte linha da saída. Ele é usado em uma etapa posterior (opcional).

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

   Ao iniciar um grupo de nós com instâncias Inf1, o eksctl instala automaticamente o plug-in de dispositivo AWS Neuron Kubernetes. Este plug-in anuncia dispositivos Neuron como um recurso de sistema para o agendador do Kubernetes, que pode ser solicitado por um contêiner. Além das políticas padrão do IAM do nó do Amazon EKS, a política de acesso somente leitura do Amazon S3 é adicionada para que a aplicação de exemplo, abordada em uma etapa posterior, possa carregar um modelo treinado do Amazon S3.

2. Verifique se todos os Pods foram iniciados corretamente.

   kubectl get pods -n kube-system
   

   Saída abreviada:

   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

1. Adicione a política AmazonS3ReadOnlyAccess do política do IAM à função de instância do nó que foi criada na etapa 1 do Criar um cluster. Isso é necessário para que a aplicação de exemplo possa carregar um modelo treinado do Amazon S3.

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

2. Crie um arquivo denominado rn50_deployment.yaml com o seguinte conteúdo: Atualize o código da região e o caminho do modelo para corresponder às configurações desejadas. O nome do modelo é para fins de identificação quando um cliente faz uma solicitação ao servidor do TensorFlow. Este exemplo usa um nome de modelo para corresponder a um script de cliente ResNet50 de exemplo que será usado em uma etapa posterior para enviar solicitações de previsão.

   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

3. Implante o modelo.

   kubectl apply -f rn50_deployment.yaml
   

4. Crie um arquivo denominado rn50_service.yaml com o conteúdo a seguir. As portas HTTP e gRPC são abertas para aceitar solicitações de previsão.

   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

5. Crie um serviço Kubernetes para a aplicação de fornecimento de modelos TensorFlow.

   kubectl apply -f rn50_service.yaml
   

1. Para testar localmente, encaminhe a porta gRPC para o serviço eks-neuron-test.

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

2. Crie um script Python chamado tensorflow-model-server-infer.py com o conteúdo a seguir. Esse script executa a inferência via gRPC, que é um framework de serviço.

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

3. Execute o script para enviar previsões ao seu serviço.

   python3 tensorflow-model-server-infer.py
   

   Veja um exemplo de saída abaixo.

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