Execute a segmentação de imagens com o Amazon SageMaker JumpStart

Em dezembro de 2020, AWS anunciou a disponibilidade geral de JumpStart do Amazon SageMaker, uma capacidade de Amazon Sage Maker que ajuda você a começar de maneira rápida e fácil com o aprendizado de máquina (ML). O JumpStart fornece ajuste fino e implantação com um clique de uma ampla variedade de modelos pré-treinados em tarefas populares de ML, bem como uma seleção de soluções de ponta a ponta que resolvem problemas comuns de negócios. Esses recursos eliminam o trabalho pesado de cada etapa do processo de ML, facilitando o desenvolvimento de modelos de alta qualidade e reduzindo o tempo de implantação.

Esta postagem é a terceira de uma série sobre como usar o JumpStart para tarefas específicas de ML. No primeira postagem, mostramos como você pode executar casos de uso de classificação de imagens no JumpStart. No segundo post, mostramos como você pode executar casos de uso de classificação de texto no JumpStart. Nesta postagem, fornecemos um passo a passo sobre como ajustar e implantar um modelo de segmentação de imagens, usando modelos treinados da MXNet. Exploramos duas formas de obter o mesmo resultado: através da interface gráfica do JumpStart no Estúdio Amazon SageMaker, e programaticamente por meio de APIs JumpStart.

Se quiser ir direto para o código da API JumpStart que explicamos nesta postagem, você pode consultar os seguintes exemplos de notebooks Jupyter:

Visão geral do JumpStart

JumpStart ajuda você a começar a usar modelos de ML para uma variedade de tarefas sem escrever uma única linha de código. No momento em que este artigo foi escrito, o JumpStart permite que você faça o seguinte:

• Implante modelos pré-treinados para tarefas comuns de ML – O JumpStart permite que você resolva tarefas comuns de ML sem nenhum esforço de desenvolvimento, fornecendo fácil implantação de modelos pré-treinados em grandes conjuntos de dados disponíveis publicamente. A comunidade de pesquisa de ML se esforçou muito para disponibilizar publicamente para uso a maioria dos modelos recentemente desenvolvidos. JumpStart hospeda uma coleção de mais de 300 modelos, abrangendo as 15 tarefas de ML mais populares, como detecção de objetos, classificação de texto e geração de texto, facilitando seu uso para iniciantes. Esses modelos são extraídos de hubs de modelos populares, como TensorFlow, PyTorch, Hugging Face e MXNet.
• Ajustar modelos pré-treinados – O JumpStart permite ajustar modelos pré-treinados sem a necessidade de escrever seu próprio algoritmo de treinamento. No ML, a capacidade de transferir o conhecimento aprendido em um domínio para outro é chamada transferir aprendizado. Você pode usar a aprendizagem por transferência para produzir modelos precisos em conjuntos de dados menores, com custos de treinamento muito mais baixos do que aqueles envolvidos no treinamento do modelo original. JumpStart também inclui algoritmos de treinamento populares baseados em LightGBM, CatBoost, XGBoost e Scikit-learn, que você pode treinar do zero para regressão e classificação tabular.
• Use soluções pré-construídas – JumpStart fornece um conjunto de 17 soluções para casos de uso comuns de ML, como previsão de demanda e aplicações industriais e financeiras, que você pode implantar com apenas alguns cliques. As soluções são aplicativos de ML completos que reúnem vários serviços da AWS para resolver um caso de uso de negócios específico. Eles usam Formação da Nuvem AWS modelos e arquiteturas de referência para implantação rápida, o que significa que são totalmente personalizáveis.
• Consulte exemplos de notebook para algoritmos SageMaker – O SageMaker fornece um conjunto de algoritmos integrados para ajudar cientistas de dados e profissionais de ML a começar a treinar e implantar modelos de ML rapidamente. JumpStart fornece blocos de anotações de amostra que você pode usar para usar rapidamente esses algoritmos.
• Revise vídeos de treinamento e blogs – O JumpStart também fornece várias postagens de blog e vídeos que ensinam como usar diferentes funcionalidades do SageMaker.

O JumpStart aceita configurações personalizadas de VPC e Serviço de gerenciamento de chaves AWS (AWS KMS) para que você possa usar os modelos e soluções disponíveis com segurança em seu ambiente empresarial. Você pode passar suas configurações de segurança para o JumpStart no Studio ou por meio do SageMaker Python SDK.

