Voer machine learning-inferentieworkloads uit op AWS Graviton-gebaseerde instanties met Amazon SageMaker PlatoBlockchain Data Intelligence. Verticaal zoeken. Ai.

Voer machine learning-inferentieworkloads uit op AWS Graviton-gebaseerde instanties met Amazon SageMaker

Tijdstempel: 14 november 2022 3:08 uur

Vandaag lanceren we Amazon Sage Maker gevolgtrekking op AWS Graviton zodat u kunt profiteren van de prijs-, prestatie- en efficiëntievoordelen van Graviton-chips.

Op Graviton gebaseerde instanties zijn beschikbaar voor modelinferentie in SageMaker. Dit bericht helpt u bij het migreren en implementeren van een machine learning (ML)-inferentieworkload van x86 naar op Graviton gebaseerde instanties in SageMaker. We bieden een stapsgewijze handleiding voor het implementeren van uw door SageMaker getrainde model op op Graviton gebaseerde instanties, behandelen best practices bij het werken met Graviton, bespreken de prijs-prestatievoordelen en demonstreren hoe u een TensorFlow-model implementeert op een SageMaker Graviton-instantie.

Kort overzicht van Graviton

AWS Graviton is een familie van processors ontworpen door AWS die de beste prijs-kwaliteitverhouding bieden en energiezuiniger zijn dan hun x86-tegenhangers. AWS Graviton 3-processors zijn de nieuwste in de Graviton-processorfamilie en zijn geoptimaliseerd voor ML-workloads, inclusief ondersteuning voor bfloat16, en tweemaal de Single Instruction Multiple Data (SIMD) bandbreedte. Wanneer deze twee functies worden gecombineerd, kan Graviton 3 tot drie keer betere prestaties leveren dan Graviton 2-exemplaren. Graviton 3 gebruikt ook tot 60% minder energie voor dezelfde prestaties als vergelijkbare apparaten Amazon Elastic Compute-cloud (Amazon EC2) instanties. Dit is een geweldige functie als u uw ecologische voetafdruk wilt verkleinen en uw duurzaamheidsdoelen wilt bereiken.

Overzicht oplossingen

Om uw modellen op Graviton-instanties te implementeren, gebruikt u ofwel AWS diepe leercontainers or neem je eigen bakjes mee compatibel met Arm v8.2-architectuur.

De migratie (of nieuwe implementatie) van uw modellen van x86-aangedreven instanties naar Graviton-instanties is eenvoudig omdat AWS containers biedt om modellen te hosten met PyTorch, TensorFlow, Scikit-learn en XGBoost, en de modellen zijn architectuur-agnostisch. Desalniettemin, als u bereid bent om uw eigen bibliotheken mee te nemen, kunt u dat ook doen, zorg er gewoon voor dat uw container is gebouwd met een omgeving die Arm64-architectuur ondersteunt. Voor meer informatie, zie Uw eigen algoritmecontainer bouwen.

U moet drie stappen uitvoeren om uw model te implementeren:

  1. Maak een SageMaker-model: dit bevat onder andere de informatie over de locatie van het modelbestand, de container die zal worden gebruikt voor de implementatie en de locatie van het inferentiescript. (Als u al een bestaand model hebt geïmplementeerd in een op x86 gebaseerde inferentie-instantie, kunt u deze stap overslaan.)
  2. Een eindpuntconfiguratie maken: dit bevat informatie over het type instantie dat u wilt voor het eindpunt (bijvoorbeeld ml.c7g.xlarge voor Graviton3), de naam van het model dat u in stap 1 hebt gemaakt en het aantal instanties per eindpunt.
  3. Start het eindpunt met de eindpuntconfiguratie die in stap 2 is gemaakt.

Voorwaarden

