Otimize seus trabalhos de inferência usando inferência dinâmica em lote com o TorchServe no Amazon SageMaker

No aprendizado profundo, o processamento em lote refere-se à alimentação de múltiplas entradas em um modelo. Embora seja essencial durante o treinamento, também pode ser muito útil gerenciar os custos e otimizar o rendimento durante o tempo de inferência. Os aceleradores de hardware são otimizados para paralelismo, e o processamento em lote ajuda a saturar a capacidade computacional e muitas vezes leva a um rendimento mais alto.

O lote pode ser útil em vários cenários durante a implantação do modelo na produção. Aqui, nós os categorizamos amplamente em dois casos de uso:

• Aplicativos em tempo real onde diversas solicitações de inferência são recebidas de diferentes clientes e são agrupadas dinamicamente em lote e alimentadas no modelo de serviço. A latência geralmente é importante nesses casos de uso.
• Aplicativos offline onde diversas entradas ou solicitações são agrupadas em lote no lado do cliente e enviadas para o modelo de atendimento. Um rendimento mais alto costuma ser o objetivo desses casos de uso, o que ajuda a gerenciar os custos. Exemplos de casos de uso incluem análise de vídeo e avaliação de modelo.

Amazon Sage Maker fornece duas opções populares para seus trabalhos de inferência. Para aplicativos em tempo real, o SageMaker Hosting usa TorchServe como biblioteca de serviço de back-end que lida com o lote dinâmico das solicitações recebidas. Para aplicativos off-line, você pode usar trabalhos de transformação em lote do SageMaker. Neste post, examinamos um exemplo de cada opção para ajudá-lo a começar.

Como o TorchServe é nativamente integrado com SageMaker via Kit de ferramentas de inferência SageMaker PyTorch, você pode implantar facilmente um modelo PyTorch no TorchServe usando SageMaker Hosting. Também pode haver momentos em que você precise personalizar ainda mais seu ambiente usando imagens Docker personalizadas. Nesta postagem, mostramos primeiro como implantar um endpoint em tempo real usando o kit de ferramentas de inferência SageMaker PyTorch nativo e configurando o tamanho do lote para otimizar o rendimento. No segundo exemplo, demonstramos como usar uma imagem Docker personalizada para definir configurações avançadas do TorchServe que não estão disponíveis como uma variável de ambiente para otimizar seu trabalho de inferência em lote.

Melhores práticas para inferência em lote

O processamento em lote pode aumentar o rendimento e otimizar seus recursos porque ajuda a concluir um número maior de inferências em um determinado período de tempo, em detrimento da latência. Para otimizar a implantação do modelo para maior rendimento, a diretriz geral é aumentar o tamanho do lote até que o rendimento diminua. Na maioria das vezes, isso é adequado para aplicativos off-line, onde várias entradas são agrupadas (como quadros de vídeo, imagens ou texto) para obter resultados de previsão.

Para aplicações em tempo real, a latência costuma ser a principal preocupação. Há uma compensação entre maior rendimento e maior tamanho e latência do lote; talvez seja necessário fazer ajustes conforme necessário para atender ao seu SLA de latência. Em termos de melhores práticas na nuvem, o custo por um determinado número de inferências é uma orientação útil para tomar uma decisão informada que atenda às suas necessidades de negócios. Um fator que contribui para o gerenciamento de custos é a escolha do acelerador certo. Para mais informações, veja Escolha o melhor acelerador de IA e compilação de modelo para inferência de visão computacional com Amazon SageMaker.

Processamento em lote dinâmico do TorchServe no SageMaker

TorchServe é a biblioteca nativa PyTorch para servir modelos em produção em escala. É um desenvolvimento conjunto do Facebook e da AWS. O TorchServe permite monitorar, adicionar métricas personalizadas, oferecer suporte a vários modelos, aumentar e diminuir o número de trabalhadores por meio de APIs de gerenciamento seguras e fornecer pontos de extremidade de inferência e explicação.

Para oferecer suporte ao processamento em lote, o TorchServe fornece um recurso de lote dinâmico. Ele agrega as solicitações recebidas dentro de um período de tempo especificado, agrupa-as em lote e envia o lote para inferência. As solicitações recebidas são processadas através do manipuladores em TorchServe. TorchServe tem vários manipuladores padrão, e você pode criar um manipulador personalizado se o seu caso de uso não for coberto. Ao usar um manipulador personalizado, certifique-se de que a lógica de inferência em lote tenha sido implementada no manipulador. Um exemplo de manipulador personalizado com suporte para inferência em lote está disponível em GitHub.

Você pode configurar o lote dinâmico usando duas configurações, batch_size e max_batch_delay, seja por meio de variáveis ​​de ambiente no SageMaker ou por meio do config.properties arquivo no TorchServe (se estiver usando um contêiner personalizado). TorchServe usa qualquer uma das configurações que vem primeiro, seja o tamanho máximo do lote (batch_size) ou janela de tempo especificada para aguardar o lote de solicitações por meio max_batch_delay.

