Configurar o AutoML para preparar modelos de imagem digitalizada com Python (v1)

Artigo
06/02/2023

Importante

Os comandos da CLI do Azure neste artigo requerem a extensão , ou v1, para o azure-cli-mlAzure Machine Learning. O suporte para a extensão v1 terminará a 30 de setembro de 2025. Poderá instalar e utilizar a extensão v1 até essa data.

Recomendamos que faça a transição para a mlextensão , ou v2, antes de 30 de setembro de 2025. Para obter mais informações sobre a extensão v2, veja Extensão da CLI do Azure ML e SDK Python v2.

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.

Neste artigo, vai aprender a preparar modelos de imagem digitalizada em dados de imagem com ML automatizado no SDK Python do Azure Machine Learning.

O ML Automatizado suporta a preparação de modelos para tarefas de imagens digitalizadas, como a classificação de imagens, a deteção de objetos e a segmentação de instâncias. A criação de modelos do AutoML para tarefas de imagens digitalizadas é atualmente suportada através do SDK do Python do Azure Machine Learning. As execuções, modelos e saídas de experimentação resultantes 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.

Nota

O ML automatizado para tarefas de imagem digitalizada só está disponível através do SDK Python do Azure Machine Learning.

Pré-requisitos

Uma área de trabalho do Azure Machine Learning. Para criar a área de trabalho, veja Criar recursos da área de trabalho.
O SDK Python do Azure Machine Learning instalado. Para instalar o SDK, pode,
- Crie uma instância de computação, que instala automaticamente o SDK e está pré-configurada para fluxos de trabalho de ML. Para obter mais informações, veja Criar e gerir uma instância de computação do Azure Machine Learning.
- Instale o automl pacote, que inclui a instalação predefinida do SDK.
Nota

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

Selecionar o tipo de tarefa

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

Tipo de tarefa	Sintaxe da configuração autoMLImage
classificação de imagens	`ImageTask.IMAGE_CLASSIFICATION`
classificação de imagens com várias etiquetas	`ImageTask.IMAGE_CLASSIFICATION_MULTILABEL`
deteção de objetos de imagem	`ImageTask.IMAGE_OBJECT_DETECTION`
segmentação de instâncias de imagem	`ImageTask.IMAGE_INSTANCE_SEGMENTATION`

Este tipo de tarefa é um parâmetro obrigatório e é transmitido com o task parâmetro no AutoMLImageConfig.

Por exemplo:

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

Dados de 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 na forma de um TabularDataset do Azure Machine Learning. Pode utilizar um TabularDataset que exportou a partir de um projeto de etiquetagem de dados ou criar um novo TabularDataset com os seus dados de preparação etiquetados.

Se os seus dados de preparação estiverem num formato diferente (como 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.

Aviso

A criação de TabularDatasets a partir de dados no formato JSONL é suportada apenas com o SDK, para esta capacidade. Neste momento, a criação do conjunto de dados através da IU não é suportada. A partir de agora, a IU não reconhece o tipo de dados StreamInfo, que é o tipo de dados utilizado para URLs de imagem no formato JSONL.

Nota

O conjunto de dados de preparação tem de ter, pelo menos, 10 imagens para poder submeter uma execução de AutoML.

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 o caminho de ficheiro como um objeto StreamInfo
`image_details`	As informações de metadados de imagem consistem em 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": "AmlDatastore://image_data/Image_01.png",
      "image_details":
      {
          "format": "png",
          "width": "2230px",
          "height": "4356px"
      },
      "label": "cat"
  }
  {
      "image_url": "AmlDatastore://image_data/Image_02.jpeg",
      "image_details":
      {
          "format": "jpeg",
          "width": "3456px",
          "height": "3467px"
      },
      "label": "dog"
  }

O código seguinte é um ficheiro JSONL de exemplo para deteção de objetos:

{
    "image_url": "AmlDatastore://image_data/Image_01.png",
    "image_details":
    {
        "format": "png",
        "width": "2230px",
        "height": "4356px"
    },
    "label":
    {
        "label": "cat",
        "topX": "1",
        "topY": "0",
        "bottomX": "0",
        "bottomY": "1",
        "isCrowd": "true",
    }
}
{
    "image_url": "AmlDatastore://image_data/Image_02.png",
    "image_details":
    {
        "format": "jpeg",
        "width": "1230px",
        "height": "2356px"
    },
    "label":
    {
        "label": "dog",
        "topX": "0",
        "topY": "1",
        "bottomX": "0",
        "bottomY": "1",
        "isCrowd": "false",
    }
}

