Futtasson gépi tanulási következtetési munkaterheléseket AWS Graviton alapú példányokon az Amazon SageMaker segítségével

Ma indulunk Amazon SageMaker következtet AWS Graviton lehetővé teszi, hogy kihasználja a Graviton chipekből származó ár, teljesítmény és hatékonyság előnyeit.

Graviton-alapú példányok állnak rendelkezésre modellkövetkeztetéshez a SageMakerben. Ez a bejegyzés segít a gépi tanulási (ML) következtetési munkaterhelés áttelepítésében és üzembe helyezésében az x86-ról a Graviton-alapú példányokra a SageMakerben. Lépésről lépésre útmutatót adunk a SageMaker által betanított modell Graviton-alapú példányokon történő üzembe helyezéséhez, bemutatjuk a Gravitonnal végzett munka során bevált gyakorlatokat, megvitatjuk az ár-teljesítmény előnyeit, és bemutatjuk, hogyan telepíthet TensorFlow modellt egy SageMaker Graviton példányra.

A Graviton rövid áttekintése

Az AWS Graviton az AWS által tervezett processzorcsalád, amely a legjobb ár-teljesítményt nyújtja, és energiahatékonyabb, mint x86-os társaik. Az AWS Graviton 3 processzorok a Graviton processzorcsalád legújabb termékei, és ML-munkaterhelésekre optimalizáltak, beleértve a bfloat16 támogatását, valamint a kétszeres Single Instruction Multiple Data (SIMD) sávszélességet. Ha ezt a két funkciót kombináljuk, a Graviton 3 akár háromszor jobb teljesítményt nyújt a Graviton 2 példányokhoz képest. A Graviton 3 akár 60%-kal kevesebb energiát is használ a hasonló teljesítményhez Amazon rugalmas számítási felhő (Amazon EC2) példányok. Ez egy nagyszerű funkció, ha csökkenteni szeretné szénlábnyomát és elérni fenntarthatósági céljait.

Megoldás áttekintése

A modellek Graviton-példányokra történő telepítéséhez vagy használja AWS Deep Learning Containers or hozza a saját konténereit kompatibilis az Arm v8.2 architektúrával.

A modellek áttelepítése (vagy új telepítése) az x86-alapú példányokról a Graviton-példányokra egyszerű, mivel az AWS konténereket biztosít a PyTorch, TensorFlow, Scikit-learn és XGBoost technológiával rendelkező modellekhez, és a modellek architektúra-agnosztikusak. Mindazonáltal, ha hajlandó elhozni saját könyvtárait, ezt is megteheti, csak győződjön meg arról, hogy a konténer olyan környezettel készül, amely támogatja az Arm64 architektúrát. További információkért lásd Saját algoritmustároló építése.

A modell üzembe helyezéséhez három lépést kell végrehajtania:

1. SageMaker modell létrehozása: Ez többek között a modellfájl helyére, a telepítéshez használt tárolóra és a következtetési szkript helyére vonatkozó információkat tartalmazza. (Ha egy meglévő modellt már telepített egy x86 alapú következtetési példányban, akkor kihagyhatja ezt a lépést.)
2. Végpontkonfiguráció létrehozása: Ez információkat tartalmaz a végponthoz kívánt példány típusáról (például ml.c7g.xlarge a Graviton3 esetében), az 1. lépésben létrehozott modell nevéről és a példányok számáról végpont.
3. Indítsa el a végpontot a 2. lépésben létrehozott végpont-konfigurációval.

Előfeltételek

Mielőtt elkezdené, vegye figyelembe a következő előfeltételeket:

1. Töltse ki az előfeltételeket a felsoroltak szerint Előfeltételek.
2. A modellnek PyTorch, TensorFlow, XGBoost vagy Scikit-learn alapú modellnek kell lennie. Az alábbi táblázat összefoglalja az írás pillanatában jelenleg támogatott verziókat. A legújabb frissítésekért lásd: SageMaker Framework Containers (csak SM támogatás).
   

   .	Piton	TensorFlow	PyTorch	Scikit elsajátítható	XGBoost
   Támogatott verziók	3.8	2.9.1	1.12.1	1.0-1	1.3-1-től 1.5-1-ig

3. A következtetési szkriptet a rendszer tárolja Amazon egyszerű tárolási szolgáltatás (Amazon S3).

A következő szakaszokban végigvezetjük a telepítés lépésein.

Hozzon létre egy SageMaker modellt

Ha egy meglévő modellt már telepített egy x86-alapú következtetéspéldányban, akkor kihagyhatja ezt a lépést. Ellenkező esetben hajtsa végre a következő lépéseket a SageMaker modell létrehozásához:

1. Keresse meg azt a modellt, amelyet egy S3 vödörben tárolt. Másolja az URI-t.
   A modell URI-ját később a MODEL_S3_LOCATION.
2. Határozza meg a keretrendszer- és Python-verziót, amelyet a modellképzés során használtak.
   Ki kell választania egy tárolót az elérhető AWS Deep Learning tárolók listájából a keretrendszer és a Python verzió szerint. További információkért lásd: Több architektúrás konténerképek bemutatása az Amazon ECR-hez.
