Configurar autoML para treinar modelos de visão computacional com Python (v1)

APLICA-SE A:Python SDK azureml v1

Importante

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

Recomendamos 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 a extensão CLI Azure ML e o Python SDK v2.

Importante

Esta funcionalidade está atualmente em pré-visualização pública. Esta versão de pré-visualização é fornecida sem um acordo de nível de serviço. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas. Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.

Neste artigo, aprende-se a treinar modelos de visão computacional em dados de imagem com ML automatizado no Azure Machine Learning Python SDK.

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 experiências resultantes são executados, modelos e saídas são acessíveis a partir do estúdio do Azure Machine Learning UI. Saiba mais sobre ml automatizado para tarefas de visão computacional em dados de imagem.

Nota

ML automatizado para tarefas de visão computacional só está disponível através do Azure Machine Learning Python SDK.

Pré-requisitos

Selecione o seu tipo de tarefa

ML automatizado para imagens suporta os seguintes tipos de tarefa:

Tipo de tarefa Sintaxe config AutoMLImage
classificação de imagem ImageTask.IMAGE_CLASSIFICATION
classificação de imagem multi-rótulo ImageTask.IMAGE_CLASSIFICATION_MULTILABEL
deteção de objetos de imagem ImageTask.IMAGE_OBJECT_DETECTION
segmentação de casos de imagem ImageTask.IMAGE_INSTANCE_SEGMENTATION

Este tipo de tarefa é um parâmetro necessário e é passado na utilização do 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, é necessário trazer dados de imagem rotulados como entrada para a formação de modelos sob a forma de um Separador de Aprendizagem automática Azure. Pode utilizar um TabularDataset que exportou de um projeto de rotulagem de dados ou criar um novo TabularDataset com os seus dados de formação rotulados.

Se os seus dados de treino estiverem num formato diferente (como, pascal VOC ou COCO), pode aplicar os scripts de ajuda incluídos com os cadernos de amostra 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 Separadores Tabular a partir de dados em formato JSONL é suportada apenas com recurso ao SDK, para esta capacidade. A criação do conjunto de dados via UI não é suportada neste momento. A partir de agora, a UI não reconhece o tipo de dados StreamInfo, que é o tipo de dados utilizado para URLs de imagem em formato JSONL.

Nota

O conjunto de dados de treino precisa de ter pelo menos 10 imagens para poder submeter uma corrida de AutoML.

Amostras de esquema JSONL

A estrutura do SeparadorDataset depende da tarefa em questão. Para os 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 A informação de metadados de imagem consiste em altura, largura e formato. Este campo é opcional e, portanto, pode ou não existir.
label Uma representação json do rótulo de imagem, com base no tipo de tarefa.

Segue-se um ficheiro JSONL de amostra 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 seguinte código é um ficheiro JSONL de amostra 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

Uma vez que os seus dados estão no formato JSONL, pode criar um Separador 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)

A ML automatizada não impõe quaisquer restrições ao tamanho dos dados de formação 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 (isto é, loja blob). Não há um número mínimo de imagens ou etiquetas. No entanto, recomendamos começar com um mínimo de 10-15 amostras por etiqueta para garantir que o modelo de saída está suficientemente treinado. Quanto maior for o número total de rótulos/classes, mais amostras precisa por etiqueta.

Os dados de formação são necessários e são transmitidos através do training_data parâmetro. Pode especificar opcionalmente outro Conjunto de Dados Tabular como um conjunto de dados de validação a utilizar para o seu modelo com o validation_data parâmetro do AutoMLImageConfig. Se não for especificado nenhum conjunto de dados de validação, 20% dos seus dados de formação serão utilizados para validação por padrão, a menos que passe validation_size o 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

Fornecer um alvo de cálculo para ml automatizado para realizar formação de modelos. Os modelos ML automatizados para tarefas de visão computacional requerem SKUs GPU e apoiam famílias NC e ND. Recomendamos a série NCsv3 (com GPUs v100) para um treino mais rápido. Um alvo de computação com um VM SKU multi-GPU aproveita várias GPUs para também acelerar o treino. Além disso, quando configurar um alvo de computação com múltiplos nós, pode realizar treino de modelo mais rápido através do paralelismo ao sintonizar hiperparímetros para o seu modelo.

O alvo do cálculo é um parâmetro necessário e é transmitido utilizando 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, pode controlar o algoritmo do modelo e varrer hiperparímetros. Estes algoritmos de modelo e hiperparímetros são passados como o espaço dos parâmetros para a varredura.

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

Algoritmos de modelo suportados

A tabela seguinte resume os modelos suportados para cada tarefa de visão por computador.

