Configurar o AutoML para treinar modelos de visão computacional com Python (v1)

APLICA-SE A: Python SDK azureml v1

Neste artigo, você aprenderá a treinar modelos de visão computacional em dados de imagem com ML automatizado no SDK Python do Azure Machine Learning.

O ML Automatizado suporta a preparação de modelos para tarefas de imagens digitalizadas, como a classificação de imagens, a deteção de objetos e a segmentação de instâncias. A criação de modelos do AutoML para tarefas de imagens digitalizadas é atualmente suportada através do SDK do Python do Azure Machine Learning. As execuções, modelos e saídas de experimentação resultantes podem ser acessados a partir da interface do usuário do estúdio de Aprendizado de Máquina do Azure. Saiba mais sobre ml automatizado para tarefas de visão computacional em dados de imagem.

Pré-requisitos

• Uma área de trabalho do Azure Machine Learning. Para criar o espaço de trabalho, consulte Criar recursos do espaço de trabalho.

• O SDK Python do Azure Machine Learning instalado. Para instalar o SDK, você pode,

  • Crie uma instância de computação, que instala automaticamente o SDK e é pré-configurada para fluxos de trabalho de ML. Para obter mais informações, consulte Criar e gerenciar uma instância de computação do Azure Machine Learning.

  • Instale o automl pacote você mesmo, que inclui a instalação padrão do SDK.

  Nota

  Apenas Python 3.7 e 3.8 são compatíveis com suporte automatizado de ML para tarefas de visão computacional.

Selecione o tipo de tarefa

O ML automatizado para imagens suporta os seguintes tipos de tarefas:

Esse tipo de tarefa é um parâmetro obrigatório e é passado usando o task parâmetro no AutoMLImageConfig.

Por exemplo:

from azureml.train.automl import AutoMLImageConfig
from azureml.automl.core.shared.constants import ImageTask
automl_image_config = AutoMLImageConfig(task=ImageTask.IMAGE_OBJECT_DETECTION)

Dados de formação e validação

Para gerar modelos de visão computacional, você precisa trazer dados de imagem rotulados como entrada para treinamento de modelo na forma de um Conjunto de Dados Tabulares do Azure Machine Learning. Você pode usar um TabularDataset que você exportou de um projeto de rotulagem de dados ou criar um novo TabularDataset com seus dados de treinamento rotulados.

Se os dados de treinamento estiverem em um formato diferente (como pascal VOC ou COCO), você poderá aplicar os scripts auxiliares incluídos nos blocos de anotações de exemplo para converter os dados em JSONL. Saiba mais sobre como preparar dados para tarefas de visão computacional com ML automatizado.

Exemplos de esquema JSONL

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

A seguir está um arquivo JSONL de exemplo para classificação de imagem:

{
      "image_url": "AmlDatastore://image_data/Image_01.png",
      "image_details":
      {
          "format": "png",
          "width": "2230px",
          "height": "4356px"
      },
      "label": "cat"
  }
  {
      "image_url": "AmlDatastore://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 deteção de objetos:

{
    "image_url": "AmlDatastore://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": "AmlDatastore://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",
    }
}

Consumir dados

Quando os dados estiverem no formato JSONL, você poderá criar um TabularDataset com o seguinte código:

ws = Workspace.from_config()
ds = ws.get_default_datastore()
from azureml.core import Dataset

training_dataset = Dataset.Tabular.from_json_lines_files(
        path=ds.path('odFridgeObjects/odFridgeObjects.jsonl'),
        set_column_types={'image_url': DataType.to_stream(ds.workspace)})
training_dataset = training_dataset.register(workspace=ws, name=training_dataset_name)

O ML automatizado não impõe restrições ao tamanho dos dados de treinamento ou validação para tarefas de visão computacional. O tamanho máximo do conjunto de dados é limitado apenas pela camada de armazenamento por trás do conjunto de dados (ou seja, armazenamento de blobs). Não existe um número mínimo de imagens ou etiquetas. No entanto, recomendamos começar com um mínimo de 10-15 amostras por rótulo para garantir que o modelo de saída seja suficientemente treinado. Quanto maior o número total de rótulos/classes, mais amostras você precisa por rótulo.

