Guia de Ajuste de Hiperparâmetros do Ultralytics YOLO

Introdução

O ajuste de hiperparâmetros não é apenas uma configuração pontual, mas um processo iterativo que visa otimizar as métricas de desempenho do modelo de machine learning, como acurácia, precisão e recall. No contexto do Ultralytics YOLO, esses hiperparâmetros podem variar desde a taxa de aprendizado até detalhes arquiteturais, como o número de camadas ou tipos de funções de ativação utilizadas. A Ultralytics Platform também oferece suporte a treinamento em nuvem com hiperparâmetros configuráveis e rastreamento de métricas em tempo real.

O que são Hiperparâmetros?

Hiperparâmetros são configurações estruturais de alto nível para o algoritmo. Eles são definidos antes da fase de treinamento e permanecem constantes durante a mesma. Abaixo estão alguns hiperparâmetros comumente ajustados no Ultralytics YOLO:

• Taxa de Aprendizado (Learning Rate) lr0: Determina o tamanho do passo em cada iteração enquanto se move em direção a um mínimo na função de perda.
• Tamanho do Lote batch: Número de imagens processadas simultaneamente em uma passagem direta (forward pass).
• Número de Épocas epochs: Uma época consiste em uma passagem completa para frente e para trás de todos os exemplos de treinamento.
• Especificações de Arquitetura: Como contagens de canais, número de camadas, tipos de funções de ativação, etc.

Para uma lista completa de hiperparâmetros de aumento de dados usados no YOLO26, consulte a página de configurações.

Evolução Genética e Mutação

O Ultralytics YOLO utiliza algoritmos genéticos para otimizar hiperparâmetros. Algoritmos genéticos são inspirados no mecanismo de seleção natural e genética.

• Cruzamento (Crossover): Cada iteração combina genes de até nove das configurações com melhor aptidão vistas até agora, usando o cruzamento BLX-α com seleção de pais ponderada pela aptidão.
• Mutação: O candidato recombinado é então perturbado por um fator multiplicativo log-normal aplicado a cada hiperparâmetro (com probabilidade de 0,5 por parâmetro). A força da mutação sigma decai linearmente de 0,2 para 0,1 ao longo das primeiras 300 iterações, permitindo que o algoritmo explore amplamente no início e refine conforme converge. A iteração 1 não possui pais para cruzamento e utiliza os hiperparâmetros de treinamento padrão como base.

Preparação para o Ajuste de Hiperparâmetros

Antes de iniciar o processo de ajuste, é importante:

1. Identificar as Métricas: Determine quais métricas você usará para avaliar o desempenho do modelo. Isso pode ser AP50, pontuação F1, ou outras.
2. Definir o Orçamento de Ajuste: Defina quantos recursos computacionais você está disposto a alocar. O ajuste de hiperparâmetros pode ser computacionalmente intensivo.

Etapas Envolvidas

Inicializar Hiperparâmetros

Comece com um conjunto razoável de hiperparâmetros iniciais. Isso pode ser tanto os hiperparâmetros padrão definidos pelo Ultralytics YOLO quanto algo baseado no seu conhecimento de domínio ou experimentos anteriores.

Mutar Hiperparâmetros

Use o método _mutate para produzir um novo conjunto de hiperparâmetros com base no conjunto existente. A classe Tuner gerencia esse processo automaticamente.

Treinar o Modelo

O treinamento é realizado usando o conjunto de hiperparâmetros mutados. O desempenho do treinamento é então avaliado usando as métricas escolhidas.

Avaliar o Modelo

Use métricas como AP50, pontuação F1 ou métricas personalizadas para avaliar o desempenho do modelo. O processo de avaliação ajuda a determinar se os hiperparâmetros atuais são melhores que os anteriores.

Registrar Resultados

É crucial registrar tanto as métricas de desempenho quanto os hiperparâmetros correspondentes para referência futura. O Ultralytics YOLO salva automaticamente esses resultados no formato NDJSON.

Repetir

O processo é repetido até que o número definido de iterações seja atingido ou a métrica de desempenho seja satisfatória. Cada iteração baseia-se no conhecimento adquirido em execuções anteriores.

Descrição do Espaço de Busca Padrão

