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)

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.

  • accuracy para IMAGE_CLASSIFICATION
  • iou para IMAGE_CLASSIFICATION_MULTILABEL
  • mean_average_precision para IMAGE_OBJECT_DETECTION
  • mean_average_precision para 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:
  • O número de execuções simultâneas é fechado nos recursos disponíveis no destino de computação especificado. Certifique-se de que o destino de computação tem os recursos disponíveis para a simultaneidade pretendida.
  • 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 cadeia
    default_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.

    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.

    1. 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.
    2. 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 .

    Captura de ecrã a mostrar o aspeto da página Implementação depois de selecionar a opção Implementar..

    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.

    Captura de ecrã a mostrar o aspeto da parte superior da página de revisão depois de selecionar as opções a implementar. Captura de ecrã a mostrar o aspeto da parte inferior da página de revisão depois de selecionar as opções a implementar.

    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_size
    valid_crop_size
    256
    224
    Deteção de objetos min_size
    max_size
    box_score_thresh
    nms_iou_thresh
    box_detections_per_img
    600
    1333
    0.3
    0,5
    100
    Deteção de objetos com yolov5 img_size
    model_size
    box_score_thresh
    nms_iou_thresh
    640
    médio
    0.1
    0,5
    Segmentação de instâncias min_size
    max_size
    box_score_thresh
    nms_iou_thresh
    box_detections_per_img
    mask_pixel_score_threshold
    max_number_of_polygon_points
    export_as_image
    image_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:

    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. Captura de ecrã das visualizações geradas pelo XAI para AutoML para imagens.

    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.

    Passos seguintes