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

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

Acelera o ajuste com Ultralytics YOLO26 e Ray Tune#

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

Ray Tune#

Ray Tune é uma biblioteca de ajuste de hiperparâmetros concebida para oferecer eficiência e flexibilidade. É compatível com várias estratégias de pesquisa, paralelismo e estratégias de paragem antecipada, além de se integrar perfeitamente com frameworks populares de machine learning, incluindo o Ultralytics YOLO26.

Integração com Weights & Biases#

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

Instalação#

Para instalares 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

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 utilizar para o ajuste de hiperparâmetros com o Ray Tune. Aceita vários argumentos que permitem personalizar o processo de ajuste. Abaixo encontra-se uma explicação detalhada de cada parâmetro:

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

Descrição do espaço de pesquisa predefinido#

A tabela seguinte apresenta os parâmetros predefinidos do espaço de pesquisa 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 pesquisa personalizado#

Neste exemplo, demonstramos como utilizar um espaço de pesquisa personalizado para o ajuste de hiperparâmetros com o Ray Tune e o YOLO26. Ao forneceres um espaço de pesquisa personalizado, podes concentrar o processo de ajuste em hiperparâmetros específicos do teu 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 fragmento 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 conjunto de dados com "coco8.yaml". Fornecemos um espaço de pesquisa personalizado para a taxa de aprendizagem inicial lr0 utilizando um dicionário com a chave "lr0" e o valor tune.uniform(1e-5, 1e-2). Por fim, passamos argumentos de treino adicionais, como o número de épocas, diretamente ao método tune como epochs=50.

Exemplo de algoritmo de pesquisa#

Podes selecionar uma estratégia de pesquisa do Ray Tune pelo nome. Para algoritmos de pesquisa baseados em cadeias de texto, o Ultralytics utiliza automaticamente a métrica de otimização predefinida da tarefa atual e mode="max". Se search_alg não for fornecido, o Ultralytics utiliza o TPE multivariado do Optuna com sugestões cientes do paralelismo.

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 respetiva métrica e o modo de otimização, passa um objeto de pesquisa do Ray Tune instanciado em vez de uma cadeia de texto.

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,
)

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

Podes retomar uma sessão interrompida do Ray Tune passando resume=True. Opcionalmente, podes passar o diretório name utilizado pelo Ray Tune em runs/{task} para retomar a sessão. Caso contrário, será retomada a última sessão interrompida. Não precisas de fornecer novamente iterations e space, mas tens de fornecer novamente os restantes argumentos de treino, 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)

Processar resultados do Ray Tune#

Depois de executares uma experiência de ajuste de hiperparâmetros com o Ray Tune, poderás querer realizar várias análises aos resultados obtidos. Este guia apresenta os fluxos de trabalho comuns para processar e analisar esses resultados.

Carregar resultados da experiência do Tune a partir de um diretório#

O model.tune(use_ray=True) devolve um Ray ResultGrid e guarda a experiência em runs/{task}/tune, ou em name que passaste. Para carregar esses resultados após o script original ter terminado, retoma a sessão, o que restaura os testes guardados e devolve 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 ao nível da experiência#

Obtém uma visão geral do desempenho dos testes. Podes verificar rapidamente se ocorreram erros durante os testes.

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

Análise básica ao nível do teste#

Acede às configurações de hiperparâmetros de testes individuais e às últimas métricas comunicadas.

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

Representar graficamente todo o histórico das métricas comunicadas de um teste#

Podes representar graficamente o histórico das métricas de cada teste para veres como 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, abordámos fluxos de trabalho comuns para analisar os resultados de experiências executadas com o Ray Tune através do Ultralytics. Os passos principais incluem carregar os resultados da experiência a partir de um diretório, realizar análises básicas ao nível da experiência e do teste e representar graficamente as métricas.

Explora mais informações na página de documentação Analyze Results do Ray Tune para tirares o máximo partido das tuas experiências de ajuste de hiperparâmetros.

Perguntas frequentes#