Configurar o AutoML para treinar modelos de visão computacional
APLICA-SE A:
Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)
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 da CLI do Azure Machine Learning v2 ou o SDK do Python do Azure Machine Learning v2.
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 avaliações, modelos e saídas de experimentação resultantes podem ser acessados a partir da interface do usuário do estúdio Azure Machine Learning. Saiba mais sobre ml automatizado para tarefas de visão computacional em dados de imagem.
Pré-requisitos
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
- Uma área de trabalho do Azure Machine Learning. Para criar o espaço de trabalho, consulte Criar recursos do espaço de trabalho.
- Instale e configure a CLI (v2) e certifique-se de instalar a
mlextensão.
Selecione o tipo de tarefa
O ML automatizado para imagens suporta os seguintes tipos de tarefas:
| Tipo de tarefa | Sintaxe do trabalho AutoML |
|---|---|
| Classificação de imagens | CLI v2: image_classification SDK v2: image_classification() |
| classificação de imagem multi-rótulo | CLI v2: image_classification_multilabel SDK v2: image_classification_multilabel() |
| Deteção de objeto de imagem | CLI v2: image_object_detection SDK v2: image_object_detection() |
| segmentação de instância de imagem | CLI v2: image_instance_segmentation SDK v2: image_instance_segmentation() |
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
Este tipo de tarefa é um parâmetro obrigatório e pode ser definido usando a task chave.
Por exemplo:
task: 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 o treinamento do modelo na forma de um MLTablearquivo . Você pode criar um a MLTable partir de dados de treinamento no formato JSONL.
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.
Nota
Os dados de treinamento precisam ter pelo menos 10 imagens para poder enviar um trabalho AutoML.
Aviso
A criação de dados a partir no formato JSONL é suportada MLTable usando apenas o SDK e a CLI, para esse recurso. No momento, não há suporte para a criação da MLTable via UI.
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:
| Campo | Descrição |
|---|---|
image_url |
Contém filepath como um objeto StreamInfo |
image_details |
As informações de metadados de imagem consistem em altura, largura e formato. Este campo é opcional e, portanto, pode ou não existir. |
label |
Uma representação json do rótulo da imagem, com base no tipo de tarefa. |
O código a seguir é um arquivo JSONL de exemplo 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 deteçã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",
}
}
Consumir dados
Uma vez que seus dados estejam no formato JSONL, você pode 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 visão computacional. O tamanho máximo do conjunto de dados é limitado apenas pela camada de armazenamento por trás do conjunto de dados (Exemplo: blob store). 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.
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
Os dados de treinamento são um parâmetro necessário e são passados usando a training_data chave. Opcionalmente, você pode especificar outra MLtable como um dado de validação com a validation_data chave. Se nenhum dado 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_data_size um argumento com um valor diferente.
O nome da coluna de destino é um parâmetro obrigatório e usado como destino para a tarefa de ML supervisionada. É passado usando a target_column_name chave. Por exemplo,
target_column_name: label
training_data:
path: data/training-mltable-folder
type: mltable
validation_data:
path: data/validation-mltable-folder
type: mltable
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 destino de computação com um SKU VM MULTI-GPU 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ê pode realizar um treinamento de modelo mais rápido por meio de paralelismo ao ajustar hiperparâmetros para seu modelo.
Nota
Se você estiver usando uma instância de computação como seu destino de computação, certifique-se de que vários trabalhos AutoML não sejam executados ao mesmo tempo. Além disso, certifique-se de que max_concurrent_trials está definido como 1 nos seus limites de trabalho.
O destino de computação é passado usando o compute parâmetro. Por exemplo:
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
compute: azureml:gpu-cluster
Configurar experimentos
Para tarefas de visão computacional, você pode iniciar testes individuais, varreduras manuais ou varreduras automáticas. Recomendamos começar com uma varredura automática para obter um primeiro modelo de linha de base. Em seguida, você pode experimentar testes individuais com determinados modelos e configurações de hiperparâmetros. Finalmente, com varreduras manuais, você pode explorar vários valores de hiperparâmetros perto dos modelos mais promissores e configurações de hiperparâmetros. Este fluxo de trabalho de três passos (varredura automática, testes individuais, varreduras manuais) evita pesquisar a totalidade do espaço de hiperparâmetros, que cresce exponencialmente no número de hiperparâmetros.
As varreduras automáticas podem produzir resultados competitivos para muitos conjuntos de dados. Além disso, eles não exigem conhecimento avançado de arquiteturas de modelo, levam em conta correlações de hiperparâmetros e funcionam perfeitamente em diferentes configurações de hardware. Todas estas razões fazem deles uma forte opção para a fase inicial do seu processo de experimentação.
Métrica primária
Um trabalho de treinamento AutoML usa uma métrica primária para otimização de modelo e ajuste de hiperparâmetros. A métrica primária depende do tipo de tarefa, conforme mostrado abaixo; No momento, não há suporte para outros valores de métricas primárias.
- Precisão para classificação de imagens
- Interseção sobre união para classificação de imagem multilabel
- Precisão média para deteção de objetos de imagem
- Precisão média para segmentação de instâncias de imagem
Limites dos trabalhos
Você pode controlar os recursos gastos em seu trabalho de treinamento de Imagem AutoML especificando o , e o para o timeout_minutesmax_concurrent_trials trabalho nas configurações de limite, max_trials conforme descrito no exemplo abaixo.
| Parâmetro | Detalhe |
|---|---|
max_trials |
Parâmetro para o número máximo de ensaios a varrer. Deve ser um número inteiro entre 1 e 1000. Ao explorar apenas os hiperparâmetros padrão para uma determinada arquitetura de modelo, defina esse parâmetro como 1. O valor predefinido é 1. |
max_concurrent_trials |
Número máximo de ensaios que podem ser executados simultaneamente. Se especificado, deve ser um número inteiro entre 1 e 100. O valor predefinido é 1. NOTA: max_concurrent_trials é limitada internamente max_trials . Por exemplo, se o usuário definir max_concurrent_trials=4, , os valores serão atualizados internamente como max_concurrent_trials=2, max_trials=2max_trials=2. |
timeout_minutes |
A quantidade de tempo em minutos antes do experimento terminar. Se nenhum for especificado, o timeout_minutes padrão do experimento será de sete dias (máximo de 60 dias) |
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
limits:
timeout_minutes: 60
max_trials: 10
max_concurrent_trials: 2
Varredura automática dos hiperparâmetros do modelo (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.
É difícil prever a melhor arquitetura de modelo e 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 qualquer número de tentativas e o sistema determina automaticamente a região do espaço de hiperparâmetro a ser varrido. 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.
Acionando o AutoMode
Você pode executar varreduras automáticas definindo max_trials como um valor maior que 1 em limits e não especificando o espaço de pesquisa, o método de amostragem e a política de encerramento. Chamamos a esta funcionalidade AutoMode; veja o exemplo a seguir.
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
limits:
max_trials: 10
max_concurrent_trials: 2
Um número de ensaios entre 10 e 20 provavelmente funciona bem em muitos conjuntos de dados. O orçamento de tempo para o trabalho AutoML ainda pode ser definido, mas recomendamos fazer isso apenas se cada avaliação puder levar muito tempo.
Aviso
No momento, não há suporte para o lançamento de varreduras automáticas por meio da interface do usuário.
Ensaios individuais
Em testes individuais, você controla diretamente a arquitetura do modelo e os hiperparâmetros. A arquitetura do modelo é passada através do model_name parâmetro.
Arquiteturas de modelo suportadas
A tabela a seguir resume os modelos herdados suportados para cada tarefa de visão computacional. Usar apenas esses modelos herdados acionará execuções usando o tempo de execução herdado (onde cada execução ou avaliação individual é enviada como um trabalho de comando). Por favor, veja abaixo o suporte a HuggingFace e MMDetection.
| Tarefa | Arquiteturas de modelo | Sintaxe literal da cadeia de caracteresdefault_model* indicado com * |
|---|---|---|
| Classificação de imagens (multiclasse e multi-rótulo) |
MobileNet: Modelos leves para aplicações móveis ResNet: Redes residuais ResNeSt: Dividir redes de atenção SE-ResNeXt50: Redes de compressão e excitação ViT: Redes de transformadores de visão |
mobilenetv2 resnet18 resnet34 resnet50 resnet101 resnet152 resnest50 resnest101 seresnext vits16r224 (pequeno) vitb16r224* (base) vitl16r224 (grande) |
| Deteção de objetos | YOLOv5: Modelo de deteção de objeto de um estágio FPN RCNN ResNet mais rápido: modelos de deteção de objetos de dois estágios RetinaNet ResNet FPN: resolver desequilíbrio de classe com perda focal Nota: Consulte o model_size hiperparâmetro para tamanhos de modelo YOLOv5. |
yolov5* fasterrcnn_resnet18_fpn fasterrcnn_resnet34_fpn fasterrcnn_resnet50_fpn fasterrcnn_resnet101_fpn fasterrcnn_resnet152_fpn retinanet_resnet50_fpn |
| Segmentação de instâncias | MaskRCNN ResNet FPN | maskrcnn_resnet18_fpn maskrcnn_resnet34_fpn maskrcnn_resnet50_fpn* maskrcnn_resnet101_fpn maskrcnn_resnet152_fpn |
Arquiteturas de modelo suportadas - HuggingFace e MMDetection (visualização)
Com o novo back-end executado em pipelines do Azure Machine Learning, você também pode usar qualquer modelo de classificação de imagem do HuggingFace Hub que faz parte da biblioteca de transformadores (como microsoft/beit-base-patch16-224), bem como qualquer modelo de deteção de objeto ou segmentação de instância do MMDetection Versão 3.1.0 Model Zoo (como atss_r50_fpn_1x_coco).
Além de suportar qualquer modelo do HuggingFace Transfomers e MMDetection 3.1.0, também oferecemos uma lista de modelos curados dessas bibliotecas no registro azureml. Esses modelos selecionados foram testados minuciosamente e usam hiperparâmetros padrão selecionados a partir de benchmarking extensivo para garantir um treinamento eficaz. A tabela abaixo resume esses modelos selecionados.
| Tarefa | Arquiteturas de modelo | Sintaxe literal da cadeia de caracteres |
|---|---|---|
| Classificação de imagens (multiclasse e multi-rótulo) |
BEiT ViT DeiT SwinV2 |
microsoft/beit-base-patch16-224-pt22k-ft22kgoogle/vit-base-patch16-224facebook/deit-base-patch16-224microsoft/swinv2-base-patch4-window12-192-22k |
| Deteção de Objetos | Esparso R-CNN DETR deformável VFNet YOLOF Vitória |
mmd-3x-sparse-rcnn_r50_fpn_300-proposals_crop-ms-480-800-3x_cocommd-3x-sparse-rcnn_r101_fpn_300-proposals_crop-ms-480-800-3x_coco mmd-3x-deformable-detr_refine_twostage_r50_16xb2-50e_coco mmd-3x-vfnet_r50-mdconv-c3-c5_fpn_ms-2x_coco mmd-3x-vfnet_x101-64x4d-mdconv-c3-c5_fpn_ms-2x_coco mmd-3x-yolof_r50_c5_8x8_1x_coco |
| Segmentação de instâncias | Vitória | mmd-3x-mask-rcnn_swin-t-p4-w7_fpn_1x_coco |
Atualizamos constantemente a lista de modelos selecionados. Você pode obter a lista mais atualizada dos modelos selecionados para uma determinada tarefa usando o Python SDK:
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
Resultado:
['google-vit-base-patch16-224',
'microsoft-swinv2-base-patch4-window12-192-22k',
'facebook-deit-base-patch16-224',
'microsoft-beit-base-patch16-224-pt22k-ft22k']
Usar qualquer modelo HuggingFace ou MMDetection acionará execuções usando componentes de pipeline. Se ambos os modelos legados e HuggingFace/MMdetection forem usados, todas as execuções/testes serão acionados usando componentes.
Além de controlar a arquitetura 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.
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
Se você deseja usar os valores de hiperparâmetro padrão para uma determinada arquitetura (digamos yolov5), você pode especificá-lo usando a chave model_name na seção training_parameters. Por exemplo,
training_parameters:
model_name: yolov5
Varredura manual dos hiperparâmetros do 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. Para tarefas de visão computacional, 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.
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
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]
Definir o espaço de pesquisa de parâmetros
Você pode definir as arquiteturas de modelo e os hiperparâmetros para varrer o espaço de parâmetros. Você pode especificar uma única arquitetura de modelo ou várias.
- Consulte Avaliações individuais para obter a lista de arquiteturas de modelo suportadas 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 sampling_algorithm parâmetro:
| Tipo de amostragem | Sintaxe do trabalho AutoML |
|---|---|
| Amostragem aleatória | random |
| Amostragem de grelha | grid |
| Amostragem Bayesiana | bayesian |
Nota
Atualmente, apenas amostragem aleatória e em grade suporta espaços de hiperparâmetros condicionais.
Políticas de rescisão antecipada
Você pode encerrar automaticamente as avaliações com baixo desempenho com uma política de rescisão antecipada. A terminação antecipada melhora a eficiência computacional, economizando recursos computacionais que, de outra forma, teriam sido gastos em testes menos promissores. O ML automatizado para imagens suporta as seguintes políticas de encerramento antecipado usando o early_termination parâmetro. Se nenhuma política de rescisão for especificada, todas as avaliações serão executadas até a conclusão.
| Política de rescisão antecipada | Sintaxe do trabalho AutoML |
|---|---|
| Política de bandidos | CLI v2: bandit SDK v2: BanditPolicy() |
| Mediana da política de paragem | CLI v2: median_stopping SDK v2: MedianStoppingPolicy() |
| Política de seleção de truncamento | CLI v2: truncation_selection SDK v2: TruncationSelectionPolicy() |
Saiba mais sobre como configurar a política de encerramento antecipado para sua varredura de hiperparâmetros.
Nota
Para obter um exemplo completo de configuração de varredura, consulte este tutorial.
Você pode configurar todos os parâmetros relacionados à varredura, conforme mostrado no exemplo a seguir.
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
sweep:
sampling_algorithm: random
early_termination:
type: bandit
evaluation_interval: 2
slack_factor: 0.2
delay_evaluation: 6
Configurações fixas
Você pode passar configurações fixas ou parâmetros que não mudam durante a varredura de espaço de parâmetros, conforme mostrado no exemplo a seguir.
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
training_parameters:
early_stopping: True
evaluation_frequency: 1
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, o 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á nenhum hiperparâmetro exposto para controlar aumentos de dados.
| Tarefa | Conjunto de dados afetado | Técnica(s) de aumento de dados aplicada(s) |
|---|---|---|
| Classificação de imagem (multiclasse e multi-label) | Formação Validação e Teste |
Redimensionamento e corte aleatórios, inversão horizontal, desvio de cor (brilho, contraste, saturação e matiz), normalização usando a média e o desvio padrão do ImageNet em canal Redimensionamento, colheita central, normalização |
| Deteção de objetos, segmentação de instâncias | Formação Validação e Teste |
Corte aleatório em torno de caixas delimitadoras, expandir, inverter horizontalmente, normalização, redimensionar Normalização, redimensionamento |
| Deteção de objetos usando yolov5 | Formação Validação e Teste |
Mosaico, afim aleatório (rotação, translação, escala, cisalhamento), flip horizontal Redimensionamento da caixa de correio |
Atualmente, os aumentos definidos acima são aplicados por padrão para um ML automatizado para trabalho de imagem. Para fornecer controle sobre aumentos, o ML automatizado para imagens expõe abaixo de dois sinalizadores para desativar determinados aumentos. Atualmente, esses sinalizadores são suportados apenas para deteção de objetos e tarefas de segmentação de instância.
- apply_mosaic_for_yolo: Este sinalizador é específico apenas para o modelo Yolo. Defini-lo como False desativa o aumento de dados em mosaico, que é aplicado no momento do treinamento.
- apply_automl_train_augmentations: Definir esse sinalizador como false desativa o aumento aplicado durante o tempo de treinamento para os modelos de deteção de objetos e segmentação de instância. Para aumentos, consulte os detalhes na tabela acima.
- Para modelos de segmentação de instância e modelo de deteção de objeto não-yolo, esse sinalizador desativa apenas os três primeiros aumentos. Por exemplo: corte aleatório em torno de caixas delimitadoras, expanda, inverta horizontalmente. Os aumentos de normalização e redimensionamento ainda são aplicados independentemente dessa bandeira.
- Para o modelo Yolo, esta bandeira desliga os aumentos aleatórios afins e horizontais flip.
Estes dois sinalizadores são suportados através de advanced_settings sob training_parameters e podem ser controlados da seguinte forma.
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
training_parameters:
advanced_settings: >
{"apply_mosaic_for_yolo": false}
training_parameters:
advanced_settings: >
{"apply_automl_train_augmentations": false}
Observe que esses dois sinalizadores são independentes um do outro e também podem ser usados em combinação usando as seguintes configurações.
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 combinem-nos com outros aumentos offline para obter melhores resultados.
Formação incremental (opcional)
Uma vez que o trabalho de treinamento é feito, 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 conjunto de dados diferente para treinamento incremental. Se você estiver satisfeito com o modelo, você pode optar por parar o treinamento e usar o modelo atual.
Passe o ponto de verificação através do ID do trabalho
Você pode passar a ID do trabalho a partir da qual deseja carregar o ponto de verificação.
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
training_parameters:
checkpoint_run_id : "target_checkpoint_run_id"
Enviar o trabalho AutoML
APLICA-SE A:Extensão ml da CLI do Azure 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]
Resultados e métricas de avaliação
Os trabalhos de treinamento automatizado 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. Esses arquivos e métricas podem ser visualizados na guia saídas, logs e métricas dos trabalhos filho.
Gorjeta
Verifique como navegar para os resultados do trabalho na seção Exibir resultados do trabalho.
Para obter definições e exemplos dos gráficos e métricas de desempenho fornecidos para cada trabalho, consulte Avaliar resultados de experimentos de aprendizado de máquina automatizados.
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 azureml com o jobid correspondente. Nota: Quando você quiser alterar as configurações de inferência descritas abaixo, você precisa baixar o modelo e alterar settings.json e registrar usando a pasta de modelo atualizada.
Obtenha a melhor versão experimental
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
CLI example not available, please use Python SDK.
registar o modelo
Registre o modelo usando o caminho azureml ou o caminho baixado localmente.
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
az ml model create --name od-fridge-items-mlflow-model --version 1 --path azureml://jobs/$best_run/outputs/artifacts/outputs/mlflow-model/ --type mlflow_model --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]
Depois de registrar o modelo que deseja usar, você pode implantá-lo usando o endpoint online gerenciado deploy-managed-online-endpoint
Configurar ponto de extremidade online
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: od-fridge-items-endpoint
auth_mode: key
Criar o ponto de extremidade
Usando o criado anteriormente, criamos o MLClient ponto de extremidade 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:Extensão ml da CLI do Azure v2 (atual)
az ml online-endpoint create --file .\create_endpoint.yml --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]
Configurar a implementação online
Uma implantação é um conjunto de recursos necessários para hospedar o modelo que faz a inferência real. Criaremos 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:Extensão ml da CLI do Azure v2 (atual)
name: od-fridge-items-mlflow-deploy
endpoint_name: od-fridge-items-endpoint
model: azureml:od-fridge-items-mlflow-model@latest
instance_type: Standard_DS3_v2
instance_count: 1
liveness_probe:
failure_threshold: 30
success_threshold: 1
timeout: 2
period: 10
initial_delay: 2000
readiness_probe:
failure_threshold: 10
success_threshold: 1
timeout: 10
period: 10
initial_delay: 2000
Criar a implantação
Usando o MLClient criado anteriormente, agora criaremos a implantação no espaço de trabalho. Esse comando iniciará a criação da implantação e retornará uma resposta de confirmação enquanto a criação da implantação continuar.
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
az ml online-deployment create --file .\create_deployment.yml --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]
Atualizar 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:Extensão ml da CLI do Azure v2 (atual)
az ml online-endpoint update --name 'od-fridge-items-endpoint' --traffic 'od-fridge-items-mlflow-deploy=100' --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]
Como alternativa, você pode implantar o modelo a partir da interface do usuário do estúdio Azure Machine Learning. Navegue até o modelo que deseja implantar na guia Modelos do trabalho de ML automatizado e selecione Implantare selecione Implantar no ponto de extremidade em tempo real .
.
É assim que sua página de avaliação se parece. Podemos selecionar o tipo de instância, a contagem de instâncias e definir a porcentagem 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 obter o melhor desempenho.
Cada uma das tarefas (e alguns modelos) tem um conjunto de parâmetros. 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.
| Tarefa | Nome do parâmetro | Predefinido |
|---|---|---|
| Classificação de imagem (multiclasse e multi-label) | valid_resize_sizevalid_crop_size |
256 224 |
| Deteção de objetos | min_sizemax_sizebox_score_threshnms_iou_threshbox_detections_per_img |
600 1333 0.3 0.5 100 |
Deteção de objetos usando yolov5 |
img_sizemodel_sizebox_score_threshnms_iou_thresh |
640 médio 0.1 0.5 |
| Segmentação de instâncias | min_sizemax_sizebox_score_threshnms_iou_threshbox_detections_per_imgmask_pixel_score_thresholdmax_number_of_polygon_pointsexport_as_imageimage_type |
600 1333 0.3 0.5 100 0.5 100 False JPG |
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, verifique Treinar um modelo de deteção de objetos pequenos usando AutoML.
Testar a implementação
Marque esta seção Testar a implantação para testar a implantação e visualizar as deteções do modelo.
Gerar explicações para previsões
Importante
Essas configurações estão atualmente em visualização pública. Eles são fornecidos sem um acordo 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.
Aviso
A Explicabilidade do Modelo é suportada apenas para classificação multiclasse e classificação multirótulo.
Algumas das vantagens de usar a IA explicável (XAI) 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 preconceito
Explicações
As explicações são atribuições de recursos ou pesos dados a cada pixel na imagem de entrada com base em sua contribuição para a previsão do modelo. Cada peso pode ser negativo (negativamente correlacionado com a previsão) ou positivo (positivamente correlacionado com a previsão). Essas atribuições são calculadas em relação à classe prevista. Para a classificação multiclasse, é gerada exatamente uma matriz de atribuição de tamanho por amostra, enquanto que para a classificação multi-rótulo, a matriz de atribuição de tamanho [3, valid_crop_size, valid_crop_size][3, valid_crop_size, valid_crop_size] é gerada para cada rótulo/classe prevista para cada amostra.
Usando IA explicável no AutoML for Images no endpoint 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 a partir do ponto de extremidade on-line ou do ponto de extremidade em lote. Uma vez que a implantação é feita, esse ponto de extremidade pode ser utilizado para gerar as explicações para previsões. Em implantações online, certifique-se de passar request_settings = OnlineRequestSettings(request_timeout_ms=90000) o parâmetro e ManagedOnlineDeployment definir request_timeout_ms 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) consomem xrai mais tempo (especialmente para classificação multi-rótulo, pois precisamos gerar atribuições e/ou visualizações em relação a cada rótulo previsto). Portanto, recomendamos qualquer instância de GPU para 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.
Suportamos os 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 a gradcam guiada não requerem parâmetros de ajuste.
| Algoritmo XAI | Parâmetros específicos do algoritmo | Valores Predefinidos |
|---|---|---|
xrai |
1. : Número de passos utilizados pelo método de aproximação. n_steps Um maior número de passos leva a melhores aproximações de atribuições (explicações). O intervalo de n_steps é [2, inf], mas o desempenho das atribuições começa a convergir após 50 passos. Optional, Int 2. : Se usar a versão mais rápida do XRAI. xrai_fast se True, então o tempo de computação para explicações é mais rápido, mas leva a explicações menos precisas (atribuições) Optional, Bool |
n_steps = 50 xrai_fast = True |
integrated_gradients |
1. : Número de passos utilizados pelo método de aproximação. n_steps Um maior número de etapas leva a melhores atribuições (explicações). O intervalo de n_steps é [2, inf], mas o desempenho das atribuições começa a convergir após 50 passos.Optional, Int 2. : Método de aproximação da integral. approximation_method Os métodos de aproximação disponíveis são riemann_middle e gausslegendre.Optional, String |
n_steps = 50 approximation_method = riemann_middle |
Internamente, o algoritmo XRAI usa gradientes integrados. Assim, n_steps o parâmetro é exigido por gradientes integrados e algoritmos XRAI. Um número maior de etapas consome mais tempo para aproximar as explicações e pode resultar em problemas de tempo limite no endpoint online.
Recomendamos o uso de algoritmos XRAI Guided GradCAM Integrated Gradients Guided BackPropagation para melhores explicações, enquanto Guided BackPropagation > Guided GradCAM >> Integrated Gradients XRAI > são recomendados >> para explicações mais rápidas na ordem especificada.
Um exemplo de solicitação para o ponto de extremidade online se parece com o seguinte. Essa solicitação gera explicações quando model_explainability é definida como True. Seguir a solicitação gera visualizações e atribuições usando a 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 Repositório de notebook do GitHub para exemplos de aprendizado de máquina automatizado.
Interpretando visualizações
O ponto de extremidade implantado retorna a cadeia de caracteres de imagem codificada base64 se ambos model_explainability e visualizations estiverem definidos como True. Decodifice a cadeia de caracteres base64 conforme descrito em blocos de anotações 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 dentro de uma grade 2 x 2.
- Imagem no canto superior esquerdo (0, 0) é a imagem de entrada cortada
- Imagem no canto superior direito (0, 1) é o mapa de calor de atribuições em uma escala de cores bgyw (azul, verde, amarelo, branco), onde a contribuição de pixels brancos na classe prevista é a mais alta e pixels azuis é a menor.
- A imagem no canto inferior esquerdo (1, 0) é um mapa de calor combinado de atribuições na imagem de entrada cortada
- Imagem no canto inferior direito (1, 1) é a imagem de entrada cortada com 30% dos pixels com base nas pontuações de atribuição.
Interpretando atribuições
O ponto de extremidade implantado retorna atribuições se ambos model_explainability e attributions estiverem definidos como True. Para obter mais detalhes, consulte os cadernos de classificação multiclasse e de classificação multirótulo.
Essas atribuições dão mais controle aos usuários para gerar visualizações personalizadas ou examinar pontuações de atribuição de nível de pixel. O trecho 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 multiclasse e classificação multirótulo, consulte os documentos de esquema.
Use os valores exatos e do modelo selecionado para gerar as explicações (os valores valid_resize_size padrão são 256 e valid_crop_size 224, respectivamente). O código a seguir usa a funcionalidade de visualização do 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 AutoML para treinar em grandes conjuntos de dados, há algumas configurações experimentais que podem ser úteis.
Importante
Essas configurações estão atualmente em visualização pública. Eles são fornecidos sem um acordo 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.
Treinamento multi-GPU e multi-nó
Por padrão, cada modelo é treinado em uma única VM. Se o treinamento de um modelo estiver levando muito tempo, o uso de VMs que contenham várias GPUs pode ajudar. O tempo para treinar um modelo em grandes conjuntos de dados 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 multi-GPU, 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, certifique-se de usar uma SKU de computação que suporte InfiniBand para obter melhores resultados. Você pode configurar o número de VMs usadas para treinar um único modelo definindo a node_count_per_trial propriedade do trabalho AutoML.
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
properties:
node_count_per_trial: "2"
Streaming de arquivos de imagem do armazenamento
Por padrão, todos os arquivos de imagem são baixados para o 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 optar por 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 armazenamento.
Nota
Se o streaming estiver habilitado, verifique se a conta de armazenamento do Azure está localizada na mesma região que a computação para minimizar o custo e a latência.
APLICA-SE A:Extensão ml da CLI do Azure v2 (atual)
training_parameters:
advanced_settings: >
{"stream_image_files": true}
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. Verifique as pastas com o prefixo 'automl-image-' para amostras específicas para a construção de modelos de visão computacional.
Exemplos de código
Analise exemplos de código detalhados e casos de uso no repositório azureml-examples para obter exemplos de aprendizado de máquina automatizado.