Run Machine Learning Inference Workloads On AWS Graviton-based Instances With Amazon SageMaker

Ripubblicato da Platone

Seguaci: 0

Oggi lanciamo Amazon Sage Maker inferenza su Gravitone AWS per consentirti di sfruttare i vantaggi in termini di prezzo, prestazioni ed efficienza che derivano dai chip Graviton.

Le istanze basate su Graviton sono disponibili per l'inferenza del modello in SageMaker. Questo post ti aiuta a migrare e distribuire un carico di lavoro di inferenza di machine learning (ML) da x86 a istanze basate su Graviton in SageMaker. Forniamo una guida passo passo per distribuire il tuo modello addestrato SageMaker su istanze basate su Graviton, illustrare le migliori pratiche quando si lavora con Graviton, discutere i vantaggi in termini di rapporto qualità-prezzo e dimostrare come distribuire un modello TensorFlow su un'istanza SageMaker Graviton.

Breve panoramica di Graviton

AWS Graviton è una famiglia di processori progettata da AWS che offre il miglior rapporto qualità-prezzo e sono più efficienti dal punto di vista energetico rispetto alle loro controparti x86. I processori AWS Graviton 3 sono gli ultimi della famiglia di processori Graviton e sono ottimizzati per carichi di lavoro ML, incluso il supporto per bfloat16 e il doppio della larghezza di banda SIMD (Single Instruction Multiple Data). Quando queste due funzionalità vengono combinate, Graviton 3 può offrire prestazioni fino a tre volte migliori rispetto alle istanze Graviton 2. Graviton 3 utilizza anche fino al 60% di energia in meno per le stesse prestazioni comparabili Cloud di calcolo elastico di Amazon (Amazon EC2). Questa è un'ottima funzionalità se desideri ridurre la tua impronta di carbonio e raggiungere i tuoi obiettivi di sostenibilità.

Panoramica della soluzione

Per distribuire i tuoi modelli alle istanze di Graviton, puoi utilizzare Contenitori per l'apprendimento profondo AWS or porta i tuoi contenitori compatibile con l'architettura Arm v8.2.

La migrazione (o nuova distribuzione) dei tuoi modelli dalle istanze alimentate da x86 alle istanze Graviton è semplice perché AWS fornisce container per ospitare modelli con PyTorch, TensorFlow, Scikit-learn e XGBoost e i modelli sono indipendenti dall'architettura. Tuttavia, se sei disposto a portare le tue librerie, puoi farlo anche tu, assicurati solo che il tuo contenitore sia costruito con un ambiente che supporti l'architettura Arm64. Per ulteriori informazioni, vedere Costruire il proprio contenitore di algoritmi.

Devi completare tre passaggi per distribuire il tuo modello:

