Configurar o AutoML para treinar modelos de pesquisa visual computacional

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

Neste artigo, você aprenderá a treinar modelos de visão computacional em dados de imagem com ML automatizado. Você pode treinar modelos usando a extensão CLI do Azure Machine Learning v2 ou o SDK do Python do Azure Machine Learning v2.

O ML automatizado dá suporte ao treinamento de modelos para tarefas de pesquisa visual computacional, como classificação de imagem, detecção de objetos e segmentação de instância. Atualmente, há suporte à criação de modelos de AutoML para tarefas de pesquisa visual computacional por meio do SDK do Python do Azure Machine Learning. As avaliações, os modelos e as saídas de experimentação resultantes podem ser acessados na interface do usuário do Estúdio do Azure Machine Learning. Saiba mais sobre ML automatizado para tarefas de pesquisa visual computacional em dados de imagem.

Pré-requisitos

Selecionar o tipo de tarefa

O ML automatizado para imagens dá suporte aos seguintes tipos de tarefa:

task: image_object_detection

from azure.ai.ml import automl
image_object_detection_job = automl.image_object_detection()

Dados de treinamento e validação

Para gerar modelos da pesquisa visual computacional, você precisa trazer dados de imagem rotulados como entrada para o treinamento do modelo na forma de um MLTable. Você pode criar um MLTable de dados de treinamento no formato JSONL.

Se os dados de treinamento estão em um formato diferente (como Pascal VOC ou COCO), você pode aplicar os scripts auxiliares incluídos nos notebooks de amostra para converter os dados em JSONL. Saiba mais sobre como preparar dados para tarefas de pesquisa visual computacional ML automatizado.

Exemplos de esquema JSONL

A estrutura do TabularDataset depende da tarefa em questão. Para tipos de tarefa de pesquisa visual computacional, ele consiste nos seguintes campos:

O código a seguir é um exemplo de arquivo JSONL para classificação de imagem:

{
      "image_url": "azureml://subscriptions/<my-subscription-id>/resourcegroups/<my-resource-group>/workspaces/<my-workspace>/datastores/<my-datastore>/paths/image_data/Image_01.png",
      "image_details":
      {
          "format": "png",
          "width": "2230px",
          "height": "4356px"
      },
      "label": "cat"
  }
  {
      "image_url": "azureml://subscriptions/<my-subscription-id>/resourcegroups/<my-resource-group>/workspaces/<my-workspace>/datastores/<my-datastore>/paths/image_data/Image_02.jpeg",
      "image_details":
      {
          "format": "jpeg",
          "width": "3456px",
          "height": "3467px"
      },
      "label": "dog"
  }

O código a seguir é um arquivo JSONL de exemplo para detecção de objetos:

{
    "image_url": "azureml://subscriptions/<my-subscription-id>/resourcegroups/<my-resource-group>/workspaces/<my-workspace>/datastores/<my-datastore>/paths/image_data/Image_01.png",
    "image_details":
    {
        "format": "png",
        "width": "2230px",
        "height": "4356px"
    },
    "label":
    {
        "label": "cat",
        "topX": "1",
        "topY": "0",
        "bottomX": "0",
        "bottomY": "1",
        "isCrowd": "true",
    }
}
{
    "image_url": "azureml://subscriptions/<my-subscription-id>/resourcegroups/<my-resource-group>/workspaces/<my-workspace>/datastores/<my-datastore>/paths/image_data/Image_02.png",
    "image_details":
    {
        "format": "jpeg",
        "width": "1230px",
        "height": "2356px"
    },
    "label":
    {
        "label": "dog",
        "topX": "0",
        "topY": "1",
        "bottomX": "0",
        "bottomY": "1",
        "isCrowd": "false",
    }
}

Dados de consumo

Com os dados no formato JSONL, você poderá criar treinamento e validação MLTable, conforme mostrado abaixo.

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

O ML Automatizado não impõe restrições ao tamanho dos dados de treinamento ou validação para tarefas de pesquisa visual computacional. O tamanho máximo do conjunto de dados é limitado apenas pela camada de armazenamento por trás do conjunto de dados (exemplo: armazenamento de blob). Não há nenhum número mínimo de imagens ou rótulos. No entanto, recomendamos começar com o mínimo de 10 a 15 amostras por rótulo para ter certeza de que o modelo de saída será suficientemente treinado. Quanto maior o número total de rótulos/classes, de mais amostras você precisará por rótulo.

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

from azure.ai.ml import Input
from azure.ai.ml.constants import AssetTypes

# Training MLTable defined locally, with local data to be uploaded
my_training_data_input = Input(type=AssetTypes.MLTABLE, path=training_mltable_path)

