Execute vários modelos de aprendizado profundo na GPU com endpoints de vários modelos do Amazon SageMaker

À medida que a adoção da IA ​​está acelerando em todo o setor, os clientes estão criando modelos sofisticados que aproveitam as novas descobertas científicas em aprendizado profundo. Esses modelos de próxima geração permitem que você alcance desempenho humano de última geração nas áreas de processamento de linguagem natural (NLP), visão computacional, reconhecimento de fala, pesquisa médica, segurança cibernética, previsão de estrutura de proteínas e muitos outros . Por exemplo, grandes modelos de linguagem como GPT-3, OPT e BLOOM podem traduzir, resumir e escrever texto com nuances humanas. No espaço de visão computacional, modelos de difusão de texto para imagem como DALL-E e Imagen podem criar imagens fotorrealistas a partir de linguagem natural com um nível mais alto de compreensão visual e de linguagem do mundo ao nosso redor. Esses modelos multimodais fornecem recursos mais avançados para várias tarefas downstream e a capacidade de ajustá-los para domínios específicos, além de trazer poderosas oportunidades de negócios para nossos clientes.

Esses modelos de aprendizado profundo continuam crescendo em termos de tamanho e normalmente contêm bilhões de parâmetros de modelo para dimensionar o desempenho do modelo para uma ampla variedade de tarefas, como geração de imagens, resumo de texto, tradução de idiomas e muito mais. Há também a necessidade de personalizar esses modelos para oferecer uma experiência hiperpersonalizada aos indivíduos. Como resultado, um número maior de modelos está sendo desenvolvido pelo ajuste fino desses modelos para várias tarefas de downstream. Para atender às metas de latência e taxa de transferência dos aplicativos de IA, as instâncias de GPU são preferidas em relação às instâncias de CPU (devido ao poder computacional oferecido pelas GPUs). No entanto, as instâncias de GPU são caras e os custos podem aumentar se você estiver implantando mais de 10 modelos. Embora esses modelos possam trazer aplicativos de IA impactantes, pode ser um desafio dimensionar esses modelos de aprendizado profundo de maneira econômica devido ao tamanho e ao número de modelos.

Amazon Sage Maker os endpoints multimodelo (MMEs) fornecem uma maneira escalável e econômica de implantar um grande número de modelos de aprendizado profundo. Os MMEs são uma opção de hospedagem popular para hospedar centenas de modelos baseados em CPU entre clientes como Zendesk, Veeva e AT&T. Anteriormente, você tinha opções limitadas para implantar centenas de modelos de aprendizado profundo que precisavam de computação acelerada com GPUs. Hoje, anunciamos o suporte MME para GPU. Agora você pode implantar milhares de modelos de aprendizado profundo por trás de um endpoint do SageMaker. As MMEs agora podem executar vários modelos em um núcleo de GPU, compartilhar instâncias de GPU por trás de um endpoint em vários modelos e carregar e descarregar modelos dinamicamente com base no tráfego de entrada. Com isso, você pode economizar custos significativamente e obter o melhor desempenho de preço.

Neste post, mostramos como executar vários modelos de aprendizado profundo em GPU com SageMaker MMEs.

MMEs SageMaker

Os MMEs do SageMaker permitem que você implante vários modelos por trás de um único endpoint de inferência que pode conter uma ou mais instâncias. Com MMEs, cada instância é gerenciada para carregar e servir vários modelos. As MMEs permitem quebrar o custo linearmente crescente de hospedar vários modelos e reutilizar a infraestrutura em todos os modelos.

O diagrama a seguir ilustra a arquitetura de um SageMaker MME.

O SageMaker MME baixa dinamicamente modelos de Serviço de armazenamento simples da Amazon (Amazon S3) quando invocado, em vez de baixar todos os modelos quando o endpoint é criado pela primeira vez. Como resultado, uma invocação inicial a um modelo pode apresentar uma latência de inferência mais alta do que as inferências subsequentes, que são concluídas com baixa latência. Se o modelo já estiver carregado no contêiner quando chamado, a etapa de download e carregamento será ignorada e o modelo retornará as inferências com baixa latência. Por exemplo, suponha que você tenha um modelo que é usado apenas algumas vezes por dia. Ele é carregado automaticamente sob demanda, enquanto os modelos acessados ​​com frequência são retidos na memória e invocados com latência consistentemente baixa.

