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

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)Python SDK azure-ai-ml v2 (corrente)

Neste tutorial, aprende-se a treinar um modelo de deteção de objetos utilizando o ML automatizado Azure Machine Learning com a extensão CLI de aprendizagem da máquina Azure v2 ou a Azure Machine Learning Python SDK v2. Este modelo de deteção de objetos identifica se a imagem contém objetos, tais como uma lata, caixa, garrafa de leite ou garrafa de água.

A ML automatizada aceita definições de dados de formação e configurações, e itera automaticamente através de combinações de diferentes métodos de normalização/normalização de funcionalidades, modelos e configurações de hiperparímetro para chegar ao melhor modelo.

Você vai escrever código usando o Python SDK neste tutorial e aprender as seguintes tarefas:

  • Descarregar e transformar dados
  • Treine um modelo automatizado de deteção de objetos de aprendizagem automática
  • Especifique valores de hiperparmetro para o seu modelo
  • Realizar uma varredura de hiperparmetro
  • Implemente o seu modelo
  • Visualizar deteções

Pré-requisitos

  • Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar. Experimente hoje a versão gratuita ou paga do Azure Machine Learning.

  • Python 3.6 ou 3.7 são suportados para esta característica

  • Complete o Quickstart: Começa com o Azure Machine Learning se ainda não tiveres um espaço de trabalho para aprendizagem automática Azure.

  • Faça o download e desaperte o * ficheiro de dadosodFridgeObjects.zip. O conjunto de dados é anotado no formato Pascal VOC, onde cada imagem corresponde a um ficheiro xml. Cada ficheiro xml contém informações sobre onde está localizado o seu ficheiro de imagem correspondente e também contém informações sobre as caixas de delimitação e as etiquetas do objeto. Para utilizar estes dados, primeiro tem de os converter no formato JSONL necessário, tal como visto na secção Converte os dados descarregados para a secção JSONL do caderno.

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

Este tutorial também está disponível no repositório de exemplos azureml no GitHub. Se desejar executá-lo no seu próprio ambiente local, coloque a configuração utilizando as seguintes instruções

Configuração do alvo do cálculo

Primeiro, você precisa configurar um alvo de computação para usar para o seu treino automatizado de modelo ml. Os modelos ML automatizados para tarefas de imagem requerem SKUs GPU.

Este tutorial usa a série NCsv3 (com GPUs V100) como este tipo de alvo de computação aproveita vários GPUs para acelerar o treino. Além disso, pode configurar múltiplos nós para aproveitar o paralelismo ao sintonizar hiperparmetros para o seu modelo.

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

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

Crie um ficheiro .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 o cálculo, executou o seguinte comando CLI v2 com o caminho para o seu ficheiro .yml, nome do espaço de trabalho, grupo de recursos e ID de subscrição.

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

O cálculo criado pode ser fornecido utilizando compute a chave na configuração de automl tarefa yaml:

compute: azureml:gpu-cluster

Configuração de experiências

Pode usar uma Experiência para acompanhar as suas pistas de treino de modelos.

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

O nome da experiência pode ser fornecido com a experiment_name chave da seguinte forma:

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

Visualizar dados de entrada

Uma vez preparados os dados de imagem de entrada no formato JSONL (Linhas JSON), pode visualizar as caixas de delimitação da verdade terrestre para uma imagem. Para tal, certifique-se de que já matplotlib instalou.

%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))

Utilizando as funções de ajudante acima, para qualquer imagem, pode executar o seguinte código para exibir as caixas de delimitação.

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

plot_ground_truth_boxes_jsonl(image_file, jsonl_file)

Faça upload de dados e crie MLTable

Para utilizar os dados para a formação, faça o upload dos dados para o Armazenamento Blob predefinido do seu Espaço de Trabalho Azure ML e registe-os como um ativo. Os benefícios do registo de dados são:

  • Fácil de partilhar com outros membros da equipa
  • Versão dos metadados (localização, descrição, etc)
  • Rastreio de linhagem

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

Crie um ficheiro .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 fazer o upload das imagens como um ativo de dados, executou o seguinte comando CLI v2 com o caminho para o seu ficheiro .yml, nome do espaço de trabalho, grupo de recursos e ID de subscrição.

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 dos seus dados em formato jsonl, como mostrado abaixo. Pacote mLtable os seus dados num objeto consumível para treino.

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 Azure CLI ml v2 (corrente)

A seguinte configuração cria dados de formação 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

Configure a sua experiência de deteção de objetos

Para configurar as tarefas automatizadas de ML para tarefas relacionadas com a imagem, crie um trabalho autoML específico para tarefas.

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

task: image_object_detection
primary_metric: mean_average_precision

No seu trabalho AutoML, pode especificar os algoritmos do modelo usando model_name parâmetros e configurar as definições para realizar uma varredura de hiperparímetro sobre um espaço de pesquisa definido para encontrar o modelo ideal.

Neste exemplo, vamos formar 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 larga escala que contém mais de milhares de imagens etiquetadas com mais de 80 categorias de etiquetas.

Limites de emprego

Pode controlar os recursos gastos no seu trabalho de formação autoML Image especificando o timeout_minutes, max_trials e o max_concurrent_trials para o trabalho em definições de limite. PLease refere-se à descrição detalhada dos parâmetros de Limites de Trabalho.

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