Crea un modello SageMaker: questo conterrà, tra gli altri parametri, le informazioni sulla posizione del file del modello, il contenitore che verrà utilizzato per la distribuzione e la posizione dello script di inferenza. (Se disponi di un modello esistente già distribuito in un'istanza di inferenza basata su x86, puoi saltare questo passaggio).
Crea una configurazione dell'endpoint: conterrà informazioni sul tipo di istanza che desideri per l'endpoint (ad esempio, ml.c7g.xlarge per Graviton3), il nome del modello che hai creato nel passaggio 1 e il numero di istanze per punto finale.
Avvia l'endpoint con la configurazione dell'endpoint creata nel passaggio 2.

Prerequisiti

Prima di iniziare, considera i seguenti prerequisiti:

Completare i prerequisiti elencati in Prerequisiti.
Il tuo modello dovrebbe essere un modello basato su PyTorch, TensorFlow, XGBoost o Scikit-learn. La tabella seguente riassume le versioni attualmente supportate al momento della stesura di questo documento. Per gli ultimi aggiornamenti, fare riferimento a Contenitori SageMaker Framework (solo supporto SM).

. Python TensorFlow PyTorch Scikit-learn XGBoost

Versioni supportate 3.8 2.9.1 1.12.1 1.0-1 1.3-1 a 1.5-1
Lo script di inferenza è memorizzato in Servizio di archiviazione semplice Amazon (Amazon S3).

Nelle sezioni seguenti, ti guidiamo attraverso i passaggi della distribuzione.

Crea un modello SageMaker

Se hai già un modello esistente distribuito in un'istanza di inferenza basata su x86, puoi saltare questo passaggio. Altrimenti, completa i seguenti passaggi per creare un modello SageMaker:

Individua il modello che hai archiviato in un bucket S3. Copia l'URI.
Utilizzerai l'URI del modello più avanti nel file MODEL_S3_LOCATION.
Identificare la versione del framework e la versione di Python utilizzate durante l'addestramento del modello.
Devi selezionare un container dall'elenco di AWS Deep Learning Container disponibili per il tuo framework e la tua versione di Python. Per ulteriori informazioni, fare riferimento a Presentazione di immagini di container multi-architettura per Amazon ECR.
Individua l'URI dello script Python di inferenza nel bucket S3 (il nome file comune è inference.py).
L'URI dello script di inferenza è necessario nel file INFERENCE_SCRIPT_S3_LOCATION.

Con queste variabili, puoi quindi chiamare l'API SageMaker con il seguente comando:

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

Puoi anche creare immagini con più architetture e utilizzare la stessa immagine ma con tag diversi. Puoi indicare su quale architettura verrà distribuita la tua istanza. Per ulteriori informazioni, fare riferimento a Presentazione di immagini di container multi-architettura per Amazon ECR.

Crea una configurazione dell'endpoint

Dopo aver creato il modello, devi creare una configurazione dell'endpoint eseguendo il seguente comando (nota il tipo di istanza che stiamo utilizzando):

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

Lo screenshot seguente mostra i dettagli di configurazione dell'endpoint sulla console SageMaker.

Avvia l'endpoint

Con la configurazione dell'endpoint creata nel passaggio precedente, puoi distribuire l'endpoint:

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

Attendi fino a quando l'endpoint del modello non viene distribuito. Le previsioni possono essere richieste nello stesso modo in cui richiedi le previsioni per i tuoi endpoint distribuiti in istanze basate su x86.

Lo screenshot seguente mostra il tuo endpoint sulla console SageMaker.

Cosa è supportato

SageMaker fornisce contenitori profondi Graviton ottimizzati per le prestazioni per i framework TensorFlow e PyTorch. Questi contenitori supportano la visione artificiale, l'elaborazione del linguaggio naturale, i consigli e i casi d'uso generici di inferenza basati su modelli profondi e ampi. Oltre ai container di deep learning, SageMaker fornisce anche container per framework ML classici come XGBoost e Scikit-learn. I contenitori sono binari compatibili tra le istanze c6g/m6g e c7g, pertanto la migrazione dell'applicazione di inferenza da una generazione all'altra è perfetta.

C6g/m6g supporta fp16 (float a mezza precisione) e per i modelli compatibili fornisce prestazioni equivalenti o migliori rispetto alle istanze c5. C7g aumenta sostanzialmente le prestazioni ML raddoppiando la larghezza SIMD e supportando bfloat-16 (bf16), che è la piattaforma più conveniente per l'esecuzione dei tuoi modelli.

Sia c6g/m6g che c7g forniscono buone prestazioni per ML classico (ad esempio, XGBoost) rispetto ad altre istanze CPU in SageMaker. Il supporto Bfloat-16 su c7g consente una distribuzione efficiente di modelli addestrati bf16 o AMP (Automatic Mixed Precision). Il backend Arm Compute Library (ACL) su Graviton fornisce kernel bfloat-16 che possono accelerare anche gli operatori fp32 tramite la modalità matematica veloce, senza la quantizzazione del modello.

Migliori pratiche consigliate

Nelle istanze Graviton, ogni vCPU è un core fisico. Non vi è alcuna contesa per le risorse CPU comuni (a differenza di SMT) e il ridimensionamento delle prestazioni del carico di lavoro è lineare con ogni aggiunta di vCPU. Pertanto, si consiglia di utilizzare l'inferenza batch ogni volta che il caso d'uso lo consente. Ciò consentirà un uso efficiente delle vCPU elaborando in parallelo il batch su ciascun core fisico. Se l'inferenza batch non è possibile, è necessaria la dimensione ottimale dell'istanza per un determinato payload per garantire che l'overhead di pianificazione del thread del sistema operativo non superi la potenza di calcolo fornita con le vCPU aggiuntive.

TensorFlow viene fornito con i kernel Eigen per impostazione predefinita e si consiglia di passare a OneDNN con ACL per ottenere il back-end di inferenza più ottimizzato. Il backend OneDNN e la modalità matematica veloce bfloat-16 possono essere abilitati durante l'avvio del servizio contenitore:

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

Il comando servente precedente ospita un modello resnet50 standard con due configurazioni importanti:

-e TF_ENABLE_ONEDNN_OPTS=1
-e DNNL_DEFAULT_FPMATH_MODE=BF16

Questi possono essere passati al contenitore di inferenza nel modo seguente:

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

Esempio di distribuzione

In questo post, ti mostriamo come distribuire un modello TensorFlow, addestrato in SageMaker, su un'istanza di inferenza SageMaker basata su Graviton.

Puoi eseguire l'esempio di codice in un'istanza notebook SageMaker, un Amazon Sage Maker Studio notebook o un notebook Jupyter in modalità locale. Devi recuperare il ruolo di esecuzione di SageMaker se usi un notebook Jupyter in modalità locale.

L'esempio seguente considera il set di dati CIFAR-10. Puoi seguire l'esempio del taccuino dagli esempi di SageMaker Repository GitHub per riprodurre il modello utilizzato in questo post. Usiamo il modello addestrato e il cifar10_keras_main.py Script Python per inferenza.

Il modello è archiviato in un bucket S3: s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz

I cifar10_keras_main.py lo script, che può essere utilizzato per l'inferenza, è archiviato in:s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/script/cifar10_keras_main.py

Usiamo il us-east-1 Area e distribuisci il modello su un'istanza basata su Graviton ml.c7g.xlarge. Sulla base di ciò, l'URI del nostro AWS Deep Learning Container è 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker

Configurare con il seguente codice:

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

Scarica il set di dati per il test degli endpoint:

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

Crea il modello e la configurazione dell'endpoint e distribuisci l'endpoint:

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)

