Transferir aprendizado para modelos de detecção de objetos do TensorFlow no Amazon SageMaker

Amazon Sage Maker oferece um conjunto de algoritmos integrados, modelos pré-treinados e modelos de solução pré-criados para ajudar cientistas de dados e profissionais de machine learning (ML) a começar a treinar e implantar modelos de ML rapidamente. Você pode usar esses algoritmos e modelos para aprendizado supervisionado e não supervisionado. Eles podem processar vários tipos de dados de entrada, incluindo tabular, imagem e texto.

Esta postagem é a segunda de uma série sobre os novos algoritmos integrados no SageMaker. No primeira postagem, mostramos como o SageMaker fornece um algoritmo integrado para classificação de imagens. Hoje, anunciamos que o SageMaker fornece um novo algoritmo integrado para detecção de objetos usando o TensorFlow. Este algoritmo de aprendizagem supervisionada oferece suporte à aprendizagem por transferência para muitos modelos pré-treinados disponíveis no TensorFlow. Ele pega uma imagem como entrada e gera os objetos presentes na imagem junto com as caixas delimitadoras. Você pode ajustar esses modelos pré-treinados usando a aprendizagem por transferência, mesmo quando um grande número de imagens de treinamento não estiver disponível. Está disponível através do SageMaker algoritmos integrados bem como através do IU JumpStart do SageMaker in Estúdio Amazon SageMaker. Para obter mais informações, consulte Tensorflow de detecção de objetos e o caderno de exemplo Introdução ao SageMaker Tensorflow – Detecção de objetos.

A detecção de objetos com TensorFlow no SageMaker fornece aprendizagem de transferência em muitos modelos pré-treinados disponíveis no TensorFlow Hub. De acordo com o número de rótulos de classe nos dados de treinamento, um novo cabeçote de detecção de objetos inicializado aleatoriamente substitui o cabeçote existente do modelo TensorFlow. Toda a rede, incluindo o modelo pré-treinado, ou apenas a camada superior (cabeça de detecção de objetos) pode ser ajustada nos novos dados de treinamento. Neste modo de aprendizagem por transferência, você pode obter treinamento mesmo com um conjunto de dados menor.

Como usar o novo algoritmo de detecção de objetos TensorFlow

Esta seção descreve como usar o algoritmo de detecção de objetos do TensorFlow com o SDK Python do SageMaker. Para obter informações sobre como usá-lo na interface do Studio, consulte SageMaker JumpStart.

O algoritmo suporta o aprendizado de transferência para os modelos pré-treinados listados em Modelos TensorFlow. Cada modelo é identificado por um único model_id. O código a seguir mostra como ajustar um modelo ResNet50 V1 FPN identificado por model_id tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8 em um conjunto de dados de treinamento personalizado. Para cada model_id, para iniciar um trabalho de treinamento do SageMaker por meio do Estimador classe do SageMaker Python SDK, você precisa buscar o URI da imagem Docker, o URI do script de treinamento e o URI do modelo pré-treinado por meio das funções utilitárias fornecidas no SageMaker. O URI do script de treinamento contém todo o código necessário para processamento de dados, carregamento do modelo pré-treinado, treinamento do modelo e salvamento do modelo treinado para inferência. O URI do modelo pré-treinado contém a definição da arquitetura do modelo pré-treinado e os parâmetros do modelo. Observe que o URI da imagem Docker e o URI do script de treinamento são iguais para todos os modelos de detecção de objetos do TensorFlow. O URI do modelo pré-treinado é específico para o modelo específico. Os tarballs do modelo pré-treinados foram pré-baixados do TensorFlow e salvos com a assinatura do modelo apropriada em Serviço de armazenamento simples da Amazon (Amazon S3), de modo que o trabalho de treinamento seja executado em isolamento de rede. Veja o seguinte código:

from sagemaker import image_uris, model_uris, script_urisfrom sagemaker.estimator import Estimator