Houd rekening met de volgende vereisten voordat u begint:

  1. Voltooi de vereisten zoals vermeld in Voorwaarden.
  2. Uw model moet een op PyTorch, TensorFlow, XGBoost of Scikit gebaseerd model zijn. De volgende tabel geeft een overzicht van de versies die momenteel worden ondersteund op het moment van schrijven. Voor de laatste updates, zie SageMaker Framework Containers (alleen SM-ondersteuning).
    . Python TensorFlow PyTorch Scikit leren XGBoost
    Ondersteunde versies 3.8 2.9.1 1.12.1 1.0-1 1.3-1 naar 1.5-1
  3. Het inferentiescript is opgeslagen in Amazon eenvoudige opslagservice (Amazone S3).

In de volgende secties leiden we u door de implementatiestappen.

Een SageMaker-model maken

Als u al een bestaand model hebt geïmplementeerd in een op x86 gebaseerde inferentie-instantie, kunt u deze stap overslaan. Voer anders de volgende stappen uit om een ​​SageMaker-model te maken:

  1. Zoek het model dat u in een S3-bucket hebt opgeslagen. Kopieer de URI.
    U gebruikt de model-URI later in de MODEL_S3_LOCATION.
  2. Identificeer de Framework-versie en de Python-versie die tijdens de model training zijn gebruikt.
    U moet een container selecteren uit de lijst met beschikbare AWS Deep Learning-containers volgens uw framework en Python-versie. Voor meer informatie, zie Introductie van multi-architectuur containerimages voor Amazon ECR.
  3. Zoek de URI van het inferentie Python-script in de S3-bucket (de algemene bestandsnaam is inference.py).
    De URI van het inferentiescript is nodig in het INFERENCE_SCRIPT_S3_LOCATION.
  4. Met deze variabelen kunt u vervolgens de SageMaker API aanroepen met de volgende opdracht: 
    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= 
)

U kunt ook afbeeldingen met meerdere architectuur maken en dezelfde afbeelding gebruiken, maar met verschillende tags. U kunt aangeven op welke architectuur uw instance wordt ingezet. Voor meer informatie, zie Introductie van multi-architectuur containerimages voor Amazon ECR.

Maak een eindpuntconfiguratie

Nadat u het model hebt gemaakt, moet u een eindpuntconfiguratie maken door de volgende opdracht uit te voeren (let op het type exemplaar dat we gebruiken):

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

De volgende schermafbeelding toont de configuratiedetails van het eindpunt op de SageMaker-console.

Start het eindpunt

Met de eindpuntconfiguratie die in de vorige stap is gemaakt, kunt u het eindpunt implementeren:

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

Wacht tot uw modeleindpunt is geïmplementeerd. Voorspellingen kunnen op dezelfde manier worden aangevraagd als u voorspellingen aanvraagt ​​voor uw eindpunten die zijn geïmplementeerd in x86-gebaseerde instanties.

De volgende schermafbeelding toont uw eindpunt op de SageMaker-console.

SageMaker-eindpunt van configuratie

Wat wordt ondersteund

SageMaker biedt voor prestaties geoptimaliseerde Graviton diepe containers voor TensorFlow- en PyTorch-frameworks. Deze containers ondersteunen computervisie, verwerking van natuurlijke taal, aanbevelingen en generieke deep en wide model-based inference use cases. Naast deep learning-containers biedt SageMaker ook containers voor klassieke ML-frameworks zoals XGBoost en Scikit-learn. De containers zijn binair compatibel met c6g/m6g- en c7g-instanties, waardoor het migreren van de inferentietoepassing van de ene generatie naar de andere naadloos verloopt.

C6g/m6g ondersteunt fp16 (half-precision float) en levert voor compatibele modellen gelijkwaardige of betere prestaties in vergelijking met c5-instanties. C7g verhoogt de ML-prestaties aanzienlijk door de SIMD-breedte te verdubbelen en bfloat-16 (bf16) te ondersteunen, het meest kostenefficiënte platform voor het uitvoeren van uw modellen.

