Machine Learning-Inferenz mit AWS Inferentia - Amazon EKS
VoraussetzungenErstellen eines Clusters(Optional) Stellen Sie ein TensorFlow Serving-Anwendungs-Image bereit(Optional) Treffen Sie Prognosen für Ihren TensorFlow Serving-Service

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Machine Learning-Inferenz mit AWS Inferentia

In diesem Thema wird beschrieben, wie Sie einen Amazon-EKS-Cluster mit Knoten erstellen, die Amazon EC2 Inf1 ausführen, und wie Sie (optional) eine Beispielanwendung bereitstellen. Amazon EC2 Inf1-Instances werden mit AWS Inferentia-Chips betrieben, die speziell für hohe Leistung und kostengünstigste Inferenz in der Cloud entwickelt wurden. AWS Modelle für maschinelles Lernen werden mithilfe von AWS Neuron, einem speziellen Software Development Kit (SDK), das aus Compiler-, Runtime- und Profiling-Tools besteht, in Containern bereitgestellt, die die Inferenzleistung von Inferentia-Chips für maschinelles Lernen optimieren. AWS Neuron unterstützt beliebte Frameworks für maschinelles Lernen wie TensorFlow PyTorch, und MXNet.

Anmerkung

Die logischen IDs von Neuron-Geräten müssen konsekutiv sein. Wenn ein Pod, der mehrere Neuron-Geräte anfordert, auf den Instance-Typen inf1.6xlarge oder inf1.24xlarge geplant wird (die mehr als ein Neuron-Gerät besitzen), wird dieser Pod nicht gestartet, wenn der Kubernetes Scheduler keine konsekutiven Geräte-IDs auswählt. Weitere Informationen finden Sie unter Logische Geräte-IDs müssen konsekutiv sein auf GitHub.

Voraussetzungen

  • eksctl ist auf Ihrem Computer installiert. Eine Installationsanleitung finden Sie bei Bedarf in der Dokumentation zu eksctl unter Installation.

  • Installieren Sie kubectl auf Ihrem Computer. Weitere Informationen finden Sie unter Installieren oder Aktualisieren von kubectl.

  • Installieren Sie python3 auf Ihrem Computer (optional). Wenn Sie es noch nicht installiert haben, finden Sie unter Python-Downloads entsprechende Installationsanweisungen.

Erstellen eines Clusters

Erstellen Sie einen Cluster mit Amazon-EC2-Instance-Knoten, auf denen Inf1-Instances ausgeführt werden.

  1. Erstellen Sie einen Cluster mit Knoten, auf denen Inf1 Amazon-EC2-Instances ausgeführt werden. Sie können inf1.2xlarge mit jedem Inf1-Instance-Typ ersetzen. Das eksctl-Dienstprogramm erkennt, dass Sie eine Knotengruppe mit einem Inf1-Instance-Typ starten, und startet Ihre Knoten mit einem der für Amazon EKS optimierten beschleunigten Amazon-Linux-AMIs.

    Anmerkung

    Sie können IAM-Rollen nicht für Dienstkonten mit Serving verwenden. 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
    Anmerkung

    Notieren Sie den Wert der folgenden Ausgabezeile. Dieser wird in einem späteren (optionalen) Schritt verwendet.

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

    Beim Starten einer Knotengruppe mit Inf1 Instanzen wird das AWS Kubernetes Neuron-Geräte-Plugin eksctl automatisch installiert. Dieses Plugin zeigt dem Kubernetes Scheduler Neuron-Geräte als Systemressourcen an, die von einem Container angefordert werden können. Zusätzlich zu den Standardrichtlinien für Amazon-EKS-Knoten wird die IAM-Richtlinie für den schreibgeschützten Zugriff von Amazon S3 hinzugefügt. So kann die in einem späteren Schritt behandelte Beispielanwendung ein trainiertes Modell aus Amazon S3 laden.

  2. Überprüfen Sie, ob alle Pods korrekt gestartet wurden.

    kubectl get pods -n kube-system

    Gekürzte Ausgabe:

    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

