Execute cargas de trabalho de inferência de machine learning em instâncias baseadas em AWS Graviton com o Amazon SageMaker

Hoje, estamos lançando Amazon Sage Maker inferência sobre AWS Graviton para permitir que você aproveite os benefícios de preço, desempenho e eficiência provenientes dos chips Graviton.

Instâncias baseadas em graviton estão disponíveis para inferência de modelo no SageMaker. Esta postagem ajuda você a migrar e implantar uma carga de trabalho de inferência de aprendizado de máquina (ML) de x86 para instâncias baseadas em Graviton no SageMaker. Fornecemos um guia passo a passo para implantar seu modelo treinado SageMaker em instâncias baseadas em Graviton, abordamos as práticas recomendadas ao trabalhar com Graviton, discutimos os benefícios de preço e desempenho e demonstramos como implantar um modelo TensorFlow em uma instância SageMaker Graviton.

Breve visão geral do Graviton

AWS Graviton é uma família de processadores projetados pela AWS que oferece a melhor relação custo-benefício e é mais eficiente em termos de energia do que seus equivalentes x86. Os processadores AWS Graviton 3 são os mais recentes da família de processadores Graviton e são otimizados para cargas de trabalho de ML, incluindo suporte para bfloat16 e o ​​dobro da largura de banda Single Instruction Multiple Data (SIMD). Quando esses dois recursos são combinados, o Graviton 3 pode oferecer desempenho até três vezes melhor do que as instâncias do Graviton 2. Graviton 3 também usa até 60% menos energia para o mesmo desempenho comparável Amazon Elastic Compute Nuvem (Amazon EC2). Esse é um ótimo recurso se você deseja reduzir sua pegada de carbono e atingir suas metas de sustentabilidade.

Visão geral da solução

Para implantar seus modelos em instâncias Graviton, você usa Contêineres de aprendizado profundo da AWS or traga seus próprios recipientes compatível com a arquitetura Arm v8.2.

A migração (ou nova implantação) de seus modelos de instâncias x86 para instâncias Graviton é simples porque a AWS fornece contêineres para hospedar modelos com PyTorch, TensorFlow, Scikit-learn e XGBoost, e os modelos são independentes de arquitetura. No entanto, se você estiver disposto a trazer suas próprias bibliotecas, também poderá fazê-lo, apenas certifique-se de que seu contêiner seja construído com um ambiente compatível com a arquitetura Arm64. Para mais informações, veja Construindo seu próprio contêiner de algoritmo.

Você precisa concluir três etapas para implantar seu modelo:

1. Crie um modelo do SageMaker: conterá, entre outros parâmetros, as informações sobre a localização do arquivo de modelo, o contêiner que será usado para a implantação e a localização do script de inferência. (Se você tiver um modelo existente já implantado em uma instância de inferência baseada em x86, poderá pular esta etapa.)
2. Criar uma configuração de endpoint: conterá informações sobre o tipo de instância que você deseja para o endpoint (por exemplo, ml.c7g.xlarge para Graviton3), o nome do modelo que você criou na etapa 1 e o número de instâncias por ponto final.
3. Inicie o endpoint com a configuração de endpoint criada na etapa 2.

Pré-requisitos

Antes de começar, considere os seguintes pré-requisitos:

1. Conclua os pré-requisitos listados em Pré-requisitos.
2. Seu modelo deve ser um modelo baseado em PyTorch, TensorFlow, XGBoost ou Scikit-learn. A tabela a seguir resume as versões com suporte no momento. Para obter as atualizações mais recentes, consulte SageMaker Framework Containers (somente suporte SM).
   

   .	Python	TensorFlow	PyTorch	Scikit-learn	XGBoostName
   Versões suportadas	3.8	2.9.1	1.12.1	1.0-1	1.3-1 para 1.5-1

3. O script de inferência é armazenado em Serviço de armazenamento simples da Amazon (Amazônia S3).

Nas seções a seguir, orientamos você pelas etapas de implantação.

Criar um modelo do SageMaker

Se você tiver um modelo existente já implantado em uma instância de inferência baseada em x86, poderá pular esta etapa. Caso contrário, conclua as etapas a seguir para criar um modelo SageMaker:

1. Localize o modelo que você armazenou em um bucket do S3. Copie o URI.
   Você usa o modelo URI mais tarde no MODEL_S3_LOCATION.
2. Identifique a versão da estrutura e a versão do Python que foi usada durante o treinamento do modelo.
   Você precisa selecionar um contêiner na lista de AWS Deep Learning Containers disponíveis de acordo com sua estrutura e versão do Python. Para mais informações, consulte Apresentando imagens de contêiner multiarquitetura para Amazon ECR.