Os dados de treinamento são necessários e são passados usando o training_data parâmetro. Opcionalmente, você pode especificar outro TabularDataset como um conjunto de dados de validação a ser usado para seu modelo com o validation_data parâmetro AutoMLImageConfig. Se nenhum conjunto de dados de validação for especificado, 20% dos dados de treinamento serão usados para validação por padrão, a menos que você passe validation_size um argumento com um valor diferente.

Por exemplo:

from azureml.train.automl import AutoMLImageConfig
automl_image_config = AutoMLImageConfig(training_data=training_dataset)

Computação para executar a experimentação

Forneça um destino de computação para ML automatizado para conduzir treinamento de modelo. Os modelos de ML automatizados para tarefas de visão computacional requerem SKUs de GPU e suportam as famílias NC e ND. Recomendamos a série NCsv3 (com GPUs v100) para um treinamento mais rápido. Um alvo de computação com um SKU VM MULTI-GPU aproveita 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ê pode realizar um treinamento de modelo mais rápido por meio de paralelismo ao ajustar hiperparâmetros para seu modelo.

O destino de computação é um parâmetro obrigatório e é passado usando o compute_target parâmetro do AutoMLImageConfig. Por exemplo:

from azureml.train.automl import AutoMLImageConfig
automl_image_config = AutoMLImageConfig(compute_target=compute_target)

Configurar algoritmos de modelo e hiperparâmetros

Com suporte para tarefas de visão computacional, você pode controlar o algoritmo do modelo e varrer hiperparâmetros. Esses algoritmos de modelo e hiperparâmetros são passados como o espaço de parâmetro para a varredura.

O algoritmo do modelo é necessário e é passado via model_name parâmetro. Você pode especificar um único model_name ou escolher entre vários.

Algoritmos de modelo suportados

A tabela a seguir resume os modelos suportados para cada tarefa de visão computacional.

Além de controlar o algoritmo do modelo, você também pode ajustar os hiperparâmetros usados para o treinamento do modelo. Embora muitos dos hiperparâmetros expostos sejam agnósticos ao modelo, há casos em que os hiperparâmetros são específicos da tarefa ou do modelo. Saiba mais sobre os hiperparâmetros disponíveis para essas instâncias.

Aumento de dados

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

Definir as configurações do experimento

Antes de fazer uma grande varredura para procurar os modelos e hiperparâmetros ideais, recomendamos tentar os valores padrão para obter uma primeira linha de base. Em seguida, você pode explorar vários hiperparâmetros para o mesmo modelo antes de varrer vários modelos e seus parâmetros. Dessa forma, você pode empregar uma abordagem mais iterativa, porque com vários modelos e vários hiperparâmetros para cada um, o espaço de pesquisa cresce exponencialmente e você precisa de mais iterações para encontrar as configurações ideais.

Se você deseja usar os valores de hiperparâmetro padrão para um determinado algoritmo (digamos yolov5), você pode especificar a configuração para sua imagem AutoML é executada da seguinte maneira:

from azureml.train.automl import AutoMLImageConfig
from azureml.train.hyperdrive import GridParameterSampling, choice
from azureml.automl.core.shared.constants import ImageTask

automl_image_config_yolov5 = AutoMLImageConfig(task=ImageTask.IMAGE_OBJECT_DETECTION,
                                               compute_target=compute_target,
                                               training_data=training_dataset,
                                               validation_data=validation_dataset,
                                               hyperparameter_sampling=GridParameterSampling({'model_name': choice('yolov5')}),
                                               iterations=1)

Depois de criar um modelo de linha de base, convém otimizar o desempenho do modelo para varrer o algoritmo do modelo e o espaço de hiperparâmetros. Você pode usar a seguinte configuração de exemplo para varrer os hiperparâmetros para cada algoritmo, escolhendo entre um intervalo de valores para learning_rate, otimizador, lr_scheduler, etc., para 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 o algoritmo especificado.

