Kör inferensarbetsbelastningar för maskininlärning på AWS Graviton-baserade instanser med Amazon SageMaker PlatoBlockchain Data Intelligence. Vertikal sökning. Ai.

Kör inferensarbetsbelastningar för maskininlärning på AWS Graviton-baserade instanser med Amazon SageMaker

Tidsstämpel: 14 november 2022 3:08

Idag lanserar vi Amazon SageMaker slutsats om AWS Graviton för att du ska kunna dra nytta av pris-, prestanda- och effektivitetsfördelarna som kommer från Graviton-chips.

Graviton-baserade instanser är tillgängliga för modellslutledning i SageMaker. Det här inlägget hjälper dig att migrera och distribuera en arbetsbelastning för maskininlärning (ML) från x86 till Graviton-baserade instanser i SageMaker. Vi tillhandahåller en steg-för-steg-guide för att distribuera din SageMaker-utbildade modell till Graviton-baserade instanser, täcker bästa praxis när du arbetar med Graviton, diskuterar pris-prestandafördelarna och demonstrerar hur man distribuerar en TensorFlow-modell på en SageMaker Graviton-instans.

Kort översikt över Graviton

AWS Graviton är en familj av processorer designade av AWS som ger bästa pris-prestanda och är mer energieffektiva än sina x86-motsvarigheter. AWS Graviton 3-processorer är de senaste i Graviton-processorfamiljen och är optimerade för ML-arbetsbelastningar, inklusive stöd för bfloat16, och dubbelt så mycket Single Instruction Multiple Data (SIMD) bandbredd. När dessa två funktioner kombineras kan Graviton 3 leverera upp till tre gånger bättre prestanda jämfört med Graviton 2-instanser. Graviton 3 använder också upp till 60 % mindre energi för samma prestanda som jämförbara Amazon Elastic Compute Cloud (Amazon EC2) instanser. Detta är en bra funktion om du vill minska ditt koldioxidavtryck och uppnå dina hållbarhetsmål.

Lösningsöversikt

För att distribuera dina modeller till Graviton-instanser använder du antingen AWS Deep Learning-behållare or ta med egna behållare kompatibel med Arm v8.2-arkitektur.

Migreringen (eller ny distribution) av dina modeller från x86-drivna instanser till Graviton-instanser är enkel eftersom AWS tillhandahåller behållare för värdmodeller med PyTorch, TensorFlow, Scikit-learn och XGBoost, och modellerna är arkitekturagnostiska. Ändå, om du är villig att ta med dina egna bibliotek, kan du också göra det, se bara till att din container är byggd med en miljö som stöder Arm64-arkitektur. För mer information, se Bygg din egen algoritmbehållare.

Du måste slutföra tre steg för att distribuera din modell:

  1. Skapa en SageMaker-modell: Denna kommer bland andra parametrar att innehålla information om modellfilens plats, behållaren som kommer att användas för distributionen och platsen för slutledningsskriptet. (Om du redan har en befintlig modell distribuerad i en x86-baserad slutledningsinstans kan du hoppa över det här steget.)
  2. Skapa en ändpunktskonfiguration: Denna kommer att innehålla information om vilken typ av instans du vill ha för ändpunkten (till exempel ml.c7g.xlarge för Graviton3), namnet på modellen du skapade i steg 1 och antalet instanser per slutpunkt.
  3. Starta slutpunkten med slutpunktskonfigurationen som skapades i steg 2.

Förutsättningar

Innan du börjar, överväga följande förutsättningar:

  1. Fyll i förutsättningarna enligt listan i Förutsättningar.
  2. Din modell bör vara antingen en PyTorch-, TensorFlow-, XGBoost- eller Scikit-learn-baserad modell. Följande tabell sammanfattar de versioner som för närvarande stöds när detta skrivs. För de senaste uppdateringarna, se SageMaker Framework Containers (endast SM-stöd).
    . Python TensorFlow PyTorch Scikit lära XGBoost
    Versioner som stöds 3.8 2.9.1 1.12.1 1.0-1 1.3-1 till 1.5-1
  3. Slutledningsskriptet lagras i Amazon enkel lagringstjänst (Amazon S3).

I följande avsnitt leder vi dig genom installationsstegen.

Skapa en SageMaker-modell

Om du redan har en befintlig modell distribuerad i en x86-baserad slutledningsinstans kan du hoppa över det här steget. Utför annars följande steg för att skapa en SageMaker-modell:

  1. Leta reda på modellen som du lagrade i en S3-hink. Kopiera URI:n.
    Du använder modellen URI senare i MODEL_S3_LOCATION.
  2. Identifiera ramversionen och Python-versionen som användes under modellutbildningen.
    Du måste välja en behållare från listan över tillgängliga AWS Deep Learning-behållare enligt ditt ramverk och din Python-version. För mer information, se Vi introducerar containerbilder med flera arkitekturer för Amazon ECR.
  3. Leta reda på slutlednings-Python-skriptets URI i S3-bucket (det vanliga filnamnet är inference.py).
    Slutledningsskriptets URI behövs i INFERENCE_SCRIPT_S3_LOCATION.
  4. Med dessa variabler kan du sedan anropa SageMaker API med följande kommando: 
    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= 
)