3. Keresse meg a következtetés Python szkript URI-jét az S3 tárolóban (a közös fájlnév: inference.py).
   A következtetési szkript URI-ja szükséges a INFERENCE_SCRIPT_S3_LOCATION.
4. Ezekkel a változókkal hívhatja meg a SageMaker API-t a következő paranccsal:

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

Több architektúrájú képeket is létrehozhat, és ugyanazt a képet használhatja, de különböző címkékkel. Megadhatja, hogy a példány melyik architektúrára kerüljön telepítésre. További információkért lásd: Több architektúrás konténerképek bemutatása az Amazon ECR-hez.

Hozzon létre egy végpont konfigurációt

A modell létrehozása után létre kell hoznia egy végpont konfigurációt a következő parancs futtatásával (figyelje meg a használt példány típusát):

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

A következő képernyőkép a végpont konfigurációs részleteit mutatja a SageMaker konzolon.

Indítsa el a végpontot

Az előző lépésben létrehozott végpont konfigurációval telepítheti a végpontot:

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

Várja meg, amíg a modell végpontja telepítésre kerül. Az előrejelzések ugyanúgy kérhetők, mint az x86-alapú példányokban telepített végpontokhoz.

A következő képernyőkép a végpontját mutatja a SageMaker konzolon.

Mi támogatott

A SageMaker teljesítmény-optimalizált Graviton mélykonténereket biztosít a TensorFlow és PyTorch keretrendszerekhez. Ezek a tárolók támogatják a számítógépes látást, a természetes nyelvi feldolgozást, az ajánlásokat és az általános mély és széles modellalapú következtetési felhasználási eseteket. A mély tanulási konténerek mellett a SageMaker konténereket is biztosít a klasszikus ML keretrendszerekhez, mint például az XGBoost és a Scikit-learn. A tárolók binárisan kompatibilisek a c6g/m6g és c7g példányok között, ezért a következtetési alkalmazás egyik generációról a másikra történő migrálása zökkenőmentes.

A C6g/m6g támogatja az fp16-ot (félpontos lebegés), és a kompatibilis modellek esetében a c5 példányokkal egyenértékű vagy jobb teljesítményt biztosít. A C7g jelentősen növeli az ML teljesítményt a SIMD szélességének megduplázásával és a bfloat-16 (bf16) támogatásával, amely a legköltséghatékonyabb platform a modellek futtatásához.

Mind a c6g/m6g, mind a c7g jó teljesítményt nyújt a klasszikus ML-hez (például az XGBoosthoz) a SageMaker többi CPU-példányához képest. A c16g Bfloat-7 támogatása lehetővé teszi a bf16 vagy AMP (Automatic Mixed Precision) betanított modellek hatékony telepítését. A Graviton Arm Compute Library (ACL) háttérprogramja bfloat-16 kerneleket biztosít, amelyek még az fp32 operátorokat is felgyorsíthatják gyors matematikai módban, a modell kvantálása nélkül.

Ajánlott bevált gyakorlatok

Graviton példányokon minden vCPU egy fizikai mag. Nincs vita a közös CPU-erőforrásokért (ellentétben az SMT-vel), és a terhelési teljesítmény skálázása lineáris minden vCPU-hozzáadás esetén. Ezért ajánlatos kötegelt következtetést használni, amikor a használati eset megengedi. Ez lehetővé teszi a vCPU-k hatékony használatát azáltal, hogy párhuzamosan dolgozza fel a kötegeket minden egyes fizikai magon. Ha a kötegelt következtetés nem lehetséges, egy adott hasznos adathoz az optimális példányméretre van szükség annak biztosítására, hogy az operációs rendszer szálütemezési többletterhelése ne haladja meg a további vCPU-khoz tartozó számítási teljesítményt.

A TensorFlow alapértelmezés szerint Eigen kernelekkel érkezik, és ajánlott a OneDNN-re váltani az ACL-lel, hogy a leginkább optimalizált következtetési háttérrendszert kapja. A OneDNN háttérrendszer és a bfloat-16 gyors matematikai mód engedélyezhető a konténerszolgáltatás indításakor:

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

Az előző kiszolgálási parancs egy szabványos resnet50 modellt tartalmaz két fontos konfigurációval:

-e TF_ENABLE_ONEDNN_OPTS=1
-e DNNL_DEFAULT_FPMATH_MODE=BF16

Ezeket a következő módon lehet átadni a következtetési tárolónak:

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

Telepítési példa

Ebben a bejegyzésben megmutatjuk, hogyan telepíthet egy SageMakerben betanított TensorFlow modellt egy Graviton-alapú SageMaker következtetési példányra.

A kódmintát futtathatja egy SageMaker notebook példányban, egy Amazon SageMaker Studio notebook, vagy egy Jupyter notebook helyi módban. Ha Jupyter-jegyzetfüzetet helyi módban használ, le kell kérnie a SageMaker végrehajtási szerepkört.