Métrica primária

A métrica primária usada para otimização de modelo e ajuste de hiperparâmetros depende do tipo de tarefa. No momento, não há suporte para o uso de outros valores de métricas primárias.

• accuracy para IMAGE_CLASSIFICATION
• iou para IMAGE_CLASSIFICATION_MULTILABEL
• mean_average_precision para IMAGE_OBJECT_DETECTION
• mean_average_precision para IMAGE_INSTANCE_SEGMENTATION

Orçamento da experiência

Opcionalmente, você pode especificar o orçamento máximo de tempo para seu experimento AutoML Vision usando experiment_timeout_hours - a quantidade de tempo em horas antes do término do experimento. Se nenhum for especificado, o tempo limite padrão do experimento será de sete dias (máximo de 60 dias).

Hiperparâmetros abrangentes para o seu modelo

Ao treinar modelos de visão computacional, o desempenho do modelo depende muito dos valores de hiperparâmetros selecionados. Muitas vezes, você pode querer ajustar os hiperparâmetros para obter o desempenho ideal. Com suporte para tarefas de visão computacional em ML automatizado, você pode varrer hiperparâmetros para encontrar as configurações ideais para o seu modelo. Esse recurso aplica os recursos de ajuste de hiperparâmetro no Aprendizado de Máquina do Azure. Saiba como ajustar hiperparâmetros.

Definir o espaço de pesquisa de parâmetros

Você pode definir os algoritmos de modelo e hiperparâmetros para varrer no espaço de parâmetros.

• Consulte Configurar algoritmos de modelo e hiperparâmetros para obter a lista de algoritmos de modelo suportados para cada tipo de tarefa.
• Consulte Hiperparâmetros para tarefas de visão computacional hiperparâmetros para cada tipo de tarefa de visão computacional.
• Veja detalhes sobre distribuições suportadas para hiperparâmetros discretos e contínuos.

Métodos de amostragem para a varredura

Ao varrer hiperparâmetros, você precisa especificar o método de amostragem a ser usado para varrer o espaço de parâmetros definido. Atualmente, os seguintes métodos de amostragem são suportados com o hyperparameter_sampling parâmetro:

• Amostragem aleatória
• Amostragem em grelha
• Amostragem bayesiana

Políticas de rescisão antecipada

Você pode encerrar automaticamente execuções com baixo desempenho com uma política de encerramento antecipado. A terminação antecipada melhora a eficiência computacional, economizando recursos de computação que, de outra forma, teriam sido gastos em configurações menos promissoras. O ML automatizado para imagens suporta as seguintes políticas de encerramento antecipado usando o early_termination_policy parâmetro. Se nenhuma política de terminação for especificada, todas as configurações serão executadas até a conclusão.

• Política de bandidos
• Mediana da política de paragem
• Política de seleção de truncamento

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

Recursos para a varredura

Você pode controlar os recursos gastos em sua varredura de hiperparâmetros especificando o iterations e o max_concurrent_iterations para a varredura.

Argumentos

Você pode passar configurações fixas ou parâmetros que não mudam durante a varredura de espaço de parâmetro como argumentos. Os argumentos são passados em pares nome-valor e o nome deve ser prefixado por um traço duplo.

from azureml.train.automl import AutoMLImageConfig
arguments = ["--early_stopping", 1, "--evaluation_frequency", 2]
automl_image_config = AutoMLImageConfig(arguments=arguments)

Formação incremental (opcional)

Uma vez que a execução de treinamento é feita, você tem a opção de treinar ainda mais o modelo carregando o ponto de verificação do modelo treinado. Você pode usar o mesmo conjunto de dados ou um conjunto de dados diferente para treinamento incremental.

Há duas opções disponíveis para treinamento incremental. É possível