# Validation MLTable defined locally, with local data to be uploaded
my_validation_data_input = Input(type=AssetTypes.MLTABLE, path=validation_mltable_path)

# WITH REMOTE PATH: If available already in the cloud/workspace-blob-store
# my_training_data_input = Input(type=AssetTypes.MLTABLE, path="azureml://datastores/workspaceblobstore/paths/vision-classification/train")
# my_validation_data_input = Input(type=AssetTypes.MLTABLE, path="azureml://datastores/workspaceblobstore/paths/vision-classification/valid")

from azure.ai.ml import automl
image_object_detection_job = automl.image_object_detection(
    training_data=my_training_data_input,
    validation_data=my_validation_data_input,
    target_column_name="label"
)

Computação para executar o experimento

Forneça um destino de computação para o ML automatizado realizar o treinamento do modelo. Os modelos de ML automatizados para tarefas de pesquisa visual computacional exigem SKUs de GPU e dão suporte às famílias NC e ND. Recomendamos a série NCsv3 (com GPUs v100) para um treinamento mais rápido. Um destino de computação com um SKU de VM com várias GPUs usa várias GPUs para também acelerar o treinamento. Além disso, ao configurar um destino de computação com vários nós, você poderá realizar um treinamento de modelo mais rápido por meio de paralelismo com o ajuste de hiperparâmetros para o modelo.

O destino de computação é transmitido pelo uso do parâmetro compute. Por exemplo:

compute: azureml:gpu-cluster

from azure.ai.ml import automl

compute_name = "gpu-cluster"
image_object_detection_job = automl.image_object_detection(
    compute=compute_name,
)

Configurar experimentos

Para tarefas de pesquisa visual computacional, você pode iniciar avaliações individuais, varreduras manuais ou varreduras automáticas. É recomendável começar com uma varredura automática para obter um primeiro modelo de linha de base. Em seguida, você pode experimentar avaliações individuais com alguns modelos e configurações de hiperparâmetro. Por fim, com varreduras manuais, é possível explorar vários valores de hiperparâmetro próximos a modelos mais promissores e configurações de hiperparâmetro. Este fluxo de trabalho de três etapas (varredura automática, avaliações individuais, varreduras manuais) evita pesquisar a totalidade do espaço do hiperparâmetro, que cresce exponencialmente no número de hiperparâmetros.

Varreduras automáticas podem suspender resultados competitivos para muitos conjuntos de dados. Além disso, não exigem conhecimento avançado de arquiteturas de modelos, levam em conta as correlações de hiperparâmetros e funcionam perfeitamente em diferentes configurações de hardware. Todos esses motivos as tornam uma opção forte para o estágio inicial do processo de experimentação.

Métrica principal

Um trabalho de treinamento do AutoML usa uma métrica primária para otimização de modelo e ajuste de hiperparâmetro. A métrica primária depende do tipo de tarefa, conforme mostrado abaixo; no momento, não há suporte para outros valores de métrica primária.

• Precisão para classificação de imagem
• Interseção sobre união para classificação de imagens multirrótulo
• Precisão média para detecção de objetos da imagem
• Precisão média para segmentação de instância de imagem

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, conforme descrito no exemplo abaixo.

limits:
  timeout_minutes: 60
  max_trials: 10
  max_concurrent_trials: 2

# Set limits
image_object_detection_job.set_limits(
    timeout_minutes=60,
    max_trials=10,
    max_concurrent_trials=2,
)

Hiperparâmetros do modelo de varredura automática (AutoMode)

É difícil prever a melhor arquitetura de modelo e os melhores hiperparâmetros para um conjunto de dados. Além disso, em alguns casos, o tempo humano alocado para ajustar hiperparâmetros pode ser limitado. Para tarefas de visão computacional, você pode especificar várias avaliações e o sistema determina automaticamente a região do espaço de hiperparâmetros a ser varrida. Não é necessário definir um espaço de pesquisa de hiperparâmetros, um método de amostragem ou uma política de encerramento antecipado.

Disparar o AutoMode

Para executar varreduras automáticas, defina max_trials como um valor maior que 1 em limits e não especifique o espaço de pesquisa, o método de amostragem e a política de encerramento. Chamamos essa funcionalidade de AutoMode; veja o exemplo a seguir.

limits:
  max_trials: 10
  max_concurrent_trials: 2

image_object_detection_job.set_limits(max_trials=10, max_concurrent_trials=2)

Um número de tentativas entre 10 e 20 provavelmente funciona bem em muitos conjuntos de dados. O orçamento de tempo para o trabalho do AutoML ainda pode ser definido, mas será recomendável fazer isso somente se cada avaliação demorar muito.

Avaliações individuais