SageMaker MMEs com suporte a GPU

SageMaker MMEs com GPU funcionam usando Servidor de inferência NVIDIA Triton. O NVIDIA Triton Inference Server é um software de serviço de inferência de código aberto que simplifica o processo de serviço de inferência e oferece alto desempenho de inferência. Triton suporta todas as principais estruturas de treinamento e inferência, como TensorFlow, NVIDIA® TensorRT™, PyTorch, MXNet, Python, ONNX, XGBoost, Scikit-learn, RandomForest, OpenVINO, C++ personalizado e muito mais. Ele oferece lotes dinâmicos, execuções simultâneas, quantização pós-treinamento e configuração de modelo ideal para obter inferência de alto desempenho. Além disso, o NVIDIA Triton Inference Server foi estendido para implementar Contrato de API MME, para integração com o MME.

O diagrama a seguir ilustra um fluxo de trabalho do MME.

As etapas do fluxo de trabalho são as seguintes:

1. O SageMaker MME recebe uma solicitação de invocação HTTP para um modelo específico usando TargetModel na solicitação junto com a carga útil.
2. O SageMaker roteia o tráfego para a instância correta atrás do endpoint onde o modelo de destino é carregado. O SageMaker entende o padrão de tráfego em todos os modelos por trás do MME e roteia as solicitações de maneira inteligente.
3. O SageMaker cuida do gerenciamento do modelo por trás do endpoint, carrega dinamicamente o modelo na memória do contêiner e descarrega o modelo com base na frota compartilhada de instâncias de GPU para oferecer o melhor desempenho de preço.
4. O SageMaker baixa dinamicamente modelos do Amazon S3 para o volume de armazenamento da instância. Se o modelo invocado não estiver disponível no volume de armazenamento da instância, o modelo será baixado no volume de armazenamento da instância. Se o volume de armazenamento da instância atingir a capacidade, o SageMaker excluirá todos os modelos não utilizados do volume de armazenamento.
5. O SageMaker carrega o modelo na memória do contêiner NVIDIA Triton em uma instância acelerada por GPU e atende à solicitação de inferência. O núcleo da GPU é compartilhado por todos os modelos em uma instância. Se o modelo já estiver carregado na memória do contêiner, as solicitações subsequentes serão atendidas mais rapidamente porque o SageMaker não precisa fazer download e carregá-lo novamente.
6. O SageMaker cuida da modelagem de tráfego para o endpoint MME e mantém cópias de modelo ideais em instâncias de GPU para obter o melhor desempenho de preço. Ele continua roteando o tráfego para a instância em que o modelo é carregado. Se os recursos da instância atingirem a capacidade devido à alta utilização, o SageMaker descarregará os modelos menos usados ​​do contêiner para liberar recursos para carregar modelos usados ​​com mais frequência.

As MMEs do SageMaker podem ser dimensionadas horizontalmente usando uma política de dimensionamento automático e provisionar instâncias de computação de GPU adicionais com base em métricas como invocações por instância e utilização de GPU para atender a qualquer aumento de tráfego para endpoints de MME.

Visão geral da solução

Neste post, mostramos como usar os novos recursos do SageMaker MMEs com GPU com um caso de uso de visão computacional. Para fins de demonstração, usamos um modelo pré-treinado de rede neural convolucional ResNet-50 que pode classificar imagens em 1,000 categorias. Discutimos como fazer o seguinte:

• Use um contêiner de inferência NVIDIA Triton em SageMaker MMEs, usando diferentes back-ends de estrutura de modelo Triton, como PyTorch e TensorRT
• Converta os modelos ResNet-50 para o formato otimizado do mecanismo TensorRT e implante-o com um SageMaker MME
• Configurar políticas de escalonamento automático para o MME
• Obtenha insights sobre métricas de instância e invocação usando Amazon CloudWatch

Criar artefatos de modelo

Esta seção apresenta as etapas para preparar um modelo pré-treinado ResNet-50 para ser implantado em um SageMaker MME usando as configurações de modelo do Triton Inference Server. Você pode reproduzir todas as etapas usando o bloco de notas passo a passo no GitHub.