Segmentação semântica

A segmentação semântica delineia cada classe de objetos que aparecem em uma imagem de entrada. Ele marca (classifica) cada pixel da imagem de entrada com um rótulo de classe de um conjunto predefinido de classes. Vários objetos da mesma classe são mapeados para a mesma máscara.

O modelo disponível para ajuste fino constrói uma “cabeça” de rede totalmente convolucional (FCN) no topo da rede base. A etapa de ajuste fino ajusta o FCNHead enquanto mantém os parâmetros do restante do modelo congelados e retorna o modelo ajustado. O objetivo é minimizar a perda de entropia cruzada softmax por pixel para treinar o FCN. O modelo retornado pelo ajuste fino pode ser posteriormente implantado para inferência.

O diretório de entrada deverá ser semelhante ao código a seguir se os dados de treinamento contiverem duas imagens. Os nomes dos arquivos .png podem ser qualquer coisa.

input_directory
    |--images
        |--abc.png
        |--def.png
    |--masks
        |--abc.png
        |--def.png
    class_label_to_prediction_index.json

Os arquivos de máscara devem conter informações de rótulo de classe para cada pixel.

Segmentação de instância

A segmentação de instância detecta e delineia cada objeto distinto de interesse que aparece em uma imagem. Ele marca cada pixel com um rótulo de instância. Enquanto a segmentação semântica atribui a mesma tag a pixels de vários objetos da mesma classe, a segmentação de instância rotula ainda mais os pixels correspondentes a cada ocorrência de um objeto na imagem com uma tag separada.

Atualmente, o JumpStart oferece modelos somente de inferência para segmentação de instâncias e não oferece suporte para ajuste fino.

As imagens a seguir ilustram a diferença entre a inferência na segmentação semântica e na segmentação de instâncias. A imagem original tem duas pessoas na imagem. A segmentação semântica trata várias pessoas na imagem como uma entidade: Person. No entanto, a segmentação de instâncias identifica pessoas individuais dentro do Person categoria.

Visão geral da solução

As seções a seguir fornecem uma demonstração passo a passo para realizar a segmentação semântica com JumpStart, tanto por meio da UI do Studio quanto por meio de APIs JumpStart.

Percorremos os seguintes passos:

1. Acesse o JumpStart pela interface do Studio:
   1. Execute a inferência no modelo pré-treinado.
   2. Ajuste o modelo pré-treinado.
2. Use o JumpStart programaticamente com o SageMaker Python SDK:
   1. Execute a inferência no modelo pré-treinado.
   2. Ajuste o modelo pré-treinado.

Também discutimos recursos avançados adicionais do JumpStart.

Acesse o JumpStart pela interface do Studio

Nesta seção, demonstramos como treinar e implantar modelos JumpStart por meio da UI do Studio.

Executar inferência no modelo pré-treinado

O vídeo a seguir mostra como encontrar um modelo de segmentação semântica pré-treinado no JumpStart e implantá-lo. A página do modelo contém informações valiosas sobre o modelo, como usá-lo, formato de dados esperado e alguns detalhes de ajuste fino. Você pode implantar qualquer um dos modelos pré-treinados disponíveis no JumpStart. Para inferência, escolhemos o tipo de instância ml.g4dn.xlarge. Ele fornece a aceleração de GPU necessária para baixa latência de inferência, mas a um preço mais baixo. Depois de configurar a instância de hospedagem do SageMaker, escolha Implantação. Pode levar de 5 a 10 minutos até que seu endpoint persistente esteja funcionando.

Após alguns minutos, seu endpoint estará operacional e pronto para responder às solicitações de inferência.

Da mesma forma, você pode implantar um modelo de segmentação de instância pré-treinado seguindo as mesmas etapas do vídeo anterior ao pesquisar segmentação de instância em vez de segmentação semântica na barra de pesquisa JumpStart.

Ajuste o modelo pré-treinado

O vídeo a seguir mostra como encontrar e ajustar um modelo de segmentação semântica no JumpStart. No vídeo, ajustamos o modelo usando o Conjunto de dados PennFudanPed, fornecido por padrão no JumpStart, que você pode baixar no Licença Apache 2.0.