Em avaliações individuais, você controla diretamente a arquitetura de modelo e os hiperparâmetros. A arquitetura do modelo é passado por meio do parâmetro model_name.

Arquiteturas de modelo com suporte

A tabela a seguir resume os modelos herdados com suporte para cada tarefa de visão computacional. Usar apenas esses modelos herdados disparará execuções usando o runtime herdado (em que cada execução individual ou avaliação é enviada como um trabalho de comando). Confira abaixo o suporte a HuggingFace e MMDetection.

Arquiteturas de modelo com suporte – HuggingFace e MMDetection (versão prévia)

Com o novo back-end executado nos pipelines do Azure Machine Learning, você também pode usar qualquer modelo de classificação de imagem do Hub HuggingFace que faz parte da biblioteca de transformadores (como microsoft/beit-base-patch16-224), bem como qualquer modelo de segmentação de instância ou detecção de objetos do MMDetection Versão 3.1.0 Model Zoo (como atss_r50_fpn_1x_coco).

Além de dar suporte a qualquer modelo do HuggingFace Transfomers e MMDetection 3.1.0, também oferecemos uma lista de modelos coletados dessas bibliotecas no registro azureml. Esses modelos coletados foram testados detalhadamente e usam hiperparâmetros padrão selecionados com parâmetros de comparação extensivos para garantir um treinamento eficaz. A tabela abaixo resume esses modelos coletados.

Atualizamos constantemente a lista de modelos coletados. Você pode obter a lista mais atualizada dos modelos coletados para uma determinada tarefa usando o SDK do Python:

credential = DefaultAzureCredential()
ml_client = MLClient(credential, registry_name="azureml")

models = ml_client.models.list()
classification_models = []
for model in models:
    model = ml_client.models.get(model.name, label="latest")
    if model.tags['task'] == 'image-classification': # choose an image task
        classification_models.append(model.name)

classification_models

Saída:

['google-vit-base-patch16-224',
 'microsoft-swinv2-base-patch4-window12-192-22k',
 'facebook-deit-base-patch16-224',
 'microsoft-beit-base-patch16-224-pt22k-ft22k']

O uso de qualquer modelo HuggingFace ou MMDetection disparará execuções usando componentes de pipeline. Se os modelos herdado e HuggingFace/MMdetection forem usados, todas as execuções/avaliações serão disparadas usando componentes.

Além de controlar a arquitetura de modelo, você também pode ajustar hiperparâmetros usados no treinamento do modelo. Embora muitos dos hiperparâmetros expostos independam do modelo, há instâncias em que os hiperparâmetros são específicos da tarefa do modelo. Saiba mais sobre os hiperparâmetros disponíveis para essas instâncias.

training_parameters:
    model_name: yolov5

image_object_detection_job.set_training_parameters(model_name="yolov5")

Hiperparâmetros de modelo de varredura manual

Ao treinar modelos de pesquisa visual computacional, o desempenho do modelo depende muito dos valores de hiperparâmetro selecionados. Muitas vezes, talvez seja melhor ajustar os hiperparâmetros para obter um desempenho ideal. Para tarefas da pesquisa visual computacional, você pode varrer hiperparâmetros a fim de encontrar as configurações ideais para seu modelo. Esse recurso aplica os recursos de ajuste de hiperparâmetros no Azure Machine Learning. Aprenda a ajustar hiperparâmetros.

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]

# Define search space
image_object_detection_job.extend_search_space(
    [
        SearchSpace(
            model_name=Choice(["yolov5"]),
            learning_rate=Uniform(0.0001, 0.01),
            model_size=Choice(["small", "medium"]),  # model-specific
            # image_size=Choice([640, 704, 768]),  # model-specific; might need GPU with large memory
        ),
        SearchSpace(
            model_name=Choice(["fasterrcnn_resnet50_fpn"]),
            learning_rate=Uniform(0.0001, 0.001),
            optimizer=Choice(["sgd", "adam", "adamw"]),
            min_size=Choice([600, 800]),  # model-specific
            # warmup_cosine_lr_warmup_epochs=Choice([0, 3]),
        ),
    ]
)

Defina o espaço de pesquisa de parâmetro

Você pode definir as arquiteturas de modelo e hiperparâmetros para varredura no espaço de parâmetro. É possível especificar uma única arquitetura de modelo ou vários.

• Confira Avaliações individuais para obter a lista de arquiteturas de modelos compatíveis de cada tipo de tarefa.
• Consulte Hiperparâmetros para tarefas de pesquisa visual computacional, hiperparâmetros para cada tipo de tarefa de pesquisa visual computacional.
• Veja detalhes sobre as distribuições com suporte em hiperparâmetros discretos e contínuos.

Métodos de amostragem para a varredura