Para este post, demonstramos a implantação com dois modelos. No entanto, você pode preparar e implantar centenas de modelos. Os modelos podem ou não compartilhar a mesma estrutura.

Preparar um modelo PyTorch

Primeiro, carregamos um modelo ResNet50 pré-treinado usando o pacote de modelos torchvision. Salvamos o modelo como um arquivo model.pt no formato TorchScript otimizado e serializado. O TorchScript compila uma passagem direta do modelo ResNet50 no modo ansioso com entradas de exemplo, portanto, passamos uma instância de uma imagem RGB com três canais de cores de dimensão 224 x 224.

Em seguida, precisamos preparar os modelos para o Triton Inference Server. O código a seguir mostra o repositório do modelo para o back-end da estrutura PyTorch. Triton usa o arquivo model.pt colocado no repositório do modelo para servir as previsões.

resnet
├── 1
│   └── model.pt
└── config.pbtxt

O arquivo de configuração do modelo config.pbtxt deve especificar o nome do modelo (resnet), as propriedades de plataforma e back-end (pytorch_libtorch), max_batch_size (128), e os tensores de entrada e saída junto com o tipo de dados (TYPE_FP32) em formação. Além disso, você pode especificar instance_group e dynamic_batching propriedades para obter inferência de alto desempenho. Veja o seguinte código:

name: "resnet"
platform: "pytorch_libtorch"
max_batch_size: 128
input {
  name: "INPUT__0"
  data_type: TYPE_FP32
  dims: 3
  dims: 224
  dims: 224
}
output {
  name: "OUTPUT__0"
  data_type: TYPE_FP32
  dims: 1000
}

Preparar o modelo TensorRT

NVIDIA TensorRT é um SDK para inferência de aprendizado profundo de alto desempenho e inclui um otimizador de inferência de aprendizado profundo e tempo de execução que oferece baixa latência e alta taxa de transferência para aplicativos de inferência. Usamos a ferramenta de linha de comando trtexec para gerar um mecanismo serializado TensorRT a partir de um Onnx. formato de modelo. Conclua as etapas a seguir para converter um modelo pré-treinado ResNet-50 para NVIDIA TensorRT:

1. Exporte o modelo ResNet-50 pré-treinado para um formato ONNX usando tocha.onnx.Esta etapa executa o modelo uma vez para rastrear sua execução com uma entrada de amostra e, em seguida, exporta o modelo rastreado para o arquivo especificado model.onnx.
2. Use trtexec para criar um plano de mecanismo TensorRT a partir do model.onnx Arquivo. Opcionalmente, você pode reduzir a precisão dos cálculos de ponto flutuante, simplesmente executando-os em ponto flutuante de 16 bits ou quantizando valores de ponto flutuante para que os cálculos possam ser realizados usando inteiros de 8 bits.

O código a seguir mostra a estrutura do repositório do modelo para o modelo TensorRT:

resnet
├── 1
│   └── model.plan
└── config.pbtxt

Para o modelo TensorRT, especificamos tensorrt_plan como plataforma e insira as especificações do Tensor da imagem de dimensão 224 x 224, que possui os canais de cores. O Tensor de saída com 1,000 dimensões é do tipo TYPE_FP32, correspondendo às diferentes categorias de objetos. Veja o seguinte código:

name: "resnet"
platform: "tensorrt_plan"
max_batch_size: 128
input {
  name: "input"
  data_type: TYPE_FP32
  dims: 3
  dims: 224
  dims: 224
}
output {
  name: "output"
  data_type: TYPE_FP32
  dims: 1000
}
model_warmup {
    name: "bs128 Warmup"
    batch_size: 128
    inputs: {
        key: "input"
        value: {
            data_type: TYPE_FP32
            dims: 3
            dims: 224
            dims: 224
            zero_data: false
        }
    }
}

Armazenar artefatos de modelo no Amazon S3

O SageMaker espera que os artefatos do modelo em .tar.gz formato. Eles também devem atender aos requisitos do contêiner Triton, como nome do modelo, versão, config.pbtxt arquivos e muito mais. tar a pasta que contém o arquivo de modelo como .tar.gz e faça o upload para o Amazon S3:

