Tutorial: Treinar um modelo de detecção de objetos com o AutoML e o Python

  • Artigo

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)SDK do Python azure-ai-ml v2 (atual)

Neste tutorial, você aprenderá a treinar um modelo de detecção de objetos usando o ML automatizado do Azure Machine Learning com a extensão da CLI do Azure Machine Learning v2 ou o SDK do Python do Azure Machine Learning v2. Este modelo de detecção de objetos identifica se a imagem contém objetos, como uma lata, uma caixa de papelão, uma garrafa de leite ou uma garrafa de água.

O ML automatizado aceita dados de treinamento e configurações e itera automaticamente por meio de combinações de diferentes métodos de normalização/padronização de características, modelos e configurações de hiperparâmetro, para chegar ao melhor modelo.

Neste tutorial, você escreverá um código usando o SDK do Python e aprenderá as seguintes tarefas:

  • Baixar e transformar dados
  • Treinar um modelo de detecção de objetos com machine learning automatizado
  • Especificar valores de hiperparâmetro para seu modelo
  • Executar uma varredura de hiperparâmetro
  • Implantar o seu modelo
  • Visualizar as detecções

Pré-requisitos

  • Para usar o Azure Machine Learning, primeiro você precisará de um workspace. Se você não tiver um, conclua Criar recursos necessários para começar para criar um workspace e saber mais sobre como usá-lo.

  • O Python 3.6 ou 3.7 é compatível com esse recurso

  • Baixe e descompacte o arquivo de dados *odFridgeObjects.zip. O conjunto de dados é anotado no formato Pascal VOC, em que cada imagem corresponde a um arquivo xml. Cada arquivo xml contém informações sobre onde o arquivo de imagem correspondente está localizado e também contém informações sobre as caixas delimitadoras e os rótulos de objeto. Para usar esses dados, primeiro você precisa convertê-los no formato JSONL necessário, conforme visto na seção Converter os dados baixados em JSONL do notebook.

  • Use uma instância de computação para seguir este tutorial sem instalação adicional. (Veja como criar uma instância de computação.) Ou instale a CLI/SDK para usar seu próprio ambiente local.

    APLICA-SE A:Extensão do ML da CLI do Azure v2 (atual)

    Este tutorial também está disponível no repositório azureml-examples no GitHub. Se desejar, é possível executar no seu próprio ambiente local.

Configuração do destino de computação

Observação

Para experimentar a computação sem servidor (versão prévia), ignore esta etapa e prossiga para Configuração do experimento.

Primeiro, você precisa configurar um destino de computação para usar para o treinamento do modelo de ML automatizado. Modelos de ML automatizado para tarefas de imagem exigem SKUs de GPU.

Este tutorial usa a série NCsv3 (com GPUs V100), pois esse tipo de destino de computação usa várias GPUs para acelerar o treinamento. Além disso, você pode configurar vários nós para aproveitar o paralelismo ao ajustar hiperparâmetros para o seu modelo.

O código a seguir cria uma computação de GPU de tamanho Standard_NC24s_v3 com quatro nós.

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

Crie um arquivo .yml com a configuração a seguir.

$schema: https://azuremlschemas.azureedge.net/latest/amlCompute.schema.json 
name: gpu-cluster
type: amlcompute
size: Standard_NC24s_v3
min_instances: 0
max_instances: 4
idle_time_before_scale_down: 120

Para criar a computação, execute o seguinte comando da CLI v2 com o caminho para o arquivo .yml, o nome do workspace, o grupo de recursos e a ID da assinatura.

az ml compute create -f [PATH_TO_YML_FILE] --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]

Instalação do experimento

Você pode usar um Experimento para acompanhar os trabalhos de treinamento de seu modelo.

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

O nome do experimento pode ser fornecido usando a chave experiment_name da seguinte maneira:

experiment_name: dpv2-cli-automl-image-object-detection-experiment

Visualizar dados de entrada

Depois que os dados de imagem de entrada estiverem preparados no formato JSONL (Linhas JSON), você poderá visualizar as caixas delimitadoras de verdade de uma imagem. Para isso, confirme se você tem a matplotlib instalada.

%pip install --upgrade matplotlib


%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import matplotlib.patches as patches
from PIL import Image as pil_image
import numpy as np
import json
import os

