Guia de Ajuste de Hiperparâmetros do Ultralytics YOLO

Introdução

O ajuste de hiperparâmetros não é apenas uma configuração única, mas um processo iterativo destinado a otimizar as métricas de desempenho do modelo de aprendizado de máquina, como precisão, exatidão e recall. No contexto do Ultralytics YOLO, esses hiperparâmetros podem variar desde a taxa de aprendizado até detalhes arquitetônicos, como o número de camadas ou os tipos de funções de ativação usadas.

Assista: Como Ajustar Hiperparâmetros para Melhor Desempenho do Modelo 🚀

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 ela. Aqui estão alguns hiperparâmetros comumente ajustados no Ultralytics YOLO:

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

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

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

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

• Mutação: No contexto do Ultralytics YOLO, a mutação ajuda na busca local no espaço de hiperparâmetros, aplicando pequenas mudanças aleatórias aos hiperparâmetros existentes, produzindo novos candidatos para avaliação.
• Crossover: Embora o crossover seja uma técnica popular de algoritmo genético, ele não é usado atualmente no Ultralytics YOLO para ajuste de hiperparâmetros. O foco está principalmente na mutação para gerar novos conjuntos de hiperparâmetros.

Preparando-se para o Ajuste de Hiperparâmetros

Antes de iniciar o processo de ajuste, é importante:

1. Identifique as Métricas: Determine as métricas que você usará para avaliar o desempenho do modelo. Isso pode ser AP50, F1-score ou outros.
2. Defina 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 os hiperparâmetros padrão definidos pelo Ultralytics YOLO ou algo baseado em seu conhecimento de domínio ou experimentos anteriores.

Mutar Hiperparâmetros

Use o comando _mutate método para produzir um novo conjunto de hiperparâmetros com base no conjunto existente. O Classe Tuner gerencia este processo automaticamente.

Treinar Modelo

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

Avaliar Modelo

Use métricas como AP50, F1-score 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 do 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 em formato CSV.

Repetir

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

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

A tabela a seguir lista os parâmetros de espaço de busca padrão para ajuste de hiperparâmetros em YOLO11. Cada parâmetro tem um intervalo de valores 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 model.tune() método para utilizar o Tuner classe para ajuste de hiperparâmetros do YOLO11n no COCO8 para 30 épocas com um otimizador AdamW e ignorando plotagem, checkpointing e validação, exceto na época final para um ajuste mais rápido.

from ultralytics import YOLO

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

