Rulați sarcini de lucru de inferență de învățare automată pe instanțe bazate pe AWS Graviton cu Amazon SageMaker

Astăzi, lansăm Amazon SageMaker deducere asupra AWS Graviton pentru a vă permite să profitați de avantajele de preț, performanță și eficiență care vin de la cipurile Graviton.

Instanțe bazate pe Graviton sunt disponibile pentru inferența modelului în SageMaker. Această postare vă ajută să migrați și să implementați un volum de lucru de inferență de învățare automată (ML) de la x86 la instanțe bazate pe Graviton în SageMaker. Oferim un ghid pas cu pas pentru implementarea modelului dvs. instruit SageMaker în instanțe bazate pe Graviton, acoperim cele mai bune practici atunci când lucrați cu Graviton, discutăm despre beneficiile preț-performanță și demonstrați cum să implementați un model TensorFlow pe o instanță SageMaker Graviton.

Scurtă prezentare generală a Graviton

AWS Graviton este o familie de procesoare proiectate de AWS care oferă cel mai bun preț-performanță și sunt mai eficiente din punct de vedere energetic decât omologii lor x86. Procesoarele AWS Graviton 3 sunt cele mai recente din familia de procesoare Graviton și sunt optimizate pentru sarcinile de lucru ML, inclusiv suport pentru bfloat16 și lățimea de bandă SIMD (Single Instruction Multiple Data) de două ori. Când aceste două funcții sunt combinate, Graviton 3 poate oferi performanțe de până la trei ori mai bune față de instanțele Graviton 2. Graviton 3 utilizează, de asemenea, până la 60% mai puțină energie pentru aceeași performanță ca și cea comparabilă Cloud Elastic de calcul Amazon (Amazon EC2). Aceasta este o caracteristică excelentă dacă doriți să vă reduceți amprenta de carbon și să vă atingeți obiectivele de sustenabilitate.

Prezentare generală a soluțiilor

Pentru a vă implementa modelele în instanțele Graviton, fie utilizați Containere de învățare profundă AWS or aduceți-vă propriile recipiente compatibil cu arhitectura Arm v8.2.

Migrarea (sau implementarea nouă) a modelelor dvs. de la instanțe alimentate x86 la instanțe Graviton este simplă, deoarece AWS oferă containere pentru a găzdui modele cu PyTorch, TensorFlow, Scikit-learn și XGBoost, iar modelele sunt agnostice de arhitectură. Cu toate acestea, dacă sunteți dispus să vă aduceți propriile biblioteci, puteți, de asemenea, să faceți acest lucru, asigurați-vă doar că containerul dvs. este construit cu un mediu care acceptă arhitectura Arm64. Pentru mai multe informații, vezi Construiește-ți propriul container de algoritm.

Trebuie să parcurgeți trei pași pentru a vă implementa modelul:

1. Creați un model SageMaker: acesta va conține, printre alți parametri, informații despre locația fișierului model, containerul care va fi utilizat pentru implementare și locația scriptului de inferență. (Dacă aveți un model existent deja implementat într-o instanță de inferență bazată pe x86, puteți sări peste acest pas.)
2. Creați o configurație a punctului final: aceasta va conține informații despre tipul de instanță pe care o doriți pentru punctul final (de exemplu, ml.c7g.xlarge pentru Graviton3), numele modelului creat la pasul 1 și numărul de instanțe pe punct final.
3. Lansați punctul final cu configurația punctului final creată la pasul 2.

Cerințe preliminare

Înainte de a începe, luați în considerare următoarele cerințe preliminare:

1. Completați cerințele prealabile, așa cum sunt enumerate în Cerințe preliminare.
2. Modelul dvs. ar trebui să fie un model bazat pe PyTorch, TensorFlow, XGBoost sau Scikit-learn. Următorul tabel rezumă versiunile suportate în prezent la momentul scrierii acestui articol. Pentru cele mai recente actualizări, consultați SageMaker Framework Containers (doar suport SM).
   

   .	Piton	TensorFlow	PyTorch	Scikit-învață	XGBoost
   Versiuni acceptate	3.8	2.9.1	1.12.1	1.0-1	1.3-1 până la 1.5-1

3. Scriptul de inferență este stocat în Serviciul Amazon de stocare simplă (Amazon S3).

În secțiunile următoare, vă prezentăm pașii de implementare.

Creați un model SageMaker

Dacă aveți un model existent deja implementat într-o instanță de inferență bazată pe x86, puteți sări peste acest pas. În caz contrar, parcurgeți următorii pași pentru a crea un model SageMaker:

1. Găsiți modelul pe care l-ați depozitat într-o găleată S3. Copiați URI-ul.
   Utilizați modelul URI mai târziu în MODEL_S3_LOCATION.
