Zaženite delovne obremenitve sklepanja strojnega učenja na instancah, ki temeljijo na AWS Graviton, z Amazon SageMaker

Danes začenjamo Amazon SageMaker sklepanje o AWS Graviton da vam omogočimo, da izkoristite prednosti cene, zmogljivosti in učinkovitosti, ki jih prinašajo čipi Graviton.

Primerki, ki temeljijo na Gravitonu, so na voljo za sklepanje o modelu v SageMakerju. Ta objava vam pomaga pri selitvi in ​​uvajanju delovne obremenitve sklepanja strojnega učenja (ML) iz x86 v instance, ki temeljijo na Gravitonu, v SageMakerju. Zagotavljamo vodnik po korakih za uvajanje vašega modela, usposobljenega za SageMaker, v instance, ki temeljijo na Gravitonu, pokrivamo najboljše prakse pri delu z Gravitonom, razpravljamo o prednostih cene in zmogljivosti in prikazujemo, kako uvesti model TensorFlow na instanco SageMaker Graviton.

Kratek pregled Gravitona

AWS Graviton je družina procesorjev, ki jih je zasnoval AWS, ki zagotavljajo najboljše razmerje med ceno in zmogljivostjo ter so energetsko učinkovitejši od svojih primerkov x86. Procesorji AWS Graviton 3 so najnovejši v družini procesorjev Graviton in so optimizirani za delovne obremenitve ML, vključno s podporo za bfloat16 in dvojno pasovno širino Single Instruction Multiple Data (SIMD). Ko ti dve funkciji združimo, lahko Graviton 3 zagotovi do trikrat boljšo zmogljivost v primerjavi z instancami Graviton 2. Graviton 3 porabi tudi do 60 % manj energije za enako zmogljivost kot primerljivi Amazonski elastični računalniški oblak (Amazon EC2) primerki. To je odlična funkcija, če želite zmanjšati svoj ogljični odtis in doseči svoje trajnostne cilje.

Pregled rešitev

Če želite svoje modele razmestiti v instance Graviton, uporabite bodisi AWS posode za globoko učenje or prinesite svoje posode združljiv z arhitekturo Arm v8.2.

Selitev (ali nova uvedba) vaših modelov iz instanc, ki jih poganja x86, v instance Graviton je preprosta, ker AWS zagotavlja vsebnike za gostovanje modelov s PyTorch, TensorFlow, Scikit-learn in XGBoost, modeli pa so neodvisni od arhitekture. Kljub temu, če ste pripravljeni prinesti svoje lastne knjižnice, lahko to tudi storite, le zagotovite, da je vaš vsebnik zgrajen z okoljem, ki podpira arhitekturo Arm64. Za več informacij glejte Izdelava lastnega vsebnika algoritmov.

Za uvedbo modela morate opraviti tri korake:

1. Ustvarite model SageMaker: Ta bo med drugimi parametri vseboval informacije o lokaciji datoteke modela, vsebniku, ki bo uporabljen za razmestitev, in lokaciji sklepnega skripta. (Če imate obstoječi model, ki je že nameščen v primerku sklepanja, ki temelji na x86, lahko ta korak preskočite.)
2. Ustvarite konfiguracijo končne točke: To bo vsebovalo informacije o vrsti primerka, ki ga želite za končno točko (na primer ml.c7g.xlarge za Graviton3), ime modela, ki ste ga ustvarili v 1. koraku, in število primerkov na končna točka.
3. Zaženite končno točko s konfiguracijo končne točke, ustvarjeno v 2. koraku.

Predpogoji

Preden začnete, upoštevajte naslednje predpogoje:

1. Izpolnite predpogoje, kot je navedeno v Predpogoji.
2. Vaš model mora temeljiti na PyTorch, TensorFlow, XGBoost ali Scikit-learn. Naslednja tabela povzema različice, ki so trenutno podprte od tega pisanja. Za najnovejše posodobitve glejte SageMaker Framework Containers (samo podpora za SM).
   

   .	Python	TensorFlow	PyTorch	Scikit-učite se	XGBoost
   Podprte različice	3.8	2.9.1	1.12.1	1.0-1	1.3-1 za 1.5-1

3. Sklepni skript je shranjen v Preprosta storitev shranjevanja Amazon (Amazon S3).

V naslednjih razdelkih vas vodimo skozi korake uvajanja.

Ustvarite model SageMaker

Če imate obstoječi model, ki je že nameščen v primerku sklepanja, ki temelji na x86, lahko ta korak preskočite. V nasprotnem primeru izvedite naslednje korake za ustvarjanje modela SageMaker:

1. Poiščite model, ki ste ga shranili v vedro S3. Kopirajte URI.
   URI modela uporabite pozneje v MODEL_S3_LOCATION.
2. Določite različico ogrodja in različico Python, ki sta bili uporabljeni med usposabljanjem modela.
   Izbrati morate vsebnik s seznama razpoložljivih vsebnikov za poglobljeno učenje AWS za vaš okvir in različico Python. Za več informacij glejte Predstavljamo slike vsebnikov z več arhitekturami za Amazon ECR.