!mkdir -p triton-serve-pt/resnet/1/
!mv -f workspace/model.pt triton-serve-pt/resnet/1/
!tar -C triton-serve-pt/ -czf resnet_pt_v0.tar.gz resnet
model_uri_pt = sagemaker_session.upload_data(path="resnet_pt_v0.tar.gz", key_prefix="resnet-mme-gpu")
!mkdir -p triton-serve-trt/resnet/1/
!mv -f workspace/model.plan triton-serve-trt/resnet/1/
!tar -C triton-serve-trt/ -czf resnet_trt_v0.tar.gz resnet
model_uri_trt = sagemaker_session.upload_data(path="resnet_trt_v0.tar.gz", key_prefix="resnet-mme-gpu")

Agora que carregamos os artefatos de modelo para o Amazon S3, podemos criar um SageMaker MME.

Implantar modelos com um MME

Agora implantamos um modelo ResNet-50 com dois back-ends de estrutura diferentes (PyTorch e TensorRT) em um SageMaker MME.

Observe que você pode implantar centenas de modelos e os modelos podem usar a mesma estrutura. Eles também podem usar frameworks diferentes, como mostrado neste post.

Usamos o SDK da AWS para Python (Boto3) APIs criar_modelo, create_endpoint_config e criar_endpoint para criar um MME.

Defina o contêiner de veiculação

Na definição do contêiner, defina o model_data_url para especificar o diretório do S3 que contém todos os modelos que o SageMaker MME usa para carregar e fornecer previsões. Definir Mode para MultiModel para indicar que o SageMaker cria o terminal com especificações de contêiner MME. Definimos o contêiner com uma imagem que dá suporte à implantação de MMEs com GPU. Veja o seguinte código:

container = {
"Image": ,
"ModelDataUrl": ,
"Mode": "MultiModel"
}

Criar um objeto multimodelo

Use o cliente SageMaker Boto3 para criar o modelo usando o create_model API. Passamos a definição do contêiner para a API de criação de modelo junto com ModelName e ExecutionRoleArn:

create_model_response = sm_client.create_model(
    ModelName=, ExecutionRoleArn=role, PrimaryContainer=container
)

Definir configurações do MME

Crie configurações de MME usando o create_endpoint_config API Boto3. Especifique uma instância de computação de GPU acelerada em InstanceType (usamos o tipo de instância g4dn.4xlarge). Recomendamos configurar seus endpoints com pelo menos duas instâncias. Isso permite que o SageMaker forneça um conjunto altamente disponível de previsões em várias zonas de disponibilidade para os modelos.

Com base em nossas descobertas, você pode obter melhor desempenho de preço em instâncias otimizadas para ML com um único núcleo de GPU. Portanto, o suporte do MME para o recurso de GPU só está habilitado para instâncias de núcleo de GPU única. Para obter uma lista completa de instâncias suportadas, consulte Tipos de instância de GPU compatíveis.

create_endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName=,
    ProductionVariants=[
        {
            "InstanceType": "ml.g4dn.4xlarge",
            "InitialVariantWeight": 1,
            "InitialInstanceCount": 2,
            "ModelName": ,
            "VariantName": "AllTraffic",
        }
    ],
)

Criar um MME

Com a configuração de endpoint anterior, criamos um SageMaker MME usando o criar_endpoint API. O SageMaker cria o MME, inicia a instância de computação de ML g4dn.4xlarge e implanta os modelos PyTorch e TensorRT ResNet-50 neles. Veja o seguinte código:

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=, EndpointConfigName=
)

Invoque o modelo de destino no MME

Depois de criarmos o endpoint, podemos enviar uma solicitação de inferência ao MME usando o invoke_enpoint API. Nós especificamos o TargetModel na chamada de invocação e passe a carga útil para cada tipo de modelo. O código a seguir é uma invocação de amostra para o modelo PyTorch e o modelo TensorRT:

runtime_sm_client.invoke_endpoint(
    EndpointName=,
    ContentType="application/octet-stream",
    Body=json.dumps(pt_payload),
    TargetModel='resnet_pt_v0.tar.gz', #PyTorch Model
)
runtime_sm_client.invoke_endpoint(
    EndpointName=, 
    ContentType="application/octet-stream", 
    Body=json.dumps(trt_payload),
    TargetModel='resnet_trt_v0.tar.gz' #TensorRT Model
)