2. Identificați versiunea cadrului și versiunea Python care au fost utilizate în timpul antrenamentului de model.
   Trebuie să selectați un container din lista de containere AWS Deep Learning disponibile pentru cadru și versiunea Python. Pentru mai multe informații, consultați Vă prezentăm imagini de containere cu arhitectură multiplă pentru Amazon ECR.
3. Localizați URI-ul scriptului Python de inferență în compartimentul S3 (numele obișnuit al fișierului este inference.py).
   URI-ul scriptului de inferență este necesar în INFERENCE_SCRIPT_S3_LOCATION.
4. Cu aceste variabile, puteți apela apoi API-ul SageMaker cu următoarea comandă:

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

De asemenea, puteți crea imagini cu mai multe arhitecturi și puteți utiliza aceeași imagine, dar cu etichete diferite. Puteți indica pe ce arhitectură va fi implementată instanța dvs. Pentru mai multe informații, consultați Vă prezentăm imagini de containere cu arhitectură multiplă pentru Amazon ECR.

Creați o configurație de punct final

După ce creați modelul, trebuie să creați o configurație a punctului final rulând următoarea comandă (rețineți tipul de instanță pe care îl folosim):

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

Următoarea captură de ecran arată detaliile de configurare a punctului final pe consola SageMaker.

Lansați punctul final

Cu configurația punctului final creată în pasul anterior, puteți implementa punctul final:

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

Așteptați până când punctul final al modelului este implementat. Predicțiile pot fi solicitate în același mod în care solicitați predicții pentru punctele finale implementate în instanțe bazate pe x86.

Următoarea captură de ecran vă arată punctul final pe consola SageMaker.

Ce este susținut

SageMaker oferă containere de adâncime Graviton optimizate pentru performanță pentru cadrele TensorFlow și PyTorch. Aceste containere acceptă viziunea computerizată, procesarea limbajului natural, recomandări și cazuri de utilizare a inferenței bazate pe modele profunde și largi. Pe lângă containerele de învățare profundă, SageMaker oferă și containere pentru cadrele clasice ML, cum ar fi XGBoost și Scikit-learn. Containerele sunt compatibile binar între instanțele c6g/m6g și c7g, prin urmare migrarea aplicației de inferență de la o generație la alta este fără probleme.

C6g/m6g acceptă fp16 (float cu jumătate de precizie) și pentru modelele compatibile oferă performanțe echivalente sau mai bune în comparație cu instanțele c5. C7g crește substanțial performanța ML prin dublarea lățimii SIMD și acceptând bfloat-16 (bf16), care este cea mai eficientă platformă pentru rularea modelelor dvs.

Atât c6g/m6g, cât și c7g oferă performanțe bune pentru ML clasic (de exemplu, XGBoost) în comparație cu alte instanțe CPU din SageMaker. Suportul Bfloat-16 pe c7g permite implementarea eficientă a modelelor instruite bf16 sau antrenate AMP (Automatic Mixed Precision). Backend-ul Arm Compute Library (ACL) de pe Graviton oferă nuclee bfloat-16 care pot accelera chiar și operatorii fp32 prin modul matematic rapid, fără cuantificarea modelului.

Cele mai bune practici recomandate

Pe instanțele Graviton, fiecare vCPU este un nucleu fizic. Nu există nicio dispută pentru resursele CPU comune (spre deosebire de SMT), iar scalarea performanței încărcăturii de lucru este liniară cu fiecare adăugare a vCPU. Prin urmare, se recomandă utilizarea inferenței în lot ori de câte ori cazul de utilizare permite. Acest lucru va permite utilizarea eficientă a vCPU-urilor prin procesarea paralelă a lotului pe fiecare nucleu fizic. Dacă deducerea lotului nu este posibilă, este necesară dimensiunea optimă a instanței pentru o anumită sarcină utilă pentru a se asigura că overheadul de planificare a firelor de operare de operare nu depășește puterea de calcul care vine cu vCPU-urile suplimentare.

TensorFlow vine cu nuclee Eigen în mod implicit și este recomandat să treceți la OneDNN cu ACL pentru a obține cel mai optimizat backend de inferență. Backend-ul OneDNN și modul rapid de matematică bfloat-16 pot fi activate în timpul lansării serviciului container:

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

Comanda de servire anterioară găzduiește un model resnet50 standard cu două configurații importante:

-e TF_ENABLE_ONEDNN_OPTS=1
-e DNNL_DEFAULT_FPMATH_MODE=BF16

Acestea pot fi trecute în containerul de inferență în felul următor:

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

Exemplu de implementare

În această postare, vă arătăm cum să implementați un model TensorFlow, antrenat în SageMaker, pe o instanță de inferență SageMaker alimentată de Graviton.

Puteți rula eșantionul de cod fie într-o instanță de notebook SageMaker, fie Amazon SageMaker Studio notebook sau un notebook Jupyter în modul local. Trebuie să preluați rolul de execuție SageMaker dacă utilizați un notebook Jupyter în modul local.