Consumir dados

Assim que os seus dados estiverem no formato JSONL, pode criar um TabularDataset com o seguinte código:

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

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

O ML Automatizado não impõe restrições ao tamanho dos dados de 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 amostras precisa por etiqueta.

Os dados de preparação são necessários e são transmitidos com o training_data parâmetro . Opcionalmente, pode especificar outro TabularDataset como um conjunto de dados de validação a ser utilizado para o modelo com o validation_data parâmetro AutoMLImageConfig. Se não for especificado nenhum conjunto de dados de validação, 20% dos dados de preparação serão utilizados para validação por predefinição, a menos que transmita validation_size um argumento com um valor diferente.

Por exemplo:

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

Computação para executar a experimentação

Forneça um destino de computação para 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 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, ao configurar um destino de computação com múltiplos 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_iterations está definido como 1 nos recursos de experimentação.

O destino de computação é um parâmetro necessário e é transmitido com o compute_target parâmetro do AutoMLImageConfig. Por exemplo:

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

Configurar algoritmos de modelo e hiperparâmetros

Com o suporte para tarefas de imagem digitalizada, pode controlar o algoritmo de modelo e varrer hiperparâmetros. Estes algoritmos de modelo e hiperparâmetros são transmitidos como o espaço de parâmetros para o varrimento.

O algoritmo de modelo é necessário e é transmitido através do model_name parâmetro. Pode especificar um único model_name ou escolher entre múltiplos.

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` `maskrcnn_resnet50_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.

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

Configurar as definições de experimentação

Antes de fazer uma grande pesquisa para procurar os modelos e hiperparâmetros ideais, recomendamos que experimente os valores predefinidos para obter uma primeira linha de base. Em seguida, pode explorar vários hiperparâmetros para o mesmo modelo antes de varrer vários modelos e os respetivos parâmetros. Desta forma, pode utilizar uma abordagem mais iterativa, uma vez que, com vários modelos e múltiplos hiperparâmetros para cada um, o espaço de pesquisa cresce exponencialmente e precisa de mais iterações para encontrar configurações ideais.

Se quiser utilizar os valores de hiperparâmetros predefinidos para um determinado algoritmo (por exemplo, yolov5), pode especificar a configuração para as execuções da Imagem AutoML da seguinte forma:

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

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

Depois de criar um modelo de linha de base, poderá querer otimizar o desempenho do modelo para varrer o algoritmo do modelo e o espaço do hiperparâmetros. Pode utilizar a seguinte configuração de exemplo para varrer os hiperparâmetros para cada algoritmo, escolhendo entre um intervalo de valores para learning_rate, otimizador, lr_scheduler, etc., para gerar um modelo com a métrica primária ideal. Se os valores de hiperparâmetros não forem especificados, os valores predefinidos são utilizados para o algoritmo especificado.

Métrica primária

A métrica primária utilizada para otimização de modelos e otimização de hiperparâmetros depende do tipo de tarefa. A utilização de outros valores de métricas primárias não é atualmente suportada.

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

Orçamento da experimentação

Opcionalmente, pode especificar o orçamento de tempo máximo para a sua experimentação experiment_timeout_hours de Visão AutoML com a quantidade de tempo em horas antes de a experimentação terminar. Se nenhum especificado, o tempo limite da experimentação predefinido é de sete dias (máximo de 60 dias).

Varrer hiperparâmetros para o seu modelo

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. Com o suporte para tarefas de imagem digitalizada no ML automatizado, 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.

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.

Veja Configurar algoritmos de modelo e hiperparâmetros 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 hyperparameter_sampling parâmetro:

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_policy parâmetro . Se não for especificada nenhuma política de terminação, todas as configurações serão executadas até à conclusão.

Saiba mais sobre como configurar a política de terminação antecipada para a limpeza de hiperparâmetros.

Recursos para a limpeza

Pode controlar os recursos gastos na limpeza de hiperparâmetros ao especificar o iterations e o max_concurrent_iterations para o varrimento.

Parâmetro Detalhes

iterations Parâmetro necessário 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.

max_concurrent_iterations Número máximo de execuções que podem ser executadas simultaneamente. Se não for especificado, todas as execuções são iniciadas em paralelo. Se especificado, tem de ser um número inteiro entre 1 e 100.

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.

Parâmetro	Detalhes
`iterations`	Parâmetro necessário 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.
`max_concurrent_iterations`	Número máximo de execuções que podem ser executadas simultaneamente. Se não for especificado, todas as execuções são iniciadas em paralelo. Se especificado, tem de ser um número inteiro entre 1 e 100. 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.

