Crie modelos do Amazon SageMaker usando o PyTorch Model Zoo

A implantação de modelos de aprendizado de máquina (ML) treinados e de alta qualidade para realizar inferências em lote ou em tempo real é uma peça fundamental para agregar valor aos clientes. No entanto, o processo de experimentação de ML pode ser tedioso — há muitas abordagens que requerem uma quantidade significativa de tempo para serem implementadas. É por isso que modelos de ML pré-treinados, como os fornecidos no Zoológico modelo PyTorch são tão úteis. Amazon Sage Maker fornece uma interface unificada para experimentar diferentes modelos de ML, e o PyTorch Model Zoo nos permite trocar facilmente nossos modelos de maneira padronizada.

Esta postagem de blog demonstra como executar a inferência de ML usando um modelo de detecção de objeto do PyTorch Model Zoo no SageMaker. Os modelos de ML pré-treinados do PyTorch Model Zoo já estão prontos e podem ser facilmente usados ​​como parte de aplicativos de ML. Configurar esses modelos de ML como um endpoint do SageMaker ou Transformação em lote do SageMaker trabalho para inferência online ou offline é fácil com as etapas descritas nesta postagem do blog. vamos usar um R-CNN mais rápida modelo de detecção de objetos para prever caixas delimitadoras para classes de objetos pré-definidas.

Percorremos um exemplo de ponta a ponta, desde o carregamento dos pesos do modelo de detecção de objeto Faster R-CNN, até salvá-los em um Serviço de armazenamento simples da Amazon (Amazon S3) bucket e escrever um arquivo de ponto de entrada e entender os principais parâmetros na API PyTorchModel. Por fim, implantaremos o modelo de ML, realizaremos inferência nele usando o SageMaker Batch Transform, inspecionaremos a saída do modelo de ML e aprenderemos como interpretar os resultados. Essa solução pode ser aplicada a qualquer outro modelo pré-treinado no PyTorch Model Zoo. Para obter uma lista de modelos disponíveis, consulte o Documentação do PyTorch Model Zoo.

Visão geral da solução

Esta postagem do blog seguirá as etapas a seguir. Para obter uma versão funcional completa de todas as etapas, consulte create_pytorch_model_sagemaker.ipynb

• Etapa 1: configuração
• Etapa 2: carregando um modelo de ML do PyTorch Model Zoo
• Etapa 3 Salvar e fazer upload de artefatos de modelo de ML no Amazon S3
• Etapa 4: criar scripts de inferência de modelo de ML
• Etapa 5: iniciar um trabalho de transformação em lote do SageMaker
• Passo 6: Visualizando os resultados

Diagrama de arquitetura

Estrutura de diretórios

O código para este blog pode ser encontrado neste Repositório GitHub. A base de código contém tudo o que precisamos para criar artefatos de modelo de ML, iniciar o trabalho de transformação e visualizar os resultados.

Este é o fluxo de trabalho que usamos. Todas as etapas a seguir se referirão aos módulos dessa estrutura.

sagemaker_pytorch_model_zoo --> root directory
    |- inference.py --> entry point file
    |- create_pytorch_model_sagemaker.ipynb --> walks through all steps in this blog post
    |- cars.jpg --> input image

A sagemaker_torch_model_zoo pasta deve conter inference.py como um arquivo de ponto de entrada e create_pytorch_model_sagemaker.ipynb para carregar e salvar os pesos do modelo, criar um objeto de modelo SageMaker e, finalmente, passá-lo para um trabalho de transformação em lote do SageMaker. Para trazer seus próprios modelos de ML, altere os caminhos na Etapa 1: seção de configuração do notebook e carregue um novo modelo na Etapa 2: Carregando um modelo de ML da seção PyTorch Model Zoo. O restante das etapas a seguir abaixo permaneceria o mesmo.

Etapa 1: configuração

Papéis IAM