Du kan också skapa bilder med flera arkitekturer och använda samma bild men med olika taggar. Du kan ange i vilken arkitektur din instans kommer att distribueras. För mer information, se Vi introducerar containerbilder med flera arkitekturer för Amazon ECR.

Skapa en slutpunktskonfiguration

När du har skapat modellen måste du skapa en slutpunktskonfiguration genom att köra följande kommando (notera vilken typ av instans vi använder):

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

Följande skärmdump visar slutpunktskonfigurationsdetaljerna på SageMaker-konsolen.

Starta slutpunkten

Med slutpunktskonfigurationen skapad i föregående steg kan du distribuera slutpunkten:

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

Vänta tills din modelländpunkt har distribuerats. Förutsägelser kan begäras på samma sätt som du begär förutsägelser för dina slutpunkter som distribueras i x86-baserade instanser.

Följande skärmdump visar din slutpunkt på SageMaker-konsolen.

SageMaker Endpoint från Configuration

Vad stöds

SageMaker tillhandahåller prestandaoptimerade Graviton djupa behållare för TensorFlow och PyTorch ramverk. Dessa behållare stöder datorseende, naturlig språkbehandling, rekommendationer och generiska djupa och breda modellbaserade slutledningsanvändningsfall. Förutom behållare för djupinlärning tillhandahåller SageMaker även behållare för klassiska ML-ramverk som XGBoost och Scikit-learn. Behållarna är binärkompatibla över c6g/m6g- och c7g-instanser, därför är det sömlöst att migrera inferensapplikationen från en generation till en annan.

C6g/m6g stöder fp16 (halvprecisionsflytande) och ger för kompatibla modeller likvärdig eller bättre prestanda jämfört med c5-instanser. C7g ökar ML-prestandan avsevärt genom att dubbla SIMD-bredden och stödja bfloat-16 (bf16), som är den mest kostnadseffektiva plattformen för att köra dina modeller.

Både c6g/m6g och c7g ger bra prestanda för klassisk ML (till exempel XGBoost) jämfört med andra CPU-instanser i SageMaker. Bfloat-16-stöd på c7g tillåter effektiv distribution av bf16-tränade eller AMP (Automatic Mixed Precision)-tränade modeller. Arm Compute Library (ACL) backend på Graviton tillhandahåller bfloat-16-kärnor som kan accelerera även fp32-operatörerna via snabbt matematiskt läge, utan modellkvantisering.

Rekommenderade bästa metoder

På Graviton-instanser är varje vCPU en fysisk kärna. Det finns inget argument för de vanliga CPU-resurserna (till skillnad från SMT), och skalningen av arbetsbelastningens prestanda är linjär med varje vCPU-tillägg. Därför rekommenderas det att använda batch slutledning närhelst användningsfallet tillåter. Detta kommer att möjliggöra effektiv användning av vCPU:erna genom parallell bearbetning av batchen på varje fysisk kärna. Om batch-inferensen inte är möjlig krävs den optimala instansstorleken för en given nyttolast för att säkerställa att OS-trådschemaläggningsoverhead inte uppväger beräkningskraften som kommer med de extra vCPU:erna.

TensorFlow kommer med Eigen-kärnor som standard, och det rekommenderas att byta till OneDNN med ACL för att få den mest optimerade slutledningsbackend. OneDNN-backend och bfloat-16 snabba matematikläge kan aktiveras när containertjänsten startas:

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

Det föregående serveringskommandot är värd för en standard resnet50-modell med två viktiga konfigurationer:

-e TF_ENABLE_ONEDNN_OPTS=1
-e DNNL_DEFAULT_FPMATH_MODE=BF16

Dessa kan skickas till slutledningsbehållaren på följande sätt:

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

Implementeringsexempel

I det här inlägget visar vi dig hur du distribuerar en TensorFlow-modell, utbildad i SageMaker, på en Graviton-driven SageMaker-inferensinstans.

Du kan köra kodexemplet antingen i en SageMaker notebook-instans, en Amazon SageMaker Studio anteckningsbok, eller en Jupyter-anteckningsbok i lokalt läge. Du måste hämta SageMaker-exekveringsrollen om du använder en Jupyter-anteckningsbok i lokalt läge.

Följande exempel tar hänsyn till CIFAR-10-datauppsättningen. Du kan följa notebook-exemplet från SageMaker-exemplen GitHub repo för att återge modellen som används i detta inlägg. Vi använder den utbildade modellen och cifar10_keras_main.py Python-skript för slutledning.

