Link to this sectionGuia de Ajuste de Hiperparâmetros do Ultralytics YOLO#

Link to this sectionIntroduçã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 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 Plataforma Ultralytics também suporta treinamento na nuvem com hiperparâmetros configuráveis e rastreamento de métricas em tempo real.

Link to this sectionO 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 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.
• Número de Épocas epochs: Uma época é uma passagem completa de ida e volta 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 uma lista completa de hiperparâmetros de aumento usados no YOLO26, consulte a página de configurações.

Link to this sectionEvolução Genética e Mutação#

O Ultralytics YOLO usa 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 de maior 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, de modo que o algoritmo explore amplamente no início e refine conforme converge. A iteração 1 não tem pais para cruzamento e usa os hiperparâmetros de treinamento padrão como base.

Link to this sectionPreparação para o Ajuste de Hiperparâmetros#

Antes de iniciar o processo de ajuste, é importante:

1. Identificar as Métricas: Determine as métricas que você usará para avaliar o desempenho do modelo. Isso pode ser AP50, F1-score 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.

Link to this sectionEtapas Envolvidas#

Link to this sectionInicializar 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 no seu conhecimento de domínio ou experimentos anteriores.

Link to this sectionMutar 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.

Link to this sectionTreinar Modelo#

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

Link to this sectionAvaliar 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 que os anteriores.

Link to this sectionRegistrar 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.

Link to this sectionRepetir#

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.

Link to this sectionIterações e Tamanho da População#

Com o sintonizador integrado (use_ray=False), iterations controla o número total de tentativas sequenciais. Cada tentativa treina um modelo com uma configuração de hiperparâmetro — por exemplo, iterations=40 com epochs=50 agenda 40 execuções de treinamento independentes de 50 épocas, não uma execução de 50 épocas com uma população separada de 40 candidatos.

O algoritmo genético integrado não possui um parâmetro de tamanho de população explícito. Uma vez que existam tentativas anteriores, ele seleciona até nove das configurações de maior aptidão como pais, aplica o cruzamento BLX-α e mutação, e produz um candidato por iteração.

Para tentativas paralelas ou estratégias de busca mais avançadas, defina use_ray=True para usar o Ray Tune, que recebe iterations como num_samples. Veja o guia de integração do Ray Tune para detalhes.

Link to this sectionDescriçã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 tem um intervalo de valor específico definido por uma tupla (min, max).

Link to this sectionExemplo 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, salvamento de checkpoints 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,
)

Link to this sectionRetomando 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 name do diretório 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)

Link to this sectionResultados#

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:

Link to this sectionEstrutura de Arquivos#

Veja como ficará 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

Link to this sectionDescrições de Arquivos#

Link to this sectionbest_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 futuros treinamentos 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

Link to this sectiontune_fitness.png#

Este é um gráfico que exibe a aptidão em relação ao número de iterações. Ele ajuda você a visualizar como o algoritmo genético funcionou 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, então uma execução de conjunto de dados único mostra um ponto por iteração, e uma execução de 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 aptidão de nível superior por iteração.

Link to this sectiontune_results.ndjson#

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

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

Um exemplo formatado é mostrado abaixo para legibilidade. 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"
    }
}

A 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 cuja fitness é igual à fitness de nível superior. Um objeto JSON é registrado por iteração concluída. Os caminhos save_dirs reais são absolutos; eles estão abreviados acima por legibilidade.

Link to this sectiontune_scatter_plots.png#

Este arquivo contém gráficos de dispersão gerados a partir de 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 multiplicativo tem muito pouco para expandir a partir de um valor próximo de zero.

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

Link to this sectionweights/#

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 contém 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 aptidão.

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

Link to this sectionConclusão#

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

Link to this sectionLeitura 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 Tuner class e a documentação que a acompanha. Se você tiver alguma dúvida, solicitação de recurso ou precisar de mais assistência, sinta-se à vontade para entrar em contato conosco no GitHub ou no Discord.

Link to this sectionFAQ#

Link to this sectionComo 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, verifique a página de configuração do Ultralytics YOLO.

Link to this sectionQuais são os benefícios de usar algoritmos genéticos para 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 aptidão, enquanto a mutação log-normal perturba o resultado para descobrir novos candidatos.
• 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 uma pontuação de aptidão específica da tarefa (mAP50-95 para detecção).

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

Link to this sectionQuanto 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 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 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 antecipadamente (link da seção interna). Isso ajuda a equilibrar a alocação de recursos e as metas de otimização.

Link to this sectionQuais 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 em um limiar 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 em identificar 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.

Link to this sectionPosso 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, basta definir 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.