O SageMaker executa operações na infraestrutura gerenciada pelo SageMaker. O SageMaker só pode executar ações permitidas conforme definido na função de execução do IAM que acompanha o notebook para o SageMaker. Para obter uma documentação mais detalhada sobre como criar funções IAM e gerenciar permissões IAM, consulte o Documentação de funções do AWS SageMaker. Podemos criar uma nova função, ou podemos obter o Bloco de notas SageMaker (Estúdio)função de execução padrão do executando as seguintes linhas de código:

import sagemaker

session = sagemaker.Session()

# Set a default S3 bucket
default_bucket = session.default_bucket()

# Get the region
region = boto3.Session().region_name

# Get the SageMaker Execution Role
role_arn = sagemaker.get_execution_role()

O código acima obtém a função de execução do SageMaker para a instância do notebook. Esta é a função do IAM que criamos para nossa instância de notebook SageMaker ou SageMaker Studio.

Parâmetros configuráveis ​​pelo usuário

Aqui estão todos os parâmetros configuráveis ​​necessários para criar e iniciar nosso trabalho de transformação em lote do SageMaker:

INSTANCE_TYPE= "ml.m5.xlarge"
INSTANCE_COUNT= 1
BUCKET = os.path.join("s3://", default_bucket)

DATA_PATH= os.path.join(BUCKET, "images")
IMAGE_NAME = "cars.jpg"
RANDOM_STRING_LENGTH= 16
MODEL_NAME= "FasterRCNNResnet50"

# Needs to be set to version 1.2 or higher to enable automatic PyTorch model repackaging
FRAMEWORK_VERSION= "1.2"
ENTRY_POINT_FILE_NAME= "inference.py"

SAGEMAKER_EXECUTION_ROLE_ARN= role_arn
MODEL_ARTIFACTS_FILE_NAME= os.path.join(BUCKET, "modelzoo/fasterrcnn_resnet50_fpn/model.tar.gz")
IMAGE_URI= sagemaker.image_uris.retrieve(framework="pytorch",
region=region,
version="1.9.1",
py_version="py38",
image_scope='inference',
instance_type=INSTANCE_TYPE)

Etapa 2: carregando um modelo de ML do PyTorch Model Zoo

Em seguida, especificamos um modelo de detecção de objeto do PyTorch Model Zoo e salvamos seus pesos de modelo de ML. Normalmente, salvamos um modelo PyTorch usando as extensões de arquivo .pt ou .pth. O trecho de código abaixo baixa um modelo Faster R-CNN ResNet50 ML pré-treinado do PyTorch Model Zoo:

modelo = archvision.models.detection.fasterrcnn_resnet50_fpn(pré-treinado=Verdadeiro)

A transformação em lote do SageMaker requer como entrada alguns pesos de modelo, portanto, salvaremos o modelo de ML pré-treinado como model.pt. Se quisermos carregar um modelo personalizado, podemos salvar os pesos do modelo de outro modelo PyTorch como model.pt.

H = 1080
W = 1920
scripted_fn = torch.jit.script(model, torch.randn(1, 3, H, W))
scripted_fn.save("model.pt")

Etapa 3: Salvar e fazer upload de artefatos de modelo de ML no Amazon S3

Como usaremos o SageMaker para inferência de ML, precisamos carregar os pesos do modelo em um bucket do S3. Podemos fazer isso usando os seguintes comandos ou baixando e simplesmente arrastando e soltando o arquivo diretamente no S3. Os seguintes comandos irão primeiro comprimir o grupo de arquivos dentro model.pt para um tarball e copie os pesos do modelo de nossa máquina local para o balde S3.

Note: Para executar os seguintes comandos, você precisa ter o Interface de linha de comando AWS (AWS CLI) instalado.

tar -czvf model.tar.gz model.pt
aws s3 cp model.tar.gz $MODEL_ARTIFACTS_FILE_NAME

Em seguida, copiamos nossa imagem de entrada para o S3. Abaixo está o caminho S3 completo para a imagem.

car_image_path = os.path.join(DATA_PATH, IMAGE_NAME)