3. Localize o URI do script Python de inferência no bucket S3 (o nome do arquivo comum é inference.py).
   O URI do script de inferência é necessário no INFERENCE_SCRIPT_S3_LOCATION.
4. Com essas variáveis, você pode chamar a API do SageMaker com o seguinte 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= 
   )

Você também pode criar imagens de várias arquiteturas e usar a mesma imagem, mas com tags diferentes. Você pode indicar em qual arquitetura sua instância será implantada. Para mais informações, consulte Apresentando imagens de contêiner multiarquitetura para Amazon ECR.

Criar uma configuração de endpoint

Depois de criar o modelo, você deve criar uma configuração de endpoint executando o seguinte comando (observe o tipo de instância que estamos usando):

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

A captura de tela a seguir mostra os detalhes de configuração do endpoint no console do SageMaker.

Iniciar o ponto de extremidade

Com a configuração do endpoint criada na etapa anterior, você pode implantar o endpoint:

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

Aguarde até que seu endpoint de modelo seja implantado. As previsões podem ser solicitadas da mesma forma que você solicita previsões para seus endpoints implantados em instâncias baseadas em x86.

A captura de tela a seguir mostra seu endpoint no console do SageMaker.

O que é suportado

O SageMaker fornece contêineres profundos Graviton com desempenho otimizado para estruturas TensorFlow e PyTorch. Esses contêineres oferecem suporte a visão computacional, processamento de linguagem natural, recomendações e casos de uso genéricos de inferência profunda e ampla baseados em modelos. Além de contêineres de aprendizado profundo, o SageMaker também fornece contêineres para estruturas clássicas de ML, como XGBoost e Scikit-learn. Os contêineres são binários compatíveis nas instâncias c6g/m6g e c7g, portanto, a migração do aplicativo de inferência de uma geração para outra é perfeita.

C6g/m6g suporta fp16 (flutuação de meia precisão) e para modelos compatíveis fornece desempenho equivalente ou melhor em comparação com instâncias c5. O C7g aumenta substancialmente o desempenho do ML dobrando a largura do SIMD e suportando bfloat-16 (bf16), que é a plataforma mais econômica para executar seus modelos.

Ambos c6g/m6g e c7g fornecem bom desempenho para ML clássico (por exemplo, XGBoost) em comparação com outras instâncias de CPU no SageMaker. O suporte Bfloat-16 no c7g permite a implantação eficiente de modelos treinados em bf16 ou AMP (Automatic Mixed Precision). O back-end Arm Compute Library (ACL) no Graviton fornece kernels bfloat-16 que podem acelerar até mesmo os operadores fp32 por meio do modo matemático rápido, sem a quantização do modelo.

Práticas recomendadas

Nas instâncias Graviton, cada vCPU é um núcleo físico. Não há contenção para os recursos de CPU comuns (ao contrário do SMT), e o dimensionamento do desempenho da carga de trabalho é linear a cada adição de vCPU. Portanto, é recomendável usar a inferência em lote sempre que o caso de uso permitir. Isso permitirá o uso eficiente das vCPUs pelo processamento paralelo do lote em cada núcleo físico. Se a inferência em lote não for possível, o tamanho de instância ideal para uma determinada carga útil será necessário para garantir que a sobrecarga de agendamento de encadeamento do SO não supere o poder de computação que vem com as vCPUs adicionais.

O TensorFlow vem com kernels Eigen por padrão e é recomendável mudar para OneDNN com ACL para obter o back-end de inferência mais otimizado. O back-end OneDNN e o modo matemático rápido bfloat-16 podem ser ativados ao iniciar o serviço de contêiner:

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

O comando de serviço anterior hospeda um modelo resnet50 padrão com duas configurações importantes:

-e TF_ENABLE_ONEDNN_OPTS=1
-e DNNL_DEFAULT_FPMATH_MODE=BF16

Eles podem ser passados ​​para o contêiner de inferência da seguinte maneira:

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

Exemplo de implantação

Nesta postagem, mostramos como implantar um modelo do TensorFlow, treinado no SageMaker, em uma instância de inferência do SageMaker com tecnologia Graviton.

Você pode executar o exemplo de código em uma instância de bloco de anotações do SageMaker, em um Estúdio Amazon SageMaker notebook ou um notebook Jupyter no modo local. Você precisa recuperar a função de execução do SageMaker se usar um notebook Jupyter no modo local.