Com as integrações do TorchServe com o SageMaker, agora você pode implantar modelos PyTorch nativamente no SageMaker, onde pode definir um modelo SageMaker PyTorch. Você pode adicionar carregamento de modelo personalizado, inferência e lógica de pré-processamento e pós-processamento em um script passado como um ponto de entrada para o SageMaker PyTorch (consulte o código de exemplo a seguir). Como alternativa, você pode usar um contêiner personalizado para implantar seus modelos. Para mais informações, veja O servidor de modelo SageMaker PyTorch.

Você pode definir o tamanho do lote para modelos PyTorch no SageMaker por meio de variáveis ​​de ambiente. Se você optar por usar um contêiner personalizado, poderá agrupar Configurações in config.properties com seu modelo ao empacotar seu modelo no TorchServe. O trecho de código a seguir mostra um exemplo de como definir o tamanho do lote usando variáveis ​​de ambiente e como implantar um modelo PyTorch no SageMaker:

from SageMaker.pytorch.model import PyTorchModel env_variables_dict = { "SAGEMAKER_TS_BATCH_SIZE": "3", "SAGEMAKER_TS_MAX_BATCH_DELAY": "100000"
} pytorch_model = PyTorchModel( model_data=model_artifact, role=role, source_dir="code", framework_version='1.9', entry_point="inference.py", env=env_variables_dict
) predictor = pytorch_model.deploy(initial_instance_count=1, instance_type="ml.c5.2xlarge", serializer=SageMaker.serializers.JSONSerializer(), deserializer=SageMaker.deserializers.BytesDeserializer())

No trecho de código, model_artifact refere-se a todos os arquivos necessários para carregar de volta o modelo treinado, que é arquivado em um arquivo .tar e enviado para um Serviço de armazenamento simples da Amazon (Amazon S3) balde. O inference.py é semelhante ao manipulador personalizado TorchServe; ele possui diversas funções que você pode substituir para acomodar a inicialização do modelo, o pré-processamento e o pós-processamento de solicitações recebidas e a lógica de inferência.

Os seguintes caderno mostra um exemplo completo de implantação de um modelo Hugging Face BERT.

Se precisar de um contêiner personalizado, você pode criar uma imagem de contêiner personalizada e enviá-la para o Registro do Amazon Elastic Container (Amazon ECR). O artefato do modelo, neste caso, pode ser um arquivo TorchServe .mar que agrupa os artefatos do modelo junto com o manipulador. Demonstraremos isso na próxima seção, onde usaremos um trabalho de transformação em lote do SageMaker.

Trabalho de transformação em lote do SageMaker

Para casos de uso off-line em que as solicitações são agrupadas em lote de uma fonte de dados, como um conjunto de dados, o SageMaker fornece trabalhos de transformação em lote. Esses trabalhos permitem ler dados de um bucket S3 e gravar os resultados em um bucket S3 de destino. Para mais informações, veja Use a transformação em lote para obter inferências de grandes conjuntos de dados. Um exemplo completo de inferência em lote usando trabalhos de transformação em lote pode ser encontrado a seguir caderno, onde utilizamos um modelo de tradução automática do concurso FLORES. Neste exemplo, mostramos como usar um contêiner personalizado para pontuar nosso modelo usando SageMaker. Usar um contêiner de inferência personalizado permite personalizar ainda mais a configuração do TorchServe. Neste exemplo, queremos alterar e desabilitar a decodificação JSON, o que podemos fazer através do TorchServe config.properties arquivo.

Ao usar um manipulador personalizado para TorchServe, precisamos ter certeza de que o manipulador implementa a lógica de inferência em lote. Cada manipulador pode ter funções personalizadas para realizar pré-processamento, inferência e pós-processamento. Um exemplo de manipulador personalizado com suporte para inferência em lote está disponível em GitHub.

Usamos nosso contêiner personalizado para agrupar os artefatos do modelo com o manipulador, como fazemos no TorchServe (criando um arquivo .mar). Também precisamos de um ponto de entrada para o contêiner Docker que inicie o TorchServe com o tamanho do lote e a decodificação JSON definidas em config.properties. Demonstramos isso no exemplo caderno.

O trabalho de transformação em lote do SageMaker requer acesso aos arquivos de entrada de um bucket S3, onde divide os arquivos de entrada em minilotes e os envia para inferência. Considere os seguintes pontos ao configurar o trabalho de transformação em lote:

• Coloque os arquivos de entrada (como um conjunto de dados) em um bucket S3 e defina-o como fonte de dados nas configurações do trabalho.
• Atribua um bucket do S3 para salvar os resultados do trabalho de transformação em lote.
• Conjunto Estratégia em lote para MultiRecord e SplitType para Line se você precisar do trabalho de transformação em lote para criar minilotes do arquivo de entrada. Se não for possível dividir automaticamente o conjunto de dados em minilotes, você poderá dividi-lo em minilotes colocando cada lote em um arquivo de entrada separado, colocado no bucket do S3 da fonte de dados.
• Certifique-se de que o tamanho do lote cabe na memória. O SageMaker geralmente trata disso automaticamente; no entanto, ao dividir lotes manualmente, isso precisa ser ajustado com base na memória.