Facoltativamente, puoi aggiungere il tuo script di inferenza a Environment in create_model se non l'hai originariamente aggiunto come artefatto al tuo modello SageMaker durante l'addestramento:

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

Devi attendere un paio di minuti affinché la distribuzione abbia luogo.

Verificare lo stato dell'endpoint con il seguente codice:
```
describe_response = client.describe_endpoint(EndpointName=ENDPOINT_NAME)
print(describe_response["EndpointStatus"]
```
Puoi anche controllare il Console di gestione AWS per vedere quando il tuo modello viene distribuito.
Configurare l'ambiente di runtime per richiamare gli endpoint:
```
runtime = boto3.Session().client(service_name="runtime.sagemaker")
```
Ora prepariamo il payload per richiamare l'endpoint. Utilizziamo lo stesso tipo di immagini utilizzate per il training del modello. Questi sono stati scaricati nei passaggi precedenti.
Trasmetti il payload ai tensori e imposta il formato corretto previsto dal modello. Per questo esempio, richiediamo solo una previsione.
```
input_image = x_test[0].reshape(1,32,32,3)
```
Otteniamo l'output del modello come un array.

Possiamo trasformare questo output in probabilità se vi applichiamo 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())

Pulisci risorse

I servizi coinvolti in questa soluzione comportano dei costi. Quando hai finito di usare questa soluzione, ripulisci le seguenti risorse:

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

Confronto prezzo-prestazioni

Le istanze basate su Graviton offrono il prezzo più basso e il miglior rapporto qualità-prezzo rispetto alle istanze basate su x86. Analogamente alle istanze EC2, gli endpoint di inferenza SageMaker con istanze ml.c6g (Graviton 2) offrono un prezzo inferiore del 20% rispetto a ml.c5 e le istanze Graviton 3 ml.c7g sono più economiche del 15% rispetto alle istanze ml.c6. Per ulteriori informazioni, fare riferimento a Prezzi di Amazon SageMaker.

Conclusione

In questo post, abbiamo presentato la funzionalità SageMaker appena lanciata per distribuire modelli in istanze di inferenza basate su Graviton. Ti abbiamo fornito indicazioni sulle best practice e discusso brevemente i vantaggi in termini di prezzo e prestazioni del nuovo tipo di istanze di inferenza.

Per saperne di più su Graviton, fare riferimento a Processore gravitonico AWS. Puoi iniziare con le istanze EC2 basate su AWS Graviton sulla console Amazon EC2 e facendo riferimento a Guida tecnica di AWS Graviton. Puoi distribuire un endpoint del modello Sagemaker per l'inferenza su Graviton con il codice di esempio in questo post del blog.

Circa gli autori

Vittorio Jaramillo, PhD, è un Senior Machine Learning Engineer in AWS Professional Services. Prima di AWS, è stato professore universitario e ricercatore in manutenzione predittiva. Nel tempo libero si diverte a guidare la sua moto e i meccanici di moto fai-da-te.

Zmnako Awrahman, dottore di ricerca, è un Practice Manager, ML SME e membro della Machine Learning Technical Field Community (TFC) presso Amazon Web Services. Aiuta i clienti a sfruttare la potenza del cloud per estrarre valore dai propri dati con l'analisi dei dati e l'apprendimento automatico.

Sunita Nadampalli è un responsabile dello sviluppo software presso AWS. Dirige le ottimizzazioni delle prestazioni del software Graviton per carichi di lavoro machine leaning, HPC e multimediali. È appassionata di sviluppo open source e offre soluzioni software convenienti con i SoC Arm.

Giovanni Liu è un Software Development Engineer nel team di Amazon SageMaker. Il suo lavoro attuale si concentra sull'aiutare gli sviluppatori a ospitare in modo efficiente modelli di machine learning e migliorare le prestazioni di inferenza. È appassionata di analisi dei dati spaziali e utilizza l'intelligenza artificiale per risolvere i problemi della società.

Alan Tan è un Senior Product Manager di SageMaker, che guida gli sforzi sull'inferenza di modelli di grandi dimensioni. È appassionato di applicare l'apprendimento automatico all'area dell'analisi. Al di fuori del lavoro, ama la vita all'aria aperta.