Zowel c6g/m6g als c7g bieden goede prestaties voor klassieke ML (bijvoorbeeld XGBoost) in vergelijking met andere CPU-instanties in SageMaker. Bfloat-16-ondersteuning op c7g maakt een efficiënte inzet van bf16-getrainde of AMP-getrainde modellen (Automatic Mixed Precision) mogelijk. De Arm Compute Library (ACL)-backend op Graviton biedt bfloat-16-kernels die zelfs de fp32-operators kunnen versnellen via de snelle wiskundige modus, zonder de modelkwantisatie.

Aanbevolen praktische tips

Op Graviton-instanties is elke vCPU een fysieke kern. Er is geen strijd voor de gemeenschappelijke CPU-resources (in tegenstelling tot SMT) en de schaling van de werklastprestaties is lineair met elke vCPU-toevoeging. Daarom wordt aanbevolen om batchgevolgtrekkingen te gebruiken wanneer de use case dit toelaat. Dit maakt efficiënt gebruik van de vCPU's mogelijk door de batch op elke fysieke kern parallel te verwerken. Als de batch-inferentie niet mogelijk is, is de optimale instantiegrootte voor een bepaalde payload vereist om ervoor te zorgen dat de OS-threadplanning-overhead niet opweegt tegen de rekenkracht die wordt geleverd met de extra vCPU's.

TensorFlow wordt standaard geleverd met Eigen-kernels en het wordt aanbevolen om over te schakelen naar OneDNN met ACL om de meest geoptimaliseerde inferentie-backend te krijgen. De OneDNN-backend en de bfloat-16 snelle wiskundige modus kunnen worden ingeschakeld tijdens het starten van de containerservice:

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

Het voorgaande bedieningscommando host een standaard resnet50-model met twee belangrijke configuraties:

-e TF_ENABLE_ONEDNN_OPTS=1
-e DNNL_DEFAULT_FPMATH_MODE=BF16

Deze kunnen op de volgende manier worden doorgegeven aan de inferentiecontainer:

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

Implementatie voorbeeld

In dit bericht laten we u zien hoe u een TensorFlow-model, getraind in SageMaker, implementeert op een door Graviton aangedreven SageMaker-inferentie-instantie.

U kunt het codevoorbeeld uitvoeren in een SageMaker-notebookinstantie, en Amazon SageMaker Studio notebook of een Jupyter-notebook in lokale modus. U moet de SageMaker-uitvoeringsrol ophalen als u een Jupyter-notebook in lokale modus gebruikt.

In het volgende voorbeeld wordt de gegevensset CIFAR-10 beschouwd. U kunt het notebookvoorbeeld volgen uit de SageMaker-voorbeelden GitHub repo om het model te reproduceren dat in dit bericht wordt gebruikt. We gebruiken het getrainde model en de cifar10_keras_main.py Python-script voor gevolgtrekking.

Het model wordt opgeslagen in een S3-bucket: s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz

De cifar10_keras_main.py script, dat kan worden gebruikt voor de gevolgtrekking, is opgeslagen op:s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/script/cifar10_keras_main.py

We maken gebruik van de us-east-1 Regio en implementeer het model op een ml.c7g.xlarge Graviton-gebaseerde instantie. Op basis hiervan is de URI van onze AWS Deep Learning Container 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker

  1. Stel in met de volgende code: 
    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. Download de dataset voor eindpunttesten: 
    from keras.datasets import cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()

  3. Maak het model en de eindpuntconfiguratie en implementeer het eindpunt: 
    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. Optioneel kunt u uw inferentiescript toevoegen aan Environment in create_model als u het oorspronkelijk niet als een artefact aan uw SageMaker-model hebt toegevoegd tijdens de training: 
    "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)

    U moet een paar minuten wachten voordat de implementatie plaatsvindt.

  5. Controleer de eindpuntstatus met de volgende code: 
    describe_response = client.describe_endpoint(EndpointName=ENDPOINT_NAME)