• Passe o ID de execução do qual você deseja carregar o ponto de verificação.
• Passe os pontos de verificação através de um FileDataset.

Passe o ponto de verificação através do ID de execução

Para encontrar o ID de execução do modelo desejado, você pode usar o código a seguir.

# find a run id to get a model checkpoint from
target_checkpoint_run = automl_image_run.get_best_child()

Para passar um ponto de verificação através do ID de execução, você precisa usar o checkpoint_run_id parâmetro.

automl_image_config = AutoMLImageConfig(task='image-object-detection',
                                        compute_target=compute_target,
                                        training_data=training_dataset,
                                        validation_data=validation_dataset,
                                        checkpoint_run_id= target_checkpoint_run.id,
                                        primary_metric='mean_average_precision',
                                        **tuning_settings)

automl_image_run = experiment.submit(automl_image_config)
automl_image_run.wait_for_completion(wait_post_processing=True)

Passe o ponto de verificação via FileDataset

Para passar um ponto de verificação por meio de um FileDataset, você precisa usar os checkpoint_dataset_id parâmetros e checkpoint_filename .

# download the checkpoint from the previous run
model_name = "outputs/model.pt"
model_local = "checkpoints/model_yolo.pt"
target_checkpoint_run.download_file(name=model_name, output_file_path=model_local)

# upload the checkpoint to the blob store
ds.upload(src_dir="checkpoints", target_path='checkpoints')

# create a FileDatset for the checkpoint and register it with your workspace
ds_path = ds.path('checkpoints/model_yolo.pt')
checkpoint_yolo = Dataset.File.from_files(path=ds_path)
checkpoint_yolo = checkpoint_yolo.register(workspace=ws, name='yolo_checkpoint')

automl_image_config = AutoMLImageConfig(task='image-object-detection',
                                        compute_target=compute_target,
                                        training_data=training_dataset,
                                        validation_data=validation_dataset,
                                        checkpoint_dataset_id= checkpoint_yolo.id,
                                        checkpoint_filename='model_yolo.pt',
                                        primary_metric='mean_average_precision',
                                        **tuning_settings)

automl_image_run = experiment.submit(automl_image_config)
automl_image_run.wait_for_completion(wait_post_processing=True)

Enviar a execução

Quando você tiver seu AutoMLImageConfig objeto pronto, poderá enviar o experimento.

ws = Workspace.from_config()
experiment = Experiment(ws, "Tutorial-automl-image-object-detection")
automl_image_run = experiment.submit(automl_image_config)

Resultados e métricas de avaliação

As execuções automatizadas de treinamento de ML 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, que podem ser visualizados na guia de saídas e logs e métricas das execuções filhas.

Para obter definições e exemplos dos gráficos e métricas de desempenho fornecidos para cada execução, consulte Avaliar resultados de experimentos de aprendizado de máquina automatizados

Registrar e implantar modelo

Quando a execução for concluída, você poderá registrar o modelo que foi criado a partir da melhor execução (configuração que resultou na melhor métrica primária)

best_child_run = automl_image_run.get_best_child()
model_name = best_child_run.properties['model_name']
model = best_child_run.register_model(model_name = model_name, model_path='outputs/model.pt')

Depois de registrar o modelo que deseja usar, você pode implantá-lo como um serviço Web nas Instâncias de Contêiner do Azure (ACI) ou no Serviço Kubernetes do Azure (AKS). O ACI é a opção perfeita para testar implantações, enquanto o AKS é mais adequado para uso de produção em alta escala.

Este exemplo implanta o modelo como um serviço Web no AKS. Para implantar no AKS, primeiro crie um cluster de computação AKS ou use um cluster AKS existente. Você pode usar SKUs de GPU ou CPU VM para seu cluster de implantação.

from azureml.core.compute import ComputeTarget, AksCompute
from azureml.exceptions import ComputeTargetException

# Choose a name for your cluster
aks_name = "cluster-aks-gpu"

# Check to see if the cluster already exists
try:
    aks_target = ComputeTarget(workspace=ws, name=aks_name)
    print('Found existing compute target')