Ao varrer hiperparâmetros, você precisará especificar o método de amostragem a ser usado na varredura do espaço de parâmetro definido. Atualmente, os seguintes métodos de amostragem são compatíveis com o parâmetro sampling_algorithm:

Políticas de término antecipado

Você pode encerrar automaticamente avaliações de baixo desempenho com uma política de término antecipado. O encerramento antecipado melhora a eficiência computacional, pois economiza recursos de computação que, de outra forma, seriam gastos em avaliações menos promissoras. O ML automatizado para imagens dá suporte às políticas de término antecipado abaixo por meio do parâmetro early_termination. Se nenhuma política de encerramento for especificada, todas as avaliações serão executadas até a conclusão.

Saiba mais sobre como configurar a política de encerramento antecipado para a varredura de hiperparâmetros.

Você pode configurar todos os parâmetros relacionados à varredura, conforme mostrado no exemplo a seguir.

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

# Configure sweep settings
image_object_detection_job.set_sweep(
    sampling_algorithm="random",
    early_termination=BanditPolicy(
        evaluation_interval=2, slack_factor=0.2, delay_evaluation=6
    ),
)

Configurações fixas

Você pode passar configurações ou parâmetros fixoa que não são alterados durante a varredura do espaço de parâmetros, conforme mostrado no exemplo a seguir.

training_parameters:
  early_stopping: True
  evaluation_frequency: 1

# Pass the fixed settings or parameters
image_object_detection_job.set_training_parameters(
    early_stopping=True, evaluation_frequency=1
)

Aumento de dados

Em geral, o desempenho do modelo de aprendizado profundo costuma melhorar com mais dados. O aumento de dados é uma técnica prática para ampliar o tamanho dos dados e a variabilidade de um conjunto de dados, o que ajuda a evitar o sobreajuste e a melhorar a capacidade de generalização do modelo em dados não vistos. O ML automatizado aplica técnicas de aumento de dados diferentes com base na tarefa de pesquisa visual computacional antes de alimentar o modelo com as imagens de entrada. Atualmente, não há nenhum hiperparâmetro exposto para controlar os aumentos de dados.

Atualmente, os aumentos definidos acima são aplicados por padrão para um ML automatizado para trabalho de imagem. Para fornecer controle sobre os aumentos, o ML automatizado para imagens expõe abaixo de dois sinalizadores para desativar determinados aumentos. Atualmente, esses sinalizadores só têm suporte para tarefas de segmentação de instância e detecção de objetos.

1. apply_mosaic_for_yolo: esse sinalizador é específico apenas para o modelo Yolo. A configuração como False desativa o aumento de dados do mosaico aplicado no momento do treinamento.
2. apply_automl_train_augmentations: definir esse sinalizador como false desativa o aumento aplicado durante o tempo de treinamento para os modelos de segmentação de instância e detecção de objetos. Para aumentos, consulte os detalhes na tabela acima.
   • Para o modelo de detecção de objetos não yolo e modelos de segmentação de instância, esse sinalizador desativa apenas os três primeiros aumentos. Por exemplo: corte aleatório em torno de caixas delimitadoras, expansão, inversão horizontal. Os aumentos de normalização e redimensionamento ainda são aplicados independentemente desse sinalizador.
   • Para o modelo Yolo, esse sinalizador desativa os aumentos aleatórios similares e de inversão horizontal.

Esses dois sinalizadores têm suporte por meio de advanced_settings em training_parameters e podem ser controlados da maneira a seguir.

training_parameters:
  advanced_settings: >
    {"apply_mosaic_for_yolo": false}

training_parameters:
  advanced_settings: >
    {"apply_automl_train_augmentations": false}

training_parameters:
 advanced_settings: >
   {"apply_automl_train_augmentations": false, "apply_mosaic_for_yolo": false}

from azure.ai.ml import automl

image_object_detection_job = automl.image_object_detection(...)

image_object_detection_job.set_training_parameters(
    ...,
    advanced_settings='{"apply_mosaic_for_yolo": false}'
)

from azure.ai.ml import automl

image_object_detection_job = automl.image_object_detection(...)

image_object_detection_job.set_training_parameters(
    ...,
    advanced_settings='{"apply_automl_train_augmentations": false}'
)

from azure.ai.ml import automl

image_object_detection_job = automl.image_object_detection(...)

image_object_detection_job.set_training_parameters(
    ...,
    advanced_settings='{"apply_automl_train_augmentations": false, "apply_mosaic_for_yolo": false}'
)

Em nossos experimentos, descobrimos que esses aumentos ajudam o modelo a generalizar melhor. Portanto, quando esses aumentos são desligados, recomendamos que os usuários os combinem com outros aumentos offline para obter melhores resultados.