Tarefa Algoritmos de modelo Sintaxe literal de corda
default_model* denotado com *
Classificação de imagens
(multi-classes e multi-rótulos)
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 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 objetos de um estágio
RCNN ResNet FPN mais rápido: Dois modelos de deteção de objetos de estágio
RetinaNet ResNet FPN: resolver o desequilíbrio de classe com a perda focal

Nota: Consulte o model_size hiperparímetro para os tamanhos do 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, também pode sintonizar hiperparímetros usados para o treino de modelos. Embora muitos dos hiperparímetros expostos sejam modelo-agnósticos, existem casos em que os hiperparímetros são específicos da tarefa ou específicos do modelo. Saiba mais sobre os hiperparmetros disponíveis para estes casos.

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 dos dados e a variabilidade de um conjunto de dados que ajuda a prevenir a sobremontagem e a melhorar a capacidade de generalização do modelo em dados invisíveis. A ML automatizada aplica diferentes técnicas de aumento de dados com base na tarefa de visão computacional, antes de alimentar imagens de entrada no modelo. Atualmente, não existe hiperparímetro exposto para controlar os aumentos de dados.

Tarefa Conjunto de dados impactado Técnica de aumento de dados aplicada
Classificação de imagem (multi-classe e multi-rótulo) Formação


Teste de Validação &
Redimensionação aleatória e cultura, flip horizontal, nervosismo de cor (brilho, contraste, saturação e tonalidade), normalização utilizando o desvio médio e padrão do ImageNet em termos de canal


Redimensionar, central, normalização
Deteção de objetos, segmentação de instâncias Formação

Teste de Validação &
Cultura aleatória em torno de caixas de delimitação, expansão, viragem horizontal, normalização, redimensionamento


Normalização, redimensionar
Deteção de objetos usando yolov5 Formação

Teste de Validação &
Mosaico, affine aleatório (rotação, tradução, balança, tesoura), flip horizontal


Redimensionamento de caixa de correio

Configure as definições da sua experiência

Antes de fazer uma grande varredura para procurar os modelos e hiperparímetros ideais, recomendamos experimentar os valores padrão 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 seus parâmetros. Desta forma, pode empregar uma abordagem mais iterativa, porque com vários modelos e múltiplos hiperparmetros para cada um, o espaço de pesquisa cresce exponencialmente e precisa de mais iterações para encontrar configurações ideais.

Se desejar utilizar os valores de hiperparímetro predefinidos para um determinado algoritmo (digamos yolov5), pode especificar o config para o seu AutoML Image executa 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)

Uma vez construído um modelo de base, talvez queira otimizar o desempenho do modelo de forma a varrer o algoritmo do modelo e o espaço do hiperparímetro. Pode utilizar a amostra seguinte para varrer os hiperparmetros para cada algoritmo, escolhendo entre uma gama de valores para learning_rate, otimizador, lr_scheduler, etc., para gerar um modelo com a métrica primária ideal. Se os valores do hiperparmetro 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 a otimização do modelo e a afinação do hiperparímetro depende do tipo de tarefa. A utilização de outros valores métricos primários não é suportada atualmente.

  • 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 de experiências

Pode especificar opcionalmente o orçamento de tempo máximo para a sua experiência AutoML Vision utilizando experiment_timeout_hours - o tempo em horas antes do fim da experiência. Se nenhum especificado, o tempo limite de experiências padrão é de sete dias (máximo 60 dias).

Hiperparmetros de varredura para o seu modelo

Ao treinar modelos de visão computacional, o desempenho do modelo depende fortemente dos valores do hiperparímetro selecionados. Muitas vezes, é melhor afinar os hiperparmetros para obter um desempenho ideal. Com suporte para tarefas de visão computacional em ML automatizado, pode varrer hiperparímetros para encontrar as definições ideais para o seu modelo. Esta função aplica as capacidades de afinação do hiperparímetro no Azure Machine Learning. Aprenda a sintonizar hiperparímetros.

Defina o espaço de pesquisa de parâmetros

Pode definir os algoritmos de modelo e hiperparímetros para varrer no espaço dos parâmetros.

Métodos de amostragem para a varredura

Ao varrer hiperparmetros, é necessário especificar o método de amostragem a utilizar para varrer o espaço do parâmetro definido. Atualmente, os seguintes métodos de amostragem são suportados com o hyperparameter_sampling parâmetro:

Nota

Atualmente apenas a amostragem aleatória suporta espaços de hiperparímetro condicional.

Políticas de rescisão antecipada

Pode terminar automaticamente com uma política de rescisão antecipada. A rescisão precoce melhora a eficiência computacional, poupando recursos computacionais que de outra forma teriam sido gastos em configurações menos promissoras. ML automatizado para imagens suporta as seguintes políticas de terminação antecipada usando o early_termination_policy parâmetro. Se não for especificada nenhuma política de rescisão, todas as configurações serão executadas até ao fim.