def plot_ground_truth_boxes(image_file, ground_truth_boxes):
    # Display the image
    plt.figure()
    img_np = mpimg.imread(image_file)
    img = pil_image.fromarray(img_np.astype("uint8"), "RGB")
    img_w, img_h = img.size

    fig,ax = plt.subplots(figsize=(12, 16))
    ax.imshow(img_np)
    ax.axis("off")

    label_to_color_mapping = {}

    for gt in ground_truth_boxes:
        label = gt["label"]

        xmin, ymin, xmax, ymax =  gt["topX"], gt["topY"], gt["bottomX"], gt["bottomY"]
        topleft_x, topleft_y = img_w * xmin, img_h * ymin
        width, height = img_w * (xmax - xmin), img_h * (ymax - ymin)

        if label in label_to_color_mapping:
            color = label_to_color_mapping[label]
        else:
            # Generate a random color. If you want to use a specific color, you can use something like "red".
            color = np.random.rand(3)
            label_to_color_mapping[label] = color

        # Display bounding box
        rect = patches.Rectangle((topleft_x, topleft_y), width, height,
                                 linewidth=2, edgecolor=color, facecolor="none")
        ax.add_patch(rect)

        # Display label
        ax.text(topleft_x, topleft_y - 10, label, color=color, fontsize=20)

    plt.show()

def plot_ground_truth_boxes_jsonl(image_file, jsonl_file):
    image_base_name = os.path.basename(image_file)
    ground_truth_data_found = False
    with open(jsonl_file) as fp:
        for line in fp.readlines():
            line_json = json.loads(line)
            filename = line_json["image_url"]
            if image_base_name in filename:
                ground_truth_data_found = True
                plot_ground_truth_boxes(image_file, line_json["label"])
                break
    if not ground_truth_data_found:
        print("Unable to find ground truth information for image: {}".format(image_file))

Usando as funções auxiliares acima, para qualquer imagem específica, execute o código a seguir para exibir as caixas delimitadoras.

image_file = "./odFridgeObjects/images/31.jpg"
jsonl_file = "./odFridgeObjects/train_annotations.jsonl"

plot_ground_truth_boxes_jsonl(image_file, jsonl_file)

Carregar dados e criar MLTable

Para usar os dados para treinamento, carregue os dados no Armazenamento de Blobs padrão do workspace do Azure Machine Learning e registre-os como um ativo. Os benefícios do registro dos dados são:

  • Fácil de compartilhar com outros membros da equipe
  • Controle de versão dos metadados (local, descrição etc.)
  • Acompanhamento de linhagem

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

Crie um arquivo .yml com a configuração a seguir.

$schema: https://azuremlschemas.azureedge.net/latest/data.schema.json
name: fridge-items-images-object-detection
description: Fridge-items images Object detection
path: ./data/odFridgeObjects
type: uri_folder

Para carregar as imagens como um ativo de dados, execute o seguinte comando da CLI v2 com o caminho para o arquivo .yml, o nome do workspace, o grupo de recursos e a ID da assinatura.

az ml data create -f [PATH_TO_YML_FILE] --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]

A próxima etapa é criar MLTable com base em seus dados no formato JSONL, conforme mostrado abaixo. O MLtable empacota seus dados em um objeto consumível para treinamento.

paths:
  - file: ./train_annotations.jsonl
transformations:
  - read_json_lines:
        encoding: utf8
        invalid_lines: error
        include_path_column: false
  - convert_column_types:
      - columns: image_url
        column_type: stream_info

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

A configuração a seguir cria dados de treinamento e validação com base na MLTable.

target_column_name: label
training_data:
  path: data/training-mltable-folder
  type: mltable
validation_data:
  path: data/validation-mltable-folder
  type: mltable

Configurar o experimento de detecção de objetos

Para configurar trabalhos de ML automatizado para tarefas relacionadas à imagem, crie um trabalho do AutoML específico da tarefa.

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

Para usar a computação sem servidor (versão prévia), substitua a linha compute: azureml:gpu-cluster por neste código:

resources:
 instance_type: Standard_NC24s_v3
 instance_count: 4

task: image_object_detection
primary_metric: mean_average_precision
compute: azureml:gpu-cluster

Limpeza automática de hiperparâmetro para tarefas de imagem (AutoMode)

Importante

Esse recurso está atualmente em visualização pública. Essa versão prévia é fornecida sem um contrato de nível de serviço. Alguns recursos podem não ter suporte ou podem ter restrição de recursos. Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

Em seu trabalho de AutoML, você pode executar uma varredura automática de hiperparâmetro para encontrar o modelo ideal (chamamos essa funcionalidade de AutoMode). Você só especifica o número de avaliações. O espaço de pesquisa de hiperparâmetro, o método de amostragem e a política de encerramento antecipado não são necessários. O sistema determinará automaticamente a região do espaço de hiperparâmetro para varredura com base no número de avaliações. Um valor entre 10 e 20 provavelmente funcionará bem em muitos conjuntos de dados.

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