Podemos copiar esta imagem para S3 com outro comando aws s3 cp.

aws s3 cp cars.jpg $car_image_path

Etapa 4: criar scripts de inferência de modelo de ML

Agora vamos examinar nosso arquivo de ponto de entrada, inference.py módulo. Podemos implantar um modelo PyTorch treinado fora do SageMaker usando a classe PyTorchModel. Primeiro, instanciamos o objeto PyTorchModelZoo. Em seguida, construiremos um arquivo de ponto de entrada inference.py para executar a inferência de ML usando a transformação em lote do SageMaker em dados de amostra hospedados no Amazon S3.

Entendendo o objeto PyTorchModel

A Modelo PyTorch class dentro da API Python do SageMaker nos permite realizar inferência de ML usando nosso artefato de modelo baixado.

Para iniciar a classe PyTorchModel, precisamos entender os seguintes parâmetros de entrada:

• name: Nome do modelo; recomendamos usar o nome do modelo + data e hora ou uma string aleatória + data e hora para exclusividade.
• model_data: o S3 URI do artefato de modelo de ML empacotado.
• entry_point: um arquivo Python definido pelo usuário a ser usado pela imagem do Docker de inferência para definir manipuladores para solicitações recebidas. O código define o carregamento do modelo, pré-processamento de entrada, lógica de previsão e pós-processamento de saída.
• framework_version: precisa ser definido para a versão 1.2 ou superior para habilitar o reempacotamento automático do modelo PyTorch.
• source_dir: O diretório do arquivo entry_point.
• role: uma função do IAM para fazer solicitações de serviço da AWS.
• image_uri: use esta imagem de contêiner Docker do Amazon ECR como base para o ambiente de computação do modelo de ML.
• sagemaker_session: A sessão do SageMaker.
• py_version: A versão do Python a ser usada

O trecho de código a seguir instancia a classe PyTorchModel para realizar inferência usando o modelo pré-treinado PyTorch:

model = PyTorchModel(
               name=RANDOM_STRING,
               model_data=MODEL_ARTIFACTS_FILE_NAME,
               entry_point=ENTRY_POINT_FILE_NAME,
               framework_version=FRAMEWORK_VERSION,
               role=SAGEMAKER_EXECUTION_ROLE_ARN,
               sagemaker_session=sagemaker_session,
               image_uri=IMAGE_URI,
        )

Entendendo o arquivo de ponto de entrada (inference.py)

O parâmetro entry_point aponta para um arquivo Python chamado inference.py. Esse ponto de entrada define o carregamento do modelo, o pré-processamento de entrada, a lógica de previsão e o pós-processamento de saída. Ele complementa o código de serviço do modelo de ML no PyTorch pré-construído Contêiner de aprendizado profundo do SageMaker imagem.

Inference.py conterá as seguintes funções. Em nosso exemplo, implementamos o model_fn, input_fn, predict_fn e output_fn funções para substituir o manipulador de inferência PyTorch padrão.

1. model_fn: usa um diretório contendo pontos de verificação de modelo estático na imagem de inferência. Abre e carrega o modelo de um caminho especificado e retorna um modelo PyTorch.
2. input_fn: recebe a carga útil da solicitação recebida (request_body) e o tipo de conteúdo de uma solicitação recebida (request_content_type) como entrada. Lida com a decodificação de dados. Essa função precisa ser ajustada para qual entrada o modelo está esperando.
3. predict_fn: chama um modelo em dados desserializados em input_fn. Executa a previsão no objeto desserializado com o modelo de ML carregado.
4. output_fn: Serializa o resultado da previsão no tipo de conteúdo de resposta desejado. Converte as previsões obtidas da função predict_fn nos formatos JSON, CSV ou NPY.

Etapa 5: iniciar um trabalho de transformação em lote do SageMaker

