Partilhar via

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

  • Artigo

APLICA-SE A:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

Neste tutorial, você aprenderá a treinar um modelo de deteção de objeto 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 deteção de objetos identifica se a imagem contém objetos, como uma lata, caixa, garrafa de leite ou garrafa de água.

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

Você escreve código usando o Python SDK neste tutorial e aprende as seguintes tarefas:

  • Baixar e transformar dados
  • Treinar um modelo automatizado de deteção de objetos de aprendizado de máquina
  • Especificar valores de hiperparâmetros para o seu modelo
  • Executar uma varredura de hiperparâmetros
  • Implementar o modelo
  • Visualizar deteções

Pré-requisitos

  • Para usar o Azure Machine Learning, você precisa de um espaço de trabalho. Se você não tiver um, conclua Criar recursos necessários para começar a criar um espaço de trabalho e saiba mais sobre como usá-lo.

  • Python 3.9 ou 3.10 são suportados para este recurso

  • Transfira e descomprima o *ficheiro de dados odFridgeObjects.zip. O conjunto de dados é anotado no formato Pascal VOC, onde cada imagem corresponde a um arquivo xml. Cada arquivo xml contém informações sobre onde seu 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 para o formato JSONL necessário, como 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: Azure CLI ml extension v2 (atual)

    Este tutorial também está disponível no repositório azureml-examples no GitHub. Se você deseja executá-lo em seu próprio ambiente local:

Configuração do destino de computação

Nota

Para tentar a computação sem servidor (visualização), ignore esta etapa e prossiga para a configuração do experimento.

Primeiro, você precisa configurar um destino de computação para usar em seu treinamento automatizado de modelo de ML. Modelos de ML automatizados 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 seu modelo.

O código a seguir cria um cálculo de GPU de tamanho Standard_NC24s_v3 com quatro nós.

APLICA-SE A: Azure CLI ml extension v2 (atual)

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

$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 espaço de trabalho, 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]

Configuração da experiência

Você pode usar um experimento para acompanhar seus trabalhos de treinamento modelo.

APLICA-SE A: Azure CLI ml extension v2 (atual)

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

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

Visualizar dados de entrada

Depois de preparar os dados da imagem de entrada no formato JSONL (JSON Lines), você pode visualizar as caixas delimitadoras da verdade do solo para uma imagem. Para fazer isso, certifique-se de ter matplotlib instalado.

%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, você pode executar 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)

Carregue dados e crie MLTable

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

  • Fácil de partilhar com outros membros da equipa
  • Controle de versão dos metadados (localização, descrição, etc.)
  • Rastreamento de linhagem

APLICA-SE A: Azure CLI ml extension v2 (atual)

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

$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 espaço de trabalho, 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]

O próximo passo é criar MLTable a partir de seus dados no formato jsonl, como mostrado abaixo. MLtable empacotar 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: Azure CLI ml extension v2 (atual)

A configuração a seguir cria dados de treinamento e validação do MLTable.

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

Configurar seu experimento de deteção de objetos

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

APLICA-SE A: Azure CLI ml extension v2 (atual)

Para usar computação sem servidor (visualização), substitua a linha compute: azureml:gpu-cluster por este código:

resources:
 instance_type: Standard_NC24s_v3
 instance_count: 4

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

Varredura automática de hiperparâmetros para tarefas de imagem (AutoMode)

Importante

Esta funcionalidade está atualmente em pré-visualização pública. Esta versão de pré-visualização é fornecida sem um contrato de nível de serviço. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas. Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.

Em seu trabalho AutoML, você pode executar uma varredura automática de hiperparâmetros para encontrar o modelo ideal (chamamos essa funcionalidade de AutoMode). Você especifica apenas o número de tentativas; O espaço de pesquisa de hiperparâmetros, 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 a ser varrido com base no número de tentativas. Um valor entre 10 e 20 provavelmente funcionará bem em muitos conjuntos de dados.

APLICA-SE A: Azure CLI ml extension 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: Azure CLI ml extension v2 (atual)

Para enviar seu trabalho AutoML, execute o seguinte comando da CLI v2 com o caminho para o arquivo .yml, o nome do espaço de trabalho, 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]

Varredura manual de hiperparâmetros para tarefas de imagem

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

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

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

Limites dos trabalhos

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

APLICA-SE A: Azure CLI ml extension 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âmetros para cada arquitetura yolov5 definida e fasterrcnn_resnet50_fpn. No espaço de pesquisa, especifique o intervalo de valores para learning_rate, optimizer, lr_scheduler, etc., para o AutoML escolher 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 selecionar amostras desse espaço de parâmetro usando o random sampling_algorithm. Os limites de trabalho configurados acima, diz ao ML automatizado para tentar um total de 10 testes com essas amostras diferentes, executando dois testes de cada vez em nosso destino de computação, que foi configurado usando quatro nós. Quanto mais parâmetros o espaço de pesquisa tiver, mais tentativas você precisará para encontrar os modelos ideais.