Configurar políticas de escalonamento automático para o GPU MME

Os MMEs SageMaker suportam dimensionamento automático para seus modelos hospedados. O escalonamento automático ajusta dinamicamente o número de instâncias provisionadas para um modelo em resposta a alterações em sua carga de trabalho. Quando a carga de trabalho aumenta, o escalonamento automático coloca mais instâncias online. Quando a carga de trabalho diminui, o escalonamento automático remove instâncias desnecessárias para que você não pague por instâncias provisionadas que não está usando.

Na política de escalonamento a seguir, usamos a métrica personalizada GPUUtilization no TargetTrackingScalingPolicyConfiguration configuração e definir um TargetValue of 60.0 para o valor desejado dessa métrica. Essa política de escalonamento automático provisiona instâncias adicionais de até MaxCapacity quando a utilização da GPU é superior a 60%.

auto_scaling_client = boto3.client('application-autoscaling')

resource_id='endpoint/' +  + '/variant/' + 'AllTraffic' 
response = auto_scaling_client.register_scalable_target(
    ServiceNamespace='sagemaker',
    ResourceId=resource_id,
    ScalableDimension='sagemaker:variant:DesiredInstanceCount',
    MinCapacity=1,
    MaxCapacity=5
)

response = auto_scaling_client.put_scaling_policy(
    PolicyName='GPUUtil-ScalingPolicy',
    ServiceNamespace='sagemaker',
    ResourceId=resource_id,
    ScalableDimension='sagemaker:variant:DesiredInstanceCount', 
    PolicyType='TargetTrackingScaling',
    TargetTrackingScalingPolicyConfiguration={
        'TargetValue': 60.0, 
        'CustomizedMetricSpecification':
        {
            'MetricName': 'GPUUtilization',
            'Namespace': '/aws/sagemaker/Endpoints',
            'Dimensions': [
                {'Name': 'EndpointName', 'Value':  },
                {'Name': 'VariantName','Value': 'AllTraffic'}
            ],
            'Statistic': 'Average',
            'Unit': 'Percent'
        },
        'ScaleInCooldown': 600,
        'ScaleOutCooldown': 200 
    }
)

Recomendamos usar GPUUtilization or InvocationsPerInstance para configurar políticas de dimensionamento automático para seu MME. Para mais detalhes, consulte Definir políticas de escalonamento automático para implantações de endpoint de vários modelos

Métricas do CloudWatch para MMEs de GPU

Os MMEs do SageMaker fornecem as seguintes métricas em nível de instância para monitorar:

• LoadedModelCount – Número de modelos carregados nos contêineres
• Utilização de GPU – Porcentagem de unidades GPU que são usadas pelos contêineres
• Utilização de memória GPU – Porcentagem de memória GPU usada pelos contêineres
• Utilização do disco – Porcentagem de espaço em disco usado pelos contêineres

Essas métricas permitem planejar a utilização efetiva dos recursos da instância de GPU. No gráfico a seguir, vemos GPUMemoryUtilization foi de 38.3% quando mais de 16 modelos ResNet-50 foram carregados no contêiner. A soma da utilização de cada núcleo de CPU individual (CPUUtilization) foi de 60.9%, e a porcentagem de memória utilizada pelos contêineres (MemoryUtilization) foi de 9.36%.

Os MMEs do SageMaker também fornecem métricas de carregamento de modelo para obter insights no nível de invocação de modelo:

• ModelLoadingWaitTime – Intervalo de tempo para que o modelo seja baixado ou carregado
• Hora de descarga do modelo – Intervalo de tempo para descarregar o modelo do container
• Tempo de download do modelo – Hora de baixar o modelo do Amazon S3
• ModeloCacheHit – Número de invocações ao modelo que já estão carregadas no container

No gráfico a seguir, podemos observar que levou 8.22 segundos para um modelo responder a uma solicitação de inferência (ModelLatency), e 24.1 milissegundos foram adicionados à latência de ponta a ponta devido a sobrecargas do SageMaker (OverheadLatency). Também podemos ver quaisquer métricas de erros de chamadas para invocar uma chamada de API de endpoint, como Invocation4XXErrors e Invocation5XXErrors.

Para obter mais informações sobre as métricas do MME CloudWatch, consulte Métricas do CloudWatch para implantações de endpoint de vários modelos.

