Führen Sie Inferenz-Workloads für maschinelles Lernen auf AWS Graviton-basierten Instances mit Amazon SageMaker aus

Heute starten wir Amazon Sage Maker Schlussfolgerung auf AWS Graviton damit Sie die Preis-, Leistungs- und Effizienzvorteile von Graviton-Chips nutzen können.

Graviton-basierte Instanzen sind für Modellrückschlüsse in SageMaker verfügbar. Dieser Beitrag hilft Ihnen bei der Migration und Bereitstellung einer Inferenz-Workload für maschinelles Lernen (ML) von x86 auf Graviton-basierte Instanzen in SageMaker. Wir bieten eine Schritt-für-Schritt-Anleitung zur Bereitstellung Ihres mit SageMaker trainierten Modells auf Graviton-basierten Instanzen, behandeln Best Practices bei der Arbeit mit Graviton, diskutieren die Preis-Leistungs-Vorteile und demonstrieren, wie Sie ein TensorFlow-Modell auf einer SageMaker Graviton-Instanz bereitstellen.

Kurzer Überblick über Graviton

AWS Graviton ist eine von AWS entwickelte Familie von Prozessoren, die das beste Preis-Leistungs-Verhältnis bieten und energieeffizienter sind als ihre x86-Pendants. AWS Graviton 3-Prozessoren sind die neuesten in der Graviton-Prozessorfamilie und sind für ML-Workloads optimiert, einschließlich Unterstützung für bfloat16 und der doppelten SIMD-Bandbreite (Single Instruction Multiple Data). Wenn diese beiden Funktionen kombiniert werden, kann Graviton 3 im Vergleich zu Graviton 2-Instanzen eine bis zu dreimal bessere Leistung liefern. Graviton 3 verbraucht außerdem bis zu 60 % weniger Energie bei gleicher Leistung als vergleichbare Geräte Amazon Elastic Compute-Cloud (Amazon EC2)-Instanzen. Dies ist eine großartige Funktion, wenn Sie Ihren COXNUMX-Fußabdruck reduzieren und Ihre Nachhaltigkeitsziele erreichen möchten.

Lösungsüberblick

Um Ihre Modelle auf Graviton-Instanzen bereitzustellen, verwenden Sie entweder AWS Deep Learning Container or Bringen Sie Ihre eigenen Behälter mit kompatibel mit Arm v8.2-Architektur.

Die Migration (oder Neubereitstellung) Ihrer Modelle von x86-basierten Instances zu Graviton-Instances ist einfach, da AWS Container zum Hosten von Modellen mit PyTorch, TensorFlow, Scikit-learn und XGBoost bereitstellt und die Modelle architekturunabhängig sind. Wenn Sie jedoch bereit sind, Ihre eigenen Bibliotheken mitzubringen, können Sie dies auch tun, stellen Sie jedoch sicher, dass Ihr Container mit einer Umgebung erstellt wurde, die die Arm64-Architektur unterstützt. Weitere Informationen finden Sie unter Erstellen Sie Ihren eigenen Algorithmus-Container.

Sie müssen drei Schritte ausführen, um Ihr Modell bereitzustellen:

1. Erstellen Sie ein SageMaker-Modell: Dieses enthält neben anderen Parametern die Informationen über den Speicherort der Modelldatei, den Container, der für die Bereitstellung verwendet wird, und den Speicherort des Inferenzskripts. (Wenn Sie bereits ein vorhandenes Modell in einer x86-basierten Inferenzinstanz bereitgestellt haben, können Sie diesen Schritt überspringen.)
2. Erstellen Sie eine Endpunktkonfiguration: Diese enthält Informationen über den gewünschten Instanztyp für den Endpunkt (z. B. ml.c7g.xlarge für Graviton3), den Namen des Modells, das Sie in Schritt 1 erstellt haben, und die Anzahl der Instanzen pro Endpunkt.
3. Starten Sie den Endpunkt mit der in Schritt 2 erstellten Endpunktkonfiguration.

Voraussetzungen:

Berücksichtigen Sie vor dem Start die folgenden Voraussetzungen:

