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

O ajuste de hiperparâmetros no Ultralytics YOLO é uma pesquisa iterativa e automatizada que otimiza configurações — como taxa de aprendizado, pesos de perda e força de aumento — para maximizar as métricas de desempenho de um modelo de machine learning, como precisão, acurácia e recall. Em vez de testar esses valores manualmente, o Ultralytics YOLO explora o espaço de hiperparâmetros com um algoritmo genético que muta e avalia configurações candidatas em vários treinos curtos.

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 sectionComo funciona o loop de ajuste#

Para cada iteração, o ajustador (tuner) integrado repete o seguinte loop:

1. Inicializar hiperparâmetros — comece a partir de uma base razoável, seja os hiperparâmetros padrão definidos pelo Ultralytics YOLO ou valores baseados no seu conhecimento de domínio ou experimentos anteriores.
2. Mutar hiperparâmetros — a classe Tuner produz um novo conjunto de hiperparâmetros a partir do conjunto existente com o seu método _mutate, automaticamente.
3. Treinar o modelo — treine usando os hiperparâmetros mutados e, em seguida, avalie o desempenho do treino com as métricas escolhidas.
4. Avaliar o modelo — utiliza métricas como AP50, F1-score ou métricas personalizadas através do processo de avaliação para determinar se os hiperparâmetros atuais melhoram em relação aos anteriores.
5. Registrar resultados — grave 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.
6. Repetir — continue até que o número definido de iterações seja atingido ou que a métrica de desempenho seja satisfatória, com cada iteração aproveitando o conhecimento obtido 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 sectionEspaço de pesquisa 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 (pretty-printed) segue 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"
    }
}

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 futuros treinos e análises de modelos.

Link to this sectionConclusão#

O ajuste de hiperparâmetros no Ultralytics YOLO é simples de iniciar e poderoso internamente, combinando crossover BLX-α com mutação log-normal em um algoritmo genético. Seguir o loop descrito neste guia permite que você ajuste sistematicamente seu modelo para um melhor desempenho e, em seguida, reutilize o arquivo best_hyperparameters.yaml resultante para inicializar futuras execuções de treino. Para escalar o ajuste em tentativas paralelas e usar algoritmos de pesquisa mais avançados, continue com o guia de integração do Ray Tune ou execute jobs gerenciados com hiperparâmetros configuráveis e rastreamento de métricas em tempo real na Ultralytics Platform via treinamento na nuvem.

Para informações mais profundas, explora o código-fonte da classe Tuner. Se tiveres dúvidas ou pedidos de funcionalidades, entra em contacto 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?#

Defina um valor inicial com o parâmetro lr0 — valores comuns variam de 0.001 a 0.01 — e deixe o ajuste mutá-lo a partir daí para encontrar o ótimo. Você pode automatizar isso com o método model.tune(). 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 os algoritmos genéticos podem otimizar hiperparâmetros, confere 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 com antecedência, conforme abordado em Preparing for Hyperparameter Tuning. 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.