Ultralytics YOLO Guia de afinação de hiperparâmetros

Introdução

A afinação dos hiperparâmetros não é apenas uma configuração única, mas um processo iterativo destinado a otimizar os parâmetros de desempenho do modelo de aprendizagem automática, como a exatidão, a precisão e a recuperação. No contexto de Ultralytics YOLO , estes hiperparâmetros podem variar desde a taxa de aprendizagem até aos detalhes da arquitetura, como o número de camadas ou os tipos de funções de ativação utilizadas.

O que são hiperparâmetros?

Os hiperparâmetros são definições estruturais de alto nível para o algoritmo. São definidos antes da fase de treino e permanecem constantes durante a mesma. Aqui estão alguns hiperparâmetros comumente ajustados em Ultralytics YOLO :

• Taxa de aprendizagem 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 numa passagem para a frente.
• Número de épocas epochs: Uma época é uma passagem completa para a frente e para trás de todos os exemplos de treino.
• Especificidades da arquitetura: Como a contagem de canais, o número de camadas, os tipos de funções de ativação, etc.

Para obter uma lista completa dos hiperparâmetros de aumento utilizados em YOLOv8 , consulta a página de configurações.

Evolução genética e mutação

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

• Mutação: No contexto de Ultralytics YOLO , a mutação ajuda a pesquisar localmente o espaço dos hiperparâmetros, aplicando pequenas alterações aleatórias aos hiperparâmetros existentes, produzindo novos candidatos para avaliação.
• Cruzamento: Embora o crossover seja uma técnica popular de algoritmo genético, não é atualmente utilizado em Ultralytics YOLO para afinação de hiperparâmetros. O foco está principalmente na mutação para gerar novos conjuntos de hiperparâmetros.

Preparação para o ajuste de hiperparâmetros

Antes de iniciares o processo de afinação, é importante:

1. Identifica as métricas: Determina as métricas que utilizarás para avaliar o desempenho do modelo. Pode ser AP50, F1-score ou outros.
2. Define o orçamento do Tuning: Define a quantidade de recursos computacionais que estás disposto a atribuir. O ajuste de hiperparâmetros pode ser computacionalmente intensivo.

Etapas envolvidas

Inicializa os hiperparâmetros

Começa com um conjunto razoável de hiperparâmetros iniciais. Este pode ser o conjunto de hiperparâmetros predefinido por Ultralytics YOLO ou algo baseado no teu conhecimento do domínio ou em experiências anteriores.

Mutação de hiperparâmetros

Utiliza o _mutate para produzir um novo conjunto de hiperparâmetros com base no conjunto existente.

Modelo de comboio

O treino é efectuado utilizando o conjunto mutado de hiperparâmetros. O desempenho do treino é então avaliado.

Avalia o modelo

Utiliza métricas como AP50, F1-score ou métricas personalizadas para avaliar o desempenho do modelo.

Resultados do registo

É crucial registar tanto as métricas de desempenho como os hiperparâmetros correspondentes para referência futura.

Repete

O processo é repetido até que o número definido de iterações seja atingido ou a métrica de desempenho seja satisfatória.

Exemplo de utilização

Vê aqui como utilizar o model.tune() para utilizar o método Tuner classe para a afinação de hiperparâmetros de YOLOv8n no COCO8 durante 30 épocas com um optimizador AdamW e saltando a plotagem, o ponto de controlo e a validação, exceto na última época, para uma afinação mais rápida.

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO('yolov8n.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)

Resultados

Depois de ter concluído com êxito o processo de afinação dos hiperparâmetros, obtém vários ficheiros e directórios que encapsulam os resultados da afinação. A seguir, descreve cada um deles:

Estrutura do ficheiro

Eis como será a estrutura de directórios dos resultados. Treina directórios como train1/ contém iterações de afinação individuais, ou seja, um modelo treinado com um conjunto de hiperparâmetros. Os tune/ contém os resultados da afinação de todos os treinos de modelos 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 ficheiros

best_hyperparameters.yaml

Este arquivo YAML contém os hiperparâmetros de melhor desempenho encontrados durante o processo de ajuste. Podes utilizar este ficheiro para inicializar treinos futuros com estas definições optimizadas.

• Formato: YAML
• Usa: Resultados do hiperparâmetro
• 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
  

melhor_fitness.png

Este é um gráfico que mostra a aptidão (normalmente uma métrica de desempenho como AP50) contra o número de iterações. Ajuda-te a visualizar o desempenho do algoritmo genético ao longo do tempo.

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

sintoniza_resultados.csv

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

• Formato: CSV
• Usa-o: Acompanhamento 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 gráficos de dispersão gerados a partir de tune_results.csvajudando-te a visualizar as relações entre diferentes hiperparâmetros e métricas de desempenho. Observa que os hiperparâmetros inicializados em 0 não serão ajustados, como degrees e shear abaixo.

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

pesos/

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

• last.pt: Os last.pt são os pesos da última época de treino.
• best.pt: Os pesos best.pt para a iteração que obteve a melhor pontuação de aptidão.

Utilizando estes resultados, podes tomar decisões mais informadas para as tuas futuras formações e análises de modelos. Não hesites em consultar estes artefactos para compreenderes o desempenho do teu modelo e como o podes melhorar ainda mais.

Conclusão

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

Ler mais

1. Otimização de hiperparâmetros na Wikipédia
2. YOLOv5 Guia de evolução de hiperparâmetros
3. Afinação eficiente de hiperparâmetros com Ray Tune e YOLOv8

Para obteres informações mais detalhadas, podes explorar a Tuner código-fonte da classe e a documentação que a acompanha. Se tiveres dúvidas, pedidos de funcionalidades ou precisares de mais assistência, não hesites em contactar-nos através de GitHub ou Discórdia.

Comentários