print(describe_response["EndpointStatus"]

    U kunt ook de AWS-beheerconsole om te zien wanneer uw model is geïmplementeerd.

  6. Stel de runtime-omgeving in om de eindpunten aan te roepen: 
    runtime = boto3.Session().client(service_name="runtime.sagemaker")

    Nu bereiden we de payload voor om het eindpunt aan te roepen. We gebruiken hetzelfde type afbeeldingen dat wordt gebruikt voor de training van het model. Deze zijn in eerdere stappen gedownload.

  7. Cast de payload naar tensoren en stel het juiste formaat in dat het model verwacht. Voor dit voorbeeld vragen we slechts één voorspelling. 
    input_image = x_test[0].reshape(1,32,32,3)

    We krijgen de modeluitvoer als een array.

  8. We kunnen deze uitvoer omzetten in waarschijnlijkheden als we er een softmax op toepassen: 
    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())

Ruim middelen op

De diensten die bij deze oplossing betrokken zijn, brengen kosten met zich mee. Wanneer u klaar bent met het gebruik van deze oplossing, ruimt u de volgende bronnen op:

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

Prijs-prestatie vergelijking

Op Graviton gebaseerde instanties bieden de laagste prijs en de beste prijs-prestatieverhouding in vergelijking met op x86 gebaseerde instanties. Net als bij EC2-instanties, bieden de SageMaker-inferentie-eindpunten met ml.c6g-instanties (Graviton 2) een 20% lagere prijs in vergelijking met ml.c5, en de Graviton 3 ml.c7g-instanties zijn 15% goedkoper dan ml.c6-instanties. Voor meer informatie, zie Amazon SageMaker-prijzen.

Conclusie

In dit bericht hebben we de onlangs gelanceerde SageMaker-mogelijkheid getoond om modellen te implementeren in door Graviton aangedreven inferentie-instanties. We gaven u advies over best practices en bespraken kort de prijs-prestatievoordelen van het nieuwe type inferentie-exemplaren.

Voor meer informatie over Graviton, zie AWS Graviton-processor. U kunt aan de slag met op AWS Graviton gebaseerde EC2-instanties op de Amazon EC2-console en door te verwijzen naar AWS Graviton technische gids. U kunt een Sagemaker-modeleindpunt voor inferentie op Graviton implementeren met de voorbeeldcode in dit blogbericht.

Over de auteurs

Victor JaramilloVictor Jaramillo, PhD, is Senior Machine Learning Engineer bij AWS Professional Services. Voordat hij bij AWS kwam, was hij universiteitsprofessor en onderzoeker op het gebied van voorspellend onderhoud. In zijn vrije tijd houdt hij van motorrijden en doe-het-zelf motormonteurs.

Zmnako AwrahmanZmnako Awrahman, PhD, is Practice Manager, ML SME en lid van de Machine Learning Technical Field Community (TFC) bij Amazon Web Services. Hij helpt klanten de kracht van de cloud te benutten om waarde uit hun data te halen met data-analyse en machine learning.

Sunita NadampalliSunita Nadampalli is Software Development Manager bij AWS. Ze leidt Graviton-softwareprestatie-optimalisaties voor machineleuning, HPC en multimedia-workloads. Ze is gepassioneerd door open-sourceontwikkeling en het leveren van kosteneffectieve softwareoplossingen met Arm SoC's.

John LiuJohn Liu is een Software Development Engineer in het Amazon SageMaker-team. Haar huidige werk is gericht op het helpen van ontwikkelaars om machine learning-modellen efficiënt te hosten en de prestaties van gevolgtrekkingen te verbeteren. Ze is gepassioneerd door ruimtelijke data-analyse en het gebruik van AI om maatschappelijke problemen op te lossen.

Alan TanAlan Tan is Senior Product Manager bij SageMaker en leidt inspanningen op het gebied van grote modelinferentie. Hij heeft een passie voor het toepassen van machine learning op het gebied van analytics. Buiten zijn werk geniet hij van het buitenleven.

Tijdstempel:

Meer van AWS-machine learning