model_id, model_version = "tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8", "*"
training_instance_type = "ml.p3.2xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(model_id=model_id,model_version=model_version,image_scope="training",instance_type=training_instance_type,region=None,framework=None)# Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training")# Retrieve the pre-trained model tarball for transfer learning
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tensorflow-od-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"

Com esses artefatos de treinamento específicos do modelo, você pode construir um objeto do Estimador classe:

# Create SageMaker Estimator instance
tf_od_estimator = Estimator(
    role=aws_role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,)

Em seguida, para transferir aprendizado em seu conjunto de dados personalizado, talvez seja necessário alterar os valores padrão dos hiperparâmetros de treinamento, listados em Hiperparâmetros. Você pode buscar um dicionário Python desses hiperparâmetros com seus valores padrão chamando hyperparameters.retrieve_default, atualize-os conforme necessário e, em seguida, passe-os para a classe Estimator. Observe que os valores padrão de alguns dos hiperparâmetros são diferentes para modelos diferentes. Para modelos grandes, o tamanho do lote padrão é menor e o train_only_top_layer hiperparâmetro é definido como True. O hiperparâmetro train_only_top_layer define quais parâmetros do modelo mudam durante o processo de ajuste fino. Se train_only_top_layer is True, os parâmetros das camadas de classificação mudam e o restante dos parâmetros permanece constante durante o processo de ajuste fino. Por outro lado, se train_only_top_layer is False, todos os parâmetros do modelo são ajustados. Veja o seguinte código:

from sagemaker import hyperparameters# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)# [Optional] Override default hyperparameters with custom values
hyperparameters["epochs"] = "5"

Nós fornecemos o Conjunto de dados PennFudanPed como um conjunto de dados padrão para ajustar os modelos. O conjunto de dados compreende imagens de pedestres. O código a seguir fornece o conjunto de dados de treinamento padrão hospedado em buckets S3:

# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/PennFudanPed_COCO_format/"

training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"

Por fim, para iniciar o trabalho de treinamento do SageMaker para ajustar o modelo, chame .fit no objeto da classe Estimator, ao passar a localização S3 do conjunto de dados de treinamento:

# Launch a SageMaker Training job by passing s3 path of the training data
tf_od_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Para obter mais informações sobre como usar o novo algoritmo de detecção de objetos SageMaker TensorFlow para transferência de aprendizagem em um conjunto de dados personalizado, implantar o modelo ajustado, executar inferência no modelo implantado e implantar o modelo pré-treinado como está, sem primeiro ajuste fino em um conjunto de dados personalizado, consulte o seguinte bloco de anotações de exemplo: Introdução ao SageMaker TensorFlow – Detecção de objetos.

Interface de entrada/saída para o algoritmo de detecção de objetos do TensorFlow

Você pode ajustar cada um dos modelos pré-treinados listados em Modelos do TensorFlow a qualquer conjunto de dados que inclua imagens pertencentes a qualquer número de classes. O objetivo é minimizar o erro de previsão nos dados de entrada. O modelo retornado pelo ajuste fino pode ser implantado posteriormente para inferência. A seguir estão as instruções sobre como os dados de treinamento devem ser formatados para entrada no modelo:

• Entrada – Um diretório com imagens de subdiretório e um arquivo annotations.json.
• saída – Existem duas saídas. O primeiro é um modelo ajustado, que pode ser implantado para inferência ou treinado posteriormente usando treinamento incremental. O segundo é um arquivo que mapeia índices de classe para rótulos de classe; isso é salvo junto com o modelo.

O diretório de entrada deve ser semelhante ao exemplo a seguir:

input_directory
      | -- images
            |--abc.png
            |--def.png
      |--annotations.json

