Ajuste de hiperparâmetros eficiente com Ray Tune e YOLO26

O ajuste de hiperparâmetros é vital para alcançar o desempenho máximo do modelo ao descobrir o conjunto ideal de hiperparâmetros. Isso envolve executar testes com diferentes hiperparâmetros e avaliar o desempenho de cada teste.

Acelere 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, você pode utilizar estratégias de busca avançadas, paralelismo e parada antecipada para agilizar o processo de ajuste.

Ray 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 populares de machine learning, incluindo o Ultralytics YOLO26.

Integração com Weights & Biases

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

Instalaçã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

Utilização

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)

Parâmetros do método tune()

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

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

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

A tabela a seguir lista os parâmetros do espaço de busca padrão para o ajuste de hiperparâmetros no YOLO26 com o Ray Tune. Cada parâmetro tem um intervalo de valores específico definido por tune.uniform().

Exemplo 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, você pode concentrar o processo de ajuste em hiperparâmetros de interesse específicos.

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 de ajuste como epochs=50.

Exemplo de algoritmo de busca

Você pode selecionar uma estratégia de busca do Ray Tune por 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 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 você precisar personalizar o amostrador do buscador ou substituir sua métrica e modo de otimização, passe um objeto de busca 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,
)

Retomando uma sessão de ajuste de hiperparâmetros interrompida com Ray Tune

Você pode retomar uma sessão do Ray Tune interrompida passando resume=True. Opcionalmente, você pode passar o diretório name usado pelo Ray Tune em runs/{task} para retomar. Caso contrário, ele retomará a última sessão interrompida. Você não precisa fornecer iterations e space novamente, mas precisa 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)

Processando resultados do Ray Tune

Após executar um experimento de ajuste de hiperparâmetros com Ray Tune, você pode querer realizar várias análises sobre os resultados obtidos. Este guia o levará pelos fluxos de trabalho comuns para processar e analisar esses resultados.

Carregando resultados de experimentos de ajuste de um diretório

Após executar o experimento de ajuste com tuner.fit(), você pode carregar os resultados de um diretório. Isso é útil, especialmente se você estiver realizando a análise após o script de treinamento inicial 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()

Análise básica em nível de experimento

Obtenha uma visão geral de como os testes se saíram. Você pode verificar rapidamente se houve algum erro durante os testes.

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

Análise básica em nível de teste

Acesse as configurações de hiperparâmetros de testes individuais e as últimas métricas relatadas.

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

Plotando todo o histórico de métricas relatadas para um teste

Você pode plotar o histórico de métricas relatadas 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()

Resumo

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

Explore mais consultando a página de documentação Analyze Results do Ray Tune para aproveitar ao máximo seus experimentos de ajuste de hiperparâmetros.

FAQ

Como ajusto os hiperparâmetros do meu modelo YOLO26 usando Ray Tune?

Para ajustar os hiperparâmetros do seu modelo Ultralytics YOLO26 usando Ray Tune, siga estas etapas:

1. Instale os pacotes necessários:

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

2. Carregue seu modelo YOLO26 e comece 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)

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

Quais são os hiperparâmetros padrão para ajuste do YOLO26 com Ray Tune?

O Ultralytics YOLO26 usa os seguintes hiperparâmetros padrão para ajuste com 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 Hyperparameter Tuning.

Como 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.

Por 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 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 de forma eficaz. Para começar, consulta o guia de Hyperparameter Tuning.

Como 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 momento, a serem explorados durante o processo de ajuste. Para configurações avançadas, consulta a secção Custom Search Space Example.