A política de rescisão antecipada do Bandit também é usada. Esta política encerra testes de baixo desempenho; ou seja, aqueles testes que não estão dentro de 20% de folga do teste de melhor desempenho, o que economiza significativamente recursos de computação.

APLICA-SE A: Azure CLI ml extension 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 estiverem definidos, você poderá enviar o trabalho para treinar um modelo de imagem usando seu conjunto de dados de treinamento.

APLICA-SE A: Azure CLI ml extension v2 (atual)

Para enviar seu trabalho AutoML, execute o seguinte comando da CLI v2 com o caminho para o arquivo .yml, o nome do espaço de trabalho, 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âmetros, pode ser útil visualizar as diferentes tentativas que foram testadas usando a interface do usuário do HyperDrive. Você pode navegar até essa interface do usuário indo para a guia 'Trabalhos filho' na interface do usuário do automl_image_job principal acima, que é o trabalho pai do HyperDrive. Então você pode ir para a guia 'Empregos infantis' deste.

Como alternativa, aqui abaixo você pode ver diretamente o trabalho pai do HyperDrive e navegar até a guia 'Trabalhos filho':

APLICA-SE A: Azure CLI ml extension v2 (atual)

CLI example not available, please use Python SDK.

Registrar e implantar modelo

Quando o trabalho for concluído, você poderá registrar o modelo que foi criado a partir 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 caminho com o azureml correspondente jobid.

Obtenha a melhor versão experimental

APLICA-SE A: Azure CLI ml extension v2 (atual)

CLI example not available, please use Python SDK.

Registar o modelo

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

APLICA-SE A: Azure CLI ml extension 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 endpoint online gerenciado deploy-managed-online-endpoint

Configurar ponto de extremidade online

APLICA-SE A: Azure CLI ml extension 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 criado anteriormente, agora criaremos o Endpoint no espaço de trabalho. Este comando inicia a criação do ponto de extremidade e retorna uma resposta de confirmação enquanto a criação do ponto de extremidade continua.

APLICA-SE A: Azure CLI ml extension 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 lote em grandes volumes de dados durante um período de tempo. Confira o bloco de anotações de pontuação em lote de deteção de objetos para inferência em lote usando o ponto de extremidade de lote.

Configurar a implementação online

Uma implantação é um conjunto de recursos necessários para hospedar o modelo que faz a inferência real. Criamos uma implantação para nosso endpoint usando a ManagedOnlineDeployment classe. Você pode usar SKUs de GPU ou CPU VM para seu cluster de implantação.

APLICA-SE A: Azure CLI ml extension 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 criado anteriormente, criaremos a implantação no espaço de trabalho. Este comando inicia a criação da implantação e retorna uma resposta de confirmação enquanto a criação da implantação continua.

APLICA-SE A: Azure CLI ml extension 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 tráfego:

Por padrão, a implantação atual é definida para receber 0% de tráfego. Você pode definir a porcentagem de tráfego que a implantação atual deve receber. A soma das porcentagens de tráfego de todas as implantações com um ponto final não deve exceder 100%.

APLICA-SE A: Azure CLI ml extension 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]

Testar a implementação

APLICA-SE A: Azure CLI ml extension v2 (atual)

CLI example not available, please use Python SDK.

Visualizar deteções

Agora que você marcou uma imagem de teste, você pode visualizar as caixas delimitadoras para essa imagem. Para fazer isso, certifique-se de ter matplotlib instalado.

APLICA-SE A: Azure CLI ml extension v2 (atual)

CLI example not available, please use Python SDK.

Clean up resources (Limpar recursos)

Não conclua esta seção se planeja executar outros tutoriais do Azure Machine Learning.

Se não planeia utilizar os recursos que criou, elimine-os para não incorrer em quaisquer encargos.

  1. No portal do Azure, selecione Grupos de recursos na extremidade esquerda.
  2. Na lista, selecione o grupo de recursos que criou.
  3. Selecione Eliminar grupo de recursos.
  4. Insira o nome do grupo de recursos. Em seguida, selecione Eliminar.

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

Próximos passos

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

  • Configurou um espaço de trabalho e preparou dados para um experimento.
  • Treinou um modelo automatizado de deteção de objetos
  • Valores de hiperparâmetros especificados para seu modelo
  • Realizada uma varredura de hiperparâmetros
  • Implantou seu modelo
  • Deteções visualizadas

Nota

O uso do conjunto de dados de objetos de geladeira está disponível através da licença sob a Licença MIT.