Nota

Para obter um exemplo completo de configuração de varrimento, veja este tutorial.

Argumentos

Pode transmitir definições ou parâmetros fixos que não são alterados durante o varrimento do espaço de parâmetros como argumentos. Os argumentos são transmitidos em pares nome-valor e o nome tem de ser prefixado por um travessão duplo.

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

Preparação incremental (opcional)

Assim que a execução de preparação estiver concluída, tem 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 um conjunto de dados diferente para a preparação incremental.

Existem duas opções disponíveis para preparação incremental. Pode,

Transmita o ID de execução a partir do qual pretende carregar o ponto de verificação.
Passe os pontos de verificação através de um FileDataset.

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

Para localizar o ID de execução do modelo pretendido, pode utilizar o seguinte código.

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

Para passar um ponto de verificação através do ID de execução, tem de utilizar o checkpoint_run_id parâmetro .

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

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

Passar o ponto de verificação através de FileDataset

Para passar um ponto de verificação através de um FileDataset, tem de utilizar os checkpoint_dataset_id parâmetros e checkpoint_filename .

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

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

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

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

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

Submeter a execução

Quando tiver o objeto AutoMLImageConfig pronto, pode submeter a experimentação.

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

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 do separador saídas e registos e métricas das execuções subordinadas.

Dica

Verifique como navegar para os resultados da tarefa na 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

Depois de concluída a execução, pode registar o modelo que foi criado a partir da melhor execução (configuração que resultou na melhor métrica primária)

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

Depois de registar o modelo que pretende utilizar, pode implementá-lo como um serviço Web no Azure Container Instances (ACI) ou Azure Kubernetes Service (AKS). O ACI é a opção perfeita para testar implementações, enquanto o AKS é mais adequado para uma utilização de produção de grande escala.

Este exemplo implementa o modelo como um serviço Web no AKS. Para implementar no AKS, crie primeiro um cluster de cálculo do AKS ou utilize um cluster do AKS existente. Pode utilizar SKUs de VM de GPU ou CPU para o cluster de implementação.


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

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

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

Em seguida, pode definir a configuração de inferência, que descreve como configurar o serviço Web que contém o seu modelo. Pode utilizar o script de classificação e o ambiente da execução de preparação na configuração de inferência.

from azureml.core.model import InferenceConfig

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

Em seguida, pode implementar o modelo como um serviço Web do AKS.

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

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

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

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 de ML e selecione Implementar.

Selecionar modelo a partir das execuções de automl na IU do estúdio

Pode configurar o nome do ponto final de implementação do modelo e o cluster de inferência a utilizar para a implementação do modelo no painel Implementar um modelo .

Implementar a configuração

Atualizar a configuração da inferência

No passo anterior, transferimos o ficheiro outputs/scoring_file_v_1_0_0.py de classificação do melhor modelo para um ficheiro local score.py e utilizámo-lo para criar um InferenceConfig objeto. Este script pode ser modificado para alterar as definições de inferência específicas do modelo, se necessário, depois de ter sido transferido e antes de criar o InferenceConfig. Por exemplo, esta é a secção de código que inicializa o modelo no ficheiro de classificação:

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

Cada uma das tarefas (e alguns modelos) tem um conjunto de parâmetros no model_settings dicionário. Por 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 pretender utilizar o til e pretender controlar o comportamento dos mosaicos, 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.

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 "image-" para obter exemplos específicos da criação de modelos de imagem digitalizada.

Configurar o AutoML para preparar modelos de imagem digitalizada com Python (v1)

Pré-requisitos

Selecionar o tipo de tarefa

Dados de preparação e validação

Exemplos de esquema JSONL

Consumir dados

Computação para executar a experimentação

Configurar algoritmos de modelo e hiperparâmetros

Algoritmos de modelo suportados

Aumento de dados

Configurar as definições de experimentação

Métrica primária

Orçamento da experimentação

Varrer hiperparâmetros para o seu modelo

Definir o espaço de pesquisa de parâmetros

Métodos de amostragem para a limpeza

Políticas de cessação antecipada

Recursos para a limpeza

Argumentos

Preparação incremental (opcional)

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

Passar o ponto de verificação através de FileDataset

Submeter a execução

Saídas e métricas de avaliação

Registar e implementar o modelo

Atualizar a configuração da inferência

Blocos de notas de exemplo

Passos seguintes

Recursos adicionais