limits:
  max_trials: 10
  max_concurrent_trials: 2

Em seguida, você pode enviar o trabalho para treinar um modelo de imagem.

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

Para enviar seu trabalho do AutoML, execute o seguinte comando da CLI v2 com o caminho para o arquivo .yml, o nome do workspace, o grupo de recursos e a ID da assinatura.

az ml job create --file ./hello-automl-job-basic.yml --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]

Limpeza manual de hiperparâmetro para tarefas de imagem

No trabalho do AutoML, você pode especificar as arquiteturas do modelo usando o parâmetro model_name e definir as configurações para executar uma varredura de hiperparâmetro em um espaço de pesquisa definido para localizar o modelo ideal.

Neste exemplo, vamos treinar um modelo de detecção de objetos com yolov5 e fasterrcnn_resnet50_fpn, ambos pré-treinados no COCO, um conjunto de dados de detecção de objetos, segmentação e legendagem em grande escala que contém milhares de imagens rotuladas com mais de 80 categorias de rótulo.

Você pode executar uma varredura de hiperparâmetro em um espaço de pesquisa definido para localizar o modelo ideal.

Limites de trabalho

Você pode controlar os recursos gastos em seu trabalho de treinamento de imagem de machine learning automatizado especificando timeout_minutes, max_trials e max_concurrent_trials para o trabalho nas configurações de limite. Consulte a descrição detalhada dos parâmetros de Limites de Trabalho.

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

limits:
  timeout_minutes: 60
  max_trials: 10
  max_concurrent_trials: 2

O código a seguir define o espaço de pesquisa em preparação para a varredura de hiperparâmetro para cada arquitetura definida, yolov5 e fasterrcnn_resnet50_fpn. No espaço de pesquisa, especifique o intervalo de valores para learning_rate, optimizer, lr_scheduler etc. para que AutoML escolha enquanto tenta gerar um modelo com a métrica primária ideal. Se os valores de hiperparâmetro não forem especificados, os valores padrão serão usados para cada arquitetura.

Para as configurações de ajuste, use amostragem aleatória para escolher amostras desse espaço de parâmetro usando o sampling_algorithm random. Os limites de trabalho configurados acima informarão ao ML automatizado para experimentar um total de 10 avaliações com essas diferentes amostras, executando duas avaliações de cada vez no destino de computação, que foi configurado usando quatro nós. Quanto mais parâmetros o espaço de pesquisa tiver, mais avaliações você precisará para encontrar os modelos ideais.

A política de encerramento antecipado Bandit também é usada. Essa política encerra as avaliações com baixo desempenho, ou seja, avaliações que não estão dentro da margem de atraso de 20% da avaliação com o melhor desempenho, o que poupa consideravelmente os recursos de computação.

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

sweep:
  sampling_algorithm: random
  early_termination:
    type: bandit
    evaluation_interval: 2
    slack_factor: 0.2
    delay_evaluation: 6

search_space:
  - model_name:
      type: choice
      values: [yolov5]
    learning_rate:
      type: uniform
      min_value: 0.0001
      max_value: 0.01
    model_size:
      type: choice
      values: [small, medium]

  - model_name:
      type: choice
      values: [fasterrcnn_resnet50_fpn]
    learning_rate:
      type: uniform
      min_value: 0.0001
      max_value: 0.001
    optimizer:
      type: choice
      values: [sgd, adam, adamw]
    min_size:
      type: choice
      values: [600, 800]

Depois que o espaço de pesquisa e as configurações de varredura forem definidas, você poderá enviar o trabalho para treinar um modelo de imagem usando o conjunto de dados de treinamento.

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

Para enviar seu trabalho do AutoML, execute o seguinte comando da CLI v2 com o caminho para o arquivo .yml, o nome do workspace, o grupo de recursos e a ID da assinatura.

az ml job create --file ./hello-automl-job-basic.yml --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]

Ao fazer uma varredura de hiperparâmetro, pode ser útil visualizar as diferentes avaliações que foram experimentadas usando a interface do usuário do HyperDrive. Navegue até essa interface do usuário acessando a guia "Trabalhos filho" na interface do usuário do automl_image_job principal acima, que é o trabalho pai do HyperDrive. Em seguida, você pode acessar a guia "Trabalhos filho" dessa execução.

Como alternativa, veja abaixo diretamente o trabalho pai do HyperDrive e navegue até a respectiva guia "Trabalhos filho":

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