(Optional) Stellen Sie ein TensorFlow Serving-Anwendungs-Image bereit

Ein trainiertes Modell muss für ein Inferentia-Ziel zusammengetragen werden, bevor es auf Inferentia-Instances bereitgestellt werden kann. Um fortzufahren, benötigen Sie ein für Neuron optimiertes TensorFlow Modell, das in Amazon S3 gespeichert ist. Falls Sie noch keines haben SavedModel, folgen Sie bitte dem Tutorial zum Erstellen eines Neuron-kompatiblen ResNet 50-Modells und laden Sie das Ergebnis SavedModel auf S3 hoch. ResNet-50 ist ein beliebtes Modell für maschinelles Lernen, das für Bilderkennungsaufgaben verwendet wird. Weitere Informationen zur Kompilierung von Neuron-Modellen finden Sie unter The AWS Inferentia Chip With DLAMI im Developer Guide. AWS Deep Learning AMI

Das Beispiel-Deployment-Manifest verwaltet einen vorgefertigten Inferenz-Serving-Container, der von AWS Deep Learning Containers TensorFlow bereitgestellt wird. Im Container befinden sich die AWS Neuron Runtime und die TensorFlow Serving-Anwendung. Eine vollständige Liste der vorgefertigten Deep Learning Containers, die für Neuron optimiert sind, wird auf GitHub unter Verfügbare Images aus. Beim Start ruft der DLC Ihr Modell von Amazon S3 ab, startet Neuron TensorFlow Serving mit dem gespeicherten Modell und wartet auf Vorhersageanfragen.

Die Anzahl der Neuron-Geräte, die Ihrer Serving-Anwendung zugewiesen sind, kann angepasst werden, indem Sie die aws.amazon.com/neuron-Ressource in der Bereitstellung yaml verändern. Bitte beachten Sie, dass die Kommunikation zwischen TensorFlow Serving und der Neuron-Laufzeit über GRPC erfolgt, weshalb die Fähigkeit an den IPC_LOCK Container übergeben werden muss.

  1. Fügen Sie die IAM-Richtlinie-AmazonS3ReadOnlyAccess der Knoten-Instance-Rolle hinzu, die in Schritt 1 unter Erstellen eines Clusters erstellt wurde. Dies ist notwendig, damit die Beispielanwendung ein trainiertes Modell aus Amazon S3 laden kann.

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

  2. Erstellen Sie eine Datei mit dem Namen rn50_deployment.yaml und dem folgenden Inhalt. Aktualisieren Sie den Regions-Code und den Modellpfad entsprechend den gewünschten Einstellungen. Der Modellname dient zu Identifikationszwecken, wenn ein Client eine Anfrage an den TensorFlow Server stellt. In diesem Beispiel wird ein Modellname verwendet, der einem Beispiel-Clientskript von ResNet 50 entspricht, das in einem späteren Schritt zum Senden von Vorhersageanforderungen verwendet wird. 

    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. Stellen Sie das Modell bereit.

    kubectl apply -f rn50_deployment.yaml

  4. Erstellen Sie eine Datei mit dem Namen rn50_service.yaml und dem folgenden Inhalt. Die HTTP- und gRPC-Ports werden für die Annahme von Prognoseanforderungen geöffnet.

    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. Erstellen Sie einen Kubernetes Dienst für Ihre TensorFlow Model Serving-Anwendung.

    kubectl apply -f rn50_service.yaml

(Optional) Treffen Sie Prognosen für Ihren TensorFlow Serving-Service

  1. Um dies lokal zu testen, leiten Sie den gRPC-Port an den Service eks-neuron-test weiter.

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

  2. Erstellen Sie das Python-Skript namens tensorflow-model-server-infer.py mit folgendem Inhalt. Dieses Skript führt die Inferenz über gRPC (Service-Framework) aus.

    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. Führen Sie das Skript aus, um Prognosen an den Service zu senden.

    python3 tensorflow-model-server-infer.py

    Eine Beispielausgabe sieht wie folgt aus.

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