Modellen förvaras i en S3 hink: s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz

Smakämnen cifar10_keras_main.py skript, som kan användas för slutledning, lagras på:s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/script/cifar10_keras_main.py

Vi använder us-east-1 Regionera och distribuera modellen på en ml.c7g.xlarge Graviton-baserad instans. Baserat på detta är URI:n för vår AWS Deep Learning Container 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker

  1. Ställ in med följande kod: 
    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. Ladda ner datauppsättningen för slutpunktstestning: 
    from keras.datasets import cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()

  3. Skapa modellen och slutpunktskonfigurationen och distribuera slutpunkten: 
    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. Alternativt kan du lägga till ditt slutledningsskript till Environment in create_model om du inte ursprungligen lade till det som en artefakt till din SageMaker-modell under träningen: 
    "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)

    Du måste vänta ett par minuter på att driftsättningen ska ske.

  5. Verifiera slutpunktsstatusen med följande kod: 
    describe_response = client.describe_endpoint(EndpointName=ENDPOINT_NAME)
print(describe_response["EndpointStatus"]

    Du kan också kontrollera AWS Management Console för att se när din modell är utplacerad.

  6. Ställ in körtidsmiljön för att anropa slutpunkterna: 
    runtime = boto3.Session().client(service_name="runtime.sagemaker")

    Nu förbereder vi nyttolasten för att anropa slutpunkten. Vi använder samma typ av bilder som används för träning av modellen. Dessa laddades ner i tidigare steg.

  7. Kasta nyttolasten till tensorer och ställ in rätt format som modellen förväntar sig. För det här exemplet begär vi bara en förutsägelse. 
    input_image = x_test[0].reshape(1,32,32,3)

    Vi får modellens utdata som en array.

  8. Vi kan omvandla denna utdata till sannolikheter om vi tillämpar en softmax på den: 
    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())

Rengör resurser

Tjänsterna som ingår i denna lösning medför kostnader. När du är klar med den här lösningen, rensa upp följande resurser:

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

Pris-prestanda jämförelse

Graviton-baserade instanser erbjuder det lägsta priset och den bästa prisprestanda jämfört med x86-baserade instanser. I likhet med EC2-instanser erbjuder SageMaker slutpunkterna med ml.c6g-instanser (Graviton 2) ett 20 % lägre pris jämfört med ml.c5, och Graviton 3 ml.c7g-instanserna är 15 % billigare än ml.c6-instanser. För mer information, se Amazon SageMaker Prissättning.

Slutsats

I det här inlägget visade vi upp den nyligen lanserade SageMaker-kapaciteten för att distribuera modeller i Graviton-drivna slutledningsinstanser. Vi gav dig vägledning om bästa praxis och diskuterade kortfattat pris-prestandafördelarna med den nya typen av slutledningsinstanser.

För att lära dig mer om Graviton, se AWS Graviton-processor. Du kan komma igång med AWS Graviton-baserade EC2-instanser på Amazon EC2-konsolen och genom att hänvisa till AWS Graviton teknisk guide. Du kan distribuera en Sagemaker-modellslutpunkt för slutsats om Graviton med exempelkoden i det här blogginlägget.

Om författarna

Victor JaramilloVictor Jaramillo, PhD, är en senior maskininlärningsingenjör inom AWS Professional Services. Före AWS var han universitetsprofessor och forskare inom prediktivt underhåll. På fritiden tycker han om att köra motorcykel och gör-det-själv-motorcykelmekanik.

Zmnako AwrahmanZmnako Awrahman, PhD, är medlem i praktiken, ML SME och Machine Learning Technical Field Community (TFC) på Amazon Web Services. Han hjälper kunder att utnyttja kraften i molnet för att extrahera värde från sina data med dataanalys och maskininlärning.

Sunita NadampalliSunita Nadampalli är Software Development Manager på AWS. Hon leder Graviton mjukvaruprestandaoptimeringar för maskinlutning, HPC och multimedia arbetsbelastningar. Hon brinner för utveckling med öppen källkod och att leverera kostnadseffektiva mjukvarulösningar med Arm SoCs.

Johna LiuJohna Liu är en mjukvaruutvecklingsingenjör i Amazon SageMaker-teamet. Hennes nuvarande arbete fokuserar på att hjälpa utvecklare att effektivt vara värd för maskininlärningsmodeller och förbättra slutledningsprestanda. Hon brinner för rumslig dataanalys och att använda AI för att lösa samhällsproblem.

Alan TanAlan Tan är en Senior Product Manager hos SageMaker, som leder arbetet med att slutföra stora modeller. Han brinner för att tillämpa maskininlärning på analysområdet. Utanför jobbet tycker han om att vara utomhus.

Tidsstämpel:

Mer från AWS maskininlärning