O ajuste fino em seu próprio conjunto de dados envolve tomar a formatação correta dos dados (conforme explicado na página do modelo), carregá-los para Serviço de armazenamento simples da Amazon (Amazon S3) e especificando seu local na configuração da fonte de dados. Usamos os mesmos valores de hiperparâmetros definidos por padrão (número de épocas, taxa de aprendizado e tamanho do lote). Também usamos ml.p3.2xlarge apoiado por GPU como nossa instância de treinamento do SageMaker.

Você pode monitorar seu trabalho de treinamento em execução diretamente no console do Studio e ser notificado após sua conclusão. Após a conclusão do treinamento, você poderá implantar o modelo ajustado na mesma página que contém os detalhes do trabalho de treinamento. O fluxo de trabalho de implantação é igual à implantação de um modelo pré-treinado.

Use o JumpStart programaticamente com o SDK do SageMaker

Nas seções anteriores, mostramos como você pode usar a UI JumpStart para implantar um modelo pré-treinado e ajustá-lo interativamente, com apenas alguns cliques. No entanto, você também pode usar os modelos do JumpStart e fazer ajustes fáceis de forma programática usando APIs integradas ao SDK do SageMaker. Agora veremos um exemplo rápido de como você pode replicar o processo anterior. Todas as etapas desta demonstração estão disponíveis nos cadernos que acompanham Introdução ao JumpStart – Segmentação de instâncias e Introdução ao JumpStart – Segmentação semântica.

Executar inferência no modelo pré-treinado

Nesta seção, escolhemos um modelo pré-treinado apropriado no JumpStart, implantamos esse modelo em um endpoint SageMaker e executamos inferência no endpoint implantado.

SageMaker é uma plataforma baseada em containers Docker. O JumpStart usa o framework específico disponível Contêineres de aprendizado profundo do SageMaker (DLC). Buscamos quaisquer pacotes adicionais, bem como scripts para lidar com treinamento e inferência para a tarefa selecionada. Finalmente, os artefatos de modelo pré-treinados são buscados separadamente com model_uris, que oferece flexibilidade à plataforma. Você pode usar qualquer número de modelos pré-treinados para a mesma tarefa com um único script de treinamento ou inferência. Veja o seguinte código:

model_id, model_version = "mxnet-semseg-fcn-resnet50-ade", "*"

# Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve(
    region=None,
    framework=None,  # automatically inferred from model_id
    image_scope="inference",
    model_id=model_id,
    model_version=model_version,
    instance_type=inference_instance_type,
)

# Retrieve the inference script uri
deploy_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="inference")

base_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="inference")

Para segmentação de instância, podemos definir model_id para mxnet-semseg-fcn-resnet50-ade. O está no identificador corresponde à segmentação da instância.

Em seguida, alimentamos os recursos em um Modelo do SageMaker instância e implante um endpoint:

# Create the SageMaker model instance
model = Model(
    image_uri=deploy_image_uri,
    source_dir=deploy_source_uri,
    model_data=base_model_uri,
    entry_point="inference.py",  # entry point file in source_dir and present in deploy_source_uri
    role=aws_role,
    predictor_cls=Predictor,
    name=endpoint_name,
)

# deploy the Model. Note that we need to pass Predictor class when we deploy model through Model class,
# for being able to run inference through the sagemaker API.
base_model_predictor = model.deploy(
    initial_instance_count=1,
    instance_type=inference_instance_type,
    predictor_cls=Predictor,
    endpoint_name=endpoint_name,
)

Após alguns minutos, nosso modelo é implantado e podemos obter previsões em tempo real!

O trecho de código a seguir dá uma ideia de como é a segmentação semântica. A máscara prevista para cada pixel é visualizada. Para obter inferências de um modelo implantado, uma imagem de entrada precisa ser fornecida em formato binário. A resposta do ponto final é um rótulo previsto para cada pixel da imagem. Nós usamos o query_endpoint e parse_response funções auxiliares, que são definidas no arquivo caderno de acompanhamento:

query_response = query(base_model_predictor, pedestrian_img)
predictions, labels, image_labels = parse_response(query_response)
print("Objects present in the picture:", image_labels)

Ajuste o modelo pré-treinado