Treinamento incremental (opcional)

Após a conclusão do trabalho de treinamento, você pode optar por treinar ainda mais o modelo carregando o ponto de verificação do modelo treinado. Você pode usar o mesmo conjunto de dados ou um diferente para treinamento incremental. Se estiver satisfeito com o modelo, você pode optar por interromper o treinamento e usar o modelo atual.

Passar o ponto de verificação via ID do trabalho

Você pode passar a ID do trabalho da qual você deseja carregar o ponto de verificação.

training_parameters:
  checkpoint_run_id : "target_checkpoint_run_id"

# find a job id to get a model checkpoint from
import mlflow

# Obtain the tracking URL from MLClient
MLFLOW_TRACKING_URI = ml_client.workspaces.get(
    name=ml_client.workspace_name
).mlflow_tracking_uri
mlflow.set_tracking_uri(MLFLOW_TRACKING_URI)

from mlflow.tracking.client import MlflowClient

mlflow_client = MlflowClient()
mlflow_parent_run = mlflow_client.get_run(automl_job.name)

# Fetch the id of the best automl child trial.
target_checkpoint_run_id = mlflow_parent_run.data.tags["automl_best_child_run_id"]

image_object_detection_job = automl.image_object_detection(
    compute=compute_name,
    experiment_name=exp_name,
    training_data=my_training_data_input,
    validation_data=my_validation_data_input,
    target_column_name="label",
    primary_metric=ObjectDetectionPrimaryMetrics.MEAN_AVERAGE_PRECISION,
    tags={"my_custom_tag": "My custom value"},
)

image_object_detection_job.set_training_parameters(checkpoint_run_id=target_checkpoint_run_id)

automl_image_job_incremental = ml_client.jobs.create_or_update(
    image_object_detection_job
) 

Enviar o trabalho do AutoML

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]

# Submit the AutoML job
returned_job = ml_client.jobs.create_or_update(
    image_object_detection_job
)  # submit the job to the backend

print(f"Created job: {returned_job}")

Métricas de avaliação e saídas

Os trabalhos de treinamento do ML automatizado geram arquivos de modelo de saída, métricas de avaliação, logs e artefatos de implantação, como o arquivo de pontuação e o arquivo de ambiente. Esses arquivos e métricas podem ser visualizados na guia de saídas, logs e métricas dos trabalhos filho.

Para obter definições e exemplos dos gráficos e métricas de desempenho fornecidos para cada trabalho, confira Avaliar resultados do experimento de machine learning automatizado.

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 caminho azureml com jobid correspondente. Observação: quando quiser alterar as configurações de inferência descritas abaixo, baixe o modelo, altere o settings.json e registre-se usando a pasta do modelo atualizado.

Obter a melhor avaliação

CLI example not available, please use Python SDK.

# Get the best model's child run

best_child_run_id = mlflow_parent_run.data.tags["automl_best_child_run_id"]
print(f"Found best child run id: {best_child_run_id}")

best_run = mlflow_client.get_run(best_child_run_id)

print("Best child run: ")
print(best_run)

# Create local folder
local_dir = "./artifact_downloads"
if not os.path.exists(local_dir):
    os.mkdir(local_dir)

# Download run's artifacts/outputs
local_path = mlflow_client.download_artifacts(
    best_run.info.run_id, "outputs", local_dir
)
print(f"Artifacts downloaded in: {local_path}")
print(f"Artifacts: {os.listdir(local_path)}")

registrar o modelo

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

 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]

model_name = "od-fridge-items-mlflow-model"
model = Model(
    path=f"azureml://jobs/{best_run.info.run_id}/outputs/artifacts/outputs/mlflow-model/",
    name=model_name,
    description="my sample object detection model",
    type=AssetTypes.MLFLOW_MODEL,
)

# for downloaded file
# model = Model(
#     path=mlflow_model_dir,
#     name=model_name,
#     description="my sample object detection model",
#     type=AssetTypes.MLFLOW_MODEL,
# )

registered_model = ml_client.models.create_or_update(model)

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

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

# Creating a unique endpoint name with current datetime to avoid conflicts
import datetime

online_endpoint_name = "od-fridge-items-" + datetime.datetime.now().strftime(
    "%m%d%H%M%f"
)

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is a sample online endpoint for deploying model",
    auth_mode="key",
    tags={"foo": "bar"},
)
print(online_endpoint_name)

Criar o ponto de extremidade

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

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

ml_client.begin_create_or_update(endpoint).result()

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.

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 