limits:
  timeout_minutes: 60
  max_trials: 10
  max_concurrent_trials: 2

Hiperparametro varrendo para tarefas de imagem

Pode executar uma varredura de hiperparímetro sobre um espaço de pesquisa definido para encontrar o modelo ideal.

O seguinte código, define o espaço de pesquisa em preparação para a varredura do hiperparímetro para cada algoritmo definido, yolov5 e fasterrcnn_resnet50_fpn. No espaço de pesquisa, especifique a gama de valores paralearning_rate, optimizerlr_scheduleretc., para que o AutoML escolha à medida que tenta gerar um modelo com a métrica primária ideal. Se os valores do hiperparmetro não forem especificados, então os valores predefinidos são usados para cada algoritmo.

Para as definições de afinação, utilize amostras aleatórias para recolher amostras deste espaço de parâmetros utilizando o random sampling_algorithm. Os limites de trabalho configurados acima, diz à ML automatizada para experimentar um total de 10 ensaios com estas amostras diferentes, executando dois ensaios de cada vez no nosso alvo de computação, que foi criado usando quatro nós. Quanto mais parâmetros o espaço de pesquisa tiver, mais testes precisa para encontrar modelos ideais.

A política de rescisão antecipada do bandido também é utilizada. Esta política encerra configurações de mau desempenho; ou seja, aquelas configurações que não estão dentro de 20% da redução da configuração de melhor desempenho, o que poupa significativamente recursos computacional.

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

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]

Uma vez definidas as definições do espaço de pesquisa e varredura, pode submeter a tarefa para treinar um modelo de imagem utilizando o seu conjunto de dados de treino.

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

Para submeter o seu trabalho Deml, executou o seguinte comando CLI v2 com o caminho para o seu ficheiro .yml, nome do espaço de trabalho, grupo de recursos e ID de subscrição.

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 configurações que foram experimentantes usando o HyperDrive UI. Você pode navegar para este UI indo para o separador 'Child runs' no UI do automl_image_run principal de cima, que é a corrida dos pais do HyperDrive. Depois podes ir ao separador "Criança corre" desta.

Alternativamente, aqui abaixo pode ver diretamente a corrida dos pais do HyperDrive e navegar para o separador 'Child runs':

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

CLI example not available, please use Python SDK.

Registar e implementar modelo

Uma vez concluída a execução, pode registar o modelo que foi criado a partir da melhor execução (configuração que resultou na melhor métrica primária). Pode registar o modelo após o download ou especificar o caminho azureml com o jobid correspondente.

Obter a melhor corrida

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

CLI example not available, please use Python SDK.

Registar o modelo

Registe o modelo utilizando o caminho azureml ou o seu caminho descarregado localmente.

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

 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 registar o modelo que pretende utilizar, pode implantá-lo utilizando o ponto final gerido online gerido online

Configure ponto final on-line

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

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

Criar o ponto final

Usando o MLClient criado mais cedo, vamos agora criar o Ponto Final no espaço de trabalho. Este comando iniciará a criação do ponto final e devolverá uma resposta de confirmação enquanto a criação do ponto final continuar.

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

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 final de lote para inferição de lotes em grandes volumes de dados durante um período de tempo. Verifique o caderno de pontuação do lote de deteção de objetos para inferenificação do lote utilizando o ponto final do lote.

Configurar a implementação online

Uma implantação é um conjunto de recursos necessários para hospedar o modelo que faz a inferencing real. Vamos criar uma implantação para o nosso ponto final usando a ManagedOnlineDeployment classe. Pode utilizar SKUs GPU ou CPU VM para o seu cluster de implantação.

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

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 mais cedo, vamos agora criar a implantação no espaço de trabalho. Este comando iniciará a criação de implantação e devolverá uma resposta de confirmação enquanto a criação de implantação continua.

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

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 predefinição, a implementação atual está definida para receber 0% de tráfego. pode definir a percentagem de tráfego que a corrente de utilização deve receber. A soma das percentagens de tráfego de todas as implantações com um ponto final não deve exceder 100%.

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

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:Extensão Azure CLI ml v2 (corrente)

CLI example not available, please use Python SDK.

Visualizar deteções

Agora que marcou uma imagem de teste, pode visualizar as caixas de delimitação para esta imagem. Para tal, certifique-se de que tem matplotlib instalado.

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

CLI example not available, please use Python SDK.

Limpar os recursos

Não preencha esta secção se planeia executar outros tutoriais de Aprendizagem automática Azure.

Se não planeia usar 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. Introduza o nome do grupo de recursos. Em seguida, selecione Eliminar.

Também pode manter o grupo de recursos, mas apagar um único espaço de trabalho. Exiba as propriedades do espaço de trabalho e selecione Delete.

Passos seguintes

Neste tutorial automatizado de aprendizagem automática, fez as seguintes tarefas:

  • Configurar um espaço de trabalho e preparar dados para uma experiência.
  • Treinado um modelo automatizado de deteção de objetos
  • Valores de hiperparmetro especificados para o seu modelo
  • Realizou uma varredura de hiperparmetro
  • Implementou o seu modelo
  • Deteções visualizadas

Nota

A utilização do conjunto de dados de objetos do frigorífico está disponível através da licença ao abrigo da Licença MIT.