A tabela a seguir lista os parâmetros do espaço de busca padrão para ajuste de hiperparâmetros no YOLO26. Cada parâmetro possui um intervalo de valor específico definido por uma tupla (min, max).

Exemplo de Espaço de Busca Personalizado

Veja como definir um espaço de busca e usar o método model.tune() para utilizar a classe Tuner para o ajuste de hiperparâmetros do YOLO26n no COCO8 por 30 épocas com um otimizador AdamW, pulando plotagem, checkpointing e validação exceto na última época para um ajuste mais rápido.

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolo26n.pt")

# Define search space
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# Tune hyperparameters on COCO8 for 30 epochs
model.tune(
    data="coco8.yaml",
    epochs=30,
    iterations=300,
    optimizer="AdamW",
    space=search_space,
    plots=False,
    save=False,
    val=False,
)

Retomando uma Sessão de Ajuste de Hiperparâmetros Interrompida

Você pode retomar uma sessão de ajuste de hiperparâmetros interrompida passando resume=True. Opcionalmente, você pode passar o diretório name usado em runs/{task} para retomar. Caso contrário, ele retomará a última sessão interrompida. Você também precisa fornecer todos os argumentos de treinamento anteriores, incluindo data, epochs, iterations e space.

from ultralytics import YOLO

# Define a YOLO model
model = YOLO("yolo26n.pt")

# Define search space
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# Resume previous run
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, resume=True)

# Resume tuning run with name 'tune_exp'
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, name="tune_exp", resume=True)

Resultados

Após concluir com sucesso o processo de ajuste de hiperparâmetros, você obterá vários arquivos e diretórios que encapsulam os resultados do ajuste. O seguinte descreve cada um:

Estrutura de Arquivos

Veja como será a estrutura de diretórios dos resultados. Diretórios de treinamento como train1/ contêm iterações de ajuste individuais, isto é, um modelo treinado com um conjunto de hiperparâmetros. O diretório tune/ contém resultados de ajuste de todos os treinamentos de modelo individuais:

runs/
└── detect/
    ├── train1/
    ├── train2/
    ├── ...
    └── tune/
        ├── best_hyperparameters.yaml
        ├── tune_fitness.png
        ├── tune_results.ndjson
        ├── tune_scatter_plots.png
        └── weights/
            ├── last.pt
            └── best.pt

Descrições de Arquivos

best_hyperparameters.yaml

Este arquivo YAML contém os hiperparâmetros com melhor desempenho encontrados durante o processo de ajuste. Você pode usar este arquivo para inicializar treinamentos futuros com essas configurações otimizadas.

• Formato: YAML

• Uso: Resultados de hiperparâmetros

• Exemplo:

  # 558/900 iterations complete ✅ (45536.81s)
  # Results saved to /usr/src/ultralytics/runs/detect/tune
  # Best fitness=0.64297 observed at iteration 498
  # Best fitness metrics are {'metrics/precision(B)': 0.87247, 'metrics/recall(B)': 0.71387, 'metrics/mAP50(B)': 0.79106, 'metrics/mAP50-95(B)': 0.62651, 'val/box_loss': 2.79884, 'val/cls_loss': 2.72386, 'val/dfl_loss': 0.68503, 'fitness': 0.64297}
  # Best fitness model is /usr/src/ultralytics/runs/detect/train498
  # Best fitness hyperparameters are printed below.
  
  lr0: 0.00269
  lrf: 0.00288
  momentum: 0.73375
  weight_decay: 0.00015
  warmup_epochs: 1.22935
  warmup_momentum: 0.1525
  box: 18.27875
  cls: 1.32899
  dfl: 0.56016
  hsv_h: 0.01148
  hsv_s: 0.53554
  hsv_v: 0.13636
  degrees: 0.0
  translate: 0.12431
  scale: 0.07643
  shear: 0.0
  perspective: 0.0
  flipud: 0.0
  fliplr: 0.08631
  mosaic: 0.42551
  mixup: 0.0
  copy_paste: 0.0

tune_fitness.png

Este é um gráfico que exibe o fitness em relação ao número de iterações. Ele ajuda você a visualizar como o algoritmo genético performou ao longo do tempo.