deployment = ManagedOnlineDeployment(
    name="od-fridge-items-mlflow-deploy",
    endpoint_name=online_endpoint_name,
    model=registered_model.id,
    instance_type="Standard_DS4_V2",
    instance_count=1,
    request_settings=req_timeout,
    liveness_probe=ProbeSettings(
        failure_threshold=30,
        success_threshold=1,
        timeout=2,
        period=10,
        initial_delay=2000,
    ),
    readiness_probe=ProbeSettings(
        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.

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

ml_client.online_deployments.begin_create_or_update(deployment).result()

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

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]

# od fridge items deployment to take 100% traffic
endpoint.traffic = {"od-fridge-items-mlflow-deploy": 100}
ml_client.begin_create_or_update(endpoint).result()

Como alternativa, você pode implantar o modelo na interface do usuário do Estúdio do Azure Machine Learning. Navegue até o modelo que você deseja implantar na guia Modelos do trabalho de ML automatizado e selecione Implantar e Implantar no ponto de extremidade em tempo real.

.

esta é a aparência da sua página de revisão. podemos selecionar o tipo de instância e a contagem de instâncias e definir o percentual de tráfego para a implantação atual.

. .

Atualizar configurações de inferência

Na etapa anterior, baixamos um arquivo mlflow-model/artifacts/settings.json do melhor modelo. que pode ser usado para atualizar as configurações de inferência antes de registrar o modelo. Embora seja recomendado usar os mesmos parâmetros do treinamento para melhor desempenho.

Cada uma das tarefas (e alguns modelos) tem um conjunto de parâmetros. Por padrão, usamos os mesmos valores dos parâmetros que foram usados durante o treinamento e a validação. Dependendo do comportamento que buscamos ao usar o modelo de inferência, podemos alterar esses parâmetros. Abaixo, você pode encontrar uma lista de parâmetros para cada tipo de tarefa e modelo.

Para obter uma descrição detalhada dos hiperparâmetros específicos da tarefa, consulte Hiperparâmetros para tarefas de visão computacional no machine learning automatizado.

Se você quiser usar blocos e desejar controlar o comportamento dos blocos, os seguintes parâmetros estarão disponíveis: tile_grid_size, tile_overlap_ratio e tile_predictions_nms_thresh. Para obter mais detalhes sobre esses parâmetros, verifique Treinar um pequeno modelo de detecção de objetos usando o AutoML.

Teste a implantação

Verifique esta seção Testar a implantação para testar a implantação e visualizar as detecções do modelo.

Gerar explicações para previsões

Algumas das vantagens de usar a XAI (IA Explicável) com o AutoML para imagens:

• Melhora a transparência nas previsões complexas do modelo de visão
• Ajuda os usuários a entender os recursos/pixels importantes na imagem de entrada que estão contribuindo para as previsões do modelo
• Ajuda na solução de problemas dos modelos
• Ajuda a descobrir o desvio

Explicações

Explicações são atributos de recursos ou pesos dados a cada pixel na imagem de entrada de acordo com sua contribuição para a previsão do modelo. Cada peso pode ser negativo (correlacionado negativamente com a previsão) ou positivo (correlacionado positivamente com a previsão). Essas atribuições são calculadas em relação à classe prevista. Para a classificação de várias classes, exatamente uma matriz de atribuição de tamanho [3, valid_crop_size, valid_crop_size] é gerada por exemplo, enquanto que para a classificação de vários rótulos, a matriz de atribuição de tamanho [3, valid_crop_size, valid_crop_size] é gerada para cada rótulo/classe previsto para cada exemplo.

Usando a IA Explicável no AutoML para imagens no ponto de extremidade implantado, os usuários podem obter visualizações de explicações (atribuições sobrepostas em uma imagem de entrada) e/ou atribuições (matriz multidimensional de tamanho [3, valid_crop_size, valid_crop_size]) para cada imagem. Além das visualizações, os usuários também podem obter matrizes de atribuição para obter mais controle sobre as explicações (como gerar visualizações personalizadas usando atribuições ou examinar segmentos de atribuições). Todos os algoritmos de explicação usam imagens quadradas cortadas com tamanho valid_crop_size para gerar atribuições.

As explicações podem ser geradas do ponto de extremidade online ou do ponto de extremidade em lote. Depois que a implantação for concluída, esse ponto de extremidade poderá ser utilizado para gerar as explicações para previsões. Nas implantações online, passe o parâmetro request_settings = OnlineRequestSettings(request_timeout_ms=90000) para ManagedOnlineDeployment e defina request_timeout_ms como seu valor máximo para evitar problemas de tempo limite ao gerar explicações (consulte a seção Registrar e implantar modelo). Alguns dos métodos de explicabilidade (XAI) como xrai consomem mais tempo (especialmente para classificação de vários rótulos, pois precisamos gerar atribuições e/ou visualizações em cada rótulo previsto). Portanto, é recomendável qualquer instância de GPU para obter explicações mais rápidas. Para obter mais informações sobre o esquema de entrada e saída para gerar explicações, consulte os documentos do esquema.

Damos suporte aos seguintes algoritmos de explicabilidade de última geração no AutoML para imagens:

• XRAI (xrai)
• Gradientes integrados (integrated_gradients)
• GradCAM guiado (guided_gradcam)
• BackPropagation guiado (guided_backprop)

A tabela a seguir descreve os parâmetros de ajuste específicos do algoritmo de explicabilidade para XRAI e Gradientes Integrados. A retropropagação guiada e o gradcam guiado não exigem parâmetros de ajuste.

Internamente, o algoritmo XRAI usa gradientes integrados. Portanto, o parâmetro n_steps é exigido por gradientes integrados e algoritmos XRAI. Um número maior de etapas consome mais tempo para aproximar as explicações, e isso pode resultar em problemas de tempo limite no ponto de extremidade online.

É recomendável usar algoritmos de XRAI > GradCAM guiado > Gradientes integrados > BackPropagation guiado para obter melhores explicações, enquanto BackPropagation guiado > GradCAM guiado > Gradients integrados > XRAI são recomendados para obter explicações mais rápidas na ordem especificada.

Uma solicitação de exemplo para o ponto de extremidade online é semelhante à seguinte. Essa solicitação gera explicações quando model_explainability é definido como True. A solicitação a seguir gera visualizações e atribuições usando uma versão mais rápida do algoritmo XRAI com 50 etapas.

import base64
import json

def read_image(image_path):
    with open(image_path, "rb") as f:
        return f.read()

sample_image = "./test_image.jpg"

# Define explainability (XAI) parameters
model_explainability = True
xai_parameters = {"xai_algorithm": "xrai",
                  "n_steps": 50,
                  "xrai_fast": True,
                  "visualizations": True,
                  "attributions": True}

# Create request json
request_json = {"input_data": {"columns":  ["image"],
                               "data": [json.dumps({"image_base64": base64.encodebytes(read_image(sample_image)).decode("utf-8"),
                                                    "model_explainability": model_explainability,
                                                    "xai_parameters": xai_parameters})],
                               }
                }

request_file_name = "sample_request_data.json"

with open(request_file_name, "w") as request_file:
    json.dump(request_json, request_file)

resp = ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    deployment_name=deployment.name,
    request_file=request_file_name,
)
predictions = json.loads(resp)

