Configurar o AutoML para preparar modelos de imagem digitalizada
APLICA-SE A:
Extensão v2 da CLI do Azure (atual)SDK python azure-ai-ml v2 (atual)
Neste artigo, vai aprender a preparar modelos de imagem digitalizada em dados de imagem com ML automatizado com a extensão v2 da CLI do Azure Machine Learning ou o SDK Python v2 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 estão acessíveis a partir da IU estúdio do Azure Machine Learning. Saiba mais sobre o ml automatizado para tarefas de imagem digitalizada em dados de imagem.
Pré-requisitos
APLICA-SE A:Extensão v2 da CLI do Azure (atual)
- Uma área de trabalho do Azure Machine Learning. Para criar a área de trabalho, veja Criar recursos da área de trabalho.
- Instale e configure a CLI (v2) e certifique-se de que instala a
mlextensão.
Selecione o seu tipo de tarefa
O ML automatizado para imagens suporta os seguintes tipos de tarefas:
| Tipo de tarefa | Sintaxe da Tarefa de AutoML |
|---|---|
| classificação de imagens | CLI v2: image_classification SDK v2: image_classification() |
| etiquetas múltiplas de classificação de imagens | CLI v2: image_classification_multilabel SDK v2: image_classification_multilabel() |
| deteção de objetos 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 v2 da CLI do Azure (atual)
Este tipo de tarefa é um parâmetro obrigatório e pode ser definido com a task chave .
Por exemplo:
task: image_object_detection
Dados de preparação e validação
Para gerar modelos de imagem digitalizada, tem de trazer dados de imagem etiquetados como entrada para a preparação de modelos sob a forma de .MLTable Pode criar um a MLTable partir de dados de preparação no formato JSONL.
Se os seus dados de preparação estiverem num formato diferente (por exemplo, pascal VOC ou COCO), pode aplicar os scripts auxiliares incluídos nos blocos de notas de exemplo para converter os dados em JSONL. Saiba mais sobre como preparar dados para tarefas de imagem digitalizada com ML automatizado.
Nota
Os dados de preparação têm de ter, pelo menos, 10 imagens para poderem submeter uma execução de AutoML.
Aviso
A criação de a partir de MLTable dados no formato JSONL é suportada apenas com o SDK e a CLI, para esta capacidade. Neste momento, a criação da MLTable via IU não é suportada.
Exemplos de esquema JSONL
A estrutura do TabularDataset depende da tarefa em questão. Para tipos de tarefas de imagem digitalizada, 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 na altura, largura e formato. Este campo é opcional e, por conseguinte, pode ou não existir. |
label |
Uma representação json da etiqueta de imagem, com base no tipo de tarefa. |
Segue-se um ficheiro JSONL de exemplo para classificação de imagens:
{
"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 seguinte é um ficheiro 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
Assim que os seus dados estiverem no formato JSONL, pode criar preparação 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 preparação ou validação para tarefas de imagem digitalizada. O tamanho máximo do conjunto de dados só é limitado pela camada de armazenamento por trás do conjunto de dados (ou seja, o arquivo de blobs). Não existe um número mínimo de imagens ou etiquetas. No entanto, recomendamos que comece com um mínimo de 10 a 15 amostras por etiqueta para garantir que o modelo de saída está suficientemente preparado. Quanto maior for o número total de etiquetas/classes, mais exemplos precisa por etiqueta.
APLICA-SE A:Extensão v2 da CLI do Azure (atual)
Os dados de preparação são um parâmetro obrigatório e são transmitidos com a training_data chave . Opcionalmente, pode especificar outro MLtable como dados de validação com a validation_data chave. Se não forem especificados dados de validação, 20% dos dados de preparação serão utilizados para validação por predefinição, a menos que transmita validation_data_size um argumento com um valor diferente.
O nome da coluna de destino é um parâmetro obrigatório e é utilizado como destino para a tarefa de ML supervisionada. É transmitida com 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 o ML automatizado para realizar a preparação de modelos. Os modelos de ML automatizados para tarefas de imagem digitalizada requerem SKUs de GPU e suportam famílias de NC e ND. Recomendamos a série NCsv3 (com GPUs v100) para uma preparação mais rápida. Um destino de computação com um SKU de VM multi-GPU tira partido de várias GPUs para também acelerar a preparação. Além disso, quando configura um destino de computação com vários nós, pode realizar uma preparação de modelos mais rápida através do paralelismo ao otimizar os hiperparâmetros para o seu modelo.
Nota
Se estiver a utilizar uma instância de computação como destino de computação, certifique-se de que várias tarefas de AutoML não são executadas ao mesmo tempo. Além disso, certifique-se de que max_concurrent_trials está definido como 1 nos seus limites de tarefas.
O destino de computação é transmitido com o compute parâmetro . Por exemplo:
APLICA-SE A:Extensão v2 da CLI do Azure (atual)
compute: azureml:gpu-cluster
Configurar experimentações
Para tarefas de imagem digitalizada, pode iniciar execuções individuais, varrimentos manuais ou varrimentos automáticos. Recomendamos que comece com uma limpeza automática para obter um primeiro modelo de linha de base. Em seguida, pode experimentar execuções individuais com determinados modelos e configurações de hiperparâmetros. Por fim, com varrimentos manuais, pode explorar múltiplos valores de hiperparâmetros perto dos modelos mais promissores e das configurações de hiperparâmetros. Este fluxo de trabalho de três passos (varrimento automático, execuções individuais, varrimentos manuais) evita procurar na totalidade do espaço de hiperparâmetros, que cresce exponencialmente no número de hiperparâmetros.
As análises automáticas podem produzir resultados competitivos para muitos conjuntos de dados. Além disso, não necessitam de conhecimentos avançados sobre arquiteturas de modelos, têm em conta as correlações de hiperparâmetros e funcionam perfeitamente em diferentes configurações de hardware. Todas estas razões tornam-nas uma opção forte para a fase inicial do seu processo de experimentação.
Métrica primária
Uma tarefa de preparação de AutoML utiliza uma métrica primária para otimização de modelos e otimização de hiperparâmetros. A métrica primária depende do tipo de tarefa, conforme mostrado abaixo; outros valores de métricas primárias não são atualmente suportados.
accuracypara IMAGE_CLASSIFICATIONioupara IMAGE_CLASSIFICATION_MULTILABELmean_average_precisionpara IMAGE_OBJECT_DETECTIONmean_average_precisionpara IMAGE_INSTANCE_SEGMENTATION
Limites dos trabalhos
Pode controlar os recursos gastos na tarefa de preparação imagem autoML ao especificar o timeout_minutese max_trials o max_concurrent_trials para a tarefa nas definições de limite, conforme descrito no exemplo abaixo.
| Parâmetro | Detalhes |
|---|---|
max_trials |
Parâmetro para o número máximo de configurações a varrer. Tem de ser um número inteiro entre 1 e 1000. Ao explorar apenas os hiperparâmetros predefinidos para um determinado algoritmo de modelo, defina este parâmetro como 1. O valor predefinido é 1. |
max_concurrent_trials |
Número máximo de execuções que podem ser executadas simultaneamente. Se especificado, tem de ser um número inteiro entre 1 e 100. O valor predefinido é 1. NOTA: max_concurrent_trials está limitado max_trials a internamente. Por exemplo, se o utilizador definir max_concurrent_trials=4, max_trials=2, os valores serão atualizados internamente como max_concurrent_trials=2, max_trials=2. |
timeout_minutes |
A quantidade de tempo em minutos antes de a experimentação terminar. Se nenhuma especificada, a experimentação predefinida timeout_minutes é de sete dias (máximo de 60 dias) |
APLICA-SE A:Extensão v2 da CLI do Azure (atual)
limits:
timeout_minutes: 60
max_trials: 10
max_concurrent_trials: 2
Hiperparâmetros de modelos de varrimento automático (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.
Geralmente, é 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 atribuído aos hiperparâmetros de otimização pode ser limitado. Para tarefas de imagem digitalizada, pode especificar uma série de execuções e o sistema irá determinar automaticamente a região do espaço de hiperparâmetros a varrer. Não tem de definir um espaço de pesquisa de hiperparâmetros, um método de amostragem ou uma política de terminação antecipada.
Acionar o Modelo Automático
Pode executar varrimentos automáticos ao definir max_trials um valor superior a 1 no limits e ao não especificar o espaço de pesquisa, o método de amostragem e a política de terminação. Chamamos a esta funcionalidade Modo Automático; veja um exemplo abaixo.
APLICA-SE A:Extensão v2 da CLI do Azure (atual)
limits:
max_trials: 10
max_concurrent_trials: 2
Um número de execuções entre 10 e 20 provavelmente funcionará bem em muitos conjuntos de dados. O orçamento de tempo para a tarefa de AutoML ainda pode ser definido, mas recomendamos que o faça apenas se cada avaliação demorar muito tempo.
Aviso
Neste momento, o lançamento de varrimentos automáticos através da IU não é suportado.
Execuções individuais
Em execuções individuais, controla diretamente o algoritmo de modelo e os hiperparâmetros. O algoritmo de modelo é transmitido através do model_name parâmetro .
Algoritmos de modelo suportados
A tabela seguinte resume os modelos suportados para cada tarefa de imagem digitalizada.
| Tarefa | Algoritmos de modelo | Sintaxe literal de cadeiadefault_model* denotado com * |
|---|---|---|
| Classificação de imagens (várias classes e várias etiquetas) |
MobileNet: Modelos leves para aplicações móveis ResNet: Redes residuais ResNeSt: Redes de atenção divididas SE-ResNeXt50: Redes de aperto e excitação ViT: Redes do transformador 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 objetos de uma fase FPN RCNN ResNet mais rápida: Modelos de deteção de objetos de duas fases RetinaNet ResNet FPN: resolver o desequilíbrio da classe com a Perda Focal Nota: veja model_size hiperparâmetros 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 |
Além de controlar o algoritmo de modelo, também pode otimizar os hiperparâmetros utilizados para a preparação de modelos. Embora muitos dos hiperparâmetros expostos sejam model-agnósticos, existem instâncias em que os hiperparâmetros são específicos de tarefas ou específicos do modelo. Saiba mais sobre os hiperparâmetros disponíveis para estas instâncias.
APLICA-SE A:Extensão v2 da CLI do Azure (atual)
Se quiser utilizar os valores de hiperparâmetros predefinidos para um determinado algoritmo (por exemplo, yolov5), pode especificá-lo com a chave de model_name na secção training_parameters. Por exemplo,
training_parameters:
model_name: yolov5
Hiperparâmetros de modelos de limpeza manual
Ao preparar modelos de imagem digitalizada, o desempenho do modelo depende muito dos valores de hiperparâmetros selecionados. Muitas vezes, poderá querer otimizar os hiperparâmetros para obter um desempenho ideal. Para tarefas de imagem digitalizada, pode varrer hiperparâmetros para encontrar as definições ideais para o seu modelo. Esta funcionalidade aplica as capacidades de otimização de hiperparâmetros no Azure Machine Learning. Saiba como otimizar hiperparâmetros.
APLICA-SE A:Extensão v2 da CLI do Azure (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
Pode definir os algoritmos de modelo e os hiperparâmetros para varrer o espaço de parâmetros. Pode especificar um único algoritmo de modelo ou vários.
- Veja Execuções individuais para obter a lista de algoritmos de modelo suportados para cada tipo de tarefa.
- Veja Hiperparâmetros para hiperparâmetros de tarefas de imagem digitalizada para cada tipo de tarefa de imagem digitalizada.
- Veja detalhes sobre as distribuições suportadas para hiperparâmetros discretos e contínuos.
Métodos de amostragem para a limpeza
Ao varrer hiperparâmetros, tem de especificar o método de amostragem a utilizar 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 da Tarefa autoML |
|---|---|
| Amostragem Aleatória | random |
| Amostragem de Grelha | grid |
| Amostragem bayesiana | bayesian |
Nota
Atualmente, apenas a amostragem aleatória e de grelha suporta espaços de hiperparâmetros condicionais.
Políticas de cessação antecipada
Pode terminar automaticamente as execuções com um mau desempenho com uma política de cessação antecipada. A terminação antecipada melhora a eficiência computacional, poupando 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 terminação antecipada com o early_termination parâmetro . Se não for especificada nenhuma política de terminação, todas as configurações serão executadas até à conclusão.
| Política de cessação antecipada | Sintaxe da Tarefa autoML |
|---|---|
| Política de bandidos | CLI v2: bandit SDK v2: BanditPolicy() |
| Política de paragem mediana | CLI v2: median_stopping SDK v2: MedianStoppingPolicy() |
| Política de seleção de truncagem | CLI v2: truncation_selection SDK v2: TruncationSelectionPolicy() |
Saiba mais sobre como configurar a política de terminação antecipada para a limpeza de hiperparâmetros.
Nota
Para obter um exemplo completo de configuração de varrimento, veja este tutorial.
Pode configurar todos os parâmetros relacionados com o varrimento, conforme mostrado no exemplo abaixo.
APLICA-SE A:Extensão v2 da CLI do Azure (atual)
sweep:
sampling_algorithm: random
early_termination:
type: bandit
evaluation_interval: 2
slack_factor: 0.2
delay_evaluation: 6
Definições corrigidas
Pode transmitir definições fixas ou parâmetros que não são alterados durante a limpeza do espaço de parâmetros, conforme mostrado abaixo.
APLICA-SE A:Extensão v2 da CLI do Azure (atual)
training_parameters:
early_stopping: True
evaluation_frequency: 1
Aumento de dados
Em geral, o desempenho do modelo de aprendizagem profunda pode muitas vezes melhorar com mais dados. O aumento de dados é uma técnica prática para amplificar o tamanho e a variabilidade dos dados 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 diferentes técnicas de aumento de dados com base na tarefa de imagem digitalizada, antes de fornecer imagens de entrada ao modelo. Atualmente, não existe nenhum hiperparâmetr exposto para controlar aumentos de dados.
| Tarefa | Conjunto de dados afetado | Técnicas de aumento de dados aplicadas |
|---|---|---|
| Classificação de imagens (várias classes e várias etiquetas) | Formação Teste de Validação & |
Redimensionamento e recorte aleatórios, inverter horizontalmente, nervosismo de cores (luminosidade, contraste, saturação e matiz), normalização com a média e o desvio padrão da ImageNet em termos de canal Redimensionar, recortar centralmente, normalização |
| Deteção de objetos, segmentação de instâncias | Formação Teste de Validação & |
Recorte aleatório em torno de caixas delimitadoras, expandir, inverter horizontalmente, normalização, redimensionar Normalização, redimensionamento |
| Deteção de objetos com yolov5 | Formação Teste de Validação & |
Mosaico, afinação aleatória (rotação, tradução, escala, tesoura), inverter horizontalmente Redimensionamento da caixa de correio |
Atualmente, os aumentos definidos acima são aplicados por predefinição a um ML Automatizado para tarefa de imagem. Para fornecer controlo sobre aumentos, o ML Automatizado para imagens expõe abaixo dois sinalizadores para desativar determinados aumentos. Atualmente, estes sinalizadores só são suportados para tarefas de deteção de objetos e segmentação de instâncias.
- apply_mosaic_for_yolo: Este sinalizador é apenas específico do modelo Yolo. Defini-lo como Falso desativa o aumento de dados em mosaico que é aplicado no momento da preparação.
- apply_automl_train_augmentations: Definir este sinalizador como falso desativa o aumento aplicado durante o tempo de preparação para os modelos de segmentação de instâncias e de deteção de objetos. Para obter aumentos, veja os detalhes na tabela acima.
- Para modelos de deteção de objetos não yolo e modelos de segmentação de instâncias, este sinalizador desativa apenas os três primeiros aumentos, ou seja, Recortar aleatoriamente em torno de caixas delimitadoras, expandir, inverter horizontalmente. A normalização e o redimensionamento dos aumentos continuam a ser aplicados independentemente deste sinalizador.
- Para o modelo Yolo, este sinalizador desativa os aumentos aleatórios de affine e inversão horizontal.
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 v2 da CLI do Azure (atual)
training_parameters:
advanced_settings: >
{"apply_mosaic_for_yolo": false}
training_parameters:
advanced_settings: >
{"apply_automl_train_augmentations": false}
Tenha em atenção que estes dois sinalizadores são independentes uns dos outros e também podem ser utilizados em combinação com as seguintes definições.
training_parameters:
advanced_settings: >
{"apply_automl_train_augmentations": false, "apply_mosaic_for_yolo": false}
Nas nossas experiências, descobrimos que estes aumentos ajudam o modelo a generalizar melhor. Por conseguinte, quando estes aumentos forem desativados, recomendamos que os utilizadores os combinem com outros aumentos offline para obter melhores resultados.
Formação incremental (opcional)
Assim que a execução de preparação estiver concluída, terá a opção de preparar ainda mais o modelo ao carregar o ponto de verificação do modelo preparado. Pode utilizar o mesmo conjunto de dados ou outro para preparação incremental.
Passar o ponto de verificação através do ID de execução
Pode transmitir o ID de execução a partir do qual pretende carregar o ponto de verificação.
APLICA-SE A:Extensão v2 da CLI do Azure (atual)
training_parameters:
checkpoint_run_id : "target_checkpoint_run_id"
Submeter a tarefa de AutoML
APLICA-SE A:Extensão v2 da CLI do Azure (atual)
Para submeter a tarefa autoML, execute o seguinte comando da CLI v2 com o caminho para o ficheiro .yml, o nome da área de trabalho, o grupo de recursos e o ID da subscrição.
az ml job create --file ./hello-automl-job-basic.yml --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]
Saídas e métricas de avaliação
As execuções de preparação de ML automatizadas geram ficheiros de modelo de saída, métricas de avaliação, registos e artefactos de implementação, como o ficheiro de classificação e o ficheiro de ambiente que podem ser visualizados a partir dos resultados, registos e separadores de métricas das execuções subordinadas.
Dica
Verifique como navegar para os resultados da execução a partir da secção Ver resultados da execução .
Para obter definições e exemplos dos gráficos de desempenho e métricas fornecidos para cada execução, veja Avaliar os resultados da experimentação de machine learning automatizado.
Registar e implementar o modelo
Assim que a execução for concluída, pode registar o modelo que foi criado a partir da melhor execução (configuração que resultou na melhor métrica primária). Pode registar o modelo após a transferência ou ao especificar o caminho azureml com o jobid correspondente. Nota: se quiser alterar as definições de inferência descritas abaixo, tem de transferir o modelo e alterar settings.json e registar-se com a pasta de modelo atualizada.
Obter a melhor execução
APLICA-SE A:Extensão v2 da CLI do Azure (atual)
CLI example not available, please use Python SDK.
registar o modelo
Registe o modelo com o caminho azureml ou o caminho transferido localmente.
APLICA-SE A:Extensão v2 da CLI do Azure (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 registar o modelo que pretende utilizar, pode implementá-lo com o ponto final online gerido deploy-managed-online-endpoint
Configurar o ponto final online
APLICA-SE A:Extensão v2 da CLI do Azure (atual)
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: od-fridge-items-endpoint
auth_mode: key
Criar o ponto final
Com o MLClient criado anteriormente, vamos agora criar o Ponto Final na área de trabalho. Este comando iniciará a criação do ponto final e devolverá uma resposta de confirmação enquanto a criação do ponto final continuar.
APLICA-SE A:Extensão v2 da CLI do Azure (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 implementação é um conjunto de recursos necessários para alojar o modelo que faz a inferência real. Vamos criar uma implementação para o nosso ponto final com a ManagedOnlineDeployment classe. Pode utilizar SKUs de VM de GPU ou CPU para o cluster de implementação.
APLICA-SE A:Extensão v2 da CLI do Azure (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 implementação
Com o MLClient criado anteriormente, vamos agora criar a implementação na área de trabalho. Este comando iniciará a criação da implementação e devolverá uma resposta de confirmação enquanto a criação da implementação continuar.
APLICA-SE A:Extensão v2 da CLI do Azure (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 o tráfego:
Por predefinição, a implementação atual está definida para receber 0% de tráfego. pode definir a percentagem de tráfego que a implementação atual deve receber. A soma das percentagens de tráfego de todas as implementações com um ponto final não deve exceder os 100%.
APLICA-SE A:Extensão v2 da CLI do Azure (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]
Em alternativa, pode implementar o modelo a partir da IU do estúdio do Azure Machine Learning. Navegue para o modelo que pretende implementar no separador Modelos da execução automatizada do ML e selecione Implementar e selecione Implementar no ponto final em tempo real .
.
este é o aspeto da sua página de revisão. podemos selecionar o tipo de instância, a contagem de instâncias e definir a percentagem de tráfego para a implementação atual.
Atualizar definições de inferência
No passo anterior, transferimos um ficheiro mlflow-model/artifacts/settings.json do melhor modelo. que podem ser utilizadas para atualizar as definições de inferência antes de registar o modelo. Embora seja recomendado utilizar os mesmos parâmetros que a preparação para um melhor desempenho.
Cada uma das tarefas (e alguns modelos) tem um conjunto de parâmetros. Por predefinição, utilizamos os mesmos valores para os parâmetros que foram utilizados durante a preparação e validação. Dependendo do comportamento de que precisamos ao utilizar o modelo para inferência, podemos alterar estes parâmetros. Abaixo, pode encontrar uma lista de parâmetros para cada tipo de tarefa e modelo.
| Tarefa | Nome do parâmetro | Predefinição |
|---|---|---|
| Classificação de imagens (várias classes e várias etiquetas) | 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 com 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 Falso JPG |
Para obter uma descrição detalhada sobre hiperparâmetros específicos de tarefas, consulte Hiperparâmetros para tarefas de imagem digitalizada em machine learning automatizado.
Se quiser utilizar o til e quiser controlar o comportamento do til, estão disponíveis os seguintes parâmetros: tile_grid_sizee tile_overlap_ratiotile_predictions_nms_thresh. Para obter mais detalhes sobre estes parâmetros, veja Preparar um pequeno modelo de deteção de objetos com o AutoML.
Testar a implementação
Verifique esta secção Testar a implementação para testar a implementação e visualizar as deteções do modelo.
Gerar explicações para predições
Importante
Estas definições estão atualmente em pré-visualização pública. São fornecidos 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.
Aviso
A Explicação do Modelo é suportada apenas para classificação de várias classes e classificação de várias etiquetas.
Algumas das vantagens da utilização de IA Explicável (XAI) com AutoML para imagens:
- Melhora a transparência nas predições de modelos de visão complexas
- Ajuda os utilizadores a compreender as funcionalidades/píxeis importantes na imagem de entrada que estão a contribuir para as predições do modelo
- Ajuda na resolução de problemas dos modelos
- Ajuda a descobrir o preconceito
Explicações
As explicações são atribuições de funcionalidades ou pesos atribuídos a cada píxel na imagem de entrada com base na sua contribuição para a predição do modelo. Cada peso pode ser negativo (correlacionado negativamente com a predição) ou positivo (positivamente correlacionado com a predição). Estas atribuições são calculadas com base na classe prevista. Para a classificação de várias classes, será gerada exatamente uma matriz de atribuição de tamanho [3, valid_crop_size, valid_crop_size] por amostra, ao passo que, para a classificação de várias etiquetas, será gerada a matriz de atribuição de tamanho [3, valid_crop_size, valid_crop_size] para cada etiqueta/classe prevista para cada exemplo.
Com a IA Explicável no AutoML para Imagens no ponto final implementado, os utilizadores podem obter visualizações de explicações (atribuições sobrepostas numa 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 utilizadores também podem obter matrizes de atribuição para obter mais controlo sobre as explicações (como gerar visualizações personalizadas com atribuições ou escrutinar segmentos de atribuições). Todos os algoritmos de explicação utilizarão imagens quadradas recortadas com tamanho valid_crop_size para gerar atribuições.
As explicações podem ser geradas a partir do ponto final online ou do ponto final do lote. Assim que a implementação estiver concluída, este ponto final pode ser utilizado para gerar as explicações das predições. Em caso de implementação online, confirme que transmite request_settings = OnlineRequestSettings(request_timeout_ms=90000) o parâmetro para ManagedOnlineDeployment e define request_timeout_ms o valor máximo para evitar problemas de tempo limite ao gerar explicações (veja a secção registar e implementar modelo). Alguns dos métodos de explicação (XAI), como xrai consumir mais tempo (especialmente para classificação de várias etiquetas, pois precisamos de gerar atribuições e/ou visualizações em relação a cada etiqueta prevista). Assim, recomendamos 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, veja os documentos de esquema.
Suportamos os seguintes algoritmos de explicação de última geração no AutoML para imagens:
- XRAI (xrai)
- Gradações Integradas (integrated_gradients)
- GradCAM Guiado (guided_gradcam)
- Cópia de Segurança Guiada (guided_backprop)
A tabela seguinte descreve os parâmetros de otimização específicos do algoritmo de explicação para Gradações XRAI e Integradas. 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_steps: o número de passos utilizados pelo método de aproximação. 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. xrai_fast: Se pretende utilizar uma versão mais rápida do XRAI. 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_steps: o número de passos utilizados pelo método de aproximação. Um maior número de passos leva a atribuições melhores (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. approximation_method: Método para a aproximação do integral. 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 utiliza gradações integradas. Assim, n_steps o parâmetro é necessário para gradações integradas e algoritmos XRAI. Um maior número de passos consome mais tempo para aproximar as explicações e pode resultar em problemas de tempo limite no ponto final online.
Recomendamos a utilização de gradações de gradação orientada xRAI > gradação > de gradação orientada de gradação de gradação orientada xRAI algoritmos > de backpropagation orientados para obter explicações >>> mais rápidas na ordem especificada.
Um pedido de exemplo para o ponto final online tem o seguinte aspeto. Este pedido gera explicações quando model_explainability está definido como True. O pedido seguinte irá gerar visualizações e atribuições com uma versão mais rápida do algoritmo XRAI com 50 passos.
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, veja Repositório de blocos de notas do GitHub para exemplos de machine learning automatizado.
Interpretar Visualizações
O ponto final implementado devolve a cadeia de imagem codificada base64 se ambas model_explainabilityvisualizations e estiverem definidas como True. Descodifice a cadeia base64 conforme descrito nos blocos de notas ou utilize o seguinte código para descodificar e visualizar as cadeias de imagem base64 na prediçã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 seguinte descreve a Visualização de explicações para uma imagem de entrada de exemplo.
A figura base64 descodificada terá quatro secções de imagem numa grelha de 2 x 2.
- Imagem no Canto superior esquerdo (0, 0) é a imagem de entrada recortada
- Imagem no canto superior direito (0, 1) é o mapa térmico de atribuições numa escala de cores bgyw (azul verde-amarelo branco) onde a contribuição de píxeis brancos na classe prevista é a mais alta e os pixéis azuis são os mais baixos.
- A imagem no canto inferior esquerdo (1, 0) é misturada mapa térmico de atribuições na imagem de entrada recortada
- Imagem no canto inferior direito (1, 1) é a imagem de entrada recortada com os 30 por cento superiores dos píxeis com base nas classificações de atribuição.
Interpretar Atribuições
O ponto final implementado devolve atribuições se e model_explainabilityattributions estiverem definidos como True. Para obter mais detalhes, veja blocos de notas de classificação de várias classes e de classificação de várias etiquetas.
Estas atribuições dão mais controlo aos utilizadores para gerarem visualizações personalizadas ou para escrutinarem as classificações de atribuição ao nível dos píxeis. O fragmento de código seguinte descreve uma forma de gerar visualizações personalizadas com 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árias etiquetas, veja os documentos de esquema.
Utilize os valores exatos valid_resize_size e valid_crop_size do modelo selecionado para gerar as explicações (os valores predefinidos são 256 e 224, respetivamente). O código seguinte utiliza a funcionalidade de visualização captum para gerar visualizações personalizadas. Os utilizadores podem utilizar qualquer outra biblioteca para gerar visualizações. Para obter mais detalhes, veja 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))
Conjuntos de dados de grandes dimensões
Se estiver a utilizar o AutoML para preparar conjuntos de dados grandes, existem algumas definições experimentais que podem ser úteis.
Importante
Estas definições estão atualmente em pré-visualização pública. São fornecidos 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.
Preparação com vários GPUs e vários nós
Por predefinição, cada modelo treina numa única VM. Se a preparação de um modelo estiver a demorar demasiado tempo, a utilização de VMs que contenham várias GPUs poderá ajudar. O tempo para preparar um modelo em conjuntos de dados grandes deve diminuir em proporção aproximadamente linear ao número de GPUs utilizadas. (Por exemplo, um modelo deve preparar aproximadamente duas vezes mais rápido numa VM com duas GPUs como numa VM com uma GPU.) Se o tempo para preparar um modelo ainda for elevado numa VM com várias GPUs, pode aumentar o número de VMs utilizadas para preparar cada modelo. À semelhança da preparação de várias GPUs, o tempo de preparação de um modelo em conjuntos de dados grandes também deve diminuir em proporção aproximadamente linear ao número de VMs utilizadas. Ao preparar um modelo em várias VMs, certifique-se de que utiliza um SKU de computação que suporte o InfiniBand para obter os melhores resultados. Pode configurar o número de VMs utilizadas para preparar um único modelo ao definir a node_count_per_trial propriedade da tarefa autoML.
APLICA-SE A:Extensão v2 da CLI do Azure (atual)
properties:
node_count_per_trial: "2"
Transmitir ficheiros de imagem a partir do armazenamento
Por predefinição, todos os ficheiros de imagem são transferidos para o disco antes da preparação do modelo. Se o tamanho dos ficheiros de imagem for superior ao espaço disponível em disco, a execução falhará. Em vez de transferir todas as imagens para o disco, pode selecionar para transmitir ficheiros de imagem a partir do armazenamento do Azure, conforme necessário durante a preparação. Os ficheiros de imagem são transmitidos diretamente do armazenamento do Azure para a memória do sistema, ignorando o disco. Ao mesmo tempo, o maior número possível de ficheiros do armazenamento são colocados em cache no disco para minimizar o número de pedidos ao armazenamento.
Nota
Se a transmissão em fluxo estiver ativada, certifique-se de que 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 v2 da CLI do Azure (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 obter amostras específicas para criar modelos de imagem digitalizada.
Exemplos de código
Veja exemplos de código detalhados e casos de utilização no repositório azureml-examples para exemplos automatizados de machine learning.