A annotations.json arquivo deve conter informações para bounding_boxes e seus rótulos de classe. Deveria ter um dicionário com as chaves "images" e "annotations". O valor para o "images" a chave deve ser uma lista de entradas, uma para cada imagem do formulário {"file_name": image_name, "height": height, "width": width, "id": image_id}. O valor do "annotations" a chave deve ser uma lista de entradas, uma para cada caixa delimitadora do formulário {"image_id": image_id, "bbox": [xmin, ymin, xmax, ymax], "category_id": bbox_label}.

Inferência com o algoritmo de detecção de objetos do TensorFlow

Os modelos gerados podem ser hospedados para inferência e suporte a formatos de imagem .jpg, .jpeg e .png codificados como o application/x-image tipo de conteúdo. A imagem de entrada é redimensionada automaticamente. A saída contém as caixas, classes previstas e pontuações para cada previsão. O modelo de detecção de objetos do TensorFlow processa uma única imagem por solicitação e gera apenas uma linha no JSON. A seguir está um exemplo de resposta em JSON:

accept: application/json;verbose

{"normalized_boxes":[[xmin1, xmax1, ymin1, ymax1],....], "classes":[classidx1, class_idx2,...], "scores":[score_1, score_2,...], "labels": [label1, label2, ...], "tensorflow_model_output":}

If accept está definido para application/json, então o modelo gera apenas caixas, classes e pontuações previstas. Para obter mais detalhes sobre treinamento e inferência, consulte o caderno de exemplo Introdução ao SageMaker TensorFlow – Detecção de objetos.

Use os algoritmos integrados do SageMaker por meio da interface do JumpStart

Você também pode usar a detecção de objetos do SageMaker TensorFlow e qualquer um dos outros algoritmos integrados com apenas alguns cliques por meio da UI do JumpStart. JumpStart é um recurso do SageMaker que permite treinar e implantar algoritmos integrados e modelos pré-treinados de várias estruturas de ML e hubs de modelo por meio de uma interface gráfica. Ele também permite que você implante soluções de ML completas que unem modelos de ML e vários outros serviços da AWS para resolver um caso de uso direcionado.

A seguir estão dois vídeos que mostram como você pode replicar o mesmo processo de ajuste fino e implantação que acabamos de passar com alguns cliques por meio da interface do JumpStart.

Ajuste o modelo pré-treinado

Aqui está o processo para ajustar o mesmo modelo de detecção de objetos pré-treinados.

Implante o modelo ajustado

Após a conclusão do treinamento do modelo, você pode implantar diretamente o modelo em um endpoint persistente e em tempo real com um clique.

Conclusão

Nesta postagem, anunciamos o lançamento do algoritmo integrado de detecção de objetos SageMaker TensorFlow. Fornecemos um código de exemplo sobre como transferir a aprendizagem em um conjunto de dados personalizado usando um modelo pré-treinado do TensorFlow usando este algoritmo.

Para mais informações, confira documentação e os votos de caderno de exemplo.

Sobre os autores

Vivek Madan é um Cientista Aplicado com o Equipe do Amazon SageMaker JumpStart. Ele obteve seu doutorado pela Universidade de Illinois em Urbana-Champaign e foi pesquisador de pós-doutorado na Georgia Tech. Ele é um pesquisador ativo em aprendizado de máquina e design de algoritmos e publicou artigos em conferências EMNLP, ICLR, COLT, FOCS e SODA.

João moura é arquiteto de soluções especialista em IA/ML na Amazon Web Services. Ele se concentra principalmente em casos de uso de PNL e em ajudar os clientes a otimizar o treinamento e a implantação de modelos de aprendizado profundo. Ele também é um defensor ativo de soluções de ML de baixo código e hardware especializado em ML.

Dr. é um Cientista Aplicado Sênior com Algoritmos integrados do Amazon SageMaker e ajuda a desenvolver algoritmos de aprendizado de máquina. Ele obteve seu PhD da Universidade de Illinois Urbana Champaign. Ele é um pesquisador ativo em aprendizado de máquina e inferência estatística e publicou muitos artigos nas conferências NeurIPS, ICML, ICLR, JMLR, ACL e EMNLP.