# Define search space
search_space = {
    "lr0": (1e-5, 1e-1),
    "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, retomará a última sessão interrompida. Também precisa fornecer todos os argumentos de treino anteriores, incluindo data, epochs, iterations e space.

from ultralytics import YOLO

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

# Define search space
search_space = {
    "lr0": (1e-5, 1e-1),
    "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

Depois de concluir com sucesso o processo de ajuste de hiperparâmetros, você obterá vários arquivos e diretórios que encapsulam os resultados do ajuste. A seguir, descrevemos 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, ou seja, um modelo treinado com um conjunto de hiperparâmetros. O tune/ o diretório contém os resultados de ajuste de todos os treinamentos de modelo individuais:

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

Descrições de Arquivos

best_hyperparameters.yaml

Este arquivo YAML contém os hiperparâmetros de melhor desempenho encontrados durante o processo de ajuste. Você pode usar este arquivo para inicializar treinamentos futuros com estas 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
  

best_fitness.png

Este é um gráfico que exibe a aptidão (normalmente uma métrica de desempenho como AP50) em relação ao número de iterações. Ele ajuda você a visualizar o desempenho do algoritmo genético ao longo do tempo.

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

tune_results.csv

Um arquivo CSV contendo resultados detalhados de cada iteração durante o ajuste. Cada linha no arquivo representa uma iteração e inclui métricas como pontuação de aptidão, precisão, recall, bem como os hiperparâmetros usados.

• Formato: CSV
• Uso: Rastreamento de resultados por iteração.
• Exemplo:

    fitness,lr0,lrf,momentum,weight_decay,warmup_epochs,warmup_momentum,box,cls,dfl,hsv_h,hsv_s,hsv_v,degrees,translate,scale,shear,perspective,flipud,fliplr,mosaic,mixup,copy_paste
    0.05021,0.01,0.01,0.937,0.0005,3.0,0.8,7.5,0.5,1.5,0.015,0.7,0.4,0.0,0.1,0.5,0.0,0.0,0.0,0.5,1.0,0.0,0.0
    0.07217,0.01003,0.00967,0.93897,0.00049,2.79757,0.81075,7.5,0.50746,1.44826,0.01503,0.72948,0.40658,0.0,0.0987,0.4922,0.0,0.0,0.0,0.49729,1.0,0.0,0.0
    0.06584,0.01003,0.00855,0.91009,0.00073,3.42176,0.95,8.64301,0.54594,1.72261,0.01503,0.59179,0.40658,0.0,0.0987,0.46955,0.0,0.0,0.0,0.49729,0.80187,0.0,0.0
  

tune_scatter_plots.png

Este ficheiro contém diagramas de dispersão gerados a partir de tune_results.csv, ajudando você a visualizar as relações entre diferentes hiperparâmetros e métricas de desempenho. Observe que os hiperparâmetros inicializados em 0 não serão ajustados, como degrees e shear abaixo.

• Formato: PNG
• Utilização: Análise exploratória de dados

weights/

Este diretório contém os modelos PyTorch salvos para as últimas e as melhores iterações durante o processo de ajuste de hiperparâmetros.

• last.pt: O last.pt são os pesos da última época de treino.
• 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 os seus futuros treinos e análises de modelos. Sinta-se à vontade para consultar esses artefatos para entender o desempenho do seu modelo e como você pode melhorá-lo ainda mais.

Conclusão

O processo de ajuste de hiperparâmetros no Ultralytics YOLO é simplificado, mas poderoso, graças à sua abordagem baseada em algoritmo genético focada na mutação. Seguir os passos descritos neste guia o ajudará a ajustar sistematicamente o seu modelo para obter um melhor desempenho.

Leitura Adicional

1. Otimização de Hiperparâmetros na Wikipédia
2. Guia de Evolução de Hiperparâmetros YOLOv5
3. Ajuste Eficiente de Hiperparâmetros com Ray Tune e YOLO11

Para obter informações mais detalhadas, você pode explorar o Tuner classe código fonte e documentação que o acompanha. Se tiver alguma questão, pedido de funcionalidade ou precisar de mais assistência, sinta-se à vontade para nos contactar em GitHub ou Discord.

FAQ

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

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

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolo11n.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 obter mais detalhes, consulte a página de configuração do Ultralytics YOLO.

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

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

• Pesquisa Eficiente: Algoritmos genéticos como a mutação podem explorar rapidamente um grande conjunto de hiperparâmetros.
• Evitando 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 métricas de desempenho, como AP50 e F1-score.

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

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

O tempo necessário para o ajuste de hiperparâmetros com Ultralytics YOLO depende muito 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 YOLO11n 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 antecipadamente (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 importantes:

• AP50: A precisão média no limite de IoU de 0,50.
• F1-Score: A média harmônica de precisão e recall.
• Precisão e Recall: Métricas individuais que indicam a precisão 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 obter uma visão geral abrangente.

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

Sim, o Ultralytics YOLO11 integra-se com o Ray Tune para otimização avançada de hiperparâmetros. O Ray Tune oferece algoritmos de pesquisa 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 YOLO11, simplesmente defina o use_ray=True parâmetro no seu model.tune() chamada de método. Para mais detalhes e exemplos, consulte o Guia de integração do Ray Tune.

📅 Criado há 1 ano ✏️ Atualizado há 3 meses

Comentários