Para ajustar um modelo selecionado, precisamos obter o URI desse modelo, bem como o script de treinamento e a imagem do contêiner usada para treinamento. Felizmente, essas três entradas dependem apenas do nome do modelo, versão (para obter uma lista dos modelos disponíveis, consulte Tabela de modelos disponíveis do JumpStart)e o tipo de instância na qual você deseja treinar. Isso é demonstrado no seguinte trecho de código:

from sagemaker import image_uris, model_uris, script_uris

model_id, model_version = "mxnet-semseg-fcn-resnet50-ade", "*"
training_instance_type = "ml.p3.2xlarge"
train_image_uri = image_uris.retrieve(
    region=None,
    framework=None,
    model_id=model_id,
    model_version=model_version,
    image_scope="training",
    instance_type=training_instance_type,)# 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 to further fine-tune

train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

Nós recuperamos o model_id correspondendo ao mesmo modelo que usamos anteriormente. Agora você pode ajustar este modelo JumpStart em seu próprio conjunto de dados personalizado usando o SageMaker SDK. Usamos um conjunto de dados hospedado publicamente no Amazon S3, convenientemente focado na segmentação semântica. O conjunto de dados deve ser estruturado para ajuste fino conforme explicado na seção anterior. Veja o seguinte código de exemplo:

# URI of your training dataset
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/PennFudanPed_SemSeg/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"
training_job_name = name_from_base(f"jumpstart-example-{model_id}-transfer-learning")# Create SageMaker Estimator instance
semseg_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,)# Launch a SageMaker Training job by passing s3 path of the training data
semseg_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Obtemos os mesmos hiperparâmetros padrão para nosso modelo selecionado que vimos na seção anterior, usando sagemaker.hyperparameters.retrieve_default(). Em seguida, instanciamos um estimador SageMaker e chamamos o .fit para começar a ajustar nosso modelo, passando-lhe o URI do Amazon S3 para nossos dados de treinamento. O entry_point O script fornecido é denominado transfer_learning.py (o mesmo para outras tarefas e modelos), e o canal de dados de entrada passado para .fit deve ser nomeado training.

Enquanto o algoritmo treina, você pode monitorar seu progresso no notebook SageMaker onde você está executando o próprio código ou no Amazon CloudWatch. Quando o treinamento for concluído, os artefatos do modelo ajustados serão carregados no local de saída do Amazon S3 especificado na configuração do treinamento. Agora você pode implantar o modelo da mesma maneira que o modelo pré-treinado.

Características avançadas

Além de ajustar e implantar modelos pré-treinados, o JumpStart oferece muitos recursos avançados.

O primeiro é ajuste automático do modelo. Isso permite que você ajuste automaticamente seus modelos de ML para encontrar os valores de hiperparâmetros com a maior precisão dentro do intervalo fornecido pela API SageMaker.

A segunda é treinamento incremental. Isso permite treinar um modelo que você já ajustou usando um conjunto de dados expandido que contém um padrão subjacente não considerado em execuções de ajuste fino anteriores, o que resultou em um desempenho insatisfatório do modelo. O treinamento incremental economiza tempo e recursos porque você não precisa treinar novamente o modelo do zero.

Conclusão

Nesta postagem, mostramos como ajustar e implantar um modelo de segmentação semântica pré-treinado e como adaptá-lo para segmentação de instâncias usando JumpStart. Você pode fazer isso sem precisar escrever código. Experimente a solução você mesmo e envie-nos seus comentários.

Para saber mais sobre o JumpStart e como você pode usar modelos pré-treinados de código aberto para uma variedade de outras tarefas de ML, confira o seguinte Vídeo AWS re:Invent 2020.

Sobre os autores

Vivek Madan é um cientista aplicado da equipe Amazon SageMaker JumpStart. Ele obteve seu doutorado na 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.

Santosh Kulkarni é um arquiteto de soluções corporativas da Amazon Web Services que trabalha com clientes de esportes na Austrália. Ele é apaixonado por criar aplicativos distribuídos em larga escala para resolver problemas de negócios usando seu conhecimento em IA/ML, big data e desenvolvimento de software.

Leonardo Bachega é cientista sênior e gerente da equipe Amazon SageMaker JumpStart. Ele é apaixonado por construir serviços de IA para visão computacional.