Saiba mais sobre como configurar a política de rescisão antecipada para a sua varredura de hiperparímetros.

Recursos para a varredura

Pode controlar os recursos gastos na sua varredura de hiperparímetro, especificando o iterations e o max_concurrent_iterations para a varredura.

Parâmetro Detalhes
iterations Parâmetro necessário para o número máximo de configurações para varrer. Deve ser um inteiro entre 1 e 1000. Ao explorar apenas os hiperparmetros padrão para um determinado algoritmo de modelo, detena este parâmetro para 1.
max_concurrent_iterations Número máximo de corridas que podem ser executadas simultaneamente. Se não for especificado, todas as execuções são lançadas em paralelo. Se especificado, deve ser um número inteiro entre 1 e 100.

NOTA: O número de execuções simultâneas é fechado sobre os recursos disponíveis no alvo de computação especificado. Certifique-se de que o alvo do cálculo dispõe dos recursos disponíveis para a concordância desejada.

Nota

Para obter uma amostra completa de configuração de varredura, consulte este tutorial.

Argumentos

Pode passar definições ou parâmetros fixos que não se alterem durante a varredura do espaço do parâmetro como argumentos. Os argumentos são passados em pares de valor-nome 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 feito o treino, tem a opção de treinar ainda mais o modelo carregando o ponto de verificação do modelo treinado. Pode utilizar o mesmo conjunto de dados ou outro para treino incremental.

Existem duas opções disponíveis para treino incremental. É possível

  • Passe a identificação de execução daí a que quer carregar o posto de controlo.
  • Passe os pontos de verificação através de um FicheiroDataset.

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

Para encontrar 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 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 através do FileDataset

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

# 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 corrida

Quando tiver o seu AutoMLImageConfig objeto pronto, pode submeter a experiência.

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

O treino automatizado de ML gera ficheiros de modelos de saída, métricas de avaliação, registos e artefactos de implantação como o ficheiro de pontuação e o ficheiro de ambiente que pode ser visto a partir das saídas e registos e métricas do separador da criança.

Dica

Verifique como navegar para os resultados do trabalho a partir da secção de resultados da execução do Ver .

Para definições e exemplos dos gráficos de desempenho e métricas fornecidas para cada execução, consulte os resultados automatizados da experiência de aprendizagem automática de máquinas

Registar e implementar modelo

Uma vez 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 implantá-lo como serviço web em Azure Container Instances (ACI) ou Azure Kubernetes Service (AKS). O ACI é a opção perfeita para testar implementações, enquanto a AKS é mais adequada para uma utilização de produção de alta escala.

Este exemplo implementa o modelo como um serviço web em AKS. Para implementar em AKS, primeiro crie um cluster de computação AKS ou utilize um cluster AKS existente. Pode utilizar SKUs GPU ou CPU VM para o 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, pode definir a configuração da inferência, que descreve como configurar o serviço web que contém o seu modelo. Você pode usar o script de pontuação e o ambiente da corrida de treino na sua inferência config.

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 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 implantar o modelo a partir da UI estúdio do Azure Machine Learning. Navegue para o modelo que pretende implementar no separador Modelos da execução automatizada de ML e selecione o Implementar.

Selecione o modelo a partir do automl corre em estúdio UI

Pode configurar o nome do ponto final de implementação do modelo e o cluster de inferencing para utilizar para a sua implantação de modelo no painel de modelos .

Implementar a configuração

Atualizar a configuração da inferência

No passo anterior, descarregámos o ficheiro outputs/scoring_file_v_1_0_0.py de pontuação do melhor modelo para um ficheiro local score.py e usá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 após o seu descarregamento e antes de criar o InferenceConfig. Por exemplo, esta é a secção de código que inicializa o modelo no ficheiro 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, utilizamos os mesmos valores para os parâmetros que foram utilizados durante o treino e validação. Dependendo do comportamento que precisamos ao usar 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 imagem (multi-classe e multi-rótulo) 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 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 tarefa, consulte hiperparametros para tarefas de visão computacional na aprendizagem automática de máquinas.

Se quiser utilizar a inclinação e quiser controlar o comportamento da inclinação, estão disponíveis os seguintes parâmetros: tile_grid_sizee tile_overlap_ratiotile_predictions_nms_thresh. . Para mais detalhes sobre estes parâmetros, verifique train um modelo de deteção de pequenos objetos usando 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 prefixo 'imagem-' para amostras específicas da construção de modelos de visão computacional.

Passos seguintes