A következő példa a CIFAR-10 adatkészletet vizsgálja. Követheti a jegyzetfüzet példáját a SageMaker példáiból GitHub repo az ebben a bejegyzésben használt modell reprodukálásához. Használjuk a betanított modellt és a cifar10_keras_main.py Python szkript a következtetéshez.

A modellt egy S3 vödörben tárolják: s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz

A cifar10_keras_main.py A következtetéshez használható szkript a következő helyen található:s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/script/cifar10_keras_main.py

Az általunk használt us-east-1 Regionális és üzembe helyezi a modellt egy ml.c7g.xlarge Graviton-alapú példányon. Ennek alapján az AWS Deep Learning Containerünk URI-ja a 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker

1. Állítsa be a következő kóddal:

   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. Töltse le az adatkészletet a végpont teszteléséhez:

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

3. Hozza létre a modellt és a végpont konfigurációját, és telepítse a végpontot:

   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. Opcionálisan hozzáadhatja következtetési szkriptjét Environment in create_model ha eredetileg nem adtad hozzá műtermékként a SageMaker modelledhez az edzés során:

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

   Várnia kell néhány percet, amíg a telepítés megtörténik.

5. Ellenőrizze a végpont állapotát a következő kóddal:

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

   Azt is ellenőrizheti a AWS felügyeleti konzol hogy lássa, mikor kerül a modell üzembe.

6. Állítsa be a futási környezetet a végpontok meghívásához:

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

   Most előkészítjük a hasznos terhet a végpont meghívásához. Ugyanolyan típusú képeket használunk, mint a modell betanításánál. Ezeket az előző lépésekben töltöttük le.

7. Adja át a hasznos terhet tenzorokra, és állítsa be a megfelelő formátumot, amelyet a modell vár. Ebben a példában csak egy előrejelzést kérünk.

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

   A modell kimenetét tömbként kapjuk.

8. Ezt a kimenetet valószínűségekké alakíthatjuk, ha softmaxot alkalmazunk rá:

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

Tisztítsa meg az erőforrásokat

Az ebben a megoldásban szereplő szolgáltatások költséggel járnak. Ha végzett a megoldással, tisztítsa meg a következő erőforrásokat:

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

Ár-teljesítmény összehasonlítás

A Graviton-alapú példányok a legalacsonyabb árat és a legjobb ár-teljesítményt kínálják az x86-alapú példányokhoz képest. Az EC2 példányokhoz hasonlóan a SageMaker következtetési végpontok ml.c6g példányokkal (Graviton 2) 20%-kal alacsonyabb árat kínálnak az ml.c5 példányokhoz képest, a Graviton 3 ml.c7g példányok pedig 15%-kal olcsóbbak, mint az ml.c6 példányok. További információkért lásd: Amazon SageMaker árképzés.

Következtetés

Ebben a bejegyzésben bemutattuk az újonnan bevezetett SageMaker képességet, amellyel modelleket telepíthet a Graviton-alapú következtetési példányokban. Útmutatást adtunk a legjobb gyakorlatokról, és röviden megvitattuk az új típusú következtetési példányok ár-teljesítménybeli előnyeit.

Ha többet szeretne megtudni a Gravitonról, tekintse meg a AWS Graviton processzor. Elkezdheti az AWS Graviton alapú EC2 példányokat az Amazon EC2 konzolon és a AWS Graviton műszaki útmutató. Az ebben a blogbejegyzésben található mintakóddal telepíthet egy Sagemaker modell végpontot a Gravitonra vonatkozó következtetések levonásához.

A szerzőkről

Victor Jaramillo, PhD, az AWS Professional Services vezető gépi tanulási mérnöke. Az AWS előtt egyetemi tanár és kutató tudós volt a prediktív karbantartás területén. Szabadidejében szívesen motorozik és barkácsol motorszerelőit.

Zmnako Awrahman, PhD, az Amazon Web Services gyakorlatvezetője, az ML SME és a Machine Learning Technical Field Community (TFC) tagja. Segít az ügyfeleknek kihasználni a felhő erejét, hogy adatelemzés és gépi tanulás segítségével értéket vonjanak ki adataikból.

Sunita Nadampalli az AWS szoftverfejlesztési menedzsere. Vezeti a Graviton szoftverek teljesítményoptimalizálását a gépek hajlítására, a HPC-re és a multimédiás munkaterhelésekre. Szenvedélye a nyílt forráskódú fejlesztés és költséghatékony szoftvermegoldások szállítása az Arm SoC-kkel.

Johna Liu az Amazon SageMaker csapat szoftverfejlesztő mérnöke. Jelenlegi munkája arra összpontosít, hogy segítse a fejlesztőket a gépi tanulási modellek hatékony üzemeltetésében és a következtetési teljesítmény javításában. Szenvedélyesen rajong a térbeli adatok elemzéséért és a mesterséges intelligencia felhasználásáért a társadalmi problémák megoldására.

Alan Tan a SageMaker vezető termékmenedzsere, aki a nagy modellkövetkeztetések terén tett erőfeszítéseket vezeti. Szenvedélyesen szereti a gépi tanulást az analitika területén alkalmazni. Munkán kívül élvezi a szabad levegőt.