Ajuste eficiente de hiperparâmetros com Ray Tune e YOLO26#

O ajuste de hiperparâmetros é essencial para alcançar o melhor desempenho do modelo, pois permite descobrir o conjunto ideal de hiperparâmetros. Isso envolve executar experimentos com diferentes hiperparâmetros e avaliar o desempenho de cada um.

Acelere o ajuste com Ultralytics YOLO26 e Ray Tune#

Ultralytics YOLO26 incorpora o Ray Tune para ajustar hiperparâmetros, simplificando a otimização dos hiperparâmetros do modelo YOLO26. Com o Ray Tune, você pode usar estratégias avançadas de busca, paralelismo e interrupção antecipada para acelerar o processo de ajuste.

Ray Tune#

Ray Tune é uma biblioteca de ajuste de hiperparâmetros projetada para oferecer eficiência e flexibilidade. Ela oferece suporte a várias estratégias de busca, paralelismo e estratégias de interrupção antecipada, além de se integrar perfeitamente a frameworks populares de aprendizado de máquina, incluindo Ultralytics YOLO26.

Integração com Weights & Biases#

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, executa:

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

# Optionally install and enable W&B for per-trial logging
pip install wandb
yolo settings wandb=True

Uso#

from ultralytics import YOLO

# Carregar um modelo YOLO26n
model = YOLO("yolo26n.pt")

# Iniciar o ajuste dos hiperparâmetros para o treinamento de YOLO26n no conjunto de dados COCO8
result_grid = model.tune(data="coco8.yaml", use_ray=True)

Parâmetros do método tune()#

O método tune() no YOLO26 oferece uma interface fácil de usar para ajustar hiperparâmetros com o Ray Tune. Ele aceita vários argumentos que permitem personalizar o processo de ajuste. A seguir, explicamos cada parâmetro em detalhes:

Ao personalizar esses parâmetros, você pode ajustar o processo de otimização de hiperparâmetros à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 padrão do espaço de busca 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(), exceto close_mosaic, que usa tune.randint().

Exemplo de espaço de busca personalizado#

Neste exemplo, mostramos como usar um espaço de busca personalizado para ajustar hiperparâmetros com o Ray Tune e o YOLO26. Ao fornecer um espaço de busca personalizado, você pode concentrar o processo de ajuste nos hiperparâmetros específicos que deseja otimizar.

from ray import tune

from ultralytics import YOLO

# Define um modelo YOLO
model = YOLO("yolo26n.pt")

# Executar o Ray Tune no modelo
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() e especificamos a configuração do conjunto de dados 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). Por fim, passamos argumentos adicionais de treinamento, como o número de épocas, diretamente ao método de ajuste como epochs=50.

Exemplo de algoritmo de busca#

Você pode selecionar uma estratégia de busca do Ray Tune pelo nome. Para algoritmos de busca baseados em strings, 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 Ultralytics usará o TPE multivariado do Optuna com sugestões que levam o paralelismo em conta.

from ultralytics import YOLO

# Define um modelo YOLO
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 mecanismo de busca ou substituir a métrica e o modo de otimização, passe um objeto instanciado do mecanismo de busca do Ray Tune em vez de uma string.

from ray.tune.search.optuna import OptunaSearch

from ultralytics import YOLO

# Define um modelo YOLO
model = YOLO("yolo26n.pt")

# Definir um mecanismo de busca
searcher = OptunaSearch(
    metric="metrics/mAP50-95(B)",
    mode="max",
)

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

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

Você pode retomar uma sessão interrompida do Ray Tune passando resume=True. Opcionalmente, você pode passar o diretório name usado pelo Ray Tune em runs/{task} para retomar a sessão. Caso contrário, a última sessão interrompida será retomada. Não é necessário fornecer novamente iterations e space, mas você precisa fornecer novamente os demais argumentos de treinamento, incluindo data e epochs.

from ultralytics import YOLO

# Define um modelo YOLO
model = YOLO("yolo26n.pt")

# Retoma a execução anterior
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, resume=True)

# Retomar a execução do Ray Tune com o nome 'tune_exp_2'
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, name="tune_exp_2", resume=True)

Processar os resultados do Ray Tune#

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

Carregar os resultados do experimento do Tune a partir de um diretório#

model.tune(use_ray=True) retorna um Ray ResultGrid e salva o experimento em runs/{task}/tune ou no diretório name que você especificou. Para carregar esses resultados depois que o script original tiver sido encerrado, retome a sessão; isso restaura os experimentos salvos e retorna o mesmo ResultGrid:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
result_grid = model.tune(data="coco8.yaml", epochs=50, use_ray=True, resume=True)

Análise básica no nível do experimento#

Obtenha uma visão geral do desempenho dos experimentos. Você pode verificar rapidamente se ocorreram erros durante a execução.

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

Análise básica no nível do experimento individual#

Acesse as configurações de hiperparâmetros de cada experimento 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}")

Traçar o histórico completo das métricas relatadas para um experimento#

Você pode traçar o histórico das métricas relatadas para cada experimento e ver como elas 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["metrics/mAP50-95(B)"],
        label=f"Trial {i}",
    )

plt.xlabel("Training Iterations")
plt.ylabel("mAP50-95")
plt.legend()
plt.show()

Resumo#

Neste guia, abordamos fluxos de trabalho comuns para analisar os resultados de experimentos executados com o Ray Tune usando o Ultralytics. As principais etapas incluem carregar os resultados do experimento a partir de um diretório, realizar análises básicas no nível do experimento e dos experimentos individuais e traçar as métricas.

Explore mais a fundo a página da documentação do Ray Tune sobre análise de resultados para aproveitar ao máximo seus experimentos de ajuste de hiperparâmetros.

Perguntas frequentes#