Resumo

Nesta postagem, você aprendeu sobre o novo suporte a vários modelos do SageMaker para GPU, que permite hospedar de maneira econômica centenas de modelos de aprendizado profundo em hardware de computação acelerado. Você aprendeu como usar o NVIDIA Triton Inference Server, que cria uma configuração de repositório de modelo para diferentes back-ends de estrutura e como implantar um MME com dimensionamento automático. Esse recurso permitirá que você dimensione centenas de modelos hiperpersonalizados que são ajustados para atender às experiências exclusivas do usuário final em aplicativos de IA. Você também pode aproveitar esse recurso para obter o desempenho de preço necessário para seu aplicativo de inferência usando GPUs fracionárias.

Para começar a usar o suporte MME para GPU, consulte Suporte de endpoint multimodelo para GPU.

Sobre os autores

Dhawal Patel é Arquiteto Principal de Machine Learning na AWS. Ele trabalhou com organizações que vão de grandes empresas a startups de médio porte em problemas relacionados à computação distribuída e inteligência artificial. Ele se concentra em aprendizado profundo, incluindo domínios de PNL e visão computacional. Ele ajuda os clientes a obter inferência de modelo de alto desempenho no Amazon SageMaker.

Vikram Elango é um arquiteto de soluções especialista em IA/ML sênior na Amazon Web Services, com sede na Virgínia, EUA. A Vikram ajuda os clientes globais do setor financeiro e de seguros com design, implementação e liderança de pensamento para criar e implantar aplicativos de aprendizado de máquina em escala. Atualmente, ele está focado em processamento de linguagem natural, IA responsável, otimização de inferência e dimensionamento de ML em toda a empresa. Em seu tempo livre, ele gosta de viajar, fazer caminhadas, cozinhar e acampar com sua família.

Saurabh Trikande é gerente de produto sênior da Amazon SageMaker Inference. Ele é apaixonado por trabalhar com clientes e motivado pelo objetivo de democratizar o aprendizado de máquina. Ele se concentra nos principais desafios relacionados à implantação de aplicativos de ML complexos, modelos de ML multilocatários, otimizações de custo e à implantação de modelos de aprendizado profundo mais acessíveis. Em seu tempo livre, Saurabh gosta de caminhar, aprender sobre tecnologias inovadoras, seguir o TechCrunch e passar tempo com sua família.

Deepti Ragha é engenheiro de desenvolvimento de software na equipe do Amazon SageMaker. Seu trabalho atual se concentra na criação de recursos para hospedar modelos de aprendizado de máquina com eficiência. Em seu tempo livre, ela gosta de viajar, fazer caminhadas e cultivar plantas.

Nikhil Kulkarni é desenvolvedora de software com AWS Machine Learning, com foco em tornar as cargas de trabalho de machine learning mais eficientes na nuvem e é cocriadora de AWS Deep Learning Containers para treinamento e inferência. Ele é apaixonado por Deep Learning Systems distribuídos. Fora do trabalho, ele gosta de ler livros, tocar violão e fazer pizza.

Jiahong Liu é arquiteto de soluções na equipe de provedores de serviços de nuvem da NVIDIA. Ele auxilia os clientes na adoção de soluções de aprendizado de máquina e IA que aproveitam a computação acelerada da NVIDIA para enfrentar seus desafios de treinamento e inferência. Em seu tempo de lazer, ele gosta de origami, projetos de bricolage e jogar basquete.

Eliuth Triana é gerente de relações com o desenvolvedor na equipe NVIDIA-AWS. Ele conecta os líderes de produtos, desenvolvedores e cientistas da Amazon e da AWS com os tecnólogos e líderes de produtos da NVIDIA para acelerar as cargas de trabalho do Amazon ML / DL, produtos EC2 e serviços AWS AI. Além disso, Eliuth é um apaixonado ciclista de montanha, esquiador e jogador de pôquer.

Maximiliano Maccanti é engenheiro principal da AWS atualmente no DynamoDB, estive na equipe de lançamento do SageMaker no re:Invent 2017 e passei os 5 anos seguintes na plataforma de hospedagem adicionando todos os tipos de recursos para clientes. No meu tempo livre coleciono, conserto e brinco com consoles de videogame antigos.