Para obter mais informações sobre como gerar explicações, consulte Exemplos de repositório de notebooks do GitHub para machine learning automatizado.

Interpretar visualizações

O ponto de extremidade implantado retornará a cadeia de caracteres de imagem codificada em base64 se model_explainability e visualizations estiverem definidos como True. Decodifique a cadeia de caracteres base64 conforme descrito em notebooks ou use o código a seguir para decodificar e visualizar as cadeias de caracteres de imagem base64 na previsão.

import base64
from io import BytesIO
from PIL import Image

def base64_to_img(base64_img_str):
    base64_img = base64_img_str.encode("utf-8")
    decoded_img = base64.b64decode(base64_img)
    return BytesIO(decoded_img).getvalue()

# For Multi-class classification:
# Decode and visualize base64 image string for explanations for first input image
# img_bytes = base64_to_img(predictions[0]["visualizations"])

# For  Multi-label classification:
# Decode and visualize base64 image string for explanations for first input image against one of the classes
img_bytes = base64_to_img(predictions[0]["visualizations"][0])
image = Image.open(BytesIO(img_bytes))

A imagem a seguir descreve a Visualização de explicações para uma imagem de entrada de exemplo.

A figura base64 decodificada tem quatro seções de imagem em uma grade 2 x 2.

• Imagem no canto superior esquerdo (0, 0) é a imagem de entrada cortada
• A imagem no canto superior direito (0, 1) é o mapa de calor de atribuições em uma escala de cores bgyw (azul verde amarelo branco), em que a contribuição de pixels brancos na classe prevista é a mais alta e os pixels azuis são os mais baixos.
• A imagem no canto inferior esquerdo (1, 0) é um mapa de calor combinado de atribuições na imagem de entrada cortada
• A imagem no canto inferior direito (1, 1) é a imagem de entrada cortada com os 30% superiores dos pixels de acordo com as pontuações de atribuição.

Interpretar atribuições

O ponto de extremidade implantado retornará atribuições se model_explainability e attributions estiverem definidos como True. Para obter mais detalhes, consulte notebooks de classificação de várias classes e de classificação de vários rótulos.