1. Erfüllen Sie die Voraussetzungen wie in aufgeführt Voraussetzungen:.
2. Ihr Modell sollte entweder ein PyTorch-, TensorFlow-, XGBoost- oder Scikit-learn-basiertes Modell sein. Die folgende Tabelle fasst die Versionen zusammen, die zum Zeitpunkt dieses Schreibens derzeit unterstützt werden. Die neuesten Updates finden Sie unter SageMaker-Framework-Container (nur SM-Unterstützung).
   

   .	Python	TensorFlow	PyTorch	Scikit-lernen	XGBoost
   Unterstützte Versionen	3.8	2.9.1	1.12.1	1.0-1	1.3-1 zu 1.5-1

3. Das Inferenzskript wird gespeichert in Amazon Simple Storage-Service (Amazon S3).

In den folgenden Abschnitten führen wir Sie durch die Bereitstellungsschritte.

Erstellen Sie ein SageMaker-Modell

Wenn Sie bereits ein vorhandenes Modell in einer x86-basierten Rückschlussinstanz bereitgestellt haben, können Sie diesen Schritt überspringen. Führen Sie andernfalls die folgenden Schritte aus, um ein SageMaker-Modell zu erstellen:

1. Suchen Sie das Modell, das Sie in einem S3-Bucket gespeichert haben. Kopieren Sie den URI.
   Sie verwenden den Modell-URI später in der MODEL_S3_LOCATION.
2. Identifizieren Sie die Framework-Version und die Python-Version, die während des Modelltrainings verwendet wurden.
   Sie müssen einen Container aus der Liste der verfügbaren AWS Deep Learning-Container für Ihr Framework und Ihre Python-Version auswählen. Weitere Informationen finden Sie unter Einführung von Container-Images mit mehreren Architekturen für Amazon ECR.
3. Suchen Sie den Inferenz-Python-Skript-URI im S3-Bucket (der allgemeine Dateiname lautet inference.py).
   Der Inferenzskript-URI wird in der benötigt INFERENCE_SCRIPT_S3_LOCATION.
4. Mit diesen Variablen können Sie dann die SageMaker-API mit dem folgenden Befehl aufrufen:

   client = boto3.client("sagemaker")
   
   client.create_model(
       ModelName="Your model name",
       PrimaryContainer={
           "Image": ,
           "ModelDataUrl": ,
           "Environment": {
           "SAGEMAKER_PROGRAM": "inference.py",
           "SAGEMAKER_SUBMIT_DIRECTORY": ,
           "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
           "SAGEMAKER_REGION": 
           }
       },
       ExecutionRoleArn= 
   )

Sie können auch Multi-Architektur-Images erstellen und dasselbe Image, aber mit unterschiedlichen Tags verwenden. Sie können angeben, auf welcher Architektur Ihre Instanz bereitgestellt wird. Weitere Informationen finden Sie unter Einführung von Container-Images mit mehreren Architekturen für Amazon ECR.

Erstellen Sie eine Endpunktkonfiguration

Nachdem Sie das Modell erstellt haben, müssen Sie eine Endpunktkonfiguration erstellen, indem Sie den folgenden Befehl ausführen (beachten Sie den von uns verwendeten Instanztyp):

client.create_endpoint_config(
    EndpointConfigName= ,
    ProductionVariants=[
        {
         "VariantName": "v0",
         "ModelName": "Your model name",
         "InitialInstanceCount": 1,
         "InstanceType": "ml.c7g.xlarge",
        },
    ]
)

Der folgende Screenshot zeigt die Endpunktkonfigurationsdetails in der SageMaker-Konsole.

Starten Sie den Endpunkt

Mit der im vorherigen Schritt erstellten Endpunktkonfiguration können Sie den Endpunkt bereitstellen:

client.create_endpoint(
    EndpointName = "",
    EndpointConfigName = ""
    )

Warten Sie, bis Ihr Modellendpunkt bereitgestellt ist. Vorhersagen können auf die gleiche Weise angefordert werden wie Vorhersagen für Ihre Endpunkte, die in x86-basierten Instanzen bereitgestellt werden.

Der folgende Screenshot zeigt Ihren Endpunkt in der SageMaker-Konsole.

Was wird unterstützt

SageMaker bietet leistungsoptimierte tiefe Graviton-Container für TensorFlow- und PyTorch-Frameworks. Diese Container unterstützen Computer Vision, Verarbeitung natürlicher Sprache, Empfehlungen und generische tiefe und breite modellbasierte Inferenzanwendungsfälle. Neben Deep-Learning-Containern stellt SageMaker auch Container für klassische ML-Frameworks wie XGBoost und Scikit-learn bereit. Die Container sind über c6g/m6g- und c7g-Instanzen binärkompatibel, daher ist die Migration der Inferenzanwendung von einer Generation zur anderen nahtlos.

