Link to this sectionAjuste de hiperparâmetros eficiente com Ray Tune e YOLO26#

O ajuste de hiperparâmetros é vital para alcançar o desempenho máximo do modelo, descobrindo o conjunto ideal de hiperparâmetros. Isso envolve executar tentativas com diferentes hiperparâmetros e avaliar o desempenho de cada uma.

Link to this sectionAcelere o ajuste com Ultralytics YOLO26 e Ray Tune#

Ultralytics YOLO26 incorpora o Ray Tune para ajuste de hiperparâmetros, simplificando a otimização dos hiperparâmetros do modelo YOLO26. Com o Ray Tune, tu podes utilizar estratégias de busca avançadas, paralelismo e parada antecipada para acelerar o processo de ajuste.

Link to this sectionRay Tune#

Ray Tune é uma biblioteca de ajuste de hiperparâmetros projetada para eficiência e flexibilidade. Ela suporta várias estratégias de busca, paralelismo e estratégias de parada antecipada, e integra-se perfeitamente com estruturas de machine learning populares, incluindo o Ultralytics YOLO26.

Link to this sectionIntegração com Weights & Biases#

O YOLO26 também permite a integração opcional com o Weights & Biases para monitorar o processo de ajuste.

Link to this sectionInstalação#

Para instalar os pacotes necessários, execute:

# Install and update Ultralytics and Ray Tune packages
pip install -U ultralytics "ray[tune]"

# Optionally install W&B for logging
pip install wandb

Link to this sectionUso#

from ultralytics import YOLO

# Load a YOLO26n model
model = YOLO("yolo26n.pt")

# Start tuning hyperparameters for YOLO26n training on the COCO8 dataset
result_grid = model.tune(data="coco8.yaml", use_ray=True)

Link to this sectionParâmetros do método tune()#

O método tune() no YOLO26 fornece uma interface fácil de usar para ajuste de hiperparâmetros com o Ray Tune. Ele aceita vários argumentos que te permitem personalizar o processo de ajuste. Abaixo está uma explicação detalhada de cada parâmetro:

Ao personalizar esses parâmetros, podes ajustar o processo de otimização de hiperparâmetros para atender às tuas necessidades específicas e aos recursos computacionais disponíveis.

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 com o Ray Tune. Cada parâmetro tem uma faixa de valor específica definida por tune.uniform().

Link to this sectionExemplo de Espaço de Busca Personalizado#

Neste exemplo, demonstramos como usar um espaço de busca personalizado para ajuste de hiperparâmetros com Ray Tune e YOLO26. Ao fornecer um espaço de busca personalizado, podes concentrar o processo de ajuste em hiperparâmetros específicos de interesse.

from ray import tune

from ultralytics import YOLO

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

# Run Ray Tune on the model
result_grid = model.tune(
    data="coco8.yaml",
    space={"lr0": tune.uniform(1e-5, 1e-2)},
    epochs=50,
    use_ray=True,
)

No trecho de código acima, criamos um modelo YOLO com os pesos pré-treinados "yolo26n.pt". Em seguida, chamamos o método tune(), especificando a configuração do dataset com "coco8.yaml". Fornecemos um espaço de busca personalizado para a taxa de aprendizado inicial lr0 usando um dicionário com a chave "lr0" e o valor tune.uniform(1e-5, 1e-2). Finalmente, passamos argumentos de treinamento adicionais, como o número de épocas, diretamente para o método tune como epochs=50.

Link to this sectionExemplo de Algoritmo de Busca#

Podes selecionar uma estratégia de busca do Ray Tune pelo nome. Para algoritmos de busca baseados em string, o Ultralytics usará automaticamente a métrica de otimização padrão da tarefa atual e mode="max". Se search_alg não for fornecido, o Ray Tune usa a sua estratégia de busca aleatória padrão, BasicVariantGenerator.

from ultralytics import YOLO

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

result_grid = model.tune(
    data="coco8.yaml",
    epochs=50,
    search_alg="optuna",
    use_ray=True,
)

Se precisares de personalizar o amostrador do pesquisador ou substituir a sua métrica e modo de otimização, passa um objeto de pesquisa do Ray Tune instanciado em vez de uma string.

from ray.tune.search.optuna import OptunaSearch

from ultralytics import YOLO

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

# Define a searcher
searcher = OptunaSearch(
    metric="metrics/mAP50-95(B)",
    mode="max",
)

result_grid = model.tune(
    data="coco8.yaml",
    epochs=50,
    search_alg=searcher,
    use_ray=True,
)

Link to this sectionRetomando uma Sessão de Ajuste de Hiperparâmetros Interrompida com o Ray Tune#

Podes retomar uma sessão interrompida do Ray Tune passando resume=True. Podes opcionalmente passar o diretório name usado pelo Ray Tune em runs/{task} para retomar. Caso contrário, ele retomará a última sessão interrompida. Não precisas de fornecer iterations e space novamente, mas precisas de fornecer o restante dos argumentos de treinamento novamente, incluindo data e epochs.

from ultralytics import YOLO

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

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

# Resume Ray Tune run with name 'tune_exp_2'
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, name="tune_exp_2", resume=True)

Link to this sectionProcessando Resultados do Ray Tune#

Após executar um experimento de ajuste de hiperparâmetros com o Ray Tune, podes querer realizar várias análises nos resultados obtidos. Este guia vai orientar-te através de fluxos de trabalho comuns para processar e analisar esses resultados.

Link to this sectionCarregando Resultados de Experimentos do Tune a partir de um Diretório#

Após executar o experimento de ajuste com tuner.fit(), podes carregar os resultados de um diretório. Isto é útil, especialmente se estiveres a realizar a análise após o script inicial de treino ter terminado.

