Salta para o conteúdo

Afinação eficiente de hiperparâmetros com Ray Tune e YOLOv8

A afinação de hiperparâmetros é vital para atingir o desempenho máximo do modelo, descobrindo o conjunto ideal de hiperparâmetros. Isto envolve a execução de ensaios com diferentes hiperparâmetros e a avaliação do desempenho de cada ensaio.

Acelera a afinação com Ultralytics YOLOv8 e Ray Tune

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

Ray Tune

Ray Tune Descrição geral

Ray Tune é uma biblioteca de ajuste de hiperparâmetros concebida para ser eficiente e flexível. Suporta várias estratégias de pesquisa, paralelismo e estratégias de paragem antecipada, e integra-se perfeitamente com estruturas populares de aprendizagem automática, incluindo Ultralytics YOLOv8 .

Integração com Weights & Biases

YOLOv8 permite também a integração opcional com Weights & Biases para monitorizar o processo de afinação.

Instalação

Para instalar os pacotes necessários, executa:

Instalação

# 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

Utilização

from ultralytics import YOLO

# Load a YOLOv8n model
model = YOLO('yolov8n.pt')

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

tune() Parâmetros do método

O tune() em YOLOv8 fornece uma interface fácil de usar para o ajuste de hiperparâmetros com o Ray Tune. Aceita vários argumentos que permitem personalizar o processo de afinação. Segue-se uma explicação detalhada de cada parâmetro:

Parâmetro Tipo Descrição Valor por defeito
data str O ficheiro de configuração do conjunto de dados (em formato YAML) para executar o sintonizador. Esse arquivo deve especificar os caminhos de dados de treinamento e validação, bem como outras configurações específicas do conjunto de dados.
space dict, optional Um dicionário que define o espaço de pesquisa de hiperparâmetros para o Ray Tune. Cada chave corresponde a um nome de hiperparâmetro e o valor especifica o intervalo de valores a serem explorados durante o ajuste. Se não for fornecido, YOLOv8 usa um espaço de pesquisa padrão com vários hiperparâmetros.
grace_period int, optional O período de carência em épocas para o programador ASHA no Ray Tune. O programador não encerrará nenhuma tentativa antes deste número de épocas, permitindo que o modelo tenha algum treinamento mínimo antes de tomar uma decisão sobre a parada antecipada. 10
gpu_per_trial int, optional O número de GPUs a serem alocadas por tentativa durante o ajuste. Isso ajuda a gerenciar o uso da GPU, particularmente em ambientes com várias GPUs. Se não for fornecido, o sintonizador usará todas as GPUs disponíveis. Não tens
iterations int, optional O número máximo de tentativas a serem executadas durante o ajuste. Este parâmetro ajuda a controlar o número total de combinações de hiperparâmetros testadas, garantindo que o processo de ajuste não seja executado indefinidamente. 10
**train_args dict, optional Argumentos adicionais para passar para o train() durante o ajuste. Estes argumentos podem incluir definições como o número de épocas de treino, o tamanho do lote e outras configurações específicas do treino. {}

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

Espaço de pesquisa predefinido Descrição

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

Parâmetro Intervalo de valores Descrição
lr0 tune.uniform(1e-5, 1e-1) Taxa de aprendizagem inicial
lrf tune.uniform(0.01, 1.0) Fator de taxa de aprendizagem final
momentum tune.uniform(0.6, 0.98) Momentum
weight_decay tune.uniform(0.0, 0.001) Diminuição do peso
warmup_epochs tune.uniform(0.0, 5.0) Épocas de aquecimento
warmup_momentum tune.uniform(0.0, 0.95) Aquecimento
box tune.uniform(0.02, 0.2) Caixa de perda de peso
cls tune.uniform(0.2, 4.0) Perda de peso por classe
hsv_h tune.uniform(0.0, 0.1) Gama de aumento de tonalidade
hsv_s tune.uniform(0.0, 0.9) Gama de aumento da saturação
hsv_v tune.uniform(0.0, 0.9) Valor (brilho) intervalo de aumento
degrees tune.uniform(0.0, 45.0) Amplitude de aumento da rotação (graus)
translate tune.uniform(0.0, 0.9) Gama de aumentos de tradução
scale tune.uniform(0.0, 0.9) Escala de aumento de escala
shear tune.uniform(0.0, 10.0) Intervalo de aumento de cisalhamento (graus)
perspective tune.uniform(0.0, 0.001) Gama de aumentos de perspetiva
flipud tune.uniform(0.0, 1.0) Probabilidade de aumento da rotação vertical
fliplr tune.uniform(0.0, 1.0) Probabilidade de aumento da rotação horizontal
mosaic tune.uniform(0.0, 1.0) Probabilidade de aumento do mosaico
mixup tune.uniform(0.0, 1.0) Probabilidade de aumento da mistura
copy_paste tune.uniform(0.0, 1.0) Copia e cola a probabilidade de aumento

Exemplo de espaço de pesquisa personalizado

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

Utilização

from ultralytics import YOLO

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

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

No trecho de código acima, criamos um modelo YOLO com os pesos pré-treinados "yolov8n.pt". Em seguida, chamamos o tune() especificando a configuração do conjunto de dados com "coco128.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-1). Finalmente, passamos argumentos de treino adicionais, como o número de épocas, diretamente para o método tune como epochs=50.

Processamento dos resultados da afinação de raios

Depois de executar uma experiência de ajuste de hiperparâmetros com o Ray Tune, podes querer efetuar várias análises dos resultados obtidos. Este guia irá guiar-te através de fluxos de trabalho comuns para processar e analisar esses resultados.

Carregar resultados de experiências de afinação a partir de um diretório

Depois de executar a experiência de afinação com tuner.fit()podes carregar os resultados a partir de um diretório. Isto é útil, especialmente se estiveres a efetuar a análise depois de o script de treino inicial ter saído.

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 ao nível da experiência

Obtém uma visão geral do desempenho dos ensaios. Podes verificar rapidamente se houve algum erro durante os ensaios.

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

Análise básica do nível de julgamento

Acede a configurações de hiperparâmetros de ensaios 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}")

Traçando todo o histórico de métricas relatadas para um estudo

Podes traçar o histórico das métricas comunicadas para cada ensaio para ver como as métricas evoluíram ao longo do tempo.

import matplotlib.pyplot as plt

for result in 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

Nesta documentação, abordámos fluxos de trabalho comuns para analisar os resultados de experiências executadas com o Ray Tune utilizando Ultralytics. Os principais passos incluem o carregamento dos resultados da experiência a partir de um diretório, a realização de análises básicas ao nível da experiência e ao nível do ensaio e a representação gráfica de métricas.

Explora mais, consultando a página de documentos Analisar resultados do Ray Tune para tirar o máximo partido das tuas experiências de ajuste de hiperparâmetros.



Criado em 2023-11-12, Atualizado em 2023-11-18
Autores: glenn-jocher (2)

Comentários