C6g/m6g unterstützt fp16 (float mit halber Genauigkeit) und bietet für kompatible Modelle eine gleichwertige oder bessere Leistung im Vergleich zu c5-Instances. C7g erhöht die ML-Leistung erheblich, indem es die SIMD-Breite verdoppelt und bfloat-16 (bf16) unterstützt, die kostengünstigste Plattform zum Ausführen Ihrer Modelle.

Sowohl c6g/m6g als auch c7g bieten eine gute Leistung für klassisches ML (z. B. XGBoost) im Vergleich zu anderen CPU-Instanzen in SageMaker. Bfloat-16-Unterstützung auf c7g ermöglicht eine effiziente Bereitstellung von bf16-trainierten oder AMP-trainierten Modellen (Automatic Mixed Precision). Das Backend der Arm Compute Library (ACL) auf Graviton bietet bfloat-16-Kernel, die sogar die fp32-Operatoren über den schnellen mathematischen Modus beschleunigen können, ohne die Modellquantisierung.

Empfohlene Best Practices

Auf Graviton-Instanzen ist jede vCPU ein physischer Kern. Es gibt keine Konkurrenz um die gemeinsamen CPU-Ressourcen (anders als bei SMT), und die Skalierung der Workload-Leistung erfolgt linear mit jeder hinzugefügten vCPU. Daher wird empfohlen, die Batch-Inferenz zu verwenden, wann immer der Anwendungsfall dies zulässt. Dies ermöglicht eine effiziente Nutzung der vCPUs durch parallele Verarbeitung des Stapels auf jedem physischen Kern. Wenn die Batch-Inferenz nicht möglich ist, ist die optimale Instance-Größe für eine bestimmte Nutzlast erforderlich, um sicherzustellen, dass der Overhead der OS-Thread-Planung nicht die Rechenleistung überwiegt, die mit den zusätzlichen vCPUs einhergeht.

TensorFlow wird standardmäßig mit Eigen-Kernels geliefert, und es wird empfohlen, zu OneDNN mit ACL zu wechseln, um das am besten optimierte Inferenz-Backend zu erhalten. Das OneDNN-Backend und der schnelle Mathematikmodus bfloat-16 können beim Starten des Containerdienstes aktiviert werden:

docker run -p 8501:8501 --name tfserving_resnet 
--mount type=bind,source=/tmp/resnet,target=/models/resnet 
-e MODEL_NAME=resnet -e TF_ENABLE_ONEDNN_OPTS=1 
-e DNNL_DEFAULT_FPMATH_MODE=BF16 -e -t tfs:mkl_aarch64

Der vorangehende Serving-Befehl hostet ein standardmäßiges resnet50-Modell mit zwei wichtigen Konfigurationen:

-e TF_ENABLE_ONEDNN_OPTS=1
-e DNNL_DEFAULT_FPMATH_MODE=BF16

Diese können folgendermaßen an den Inferenzcontainer übergeben werden:

client.create_model(
    ModelName="Your model name",
    PrimaryContainer={
    "Image": ,
    "ModelDataUrl": ,
    "Environment": {
        "SAGEMAKER_PROGRAM": "inference.py",
        "SAGEMAKER_SUBMIT_DIRECTORY": "",
        "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
        "SAGEMAKER_REGION": ,
        "TF_ENABLE_ONEDNN_OPTS": "1",
        "DNNL_DEFAULT_FPMATH_MODE": "BF16"
         }
     },
     ExecutionRoleArn='ARN for AmazonSageMaker-ExecutionRole'
)

Bereitstellungsbeispiel

In diesem Beitrag zeigen wir Ihnen, wie Sie ein in SageMaker trainiertes TensorFlow-Modell auf einer Graviton-basierten SageMaker-Inferenzinstanz bereitstellen.

Sie können das Codebeispiel entweder in einer SageMaker-Notebookinstanz, einer Amazon SageMaker-Studio notebook oder ein Jupyter-Notebook im lokalen Modus. Sie müssen die SageMaker-Ausführungsrolle abrufen, wenn Sie ein Jupyter-Notebook im lokalen Modus verwenden.