O exemplo a seguir considera o conjunto de dados CIFAR-10. Você pode seguir o exemplo de notebook dos exemplos do SageMaker GitHub repo para reproduzir o modelo que é usado neste post. Usamos o modelo treinado e o cifar10_keras_main.py Script Python para inferência.

O modelo é armazenado em um bucket S3: s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz

A cifar10_keras_main.py script, que pode ser usado para a inferência, é armazenado em:s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/script/cifar10_keras_main.py

Usamos o us-east-1 Região e implante o modelo em uma instância baseada em Graviton ml.c7g.xlarge. Com base nisso, o URI do nosso AWS Deep Learning Container é 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker

1. Configure com o seguinte código:

   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. Baixe o conjunto de dados para teste de endpoint:

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

3. Crie o modelo e a configuração do endpoint e implante o 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)

4. Opcionalmente, você pode adicionar seu script de inferência a Environment in create_model se você não o adicionou originalmente como um artefato ao seu modelo SageMaker durante o treinamento:

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

   Você deve aguardar alguns minutos para que a implantação ocorra.

5. Verifique o status do terminal com o seguinte código:

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

   Você também pode verificar o Console de gerenciamento da AWS para ver quando seu modelo é implantado.

6. Configure o ambiente de tempo de execução para invocar os endpoints:

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

   Agora preparamos o payload para invocar o endpoint. Usamos o mesmo tipo de imagens usadas para o treinamento do modelo. Estes foram baixados em etapas anteriores.

7. Transmita a carga para tensores e defina o formato correto que o modelo está esperando. Para este exemplo, solicitamos apenas uma previsão.

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

   Obtemos a saída do modelo como uma matriz.

8. Podemos transformar essa saída em probabilidades se aplicarmos um softmax a ela:

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

Limpe os recursos

Os serviços envolvidos nesta solução incorrem em custos. Quando terminar de usar esta solução, limpe os seguintes recursos:

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

Comparação preço-desempenho

As instâncias baseadas em Graviton oferecem o preço mais baixo e a melhor relação preço-desempenho quando comparadas com as instâncias baseadas em x86. Semelhante às instâncias EC2, os endpoints de inferência SageMaker com instâncias ml.c6g (Graviton 2) oferecem um preço 20% menor em comparação com ml.c5, e as instâncias Graviton 3 ml.c7g são 15% mais baratas que as instâncias ml.c6. Para mais informações, consulte Preços do Amazon SageMaker.

Conclusão

Nesta postagem, mostramos o recém-lançado recurso do SageMaker para implantar modelos em instâncias de inferência baseadas em Graviton. Fornecemos orientações sobre as melhores práticas e discutimos brevemente os benefícios de preço e desempenho do novo tipo de instâncias de inferência.

Para saber mais sobre Graviton, consulte Processador AWS Graviton. Você pode começar com instâncias do EC2 baseadas em AWS Graviton no console do Amazon EC2 e consultando Guia técnico do AWS Graviton. Você pode implantar um endpoint de modelo Sagemaker para inferência em Graviton com o código de exemplo nesta postagem de blog.

Sobre os autores

Victor Jaramillo, PhD, é engenheiro sênior de aprendizado de máquina em serviços profissionais da AWS. Antes da AWS, ele foi professor universitário e cientista pesquisador em manutenção preditiva. Em seu tempo livre, ele gosta de andar de moto e de mecânicos de motocicletas DIY.

Zmnako Awrahman, PhD, é um gerente de prática, ML SME e membro da comunidade técnica de campo de aprendizado de máquina (TFC) na Amazon Web Services. Ele ajuda os clientes a aproveitar o poder da nuvem para extrair valor de seus dados com análise de dados e aprendizado de máquina.

Sunita Nadampalli é gerente de desenvolvimento de software da AWS. Ela lidera as otimizações de desempenho do software Graviton para machine leaning, HPC e cargas de trabalho multimídia. Ela é apaixonada pelo desenvolvimento de código aberto e pelo fornecimento de soluções de software econômicas com Arm SoCs.

Joana Liu é um engenheiro de desenvolvimento de software na equipe do Amazon SageMaker. Seu trabalho atual se concentra em ajudar os desenvolvedores a hospedar modelos de aprendizado de máquina com eficiência e melhorar o desempenho de inferência. Ela é apaixonada por análise de dados espaciais e usa IA para resolver problemas sociais.

Alan Tan é Gerente de Produto Sênior da SageMaker, liderando esforços na inferência de grandes modelos. Ele é apaixonado por aplicar o aprendizado de máquina à área de análise. Fora do trabalho, ele gosta de atividades ao ar livre.