experiment_path = f"{storage_path}/{exp_name}"
print(f"Loading results from {experiment_path}...")

restored_tuner = tune.Tuner.restore(experiment_path, trainable=train_mnist)
result_grid = restored_tuner.get_results()

Link to this sectionAnálise Básica ao Nível do Experimento#

Obtém uma visão geral de como os testes se comportaram. Podes verificar rapidamente se ocorreram erros durante os testes.

if result_grid.errors:
    print("One or more trials failed!")
else:
    print("No errors!")

Link to this sectionAnálise Básica ao Nível do Teste#

Acede às configurações individuais de hiperparâmetros de cada teste e às últimas métricas reportadas.

for i, result in enumerate(result_grid):
    print(f"Trial #{i}: Configuration: {result.config}, Last Reported Metrics: {result.metrics}")

Link to this sectionPlotar todo o histórico de métricas reportadas para um teste#

Podes plotar o histórico de métricas reportadas para cada teste para ver como as métricas evoluíram ao longo do tempo.

import matplotlib.pyplot as plt

for i, result in enumerate(result_grid):
    plt.plot(
        result.metrics_dataframe["training_iteration"],
        result.metrics_dataframe["mean_accuracy"],
        label=f"Trial {i}",
    )

plt.xlabel("Training Iterations")
plt.ylabel("Mean Accuracy")
plt.legend()
plt.show()

Link to this sectionResumo#

Neste guia, cobrimos fluxos de trabalho comuns para analisar os resultados de experimentos executados com Ray Tune usando Ultralytics. Os passos principais incluem carregar os resultados do experimento de um diretório, realizar análises básicas ao nível do experimento e do teste, e plotar métricas.

Explora mais consultando a página de documentação Analyze Results do Ray Tune para tirares o máximo proveito dos teus experimentos de ajuste de hiperparâmetros.

Link to this sectionFAQ#

Link to this sectionComo ajusto os hiperparâmetros do meu modelo YOLO26 usando o Ray Tune?#

Para ajustar os hiperparâmetros do teu modelo Ultralytics YOLO26 usando o Ray Tune, segue estes passos:

1. Instala os pacotes necessários:

   pip install -U ultralytics "ray[tune]"
   pip install wandb # optional for logging

2. Carrega o teu modelo YOLO26 e inicia o ajuste:

   from ultralytics import YOLO
   
   # Load a YOLO26 model
   model = YOLO("yolo26n.pt")
   
   # Start tuning with the COCO8 dataset
   result_grid = model.tune(data="coco8.yaml", use_ray=True)

Isto utiliza as estratégias de pesquisa avançadas e o paralelismo do Ray Tune para otimizar eficientemente os hiperparâmetros do teu modelo. Para mais informações, consulta a documentação do Ray Tune.

Link to this sectionQuais são os hiperparâmetros padrão para o ajuste do YOLO26 com o Ray Tune?#

O Ultralytics YOLO26 usa os seguintes hiperparâmetros padrão para ajuste com o Ray Tune:

Estes hiperparâmetros podem ser personalizados para atender às tuas necessidades específicas. Para uma lista completa e mais detalhes, consulta o guia de Ajuste de Hiperparâmetros.

Link to this sectionComo posso integrar o Weights & Biases com o ajuste do meu modelo YOLO26?#

Para integrar o Weights & Biases (W&B) com o teu processo de ajuste do Ultralytics YOLO26:

1. Instala o W&B:

   pip install wandb

2. Modifica o teu script de ajuste:

   import wandb
   
   from ultralytics import YOLO
   
   wandb.init(project="YOLO-Tuning", entity="your-entity")
   
   # Load YOLO model
   model = YOLO("yolo26n.pt")
   
   # Tune hyperparameters
   result_grid = model.tune(data="coco8.yaml", use_ray=True)

Esta configuração permitir-te-á monitorizar o processo de ajuste, rastrear configurações de hiperparâmetros e visualizar resultados no W&B.

Link to this sectionPor que devo usar o Ray Tune para otimização de hiperparâmetros com o YOLO26?#

O Ray Tune oferece inúmeras vantagens para a otimização de hiperparâmetros:

• Estratégias de Pesquisa Avançadas: Utiliza algoritmos como Bayesian Optimization e HyperOpt para uma pesquisa eficiente de parâmetros.
• Paralelismo: Suporta a execução paralela de múltiplos testes, acelerando significativamente o processo de ajuste.
• Paragem Precoce (Early Stopping): Emprega estratégias como o ASHA para terminar precocemente testes com baixo desempenho, poupando recursos computacionais.

O Ray Tune integra-se perfeitamente com o Ultralytics YOLO26, fornecendo uma interface fácil de usar para ajustar hiperparâmetros eficazmente. Para começar, consulta o guia de Ajuste de Hiperparâmetros.

Link to this sectionComo posso definir um espaço de pesquisa personalizado para o ajuste de hiperparâmetros do YOLO26?#

Para definir um espaço de pesquisa personalizado para o teu ajuste de hiperparâmetros do YOLO26 com o Ray Tune:

from ray import tune

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
search_space = {"lr0": tune.uniform(1e-5, 1e-2), "momentum": tune.uniform(0.7, 0.98)}
result_grid = model.tune(data="coco8.yaml", space=search_space, use_ray=True)

Isto personaliza o intervalo de hiperparâmetros como a taxa de aprendizagem inicial e o momentum a serem explorados durante o processo de ajuste. Para configurações avançadas, consulta a secção Exemplo de Espaço de Pesquisa Personalizado.