Para este exemplo, obteremos resultados de inferência de ML por meio de um trabalho de transformação em lote do SageMaker. Os trabalhos de transformação em lote são mais úteis quando queremos obter inferências de conjuntos de dados uma vez, sem a necessidade de um endpoint persistente. Nós instanciamos um sagemaker.transformador.Transformador objeto para criar e interagir com tarefas de transformação em lote do SageMaker.

transformer = model.transformer(instance_type=INSTANCE_TYPE, 
                                instance_count=INSTANCE_COUNT
                                )
transformer.transform(data=DATA_PATH,
                      data_type="S3Prefix",
                      content_type="application/x-image",
                      wait=True
                      )

Consulte a documentação para criar um trabalho de transformação em lote em CriarTransformJob.

Passo 6: Visualizando os resultados

Após a conclusão do trabalho de transformação em lote do SageMaker, podemos carregar as saídas de inferência de ML do Amazon S3. Para isso, navegue até o Console de gerenciamento da AWS e procure por Amazon SageMaker. No painel esquerdo, sob Inferência, Ver Tarefas de transformação em lote.

Depois de selecionar Transformação em lote, consulte a página da Web listando todos os trabalhos de transformação em lote do SageMaker. Podemos ver o progresso de nossa execução de trabalho mais recente.

Primeiro, o trabalho terá o status “InProgress”. Depois de concluído, veja a mudança de status para Concluído.

Assim que o status for marcado como concluído, podemos clicar no trabalho para visualizar os resultados. Esta página da Web contém o resumo do trabalho, incluindo as configurações do trabalho que acabamos de executar.

Debaixo Configuração de dados de saída, veremos um caminho de saída S3. É aqui que encontraremos nossa saída de inferência de ML.

Selecione o caminho de saída S3 e veja um arquivo [image_name].[file_type].out com nossos dados de saída. Nosso arquivo de saída conterá uma lista de mapeamentos. Saída de exemplo:

[
  {
    "boxes": [
      [
        214.32322692871094,
        192.18418884277344,
        830.3932495117188,
        521.6996459960938
      ],
      [
        235.6244354248047,
        301.3315734863281,
        253.6448516845703,
        312.3525695800781
      ],
      [
        183.92031860351562,
        291.7759704589844,
        207.28196716308594,
        312.1448669433594
      ],
    ],
    "labels": [
      3,
      3,
      9,
    ],
    "scores": [
      0.8823906183242798,
      0.7710548639297485,
      0.4969744384288788,
    ]
  }
]

Para visualizar essas previsões, primeiro lemos o caminho de saída de nosso objeto transformador.

def get_output_from_s3(s3uri, file_name):
    parsed_url = urlparse(s3uri)
    bucket_name = parsed_url.netloc
    prefix = parsed_url.path[1:]
    s3 = boto3.resource('s3')
    obj = s3.Object(bucket_name, '{}/{}'.format(prefix, file_name))
    return obj.get()["Body"].read().decode('utf-8')
    
# Output path from Batch Transform job
output_path = transformer.output_path

# Get the output file from S3
predictions = get_output_from_s3(output_path, "car.jpg.out")

Em seguida, processamos esse arquivo de saída e visualizamos nossas previsões. Abaixo, especificamos nosso limite de confiança. Obtemos a lista de classes do Mapeamento de objeto de conjunto de dados COCO. Durante a inferência, o modelo requer apenas os tensores de entrada e retorna as previsões pós-processadas como uma List[Dict[Tensor]], uma para cada imagem de entrada. Os campos do Dict são os seguintes, onde N é o número de detecções:

1. caixas (FloatTensor[N, 4]): as caixas previstas em [x1, y1, x2, y2] formato, com 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H, Onde W é a largura da imagem e H é a altura da imagem
2. rótulos (Int64Tensor[N]): os rótulos previstos para cada detecção
3. pontuações (Tensor[N]): as pontuações de previsão para cada detecção

Para obter mais detalhes sobre a saída, consulte o PyTorch Documentação R-CNN FPN mais rápida.