except ComputeTargetException:
    print('Creating a new compute target...')
    # Provision AKS cluster with GPU machine
    prov_config = AksCompute.provisioning_configuration(vm_size="STANDARD_NC6", 
                                                        location="eastus2")
    # Create the cluster
    aks_target = ComputeTarget.create(workspace=ws, 
                                      name=aks_name, 
                                      provisioning_configuration=prov_config)
    aks_target.wait_for_completion(show_output=True)

Em seguida, você pode definir a configuração de inferência, que descreve como configurar o serviço Web que contém seu modelo. Você pode usar o script de pontuação e o ambiente da execução de treinamento em sua configuração de inferência.

from azureml.core.model import InferenceConfig

best_child_run.download_file('outputs/scoring_file_v_1_0_0.py', output_file_path='score.py')
environment = best_child_run.get_environment()
inference_config = InferenceConfig(entry_script='score.py', environment=environment)

Em seguida, você pode implantar o modelo como um serviço Web AKS.

# Deploy the model from the best run as an AKS web service
from azureml.core.webservice import AksWebservice
from azureml.core.webservice import Webservice
from azureml.core.model import Model
from azureml.core.environment import Environment

aks_config = AksWebservice.deploy_configuration(autoscale_enabled=True,                                                    
                                                cpu_cores=1,
                                                memory_gb=50,
                                                enable_app_insights=True)

aks_service = Model.deploy(ws,
                           models=[model],
                           inference_config=inference_config,
                           deployment_config=aks_config,
                           deployment_target=aks_target,
                           name='automl-image-test',
                           overwrite=True)
aks_service.wait_for_deployment(show_output=True)
print(aks_service.state)

Como alternativa, você pode implantar o modelo a partir da interface do usuário do estúdio de Aprendizado de Máquina do Azure. Navegue até o modelo que deseja implantar na guia Modelos da execução automatizada de ML e selecione Implantar.

Você pode configurar o nome do ponto de extremidade da implantação do modelo e o cluster de inferência a serem usados para a implantação do modelo no painel Implantar um modelo .

Atualizar configuração de inferência

Na etapa anterior, baixamos o arquivo outputs/scoring_file_v_1_0_0.py de pontuação do melhor modelo para um arquivo local score.py e o usamos para criar um InferenceConfig objeto. Esse script pode ser modificado para alterar as configurações de inferência específicas do modelo, se necessário, depois de ter sido baixado e antes de criar o InferenceConfig. Por exemplo, esta é a seção de código que inicializa o modelo no arquivo de pontuação:

...
def init():
    ...
    try:
        logger.info("Loading model from path: {}.".format(model_path))
        model_settings = {...}
        model = load_model(TASK_TYPE, model_path, **model_settings)
        logger.info("Loading successful.")
    except Exception as e:
        logging_utilities.log_traceback(e, logger)
        raise
...

Cada uma das tarefas (e alguns modelos) tem um conjunto de parâmetros no model_settings dicionário. Por padrão, usamos os mesmos valores para os parâmetros que foram usados durante o treinamento e a validação. Dependendo do comportamento que precisamos ao usar o modelo para 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 sobre hiperparâmetros específicos de tarefas, consulte Hiperparâmetros para tarefas de visão computacional em aprendizado de máquina automatizado.

Se você quiser usar o lado a lado e quiser controlar o comportamento do mosaico, 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, consulte Train a small object detection model using AutoML.

Blocos de notas de exemplo

Analise os exemplos de código e casos de utilização detalhados no Repositório do bloco de notas do GitHub para amostras de machine learning automatizado. Por favor, verifique as pastas com o prefixo 'image-' para amostras específicas para a construção de modelos de visão computacional.

Próximos passos

• Tutorial: Treine um modelo de deteção de objetos com AutoML e Python.
• Faça previsões com ONNX em modelos de visão computacional do AutoML
• Solucione problemas de experimentos automatizados de ML.