• Formato: PNG
• Uso: Visualização de desempenho

O gráfico contém:

• Um marcador por iteração por conjunto de dados, portanto, uma execução com um único conjunto de dados mostra um ponto por iteração, e uma execução com múltiplos conjuntos de dados mostra um ponto por conjunto de dados por iteração.
• Uma linha pontilhada de "média suavizada" calculada como uma suavização Gaussiana (sigma=3) sobre os valores de fitness de nível superior por iteração.

tune_results.ndjson

Um arquivo NDJSON contendo resultados detalhados de cada iteração de ajuste. Cada linha é um objeto JSON com o fitness agregado, hiperparâmetros ajustados e métricas por conjunto de dados. O ajuste para conjunto de dados único e para múltiplos conjuntos de dados usa o mesmo formato de arquivo.

• Formato: NDJSON
• Uso: Acompanhamento de resultados por iteração.
• Exemplo:

Um exemplo formatado (pretty-printed) é mostrado abaixo para facilitar a leitura. No arquivo .ndjson real, cada objeto é armazenado em uma única linha.

{
    "iteration": 1,
    "fitness": 0.48628,
    "hyperparameters": {
        "lr0": 0.01,
        "lrf": 0.01,
        "momentum": 0.937,
        "weight_decay": 0.0005
    },
    "datasets": {
        "coco8": {
            "metrics/precision(B)": 0.65666,
            "metrics/recall(B)": 0.85,
            "metrics/mAP50(B)": 0.85086,
            "metrics/mAP50-95(B)": 0.64104,
            "val/box_loss": 1.57958,
            "val/cls_loss": 1.04986,
            "val/dfl_loss": 1.32641,
            "fitness": 0.64104
        },
        "coco8-grayscale": {
            "metrics/precision(B)": 0.6582,
            "metrics/recall(B)": 0.51667,
            "metrics/mAP50(B)": 0.59106,
            "metrics/mAP50-95(B)": 0.33152,
            "val/box_loss": 1.95424,
            "val/cls_loss": 1.64059,
            "val/dfl_loss": 1.70226,
            "fitness": 0.33152
        }
    },
    "save_dirs": {
        "coco8": "runs/detect/coco8",
        "coco8-grayscale": "runs/detect/coco8-grayscale"
    }
}

O fitness de nível superior é a média aritmética dos valores de fitness por conjunto de dados. Para ajuste de conjunto de dados único, o dicionário datasets possui uma entrada cujo fitness é igual ao fitness de nível superior. Um objeto JSON é gravado por iteração concluída. Os caminhos reais de save_dirs são absolutos; eles estão abreviados acima para facilitar a leitura.

tune_scatter_plots.png

Este arquivo contém gráficos de dispersão gerados a partir do tune_results.ndjson, ajudando você a visualizar as relações entre diferentes hiperparâmetros e métricas de desempenho. Hiperparâmetros cujo valor padrão é 0 (por exemplo, degrees e shear abaixo) podem evoluir apenas lentamente a partir de sua semente inicial, porque o fator de mutação multiplicativa tem muito pouco para expandir a partir de um valor próximo de zero.

• Formato: PNG
• Uso: Análise exploratória de dados

weights/

Este diretório contém os modelos PyTorch salvos para a última iteração e para a melhor iteração durante o processo de ajuste de hiperparâmetros.

• last.pt: O last.pt são os pesos da última época de treinamento.
• best.pt: Os pesos best.pt para a iteração que alcançou a melhor pontuação de fitness.

Usando esses resultados, você pode tomar decisões mais informadas para seus futuros treinamentos e análises de modelos. Sinta-se à vontade para consultar esses artefatos para entender quão bem seu modelo performou e como você pode melhorá-lo ainda mais.

Conclusão

O processo de ajuste de hiperparâmetros no Ultralytics YOLO é simplificado, porém poderoso, graças à sua abordagem baseada em algoritmo genético que combina cruzamento BLX-α com mutação log-normal. Seguir as etapas descritas neste guia ajudará você a ajustar sistematicamente seu modelo para obter um melhor desempenho.

Leitura Adicional