Essas atribuições dão mais controle aos usuários para gerar visualizações personalizadas ou examinar pontuações de atribuição no nível de pixel. O snippet de código a seguir descreve uma maneira de gerar visualizações personalizadas usando a matriz de atribuição. Para obter mais informações sobre o esquema de atribuições para classificação de várias classes e classificação de vários rótulos, consulte os documentos do esquema.

Use os valores exatos valid_resize_size e valid_crop_size do modelo selecionado para gerar as explicações (os valores padrão são 256 e 224, respectivamente). O código a seguir usa a funcionalidade de visualização Captum para gerar visualizações personalizadas. Os usuários podem utilizar qualquer outra biblioteca para gerar visualizações. Para obter mais detalhes, consulte os utilitários de visualização captum.

import colorcet as cc
import numpy as np
from captum.attr import visualization as viz
from PIL import Image
from torchvision import transforms

def get_common_valid_transforms(resize_to=256, crop_size=224):

    return transforms.Compose([
        transforms.Resize(resize_to),
        transforms.CenterCrop(crop_size)
    ])

# Load the image
valid_resize_size = 256
valid_crop_size = 224
sample_image = "./test_image.jpg"
image = Image.open(sample_image)
# Perform common validation transforms to get the image used to generate attributions
common_transforms = get_common_valid_transforms(resize_to=valid_resize_size,
                                                crop_size=valid_crop_size)
input_tensor = common_transforms(image)

# Convert output attributions to numpy array

# For Multi-class classification:
# Selecting attribution matrix for first input image
# attributions = np.array(predictions[0]["attributions"])

# For  Multi-label classification:
# Selecting first attribution matrix against one of the classes for first input image
attributions = np.array(predictions[0]["attributions"][0])

# visualize results
viz.visualize_image_attr_multiple(np.transpose(attributions, (1, 2, 0)),
                                  np.array(input_tensor),
                                  ["original_image", "blended_heat_map"],
                                  ["all", "absolute_value"],
                                  show_colorbar=True,
                                  cmap=cc.cm.bgyw,
                                  titles=["original_image", "heatmap"],
                                  fig_size=(12, 12))

Grandes conjuntos de dados

Se você estiver usando o machine learning automatizado para treinar em grandes conjuntos de dados, há algumas configurações experimentais que podem ser úteis.

Treinamento de vários GPUs e vários nós

Por padrão, cada modelo é treinado em uma única VM. Se o treinamento de um modelo estiver demorando muito, o uso de VMs que contêm várias GPUs poderá ajudar. O tempo para treinar um modelo em conjuntos de dados grandes deve diminuir em proporção aproximadamente linear ao número de GPUs usadas. (Por exemplo, um modelo deve treinar aproximadamente duas vezes mais rápido em uma VM com duas GPUs do que em uma VM com uma GPU.) Se o tempo para treinar um modelo ainda for alto em uma VM com várias GPUs, você poderá aumentar o número de VMs usadas para treinar cada modelo. Semelhante ao treinamento de várias GPUs, o tempo para treinar um modelo em grandes conjuntos de dados também deve diminuir em proporção aproximadamente linear ao número de VMs usadas. Ao treinar um modelo em várias VMs, use uma SKU de computação que dê suporte ao InfiniBand para obter melhores resultados. Você pode configurar o número de VMs usadas para treinar um único modelo definindo a propriedade node_count_per_trial do trabalho de machine learning automatizado.

properties:
  node_count_per_trial: "2"

from azure.ai.ml import automl

image_object_detection_job = automl.image_object_detection(
    ...,
    properties={"node_count_per_trial": 2}
)

Transmissão de arquivos de imagem do armazenamento

Por padrão, todos os arquivos de imagem são baixados no disco antes do treinamento do modelo. Se o tamanho dos arquivos de imagem for maior do que o espaço em disco disponível, o trabalho falhará. Em vez de baixar todas as imagens para o disco, você pode selecionar transmitir arquivos de imagem do armazenamento do Azure conforme necessário durante o treinamento. Os arquivos de imagem são transmitidos do armazenamento do Azure diretamente para a memória do sistema, ignorando o disco. Ao mesmo tempo, o maior número possível de arquivos do armazenamento é armazenado em cache no disco para minimizar o número de solicitações para o armazenamento.

training_parameters:
  advanced_settings: >
    {"stream_image_files": true}

from azure.ai.ml import automl

image_object_detection_job = automl.image_object_detection(...)

image_object_detection_job.set_training_parameters(
    ...,
    advanced_settings='{"stream_image_files": true}'
)

Blocos de anotações de exemplo

Examine exemplos de código detalhados e casos de uso no Repositório do notebook do GitHub para obter amostras de machine learning automatizado. Verifique as pastas com o prefixo "automl-image-" para obter exemplos específicos para a criação de modelos de visão computacional.

Exemplos de código

Próximas etapas

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