CLI example not available, please use Python SDK.

Registro e implantação do modelo

Quando o trabalho for concluído, você poderá registrar o modelo que foi criado da melhor avaliação (configuração que resultou na melhor métrica primária). Você pode registrar o modelo após o download ou especificando o caminhoazureml correspondente jobid.

Obter a melhor avaliação

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

CLI example not available, please use Python SDK.

Registre o modelo

Registre o modelo usando o caminho azureml ou o caminho baixado localmente.

APLICA-SE A:Extensão do ML da CLI do Azure v2 (atual)

 az ml model create --name od-fridge-items-mlflow-model --version 1 --path azureml://jobs/$best_run/outputs/artifacts/outputs/mlflow-model/ --type mlflow_model --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]

Depois de registrar o modelo que deseja usar, você pode implantá-lo usando o ponto de extremidade online gerenciado deploy-managed-online-endpoint

Configurar o ponto de extremidade online

APLICA-SE A:Extensão do ML da CLI do Azure v2 (atual)

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: od-fridge-items-endpoint
auth_mode: key

Criar o ponto de extremidade

Usando o MLClient que já foi criado, vamos criar o ponto de extremidade no workspace. Esse comando iniciará a criação do ponto de extremidade e retornará uma resposta de confirmação enquanto a criação do ponto de extremidade continuar.

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

az ml online-endpoint create --file .\create_endpoint.yml --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]

Também podemos criar um ponto de extremidade em lote para inferência em lotes em grandes volumes de dados durante um período de tempo. Confira o notebook de pontuação de lote de detecção de objeto para inferência de lote usando o terminal de lote.

Configurar a implantação online

Uma implantação é um conjunto de recursos necessários para hospedar o modelo que executa a inferência real. Criaremos uma implantação do ponto de extremidade usando a classe ManagedOnlineDeployment. Você pode usar SKUs de VM com GPU ou CPU como cluster de implantação.

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

name: od-fridge-items-mlflow-deploy
endpoint_name: od-fridge-items-endpoint
model: azureml:od-fridge-items-mlflow-model@latest
instance_type: Standard_DS3_v2
instance_count: 1
liveness_probe:
    failure_threshold: 30
    success_threshold: 1
    timeout: 2
    period: 10
    initial_delay: 2000
readiness_probe:
    failure_threshold: 10
    success_threshold: 1
    timeout: 10
    period: 10
    initial_delay: 2000

Criar a implantação

Usando o MLClient que já foi criado, vamos criar a implantação no workspace. Esse comando iniciará a criação da implantação e retornará uma resposta de confirmação enquanto a criação da implantação continuar.

APLICA-SE A:Extensão do ML da CLI do Azure v2 (atual)

az ml online-deployment create --file .\create_deployment.yml --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]

Atualizar o tráfego:

Por padrão, a implantação atual está definida para receber 0% de tráfego. você pode definir o percentual de tráfego que a implantação atual deve receber. A soma dos percentuais de tráfego de todas as implantações com um ponto de extremidade não deve exceder 100%.

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

az ml online-endpoint update --name 'od-fridge-items-endpoint' --traffic 'od-fridge-items-mlflow-deploy=100' --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]

Teste a implantação

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

CLI example not available, please use Python SDK.

Visualizar as detecções

Agora que você fez a pontuação de imagem de teste, visualize as caixas delimitadoras desta imagem. Para fazer isso, confirme se você tem a matplotlib instalada.

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)

CLI example not available, please use Python SDK.

Limpar os recursos

Não conclua esta seção caso você pretenda executar outros tutoriais do Azure Machine Learning.

Se você não pretende usar os recursos criados, exclua-os para não gerar encargos.

  1. No portal do Azure, selecione Grupos de recursos no canto esquerdo.
  2. Selecione o grupo de recursos criado na lista.
  3. Selecione Excluir grupo de recursos.
  4. Insira o nome do grupo de recursos. Em seguida, selecione Excluir.

Você também pode manter o grupo de recursos, mas excluir um único workspace. Exiba as propriedades do workspace e, em seguida, selecione Excluir.

Próximas etapas

Neste tutorial de aprendizado de máquina automatizado, você executou as seguintes tarefas:

  • Configurou um workspace e preparou os dados para um experimento.
  • Treinou um modelo automatizado de detecção de objetos
  • Especificou valores de hiperparâmetro para seu modelo
  • Realizou uma varredura de hiperparâmetro
  • Implantou seu modelo
  • Visualizou detecções

Observação

O uso do conjunto de dados de objetos de geladeira está disponível por licença nos termos da licença MIT.