A saída do modelo contém caixas delimitadoras com as respectivas pontuações de confiança. Podemos otimizar a exibição de falsos positivos removendo as caixas delimitadoras nas quais o modelo não confia. Os trechos de código a seguir processam as previsões no arquivo de saída e desenham caixas delimitadoras nas previsões onde a pontuação está acima do nosso limite de confiança. Definimos o limite de probabilidade, CONF_THRESH, para 75 neste exemplo.

def procress_batch_transform_output(predictions):
    predictions = eval(predictions)
    for pred in predictions[1:]:
        pred = pred[0]
        boxes = np.array(pred["boxes"])
        labels = np.array(pred["labels"])
        scores = np.array(pred["scores"])

        scores_idx = scores >= CONF_THRESH
        boxes_meet = boxes[scores_idx, :]
        labels_meet = labels[scores_idx]
        scores_meet = scores[scores_idx]

        labels_str = [CLASSES[i] for i in labels_meet]
        
        # Return a tuple containing labels, label index, score, and bounding box
        processed_predictions =  list(zip(labels_str, labels_meet, scores_meet, boxes_meet))
        return processed_predictions
    
    
def visualize_batch_transform_output(input_image, processed_predictions):
    # read input image from computer
    img = read_image(input_image)
    for label, label_index, score, box in processed_predictions:
        label = label + ", score: " + str(round(score, 2))
        # draw bounding box and fill color
        box = torch.tensor(box)
        box = box.unsqueeze(0)
        img = draw_bounding_boxes(img, box, width=5,labels=[label], font_size=16)

    # transform this image to PIL image
    img = torchvision.transforms.ToPILImage()(img)

    # display output
    img.show()

# Process the predictions in the output file
processed_predictions = procress_batch_transform_output(predictions)
visualize_batch_transform_output("car.jpg", processed_predictions)

Por fim, visualizamos esses mapeamentos para entender nossa saída.

Note: se a imagem não for exibida em seu bloco de anotações, localize-a na árvore de diretórios no lado esquerdo do JupyterLab e abra-a a partir daí.

Executando o código de exemplo

Para obter um exemplo de trabalho completo, clone o código no exemplos de amazon-sagemaker GitHub e executar as células no create_pytorch_model_sagemaker.ipynb notebook.

Conclusão

Nesta postagem do blog, apresentamos um exemplo completo de execução de inferência de ML usando um modelo de detecção de objeto do PyTorch Model Zoo usando a transformação em lote do SageMaker. Cobrimos o carregamento dos pesos do modelo de detecção de objeto Faster R-CNN, salvando-os em um bucket S3, escrevendo um arquivo de ponto de entrada e compreendendo os principais parâmetros na API PyTorchModel. Por fim, implantamos o modelo e realizamos a inferência do modelo de ML, visualizamos a saída do modelo e aprendemos a interpretar os resultados.

Sobre os autores

Dipika Khullar é um engenheiro de ML no Laboratório de soluções de ML da Amazon. Ela ajuda os clientes a integrar soluções de ML para resolver seus problemas de negócios. Mais recentemente, ela construiu pipelines de treinamento e inferência para clientes de mídia e modelos preditivos para marketing.

Marcelo Aberle é engenheiro de ML na organização AWS AI. Ele está liderando os esforços da MLOps no Laboratório de soluções de ML da Amazon, ajudando os clientes a projetar e implementar sistemas de ML escalonáveis. Sua missão é orientar os clientes em sua jornada de ML empresarial e acelerar seu caminho de ML para a produção.

Ninad Kulkarni é um Cientista Aplicado no Laboratório de soluções de ML da Amazon. Ele ajuda os clientes a adotar ML e AI criando soluções para resolver seus problemas de negócios. Mais recentemente, ele construiu modelos preditivos para clientes esportivos, automotivos e de mídia.

Yash Shah é Gerente Científico da Laboratório de soluções de ML da Amazon. Ele e sua equipe de cientistas aplicados e engenheiros de ML trabalham em uma variedade de casos de uso de ML de saúde, esportes, automotivo e manufatura.