Das folgende Beispiel betrachtet den CIFAR-10-Datensatz. Sie können dem Notebook-Beispiel aus den SageMaker-Beispielen folgen GitHub Repo um das Modell zu reproduzieren, das in diesem Beitrag verwendet wird. Wir verwenden das trainierte Modell und die cifar10_keras_main.py Python-Skript für Rückschlüsse.

Das Modell wird in einem S3-Bucket gespeichert: s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz

Das cifar10_keras_main.py Skript, das für die Inferenz verwendet werden kann, ist gespeichert unter:s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/script/cifar10_keras_main.py

Wir nutzen die us-east-1 Region und stellen Sie das Modell auf einer ml.c7g.xlarge Graviton-basierten Instanz bereit. Darauf basierend lautet die URI unseres AWS Deep Learning Containers 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker

1. Mit folgendem Code einrichten:

   import sagemaker
   import boto3
   import datetime
   import json
   import gzip
   import os
   
   sagemaker_session = sagemaker.Session()
   bucket = sagemaker_session.default_bucket()
   role = sagemaker.get_execution_role()
   region = sagemaker_session.boto_region_name

2. Laden Sie das Dataset für Endpunkttests herunter:

   from keras.datasets import cifar10
   (x_train, y_train), (x_test, y_test) = cifar10.load_data()

3. Erstellen Sie das Modell und die Endpunktkonfiguration und stellen Sie den Endpunkt bereit:

   timestamp = "{:%Y-%m-%d-%H-%M-%S}".format(datetime.datetime.now())
   
   client = boto3.client("sagemaker")
   
   MODEL_NAME = f"graviton-model-{timestamp}"
   ENDPOINT_NAME = f"graviton-endpoint-{timestamp}"
   ENDPOINT_CONFIG_NAME = f"graviton-endpoint-config-{timestamp}"
   
   # create sagemaker model
   create_model_response = client.create_model(
       ModelName=MODEL_NAME,
       PrimaryContainer={
       "Image":  "763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker ",
       "ModelDataUrl":  "s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz",
       "Environment": {
           "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
           "SAGEMAKER_REGION": region
           }
       },
       ExecutionRoleArn=role
   )
   print ("create_model API response", create_model_response)

4. Optional können Sie Ihr Inferenzskript hinzufügen Environment in create_model wenn Sie es während des Trainings nicht ursprünglich als Artefakt zu Ihrem SageMaker-Modell hinzugefügt haben:

   "SAGEMAKER_PROGRAM": "inference.py",
   "SAGEMAKER_SUBMIT_DIRECTORY": ,
   		
   # create sagemaker endpoint config
   create_endpoint_config_response = client.create_endpoint_config(
       EndpointConfigName=ENDPOINT_CONFIG_NAME,
       ProductionVariants=[
           {
            "VariantName": "v0",
            "ModelName": MODEL_NAME,
            "InitialInstanceCount": 1,
            "InstanceType": "ml.c7g.xlarge" 
           },
       ]
   )
   print ("ncreate_endpoint_config API response", create_endpoint_config_response)
   
   # create sagemaker endpoint
   create_endpoint_response = client.create_endpoint(
       EndpointName = ENDPOINT_NAME,
       EndpointConfigName = ENDPOINT_CONFIG_NAME,
   )
   print ("ncreate_endpoint API response", create_endpoint_response)   
   

   Sie müssen einige Minuten warten, bis die Bereitstellung erfolgt.