3. Poiščite URI sklepnega skripta Python v vedru S3 (običajno ime datoteke je inference.py).
   URI sklepnega skripta je potreben v INFERENCE_SCRIPT_S3_LOCATION.
4. S temi spremenljivkami lahko nato pokličete API SageMaker z naslednjim ukazom:

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

Ustvarite lahko tudi slike z več arhitekturami in uporabite isto sliko, vendar z različnimi oznakami. Določite lahko, na kateri arhitekturi bo vaš primerek nameščen. Za več informacij glejte Predstavljamo slike vsebnikov z več arhitekturami za Amazon ECR.

Ustvarite konfiguracijo končne točke

Ko ustvarite model, morate ustvariti konfiguracijo končne točke tako, da zaženete naslednji ukaz (upoštevajte vrsto primerka, ki ga uporabljamo):

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

Naslednji posnetek zaslona prikazuje podrobnosti konfiguracije končne točke na konzoli SageMaker.

Zaženite končno točko

S konfiguracijo končne točke, ustvarjeno v prejšnjem koraku, lahko uvedete končno točko:

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

Počakajte, da se končna točka vašega modela uvede. Napovedi je mogoče zahtevati na enak način, kot zahtevate predvidevanja za svoje končne točke, nameščene v primerkih, ki temeljijo na x86.

Naslednji posnetek zaslona prikazuje vašo končno točko na konzoli SageMaker.

Kaj je podprto

SageMaker ponuja globinske vsebnike Graviton, optimizirane za zmogljivost, za ogrodja TensorFlow in PyTorch. Ti vsebniki podpirajo računalniški vid, obdelavo naravnega jezika, priporočila in splošne primere uporabe sklepanja na podlagi globokih in širokih modelov. Poleg vsebnikov za globoko učenje SageMaker ponuja tudi vsebnike za klasična ogrodja ML, kot sta XGBoost in Scikit-learn. Vsebniki so binarno združljivi v primerih c6g/m6g in c7g, zato je selitev aplikacije za sklepanje iz ene generacije v drugo brezhibna.

C6g/m6g podpira fp16 (polovično natančno lebdenje) in za združljive modele zagotavlja enakovredno ali boljšo zmogljivost v primerjavi s primerki c5. C7g bistveno poveča zmogljivost ML s podvojitvijo širine SIMD in podporo bfloat-16 (bf16), ki je stroškovno najučinkovitejša platforma za izvajanje vaših modelov.

Tako c6g/m6g kot c7g zagotavljata dobro zmogljivost za klasični ML (na primer XGBoost) v primerjavi z drugimi primerki CPU v SageMakerju. Podpora Bfloat-16 na c7g omogoča učinkovito uvajanje modelov, usposobljenih za bf16, ali modelov, usposobljenih za AMP (Automatic Mixed Precision). Zaledje Arm Compute Library (ACL) na Gravitonu zagotavlja jedra bfloat-16, ki lahko pospešijo celo operaterje fp32 prek hitrega matematičnega načina brez kvantizacije modela.

Priporočene najboljše prakse

Na instancah Graviton je vsak vCPU fizično jedro. Ni spora za skupne vire CPE (za razliko od SMT), skaliranje zmogljivosti delovne obremenitve pa je linearno z vsakim dodatkom vCPE. Zato je priporočljivo, da uporabite paketno sklepanje, kadarkoli to dopušča primer uporabe. To bo omogočilo učinkovito uporabo vCPU-jev z vzporedno obdelavo paketa v vsakem fizičnem jedru. Če paketno sklepanje ni mogoče, je potrebna optimalna velikost primerka za dano koristno obremenitev, da se zagotovi, da obremenitev razporejanja niti OS ne odtehta računalniške moči, ki je priložena dodatnim vCPE.

TensorFlow je privzeto opremljen z jedri Eigen in priporočljivo je, da preklopite na OneDNN z ACL, da dobite najbolj optimizirano zaledje sklepanja. Zaledje OneDNN in način hitre matematike bfloat-16 lahko omogočite med zagonom vsebniške storitve:

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

Prejšnji ukaz za streženje gosti standardni model resnet50 z dvema pomembnima konfiguracijama:

-e TF_ENABLE_ONEDNN_OPTS=1
-e DNNL_DEFAULT_FPMATH_MODE=BF16

Te je mogoče posredovati v vsebnik sklepanja na naslednji način:

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

Primer uvajanja

V tem prispevku vam pokažemo, kako razmestiti model TensorFlow, usposobljen v SageMakerju, na primerku sklepanja SageMaker, ki ga poganja Graviton.

Vzorec kode lahko zaženete v primerku prenosnega računalnika SageMaker ali Amazon SageMaker Studio prenosni računalnik ali prenosni računalnik Jupyter v lokalnem načinu. Če uporabljate prenosni računalnik Jupyter v lokalnem načinu, morate pridobiti izvršilno vlogo SageMaker.