O código a seguir é um exemplo de uma tarefa de transformação em lote:

s3_bucket_name= 'SageMaker-us-west-2-XXXXXXXX'
batch_input = f"s3://{s3_bucket_name}/folder/jobename_TorchServe_SageMaker/"
batch_output = f"s3://{s3_bucket_name}/folder/jobname_TorchServe_SageMaker_output/" batch_job_name = 'job-batch' + time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
batch_job_name request = { "ModelClientConfig": { "InvocationsTimeoutInSeconds": 3600, "InvocationsMaxRetries": 1, }, "TransformJobName": batch_job_name, "ModelName": model_name, "MaxConcurrentTransforms":1, "BatchStrategy": "MultiRecord", "TransformOutput": {"S3OutputPath": batch_output, "AssembleWith": "Line", "Accept": "application/json"}, "TransformInput": { "DataSource": { "S3DataSource": {"S3DataType": "S3Prefix", "S3Uri": batch_input} }, "SplitType" : "Line", "ContentType": "application/json", }, "TransformResources": {"InstanceType": "ml.p2.xlarge", "InstanceCount": 1},
}

Quando usamos as configurações anteriores e iniciamos nosso trabalho de transformação, ele lê os arquivos de entrada do bucket S3 de origem em lotes e os envia para inferência. Os resultados são gravados no bucket S3 especificado nas saídas.

O snippet de código a seguir mostra como criar e iniciar um trabalho usando as configurações anteriores:

sm.create_transform_job(**request) while True: response = sm.describe_transform_job(TransformJobName=batch_job_name) status = response["TransformJobStatus"] if status == "Completed": print("Transform job ended with status: " + status) break if status == "Failed": message = response["FailureReason"] print("Transform failed with the following error: {}".format(message)) raise Exception("Transform job failed") print("Transform job is still in status: " + status) time.sleep(30)

Conclusão

Nesta postagem, revisamos os dois modos que o SageMaker oferece para inferência online e offline. O primeiro usa lote dinâmico fornecido no TorchServe para agrupar solicitações de vários clientes. Este último usa um trabalho de transformação do SageMaker para agrupar as solicitações de arquivos de entrada em um bucket S3 e executar a inferência.

Também mostramos como servir modelos no SageMaker usando imagens de contêiner do kit de ferramentas de inferência PyTorch nativas do SageMaker e como usar contêineres personalizados para casos de uso que exigem definições de configuração avançadas do TorchServe.

À medida que o TorchServe continua a evoluir para atender às necessidades da comunidade PyTorch, novos recursos são integrados ao SageMaker para fornecer formas de alto desempenho para servir modelos em produção. Para mais informações, confira o Repo GitHub TorchServe e os votos de Exemplos de SageMaker.

Sobre os autores

Phi Nguyen é arquiteto de soluções na AWS, ajudando os clientes em sua jornada para a nuvem, com foco especial em data lake, análises, tecnologias semânticas e aprendizado de máquina. Nas horas vagas, você pode encontrá-lo indo de bicicleta para o trabalho, treinando o time de futebol do filho ou curtindo um passeio na natureza com a família.

Nikhil Kulkarni é desenvolvedor de software da AWS Machine Learning, com foco em aumentar o desempenho das cargas de trabalho de machine learning na nuvem e é cocriador do AWS Deep Learning Containers para treinamento e inferência. Ele é apaixonado por sistemas distribuídos de Deep Learning. Fora do trabalho, gosta de ler livros, mexer no violão e fazer pizza.

Hamid Shojanazeri é engenheiro parceiro da Pytorch e trabalha na otimização e serviço de modelos OSS de alto desempenho. Hamid tem doutorado em visão computacional e trabalhou como pesquisador em laboratórios de multimídia na Austrália, Malásia e líder de PNL no Opus.ai. Gosta de encontrar soluções mais simples para problemas difíceis e é um entusiasta da arte nas horas vagas.

Geeta Chauhan lidera a AI Partner Engineering na Meta AI com experiência na construção de plataformas distribuídas resilientes, antifrágeis e em grande escala para startups e empresas Fortune 500. Sua equipe trabalha com parceiros estratégicos, líderes de aprendizado de máquina em todo o setor e todos os principais provedores de serviços em nuvem para construir e lançar novos serviços e experiências de produtos de IA; e levando modelos PyTorch da pesquisa à produção. Ela é vencedora do Women in IT – Silicon Valley – CTO do ano 2019, palestrante ilustre da ACM e líder de pensamento em tópicos que vão desde Ética em IA, Deep Learning, Blockchain, IoT. Ela é apaixonada por promover o uso de IA para o bem.