5. Überprüfen Sie den Endpunktstatus mit dem folgenden Code:

   describe_response = client.describe_endpoint(EndpointName=ENDPOINT_NAME)
   print(describe_response["EndpointStatus"]

   Sie können auch das überprüfen AWS-Managementkonsole um zu sehen, wann Ihr Modell bereitgestellt wird.

6. Richten Sie die Laufzeitumgebung ein, um die Endpunkte aufzurufen:

   runtime = boto3.Session().client(service_name="runtime.sagemaker")

   Jetzt bereiten wir die Nutzlast vor, um den Endpunkt aufzurufen. Wir verwenden die gleiche Art von Bildern, die für das Training des Modells verwendet werden. Diese wurden in vorherigen Schritten heruntergeladen.

7. Wandeln Sie die Nutzlast in Tensoren um und legen Sie das richtige Format fest, das das Modell erwartet. Für dieses Beispiel fordern wir nur eine Vorhersage an.

   input_image = x_test[0].reshape(1,32,32,3)

   Wir erhalten die Modellausgabe als Array.

8. Wir können diese Ausgabe in Wahrscheinlichkeiten umwandeln, wenn wir einen Softmax darauf anwenden:

   CONTENT_TYPE = 'application/json'
   ACCEPT = 'application/json'
   PAYLOAD = json.dumps(input_image.tolist())
   
   response = runtime.invoke_endpoint(
       EndpointName=ENDPOINT_NAME, 
       ContentType=CONTENT_TYPE,
       Accept=ACCEPT,
       Body=PAYLOAD
   )
       
   print(response['Body'].read().decode())

Ressourcen bereinigen

Die an dieser Lösung beteiligten Dienstleistungen sind mit Kosten verbunden. Wenn Sie mit der Verwendung dieser Lösung fertig sind, bereinigen Sie die folgenden Ressourcen:

client.delete_endpoint(EndpointName=ENDPOINT_NAME)
client.delete_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
client.delete_model(ModelName=MODEL_NAME)

Preis-Leistungs-Vergleich

Graviton-basierte Instanzen bieten im Vergleich zu x86-basierten Instanzen den niedrigsten Preis und das beste Preis-Leistungs-Verhältnis. Ähnlich wie EC2-Instances bieten die SageMaker-Inferenzendpunkte mit ml.c6g-Instances (Graviton 2) einen um 20 % niedrigeren Preis im Vergleich zu ml.c5, und die ml.c3g-Instances von Graviton 7 sind 15 % günstiger als ml.c6-Instances. Weitere Informationen finden Sie unter Amazon SageMaker Preise.

Zusammenfassung

In diesem Beitrag haben wir die neu eingeführte SageMaker-Funktion zum Bereitstellen von Modellen in Graviton-betriebenen Inferenzinstanzen vorgestellt. Wir haben Ihnen Tipps zu Best Practices gegeben und kurz die Preis-Leistungs-Vorteile der neuen Art von Inferenzinstanzen besprochen.

Weitere Informationen zu Graviton finden Sie unter AWS Graviton-Prozessor. Sie können mit AWS Graviton-basierten EC2-Instances auf der Amazon EC2-Konsole beginnen und sich auf beziehen Technischer Leitfaden zu AWS Graviton. Mit dem Beispielcode in diesem Blogbeitrag können Sie einen Sagemaker-Modellendpunkt für Inferenz auf Graviton bereitstellen.

Über die Autoren

Victor Jaramillo, PhD, ist Senior Machine Learning Engineer bei AWS Professional Services. Vor AWS war er Universitätsprofessor und Forschungswissenschaftler im Bereich Predictive Maintenance. In seiner Freizeit fährt er gerne Motorrad und bastelt Motorradmechaniker.

Zmnako Awrahman, PhD, ist Praxismanager, ML SME und Mitglied der Machine Learning Technical Field Community (TFC) bei Amazon Web Services. Er hilft Kunden, die Leistungsfähigkeit der Cloud zu nutzen, um mit Datenanalysen und maschinellem Lernen Wert aus ihren Daten zu ziehen.

Sunita Nadampalli ist Software Development Manager bei AWS. Sie leitet Graviton-Softwareleistungsoptimierungen für Maschinenlernen, HPC und Multimedia-Workloads. Ihre Leidenschaft gilt der Open-Source-Entwicklung und der Bereitstellung kostengünstiger Softwarelösungen mit Arm-SoCs.

John Liu ist Software Development Engineer im Amazon SageMaker-Team. Ihre aktuelle Arbeit konzentriert sich darauf, Entwicklern dabei zu helfen, Modelle für maschinelles Lernen effizient zu hosten und die Inferenzleistung zu verbessern. Ihre Leidenschaft gilt der räumlichen Datenanalyse und dem Einsatz von KI zur Lösung gesellschaftlicher Probleme.

Alan Tan ist Senior Product Manager bei SageMaker und leitet die Bemühungen zur Inferenz großer Modelle. Er setzt sich leidenschaftlich für die Anwendung von maschinellem Lernen im Bereich Analytics ein. Außerhalb der Arbeit genießt er die Natur.