1. Otimização de Hiperparâmetros na Wikipedia
2. Guia de Evolução de Hiperparâmetros do YOLOv5
3. Ajuste Eficiente de Hiperparâmetros com Ray Tune e YOLO26

Para insights mais profundos, você pode explorar o código-fonte da classe Tuner e a documentação que a acompanha. Caso você tenha alguma dúvida, solicitação de recurso ou precise de mais assistência, sinta-se à vontade para entrar em contato conosco no GitHub ou no Discord.

FAQ

Como otimizo a taxa de aprendizado para o Ultralytics YOLO durante o ajuste de hiperparâmetros?

Para otimizar a taxa de aprendizado para o Ultralytics YOLO, comece definindo uma taxa de aprendizado inicial usando o parâmetro lr0. Valores comuns variam de 0.001 a 0.01. Durante o processo de ajuste de hiperparâmetros, esse valor será mutado para encontrar a configuração ideal. Você pode utilizar o método model.tune() para automatizar esse processo. Por exemplo:

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolo26n.pt")

# Tune hyperparameters on COCO8 for 30 epochs
model.tune(data="coco8.yaml", epochs=30, iterations=300, optimizer="AdamW", plots=False, save=False, val=False)

Para mais detalhes, confira a página de configuração do Ultralytics YOLO.

Quais são os benefícios de usar algoritmos genéticos para o ajuste de hiperparâmetros no YOLO26?

Algoritmos genéticos no Ultralytics YOLO26 fornecem um método robusto para explorar o espaço de hiperparâmetros, levando a um desempenho de modelo altamente otimizado. Os principais benefícios incluem:

• Busca Eficiente: O cruzamento BLX-α combina genes dos pais com maior fitness, enquanto a mutação log-normal perturba o resultado para descobrir novos candidatos.
• Evitar Mínimos Locais: Ao introduzir aleatoriedade, eles ajudam a evitar mínimos locais, garantindo uma melhor otimização global.
• Métricas de Desempenho: Eles se adaptam com base em uma pontuação de fitness específica da tarefa (mAP50-95 para detecção).

Para ver como os algoritmos genéticos podem otimizar hiperparâmetros, confira o guia de evolução de hiperparâmetros.

Quanto tempo leva o processo de ajuste de hiperparâmetros para o Ultralytics YOLO?

O tempo necessário para o ajuste de hiperparâmetros com o Ultralytics YOLO depende amplamente de vários fatores, como o tamanho do conjunto de dados, a complexidade da arquitetura do modelo, o número de iterações e os recursos computacionais disponíveis. Por exemplo, ajustar o YOLO26n em um conjunto de dados como o COCO8 por 30 épocas pode levar de várias horas a dias, dependendo do hardware.

Para gerenciar efetivamente o tempo de ajuste, defina um orçamento de ajuste claro com antecedência (link da seção interna). Isso ajuda a equilibrar a alocação de recursos e as metas de otimização.

Quais métricas devo usar para avaliar o desempenho do modelo durante o ajuste de hiperparâmetros no YOLO?

Ao avaliar o desempenho do modelo durante o ajuste de hiperparâmetros no YOLO, você pode usar várias métricas principais:

• AP50: A precisão média no limite de IoU de 0.50.
• F1-Score: A média harmônica da precisão e do recall.
• Precisão e Recall: Métricas individuais que indicam a acurácia do modelo na identificação de verdadeiros positivos versus falsos positivos e falsos negativos.

Essas métricas ajudam você a entender diferentes aspectos do desempenho do seu modelo. Consulte o guia de métricas de desempenho do Ultralytics YOLO para uma visão geral abrangente.

Posso usar o Ray Tune para otimização avançada de hiperparâmetros com o YOLO26?

Sim, o Ultralytics YOLO26 integra-se ao Ray Tune para otimização avançada de hiperparâmetros. O Ray Tune oferece algoritmos de busca sofisticados, como Otimização Bayesiana e Hyperband, juntamente com capacidades de execução paralela para acelerar o processo de ajuste.

Para usar o Ray Tune com o YOLO26, simplesmente defina o parâmetro use_ray=True na chamada do seu método model.tune(). Para mais detalhes e exemplos, confira o guia de integração do Ray Tune.