Naslednji primer obravnava nabor podatkov CIFAR-10. Primeru zvezka lahko sledite iz primerov SageMaker GitHub repo za reprodukcijo modela, ki je uporabljen v tej objavi. Uporabljamo usposobljeni model in cifar10_keras_main.py Python skript za sklepanje.

Model je shranjen v vedru S3: s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz

O cifar10_keras_main.py skripta, ki jo lahko uporabimo za sklepanje, je shranjena na:s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/script/cifar10_keras_main.py

Mi uporabljamo us-east-1 Regija in uvedba modela na ml.c7g.xlarge Graviton temelječem primerku. Na podlagi tega je URI našega vsebnika za globoko učenje AWS 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker

1. Nastavite z naslednjo kodo:

   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. Prenesite nabor podatkov za testiranje končne točke:

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

3. Ustvarite model in konfiguracijo končne točke ter uvedite končno točko:

   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. Po želji lahko dodate svoj sklepni skript Environment in create_model če ga prvotno med usposabljanjem niste dodali kot artefakt svojemu modelu SageMaker:

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

   Počakati morate nekaj minut, da se izvede namestitev.

5. Preverite stanje končne točke z naslednjo kodo:

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

   Preverite lahko tudi Konzola za upravljanje AWS da vidite, kdaj je vaš model uveden.

6. Nastavite okolje izvajanja za priklic končnih točk:

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

   Zdaj pripravimo koristni tovor za priklic končne točke. Uporabljamo isto vrsto slik kot za usposabljanje modela. Ti so bili preneseni v prejšnjih korakih.

7. Prenesite koristni tovor na tenzorje in nastavite pravilno obliko, ki jo pričakuje model. Za ta primer zahtevamo samo eno napoved.

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

   Izhod modela dobimo kot niz.

8. Ta izhod lahko pretvorimo v verjetnosti, če zanj uporabimo mehki maksimum:

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

Očistite vire

Storitve, vključene v to rešitev, povzročajo stroške. Ko končate z uporabo te rešitve, počistite naslednje vire:

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

Primerjava cene in zmogljivosti

Instance, ki temeljijo na Gravitonu, ponujajo najnižjo ceno in najboljšo cenovno zmogljivost v primerjavi z instancami, ki temeljijo na x86. Podobno kot primerki EC2 ponujajo končne točke sklepanja SageMaker z primerki ml.c6g (Graviton 2) 20 % nižjo ceno v primerjavi z primerki ml.c5, primerki Graviton 3 ml.c7g pa so 15 % cenejši od primerkov ml.c6. Za več informacij glejte Cene Amazon SageMaker.

zaključek

V tej objavi smo predstavili novo uvedeno zmogljivost SageMaker za uvajanje modelov v primerke sklepanja, ki jih poganja Graviton. Dali smo vam napotke o najboljših praksah in na kratko razpravljali o prednostih nove vrste primerkov sklepanja glede na ceno in zmogljivost.

Če želite izvedeti več o Gravitonu, glejte Procesor AWS Graviton. Začnete lahko z instancami EC2, ki temeljijo na AWS Graviton, na konzoli Amazon EC2 in s sklicevanjem na Tehnični priročnik za AWS Graviton. Končno točko modela Sagemaker lahko uvedete za sklepanje na Graviton z vzorčno kodo v tej objavi v spletnem dnevniku.

O avtorjih

Victor Jaramillo, dr. je višji inženir strojnega učenja v AWS Professional Services. Pred AWS je bil univerzitetni profesor in raziskovalec na področju prediktivnega vzdrževanja. V prostem času se ukvarja z vožnjo z motorjem in z domačimi mojstri.

Zmnako Awrahman, dr. je vodja prakse, ML SME in član skupnosti tehničnega področja strojnega učenja (TFC) pri Amazon Web Services. Strankam pomaga izkoristiti moč oblaka za pridobivanje vrednosti iz svojih podatkov s podatkovno analitiko in strojnim učenjem.

Sunita Nadampalli je vodja razvoja programske opreme pri AWS. Vodi optimizacije zmogljivosti programske opreme Graviton za strojno nagnjene, HPC in multimedijske delovne obremenitve. Navdušena je nad odprtokodnim razvojem in zagotavljanjem stroškovno učinkovitih programskih rešitev z Arm SoC.

Johna Liu je inženir za razvoj programske opreme v ekipi Amazon SageMaker. Njeno trenutno delo se osredotoča na pomoč razvijalcem pri učinkovitem gostovanju modelov strojnega učenja in izboljšanju zmogljivosti sklepanja. Navdušena je nad analizo prostorskih podatkov in uporabo umetne inteligence za reševanje družbenih problemov.

Alan Tan je višji produktni vodja pri podjetju SageMaker, ki vodi prizadevanja za sklepanje velikih modelov. Navdušen je nad uporabo strojnega učenja na področju analitike. Izven dela uživa na prostem.