Configurar o AutoML para treinar modelos de visão computacional com Python (v1)
APLICA-SE A:
Python SDK azureml v1
Importante
Alguns dos comandos da CLI do Azure neste artigo usam a extensão , ou v1, para o azure-cli-mlAzure Machine Learning. O suporte para a extensão v1 terminará em 30 de setembro de 2025. Você poderá instalar e usar a extensão v1 até essa data.
Recomendamos que você 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, consulte Extensão CLI do Azure ML e Python SDK 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, você aprenderá a treinar modelos de visão computacional em dados de imagem com ML automatizado no SDK Python do Azure Machine Learning.
O ML Automatizado suporta a preparação de modelos para tarefas de imagens digitalizadas, como a classificação de imagens, a deteção de objetos e a segmentação de instâncias. A criação de modelos do AutoML para tarefas de imagens digitalizadas é atualmente suportada através do SDK do Python do Azure Machine Learning. As execuções, modelos e saídas de experimentação resultantes podem ser acessados a partir da interface do usuário do estúdio de Aprendizado de Máquina do Azure. Saiba mais sobre ml automatizado para tarefas de visão computacional em dados de imagem.
Nota
O ML automatizado para tarefas de visão computacional só está disponível por meio do SDK Python do Azure Machine Learning.
Pré-requisitos
Uma área de trabalho do Azure Machine Learning. Para criar o espaço de trabalho, consulte Criar recursos do espaço de trabalho.
O SDK Python do Azure Machine Learning instalado. Para instalar o SDK, você pode,
Crie uma instância de computação, que instala automaticamente o SDK e é pré-configurada para fluxos de trabalho de ML. Para obter mais informações, consulte Criar e gerenciar uma instância de computação do Azure Machine Learning.
Instale o
automlpacote você mesmo, que inclui a instalação padrão do SDK.
Nota
Apenas Python 3.7 e 3.8 são compatíveis com suporte automatizado de ML para tarefas de visão computacional.
Selecione o tipo de tarefa
O ML automatizado para imagens suporta os seguintes tipos de tarefas:
| Tipo de tarefa | Sintaxe de configuração AutoMLImage |
|---|---|
| Classificação de imagens | ImageTask.IMAGE_CLASSIFICATION |
| classificação de imagem multi-rótulo | ImageTask.IMAGE_CLASSIFICATION_MULTILABEL |
| Deteção de objeto de imagem | ImageTask.IMAGE_OBJECT_DETECTION |
| segmentação de instância de imagem | ImageTask.IMAGE_INSTANCE_SEGMENTATION |
Esse tipo de tarefa é um parâmetro obrigatório e é passado usando o task parâmetro no AutoMLImageConfig.
Por exemplo:
from azureml.train.automl import AutoMLImageConfig
from azureml.automl.core.shared.constants import ImageTask
automl_image_config = AutoMLImageConfig(task=ImageTask.IMAGE_OBJECT_DETECTION)
Dados de formação e validação
Para gerar modelos de visão computacional, você precisa trazer dados de imagem rotulados como entrada para treinamento de modelo na forma de um Conjunto de Dados Tabulares do Azure Machine Learning. Você pode usar um que você exportou de um projeto de rotulagem de dados ou criar um TabularDataset novo TabularDataset com seus dados de treinamento rotulados.
Se os dados de treinamento estiverem em um formato diferente (como pascal VOC ou COCO), você poderá aplicar os scripts auxiliares incluídos nos blocos de anotações de exemplo para converter os dados em JSONL. Saiba mais sobre como preparar dados para tarefas de visão computacional com ML automatizado.
Aviso
A criação de TabularDatasets a partir de dados no formato JSONL é suportada usando apenas o SDK, para esse recurso. No momento, não há suporte para a criação do conjunto de dados via interface do usuário. A partir de agora, a interface do usuário não reconhece o tipo de dados StreamInfo, que é o tipo de dados usado para URLs de imagem no formato JSONL.
Nota
O conjunto de dados de treinamento precisa ter pelo menos 10 imagens para poder enviar uma execução do AutoML.
Exemplos de esquema JSONL
A estrutura do TabularDataset depende da tarefa em questão. Para tipos de tarefas de visão computacional, consiste nos seguintes campos:
| Campo | Descrição |
|---|---|
image_url |
Contém filepath como um objeto StreamInfo |
image_details |
As informações de metadados de imagem consistem em altura, largura e formato. Este campo é opcional e, portanto, pode ou não existir. |
label |
Uma representação json do rótulo da imagem, com base no tipo de tarefa. |
A seguir está um arquivo JSONL de exemplo para classificação de imagem:
{
"image_url": "AmlDatastore://image_data/Image_01.png",
"image_details":
{
"format": "png",
"width": "2230px",
"height": "4356px"
},
"label": "cat"
}
{
"image_url": "AmlDatastore://image_data/Image_02.jpeg",
"image_details":
{
"format": "jpeg",
"width": "3456px",
"height": "3467px"
},
"label": "dog"
}
O código a seguir é um arquivo JSONL de exemplo para deteção de objetos:
{
"image_url": "AmlDatastore://image_data/Image_01.png",
"image_details":
{
"format": "png",
"width": "2230px",
"height": "4356px"
},
"label":
{
"label": "cat",
"topX": "1",
"topY": "0",
"bottomX": "0",
"bottomY": "1",
"isCrowd": "true",
}
}
{
"image_url": "AmlDatastore://image_data/Image_02.png",
"image_details":
{
"format": "jpeg",
"width": "1230px",
"height": "2356px"
},
"label":
{
"label": "dog",
"topX": "0",
"topY": "1",
"bottomX": "0",
"bottomY": "1",
"isCrowd": "false",
}
}
Consumir dados
Quando os dados estiverem no formato JSONL, você poderá criar um TabularDataset com o seguinte código:
ws = Workspace.from_config()
ds = ws.get_default_datastore()
from azureml.core import Dataset
training_dataset = Dataset.Tabular.from_json_lines_files(
path=ds.path('odFridgeObjects/odFridgeObjects.jsonl'),
set_column_types={'image_url': DataType.to_stream(ds.workspace)})
training_dataset = training_dataset.register(workspace=ws, name=training_dataset_name)
O ML automatizado não impõe restrições ao tamanho dos dados de treinamento ou validação para tarefas de visão computacional. O tamanho máximo do conjunto de dados é limitado apenas pela camada de armazenamento por trás do conjunto de dados (ou seja, armazenamento de blobs). Não existe um número mínimo de imagens ou etiquetas. No entanto, recomendamos começar com um mínimo de 10-15 amostras por rótulo para garantir que o modelo de saída seja suficientemente treinado. Quanto maior o número total de rótulos/classes, mais amostras você precisa por rótulo.
Os dados de treinamento são necessários e são passados usando o training_data parâmetro. Opcionalmente, você pode especificar outro TabularDataset como um conjunto de dados de validação a ser usado para seu modelo com o validation_data parâmetro AutoMLImageConfig. Se nenhum conjunto de dados de validação for especificado, 20% dos dados de treinamento serão usados para validação por padrão, a menos que você passe validation_size um argumento com um valor diferente.
Por exemplo:
from azureml.train.automl import AutoMLImageConfig
automl_image_config = AutoMLImageConfig(training_data=training_dataset)
Computação para executar a experimentação
Forneça um destino de computação para ML automatizado para conduzir treinamento de modelo. Os modelos de ML automatizados para tarefas de visão computacional requerem SKUs de GPU e suportam as famílias NC e ND. Recomendamos a série NCsv3 (com GPUs v100) para um treinamento mais rápido. Um alvo de computação com um SKU VM MULTI-GPU aproveita várias GPUs para também acelerar o treinamento. Além disso, ao configurar um destino de computação com vários nós, você pode realizar um treinamento de modelo mais rápido por meio de paralelismo ao ajustar hiperparâmetros para seu modelo.
Nota
Se você estiver usando uma instância de computação como seu destino de computação, certifique-se de que vários trabalhos AutoML não sejam executados ao mesmo tempo. Além disso, certifique-se de que max_concurrent_iterations está definido como 1 em seus recursos de experimento.
O destino de computação é um parâmetro obrigatório e é passado usando o compute_target parâmetro do AutoMLImageConfig. Por exemplo:
from azureml.train.automl import AutoMLImageConfig
automl_image_config = AutoMLImageConfig(compute_target=compute_target)
Configurar algoritmos de modelo e hiperparâmetros
Com suporte para tarefas de visão computacional, você pode controlar o algoritmo do modelo e varrer hiperparâmetros. Esses algoritmos de modelo e hiperparâmetros são passados como o espaço de parâmetro para a varredura.
O algoritmo do modelo é necessário e é passado via model_name parâmetro. Você pode especificar um único model_name ou escolher entre vários.
Algoritmos de modelo suportados
A tabela a seguir resume os modelos suportados para cada tarefa de visão computacional.
| Tarefa | Algoritmos de modelo | Sintaxe literal da cadeia de caracteresdefault_model* indicado com * |
|---|---|---|
| Classificação de imagens (multiclasse e multi-rótulo) |
MobileNet: Modelos leves para aplicações móveis ResNet: Redes residuais ResNeSt: Dividir redes de atenção SE-ResNeXt50: Redes de compressão e excitação ViT: Redes de transformadores de visão |
mobilenetv2 resnet18 resnet34 resnet50 resnet101 resnet152 resnest50 resnest101 seresnext vits16r224 (pequeno) vitb16r224* (base) vitl16r224 (grande) |
| Deteção de objetos | YOLOv5: Modelo de deteção de objeto de um estágio FPN RCNN ResNet mais rápido: modelos de deteção de objetos de dois estágios RetinaNet ResNet FPN: resolver desequilíbrio de classe com perda focal Nota: Consulte o model_size hiperparâmetro para tamanhos de modelo YOLOv5. |
yolov5* fasterrcnn_resnet18_fpn fasterrcnn_resnet34_fpn fasterrcnn_resnet50_fpn fasterrcnn_resnet101_fpn fasterrcnn_resnet152_fpn retinanet_resnet50_fpn |
| Segmentação de instâncias | MaskRCNN ResNet FPN | maskrcnn_resnet18_fpn maskrcnn_resnet34_fpn maskrcnn_resnet50_fpn* maskrcnn_resnet101_fpn maskrcnn_resnet152_fpn maskrcnn_resnet50_fpn |
Além de controlar o algoritmo do modelo, você também pode ajustar os hiperparâmetros usados para o treinamento do modelo. Embora muitos dos hiperparâmetros expostos sejam agnósticos ao modelo, há casos em que os hiperparâmetros são específicos da tarefa ou do modelo. Saiba mais sobre os hiperparâmetros disponíveis para essas instâncias.
Aumento de dados
Em geral, o desempenho do modelo de aprendizagem profunda pode melhorar com mais dados. O aumento de dados é uma técnica prática para amplificar o tamanho e a variabilidade de um conjunto de dados que ajuda a evitar o sobreajuste e melhorar a capacidade de generalização do modelo em dados não vistos. O ML automatizado aplica diferentes técnicas de aumento de dados com base na tarefa de visão computacional, antes de alimentar imagens de entrada para o modelo. Atualmente, não há hiperparâmetro exposto para controlar aumentos de dados.
| Tarefa | Conjunto de dados afetado | Técnica(s) de aumento de dados aplicada(s) |
|---|---|---|
| Classificação de imagem (multiclasse e multi-label) | Formação Validação e Teste |
Redimensionamento e corte aleatórios, inversão horizontal, desvio de cor (brilho, contraste, saturação e matiz), normalização usando a média e o desvio padrão do ImageNet em canal Redimensionamento, colheita central, normalização |
| Deteção de objetos, segmentação de instâncias | Formação Validação e Teste |
Corte aleatório em torno de caixas delimitadoras, expandir, inverter horizontalmente, normalização, redimensionar Normalização, redimensionamento |
| Deteção de objetos usando yolov5 | Formação Validação e Teste |
Mosaico, afim aleatório (rotação, translação, escala, cisalhamento), flip horizontal Redimensionamento da caixa de correio |
Definir as configurações do experimento
Antes de fazer uma grande varredura para procurar os modelos e hiperparâmetros ideais, recomendamos tentar os valores padrão para obter uma primeira linha de base. Em seguida, você pode explorar vários hiperparâmetros para o mesmo modelo antes de varrer vários modelos e seus parâmetros. Dessa forma, você pode empregar uma abordagem mais iterativa, porque com vários modelos e vários hiperparâmetros para cada um, o espaço de pesquisa cresce exponencialmente e você precisa de mais iterações para encontrar as configurações ideais.
Se você deseja usar os valores de hiperparâmetro padrão para um determinado algoritmo (digamos yolov5), você pode especificar a configuração para sua imagem AutoML é executada da seguinte maneira:
from azureml.train.automl import AutoMLImageConfig
from azureml.train.hyperdrive import GridParameterSampling, choice
from azureml.automl.core.shared.constants import ImageTask
automl_image_config_yolov5 = AutoMLImageConfig(task=ImageTask.IMAGE_OBJECT_DETECTION,
compute_target=compute_target,
training_data=training_dataset,
validation_data=validation_dataset,
hyperparameter_sampling=GridParameterSampling({'model_name': choice('yolov5')}),
iterations=1)
Depois de criar um modelo de linha de base, convém otimizar o desempenho do modelo para varrer o algoritmo do modelo e o espaço de hiperparâmetros. Você pode usar a seguinte configuração de exemplo para varrer os hiperparâmetros para cada algoritmo, escolhendo entre um intervalo de valores para learning_rate, otimizador, lr_scheduler, etc., para gerar um modelo com a métrica primária ideal. Se os valores de hiperparâmetro não forem especificados, os valores padrão serão usados para o algoritmo especificado.
Métrica primária
A métrica primária usada para otimização de modelo e ajuste de hiperparâmetros depende do tipo de tarefa. No momento, não há suporte para o uso de outros valores de métricas primárias.
accuracypara IMAGE_CLASSIFICATIONioupara IMAGE_CLASSIFICATION_MULTILABELmean_average_precisionpara IMAGE_OBJECT_DETECTIONmean_average_precisionpara IMAGE_INSTANCE_SEGMENTATION
Orçamento da experiência
Opcionalmente, você pode especificar o orçamento máximo de tempo para seu experimento AutoML Vision usando experiment_timeout_hours - a quantidade de tempo em horas antes do término do experimento. Se nenhum for especificado, o tempo limite padrão do experimento será de sete dias (máximo de 60 dias).
Hiperparâmetros abrangentes para o seu modelo
Ao treinar modelos de visão computacional, o desempenho do modelo depende muito dos valores de hiperparâmetros selecionados. Muitas vezes, você pode querer ajustar os hiperparâmetros para obter o desempenho ideal. Com suporte para tarefas de visão computacional em ML automatizado, você pode varrer hiperparâmetros para encontrar as configurações ideais para o seu modelo. Esse recurso aplica os recursos de ajuste de hiperparâmetro no Aprendizado de Máquina do Azure. Saiba como ajustar hiperparâmetros.
Definir o espaço de pesquisa de parâmetros
Você pode definir os algoritmos de modelo e hiperparâmetros para varrer no espaço de parâmetros.
- Consulte Configurar algoritmos de modelo e hiperparâmetros para obter a lista de algoritmos de modelo suportados para cada tipo de tarefa.
- Consulte Hiperparâmetros para tarefas de visão computacional hiperparâmetros para cada tipo de tarefa de visão computacional.
- Veja detalhes sobre distribuições suportadas para hiperparâmetros discretos e contínuos.
Métodos de amostragem para a varredura
Ao varrer hiperparâmetros, você precisa especificar o método de amostragem a ser usado para varrer o espaço de parâmetros definido. Atualmente, os seguintes métodos de amostragem são suportados com o hyperparameter_sampling parâmetro:
Nota
Atualmente, apenas amostragem aleatória e em grade suporta espaços de hiperparâmetros condicionais.
Políticas de rescisão antecipada
Você pode encerrar automaticamente execuções com baixo desempenho com uma política de encerramento antecipado. A terminação antecipada melhora a eficiência computacional, economizando recursos de computação que, de outra forma, teriam sido gastos em configurações menos promissoras. O ML automatizado para imagens suporta as seguintes políticas de encerramento antecipado usando o early_termination_policy parâmetro. Se nenhuma política de terminação for especificada, todas as configurações serão executadas até a conclusão.
Saiba mais sobre como configurar a política de encerramento antecipado para sua varredura de hiperparâmetros.
Recursos para a varredura
Você pode controlar os recursos gastos em sua varredura de hiperparâmetros especificando o e o iterationsmax_concurrent_iterations para a varredura.
| Parâmetro | Detalhe |
|---|---|
iterations |
Parâmetro necessário para o número máximo de configurações a serem varridas. Deve ser um número inteiro entre 1 e 1000. Ao explorar apenas os hiperparâmetros padrão para um determinado algoritmo de modelo, defina esse 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, deve ser um número inteiro entre 1 e 100. NOTA: O número de execuções simultâneas é limitado aos recursos disponíveis no destino de computação especificado. Certifique-se de que o destino de computação tenha os recursos disponíveis para a simultaneidade desejada. |
Nota
Para obter um exemplo completo de configuração de varredura, consulte este tutorial.
Argumentos
Você pode passar configurações fixas ou parâmetros que não mudam durante a varredura de espaço de parâmetro como argumentos. Os argumentos são passados em pares nome-valor e o nome deve ser prefixado por um traço duplo.
from azureml.train.automl import AutoMLImageConfig
arguments = ["--early_stopping", 1, "--evaluation_frequency", 2]
automl_image_config = AutoMLImageConfig(arguments=arguments)
Formação incremental (opcional)
Uma vez que a execução de treinamento é feita, você tem a opção de treinar ainda mais o modelo carregando o ponto de verificação do modelo treinado. Você pode usar o mesmo conjunto de dados ou um conjunto de dados diferente para treinamento incremental.
Há duas opções disponíveis para treinamento incremental. É possível
- Passe o ID de execução do qual você deseja carregar o ponto de verificação.
- Passe os pontos de verificação através de um FileDataset.
Passe o ponto de verificação através do ID de execução
Para encontrar o ID de execução do modelo desejado, você pode usar o código a seguir.
# find a run id to get a model checkpoint from
target_checkpoint_run = automl_image_run.get_best_child()
Para passar um ponto de verificação através do ID de execução, você precisa usar o checkpoint_run_id parâmetro.
automl_image_config = AutoMLImageConfig(task='image-object-detection',
compute_target=compute_target,
training_data=training_dataset,
validation_data=validation_dataset,
checkpoint_run_id= target_checkpoint_run.id,
primary_metric='mean_average_precision',
**tuning_settings)
automl_image_run = experiment.submit(automl_image_config)
automl_image_run.wait_for_completion(wait_post_processing=True)
Passe o ponto de verificação via FileDataset
Para passar um ponto de verificação por meio de um FileDataset, você precisa usar os checkpoint_dataset_id parâmetros e checkpoint_filename .
# download the checkpoint from the previous run
model_name = "outputs/model.pt"
model_local = "checkpoints/model_yolo.pt"
target_checkpoint_run.download_file(name=model_name, output_file_path=model_local)
# upload the checkpoint to the blob store
ds.upload(src_dir="checkpoints", target_path='checkpoints')
# create a FileDatset for the checkpoint and register it with your workspace
ds_path = ds.path('checkpoints/model_yolo.pt')
checkpoint_yolo = Dataset.File.from_files(path=ds_path)
checkpoint_yolo = checkpoint_yolo.register(workspace=ws, name='yolo_checkpoint')
automl_image_config = AutoMLImageConfig(task='image-object-detection',
compute_target=compute_target,
training_data=training_dataset,
validation_data=validation_dataset,
checkpoint_dataset_id= checkpoint_yolo.id,
checkpoint_filename='model_yolo.pt',
primary_metric='mean_average_precision',
**tuning_settings)
automl_image_run = experiment.submit(automl_image_config)
automl_image_run.wait_for_completion(wait_post_processing=True)
Enviar a execução
Quando você tiver seu AutoMLImageConfig objeto pronto, poderá enviar o experimento.
ws = Workspace.from_config()
experiment = Experiment(ws, "Tutorial-automl-image-object-detection")
automl_image_run = experiment.submit(automl_image_config)
Resultados e métricas de avaliação
As execuções automatizadas de treinamento de ML geram arquivos de modelo de saída, métricas de avaliação, logs e artefatos de implantação, como o arquivo de pontuação e o arquivo de ambiente, que podem ser visualizados na guia de saídas e logs e métricas das execuções filhas.
Gorjeta
Verifique como navegar para os resultados do trabalho na seção Exibir resultados da execução.
Para obter definições e exemplos dos gráficos e métricas de desempenho fornecidos para cada execução, consulte Avaliar resultados de experimentos de aprendizado de máquina automatizados
Registrar e implantar modelo
Quando a execução for concluída, você poderá registrar o modelo que foi criado a partir da melhor execução (configuração que resultou na melhor métrica primária)
best_child_run = automl_image_run.get_best_child()
model_name = best_child_run.properties['model_name']
model = best_child_run.register_model(model_name = model_name, model_path='outputs/model.pt')
Depois de registrar o modelo que deseja usar, você pode implantá-lo como um serviço Web nas Instâncias de Contêiner do Azure (ACI) ou no Serviço Kubernetes do Azure (AKS). O ACI é a opção perfeita para testar implantações, enquanto o AKS é mais adequado para uso de produção em alta escala.
Este exemplo implanta o modelo como um serviço Web no AKS. Para implantar no AKS, primeiro crie um cluster de computação AKS ou use um cluster AKS existente. Você pode usar SKUs de GPU ou CPU VM para seu cluster de implantação.
from azureml.core.compute import ComputeTarget, AksCompute
from azureml.exceptions import ComputeTargetException
# Choose a name for your cluster
aks_name = "cluster-aks-gpu"
# Check to see if the cluster already exists
try:
aks_target = ComputeTarget(workspace=ws, name=aks_name)
print('Found existing compute target')
except ComputeTargetException:
print('Creating a new compute target...')
# Provision AKS cluster with GPU machine
prov_config = AksCompute.provisioning_configuration(vm_size="STANDARD_NC6",
location="eastus2")
# Create the cluster
aks_target = ComputeTarget.create(workspace=ws,
name=aks_name,
provisioning_configuration=prov_config)
aks_target.wait_for_completion(show_output=True)
Em seguida, você pode definir a configuração de inferência, que descreve como configurar o serviço Web que contém seu modelo. Você pode usar o script de pontuação e o ambiente da execução de treinamento em sua configuração de inferência.
from azureml.core.model import InferenceConfig
best_child_run.download_file('outputs/scoring_file_v_1_0_0.py', output_file_path='score.py')
environment = best_child_run.get_environment()
inference_config = InferenceConfig(entry_script='score.py', environment=environment)
Em seguida, você pode implantar o modelo como um serviço Web AKS.
# Deploy the model from the best run as an AKS web service
from azureml.core.webservice import AksWebservice
from azureml.core.webservice import Webservice
from azureml.core.model import Model
from azureml.core.environment import Environment
aks_config = AksWebservice.deploy_configuration(autoscale_enabled=True,
cpu_cores=1,
memory_gb=50,
enable_app_insights=True)
aks_service = Model.deploy(ws,
models=[model],
inference_config=inference_config,
deployment_config=aks_config,
deployment_target=aks_target,
name='automl-image-test',
overwrite=True)
aks_service.wait_for_deployment(show_output=True)
print(aks_service.state)
Como alternativa, você pode implantar o modelo a partir da interface do usuário do estúdio de Aprendizado de Máquina do Azure. Navegue até o modelo que deseja implantar na guia Modelos da execução automatizada de ML e selecione Implantar.
Você pode configurar o nome do ponto de extremidade da implantação do modelo e o cluster de inferência a serem usados para a implantação do modelo no painel Implantar um modelo .
Atualizar configuração de inferência
Na etapa anterior, baixamos o arquivo de pontuação do melhor modelo para um arquivo outputs/scoring_file_v_1_0_0.py local score.py e o usamos para criar um InferenceConfig objeto. Esse script pode ser modificado para alterar as configurações de inferência específicas do modelo, se necessário, depois de ter sido baixado e antes de criar o InferenceConfig. Por exemplo, esta é a seção de código que inicializa o modelo no arquivo de pontuação:
...
def init():
...
try:
logger.info("Loading model from path: {}.".format(model_path))
model_settings = {...}
model = load_model(TASK_TYPE, model_path, **model_settings)
logger.info("Loading successful.")
except Exception as e:
logging_utilities.log_traceback(e, logger)
raise
...
Cada uma das tarefas (e alguns modelos) tem um conjunto de parâmetros no model_settings dicionário. Por padrão, usamos os mesmos valores para os parâmetros que foram usados durante o treinamento e a validação. Dependendo do comportamento que precisamos ao usar o modelo para inferência, podemos alterar esses parâmetros. Abaixo você pode encontrar uma lista de parâmetros para cada tipo de tarefa e modelo.
| Tarefa | Nome do parâmetro | Predefinido |
|---|---|---|
| Classificação de imagem (multiclasse e multi-label) | valid_resize_sizevalid_crop_size |
256 224 |
| Deteção de objetos | min_sizemax_sizebox_score_threshnms_iou_threshbox_detections_per_img |
600 1333 0.3 0.5 100 |
Deteção de objetos usando yolov5 |
img_sizemodel_sizebox_score_threshnms_iou_thresh |
640 médio 0.1 0.5 |
| Segmentação de instâncias | min_sizemax_sizebox_score_threshnms_iou_threshbox_detections_per_imgmask_pixel_score_thresholdmax_number_of_polygon_pointsexport_as_imageimage_type |
600 1333 0.3 0.5 100 0.5 100 False JPG |
Para obter uma descrição detalhada sobre hiperparâmetros específicos de tarefas, consulte Hiperparâmetros para tarefas de visão computacional em aprendizado de máquina automatizado.
Se você quiser usar o lado a lado e quiser controlar o comportamento do mosaico, os seguintes parâmetros estarão disponíveis: tile_grid_size, tile_overlap_ratio e tile_predictions_nms_thresh. Para obter mais detalhes sobre esses parâmetros, consulte Train a small object detection model using AutoML.
Blocos de notas de exemplo
Analise os exemplos de código e casos de utilização detalhados no Repositório do bloco de notas do GitHub para amostras de machine learning automatizado. Por favor, verifique as pastas com o prefixo 'image-' para amostras específicas para a construção de modelos de visão computacional.