Următorul exemplu ia în considerare setul de date CIFAR-10. Puteți urma exemplul de blocnotes din exemplele SageMaker GitHub repo pentru a reproduce modelul care este folosit în această postare. Folosim modelul antrenat și cifar10_keras_main.py Script Python pentru inferență.

Modelul este depozitat într-o găleată S3: s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz

cifar10_keras_main.py scriptul, care poate fi folosit pentru inferență, este stocat la:s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/script/cifar10_keras_main.py

Noi folosim us-east-1 Regiunea și implementați modelul pe o instanță bazată pe Graviton ml.c7g.xlarge. Pe baza acestui fapt, URI-ul containerului nostru AWS Deep Learning este 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker

1. Configurați cu următorul cod:

   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. Descărcați setul de date pentru testarea punctelor finale:

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

3. Creați modelul și configurația punctului final și implementați punctul final:

   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. Opțional, puteți adăuga scriptul de inferență la Environment in create_model dacă nu l-ați adăugat inițial ca artefact la modelul dvs. SageMaker în timpul antrenamentului:

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

   Trebuie să așteptați câteva minute pentru ca implementarea să aibă loc.

5. Verificați starea punctului final cu următorul cod:

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

   De asemenea, puteți verifica Consola de administrare AWS pentru a vedea când modelul dvs. este implementat.

6. Configurați mediul de rulare pentru a invoca punctele finale:

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

   Acum pregătim sarcina utilă pentru a invoca punctul final. Folosim același tip de imagini folosite pentru antrenamentul modelului. Acestea au fost descărcate în pașii anteriori.

7. Transmiteți sarcina utilă la tensori și setați formatul corect pe care modelul îl așteaptă. Pentru acest exemplu, solicităm o singură predicție.

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

   Obținem rezultatul modelului ca o matrice.

8. Putem transforma această ieșire în probabilități dacă îi aplicăm un softmax:

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

Curățați resursele

Serviciile implicate în această soluție implică costuri. Când ați terminat de utilizat această soluție, curățați următoarele resurse:

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

Comparație preț-performanță

Instanțele bazate pe Graviton oferă cel mai mic preț și cel mai bun preț-performanță în comparație cu instanțe bazate pe x86. Similar cu instanțele EC2, punctele finale de inferență SageMaker cu instanțe ml.c6g (Graviton 2) oferă un preț cu 20% mai mic în comparație cu ml.c5, iar instanțele Graviton 3 ml.c7g sunt cu 15% mai ieftine decât instanțele ml.c6. Pentru mai multe informații, consultați Prețuri Amazon SageMaker.

Concluzie

În această postare, am prezentat noua capacitate SageMaker lansată de a implementa modele în instanțe de inferență alimentate de Graviton. V-am oferit îndrumări cu privire la cele mai bune practici și am discutat pe scurt despre avantajele preț-performanță ale noului tip de instanțe de inferență.

Pentru a afla mai multe despre Graviton, consultați Procesor AWS Graviton. Puteți începe să utilizați instanțe EC2 bazate pe AWS Graviton pe consola Amazon EC2 și făcând referire la Ghid tehnic AWS Graviton. Puteți implementa un punct final model Sagemaker pentru inferență asupra Graviton cu exemplul de cod din această postare de blog.

Despre autori

dr. Victor Jaramillo, este inginer senior de învățare automată în AWS Professional Services. Înainte de AWS, a fost profesor universitar și cercetător în mentenanță predictivă. În timpul liber, îi place să meargă cu motocicleta și mecanicii de motociclete DIY.

Zmnako Awrahman, dr., este un manager de practică, ML SME și membru al comunității de câmp tehnic de învățare automată (TFC) la Amazon Web Services. El îi ajută pe clienți să profite de puterea cloud-ului pentru a extrage valoare din datele lor prin analiza datelor și învățarea automată.

Sunita Nadampalli este manager de dezvoltare software la AWS. Ea conduce optimizările performanței software-ului Graviton pentru încărcături de lucru de tip machine leaning, HPC și multimedia. Este pasionată de dezvoltarea open-source și de furnizarea de soluții software rentabile cu Arm SoC.

Ioana Liu este inginer de dezvoltare software în echipa Amazon SageMaker. Activitatea ei actuală se concentrează pe a ajuta dezvoltatorii să găzduiască eficient modele de învățare automată și să îmbunătățească performanța de inferență. Este pasionată de analiza datelor spațiale și de utilizarea inteligenței artificiale pentru a rezolva problemele societale.

Alan Tan este Senior Product Manager la SageMaker, conducând eforturile pentru inferența modelelor mari. Este pasionat de aplicarea învățării automate în domeniul analizei. În afara serviciului, se bucură de aer liber.