Эффективная настройка гиперпараметров с помощью Ray Tune и YOLO26
Подбор гиперпараметров ищет набор гиперпараметров, обеспечивающий наилучшую производительность модели. Для этого выполняются запуски с разными значениями гиперпараметров и оценивается результат каждого запуска.
Ускорь настройку с помощью Ultralytics YOLO26 и Ray Tune#
Ultralytics YOLO26 интегрируется с Ray Tune для подбора гиперпараметров. Ray Tune позволяет использовать продвинутые стратегии поиска, параллельное выполнение и раннюю остановку, чтобы ускорить подбор.
Ray Tune#
Ray Tune — библиотека для эффективного и гибкого подбора гиперпараметров. Она поддерживает различные стратегии поиска, параллельное выполнение и раннюю остановку, а также интегрируется с популярными фреймворками машинного обучения, включая Ultralytics YOLO26.
Интеграция с Weights & Biases#
YOLO26 также поддерживает необязательную интеграцию с Weights & Biases для мониторинга процесса подбора.
Установка#
Чтобы установить необходимые пакеты, выполни команду:
# 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Использование#
from ultralytics import YOLO
# Загрузить модель YOLO26n
model = YOLO("yolo26n.pt")
# Начать настройку гиперпараметров для обучения YOLO26n на наборе данных COCO8
result_grid = model.tune(data="coco8.yaml", use_ray=True)Параметры метода tune()#
Метод tune() в YOLO26 предоставляет удобный интерфейс для настройки гиперпараметров с помощью Ray Tune. Он принимает несколько аргументов, позволяющих настроить процесс. Ниже подробно описан каждый параметр:
| Параметр | Тип | Описание | Значение по умолчанию |
|---|---|---|---|
data | str or list | YAML-файл датасета для запуска тюнера, в котором указаны пути к обучающим данным и валидационным данным, а также другие настройки, относящиеся к датасету. Для классификации вместо этого укажи каталог датасета или имя встроенного датасета (например, imagenet10). При передаче списка каждая попытка выполняется на всех датасетах, а в результате указывается средняя метрика задачи. | |
space | dict, optional | Словарь, задающий пространство поиска гиперпараметров для Ray Tune. Каждый ключ соответствует имени гиперпараметра, а значение задает диапазон значений для проверки в процессе настройки. Если этот параметр не указан, YOLO26 использует пространство поиска по умолчанию с различными гиперпараметрами. | |
grace_period | int, optional | Период отсрочки в эпохах для планировщика ASHA в Ray Tune. Планировщик не завершит ни один запуск до достижения этого числа эпох (не более epochs). Не используется с search_alg="bohb". | 10 |
gpu_per_trial | int, optional | Количество GPU, выделяемых Ray для каждого испытания. Укажи это значение явно, чтобы использовать обучение на GPU; если параметр не указан, испытания не получат ресурсов GPU. | None |
iterations | int, optional | Максимальное количество испытаний, выполняемых в процессе настройки. Этот параметр позволяет ограничить общее число проверяемых комбинаций гиперпараметров и не допустить бесконечного выполнения настройки. | 300 |
search_alg | str or Searcher, optional | Стратегия поиска Ray Tune. Можно напрямую передать объект поискового алгоритма Ray или указать поддерживаемую строку, например optuna, hyperopt, bayesopt, bohb, hebo, nevergrad, zoopt, ax или random. Для поисковых алгоритмов, заданных строкой, автоматически используются метрика задачи по умолчанию и mode="max". По умолчанию используется многомерный TPE Optuna с параллельно-ориентированными рекомендациями. | "optuna" |
**train_args | dict, optional | Дополнительные аргументы, передаваемые методу train() во время настройки. К ним могут относиться такие параметры, как количество эпох обучения, размер пакета и другие настройки обучения. | {} |
Настраивая эти параметры, ты можешь адаптировать процесс оптимизации гиперпараметров под свои задачи и доступные вычислительные ресурсы.
Описание пространства поиска по умолчанию#
В следующей таблице перечислены параметры пространства поиска по умолчанию для настройки гиперпараметров YOLO26 с помощью Ray Tune. Для каждого параметра задан определенный диапазон значений tune.uniform(), кроме close_mosaic, в котором используется tune.randint().
| Параметр | Диапазон | Описание |
|---|---|---|
lr0 | tune.uniform(1e-5, 1e-2) | Начальный темп обучения, определяющий размер шага при оптимизации. Более высокие значения ускоряют обучение, но могут привести к нестабильности. |
lrf | tune.uniform(0.01, 1.0) | Коэффициент конечного темпа обучения, определяющий, насколько снизится темп обучения к концу обучения. |
momentum | tune.uniform(0.7, 0.98) | Коэффициент импульса для оптимизатора, который помогает ускорить обучение и преодолеть локальные минимумы. |
weight_decay | tune.uniform(0.0, 0.001) | Параметр регуляризации, предотвращающий переобучение за счет штрафа за большие значения весов. |
warmup_epochs | tune.uniform(0.0, 5.0) | Количество эпох с постепенным увеличением темпа обучения для стабилизации начального этапа обучения. |
warmup_momentum | tune.uniform(0.0, 0.95) | Начальное значение импульса, которое постепенно увеличивается в период разогрева. |
box | tune.uniform(1.0, 20.0) | Вес компонента функции потерь для ограничивающей рамки, регулирующий точность локализации модели. |
cls | tune.uniform(0.1, 4.0) | Вес компонента функции потерь классификации, регулирующий точность предсказания классов моделью. |
cls_pw | tune.uniform(0.0, 1.0) | Степень взвешивания классов: от отключенного режима (0.0) до полного взвешивания, обратно пропорционального частоте (1.0). |
dfl | tune.uniform(0.4, 12.0) | Вес компонента регрессии расстояния до рамки, повышающий точность локализации ограничивающих рамок. |
hsv_h | tune.uniform(0.0, 0.1) | Диапазон аугментации оттенка, добавляющий вариативность цветов и помогающий модели лучше обобщать данные. |
hsv_s | tune.uniform(0.0, 0.9) | Диапазон аугментации насыщенности, изменяющий интенсивность цвета для повышения устойчивости. |
hsv_v | tune.uniform(0.0, 0.9) | Диапазон аугментации значения (яркости), помогающий модели работать при разном освещении. |
degrees | tune.uniform(0.0, 45.0) | Диапазон аугментации поворота в градусах, улучшающий распознавание повернутых объектов. |
translate | tune.uniform(0.0, 0.9) | Диапазон аугментации переноса, сдвигающей изображения по горизонтали и вертикали. |
scale | tune.uniform(0.0, 0.95) | Диапазон аугментации масштаба, имитирующей объекты на разных расстояниях. |
shear | tune.uniform(0.0, 10.0) | Диапазон аугментации сдвига по сдвигу в градусах, имитирующей изменения перспективы. |
perspective | tune.uniform(0.0, 0.001) | Диапазон аугментации перспективы, имитирующей изменения трехмерной точки зрения. |
flipud | tune.uniform(0.0, 1.0) | Вероятность вертикального отражения при аугментации, повышающая разнообразие набора данных. |
fliplr | tune.uniform(0.0, 1.0) | Вероятность горизонтального отражения при аугментации, полезная для симметричных объектов. |
bgr | tune.uniform(0.0, 1.0) | Вероятность аугментации с перестановкой каналов BGR, помогающей добиться инвариантности к цвету. |
mosaic | tune.uniform(0.0, 1.0) | Вероятность мозаичной аугментации, объединяющей четыре изображения в один обучающий пример. |
mixup | tune.uniform(0.0, 1.0) | Вероятность аугментации MixUp, объединяющей два изображения и их метки. |
cutmix | tune.uniform(0.0, 1.0) | Вероятность аугментации CutMix, объединяющей области изображений с сохранением локальных признаков. |
copy_paste | tune.uniform(0.0, 1.0) | В режиме flip — доля объектов, подходящих для копирования в изображение; в режиме mixup — также вероятность применения этой операции. |
close_mosaic | tune.randint(0, 11) | Отключает мозаику за последние N эпох, чтобы стабилизировать обучение перед его завершением. |
Пример пользовательского пространства поиска#
В этом примере показано, как использовать пользовательское пространство поиска для подбора гиперпараметров с Ray Tune и YOLO26. Задав пользовательское пространство поиска, ты можешь сосредоточить подбор на нужных гиперпараметрах.
from ray import tune
from ultralytics import YOLO
# Определение модели YOLO
model = YOLO("yolo26n.pt")
# Запустить Ray Tune для модели
result_grid = model.tune(
data="coco8.yaml",
space={"lr0": tune.uniform(1e-5, 1e-2)},
epochs=50,
use_ray=True,
)Приведенный выше фрагмент кода создает модель YOLO с предварительно обученными весами YOLO26n, а затем вызывает метод tune() с конфигурацией набора данных coco8.yaml. Для начальной скорости обучения lr0 задается пользовательское пространство поиска в виде словаря с ключом "lr0" и значением tune.uniform(1e-5, 1e-2). Наконец, дополнительные аргументы обучения, например количество эпох, передаются непосредственно методу tune как epochs=50.
Пример алгоритма поиска#
Стратегию поиска Ray Tune можно выбрать по имени. Для алгоритмов поиска, заданных строкой, Ultralytics автоматически использует метрику оптимизации по умолчанию для текущей задачи и mode="max". Если search_alg не указан, Ultralytics использует многомерный TPE Optuna с параллельно-ориентированными рекомендациями.
from ultralytics import YOLO
# Определение модели YOLO
model = YOLO("yolo26n.pt")
result_grid = model.tune(
data="coco8.yaml",
epochs=50,
search_alg="optuna",
use_ray=True,
)Если тебе нужно настроить сэмплер поискового алгоритма или переопределить его метрику и режим оптимизации, передай экземпляр объекта поискового алгоритма Ray Tune вместо строки.
from ray.tune.search.optuna import OptunaSearch
from ultralytics import YOLO
# Определение модели YOLO
model = YOLO("yolo26n.pt")
# Определить поисковый алгоритм
searcher = OptunaSearch(
metric="metrics/mAP50-95(B)",
mode="max",
)
result_grid = model.tune(
data="coco8.yaml",
epochs=50,
search_alg=searcher,
use_ray=True,
)Возобновление прерванной настройки гиперпараметров с помощью Ray Tune#
Ты можешь возобновить прерванный сеанс Ray Tune, передав resume=True. При необходимости передай каталог name, используемый Ray Tune, через runs/{task}, чтобы продолжить сеанс. В противном случае будет возобновлен последний прерванный сеанс. Повторно указывать iterations и space не нужно, но остальные аргументы обучения, включая data и epochs, необходимо передать снова.
from ultralytics import YOLO
# Определение модели YOLO
model = YOLO("yolo26n.pt")
# Возобновление предыдущего запуска
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, resume=True)
# Возобновить запуск Ray Tune с именем 'tune_exp_2'
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, name="tune_exp_2", resume=True)Обработка результатов Ray Tune#
После эксперимента по настройке гиперпараметров с помощью Ray Tune ты можешь выполнить различные виды анализа полученных результатов. В этом руководстве рассматриваются распространенные сценарии обработки и анализа результатов.
Загрузка результатов эксперимента Tune из каталога#
model.tune(use_ray=True) возвращает объект Ray ResultGrid и сохраняет эксперимент в runs/{task}/tune или в переданном тобой каталоге name. Чтобы загрузить результаты после завершения исходного скрипта, возобнови сеанс: это восстановит сохраненные испытания и вернет тот же ResultGrid:
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
result_grid = model.tune(data="coco8.yaml", epochs=50, use_ray=True, resume=True)Базовый анализ на уровне эксперимента#
Получи обзор результатов испытаний. Ты можешь быстро проверить, возникали ли ошибки во время испытаний.
if result_grid.errors:
print("One or more trials failed!")
else:
print("No errors!")Базовый анализ на уровне испытаний#
Просмотри конфигурации гиперпараметров отдельных испытаний и последние опубликованные метрики.
for i, result in enumerate(result_grid):
print(f"Trial #{i}: Configuration: {result.config}, Last Reported Metrics: {result.metrics}")Построение графика полной истории метрик, полученных в ходе испытания#
Ты можешь построить график истории метрик для каждого испытания, чтобы увидеть, как метрики менялись со временем.
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()Итоги#
В этом руководстве мы рассмотрели распространенные сценарии анализа результатов экспериментов, проведенных с помощью Ray Tune и Ultralytics. Основные шаги: загрузить результаты эксперимента из каталога, выполнить базовый анализ на уровне эксперимента и испытаний, а также построить графики метрик.
Чтобы узнать больше о настройке гиперпараметров, изучи страницу документации Ray Tune «Анализ результатов».
Часто задаваемые вопросы#
Чтобы настроить гиперпараметры модели Ultralytics YOLO26 с помощью Ray Tune, выполни следующие шаги:
-
Установи необходимые пакеты:
pip install -U ultralytics "ray[tune]" optuna pip install wandb # optional for logging yolo settings wandb=True -
Загрузи модель YOLO26 и начни настройку:
from ultralytics import YOLO # Загрузи модель YOLO26 model = YOLO("yolo26n.pt") # Начать настройку на наборе данных COCO8 result_grid = model.tune(data="coco8.yaml", use_ray=True)
Для эффективной оптимизации гиперпараметров модели используются стратегии поиска и параллельное выполнение Ray Tune.
-
При настройке с помощью Ray Tune в Ultralytics YOLO26 по умолчанию используются следующие гиперпараметры:
Параметр Диапазон значений Описание lr0tune.uniform(1e-5, 1e-2)Начальный темп обучения lrftune.uniform(0.01, 1.0)Коэффициент конечного темпа обучения momentumtune.uniform(0.7, 0.98)Импульс weight_decaytune.uniform(0.0, 0.001)Затухание весов warmup_epochstune.uniform(0.0, 5.0)Эпохи разогрева boxtune.uniform(1.0, 20.0)Вес функции потерь для рамки clstune.uniform(0.1, 4.0)Вес функции потерь классификации cls_pwtune.uniform(0.0, 1.0)Степень взвешивания классов dfltune.uniform(0.4, 12.0)Вес функции потерь расстояния до рамки hsv_htune.uniform(0.0, 0.1)Диапазон аугментации оттенка translatetune.uniform(0.0, 0.9)Диапазон аугментации переноса Эти гиперпараметры можно настроить в соответствии с твоими задачами. Полный список и подробную информацию см. в руководстве по настройке гиперпараметров.
Чтобы интегрировать Weights & Biases (W&B) в процесс подбора параметров Ultralytics YOLO26:
-
Установи W&B:
pip install wandb wandb login yolo settings wandb=True -
Запусти настройщик:
from ultralytics import YOLO # Загрузить модель YOLO model = YOLO("yolo26n.pt") # Каждый запуск Ray создает собственный запуск W&B в этом проекте result_grid = model.tune(data="coco8.yaml", project="YOLO-Tuning", use_ray=True)
Эта настройка позволит тебе отслеживать процесс подбора параметров, конфигурации гиперпараметров и визуализировать результаты в W&B.
-
Ray Tune предлагает множество преимуществ для оптимизации гиперпараметров:
- Продвинутые стратегии поиска: используются такие алгоритмы, как байесовская оптимизация и HyperOpt, для эффективного поиска параметров.
- Параллельное выполнение: поддерживает одновременное выполнение нескольких запусков, значительно ускоряя процесс подбора параметров.
- Ранняя остановка: применяет такие стратегии, как ASHA, чтобы досрочно завершать неэффективные запуски и экономить вычислительные ресурсы.
Ray Tune встроен в Ultralytics YOLO26 через
model.tune(use_ray=True).Чтобы задать собственное пространство поиска для подбора гиперпараметров YOLO26 с помощью 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)Так ты задашь диапазоны исследуемых гиперпараметров, например начальной скорости обучения и момента импульса. Дополнительные варианты настройки смотри в разделе Пример пользовательского пространства поиска.
Комментарии40
Задай вопрос, поделись результатами или помоги кому-нибудь.
supriamir
Hi, I finish the hyperparameter tune, how to use the best parameter in best_hyperparameters.ymal for training?
Currently i manually use the manually copy the htperparameter.
model.train( data=str(dataset_yaml), epochs=epochs, imgsz=imgsz, batch=batch, project=project, name=f"fold_{k}", workers=0, patience=100, exist_ok=True, cache=False, device=0,
lr0= 0.00254, lrf= 0.02718, momentum= 0.83225, weight_decay= 0.001, warmup_epochs= 2.22741, warmup_momentum= 0.72834, box= 8.86345, cls= 0.52365, dfl= 0.45493, hsv_h= 0.01544, hsv_s= 0.44438, hsv_v= 0.37867, degrees= 0.01115, translate= 0.10045, scale= 0.33157, shear= 0.0075, perspective= 6.0e-05, flipud= 0.00882, fliplr= 0.34916, bgr= 9.0e-05, mosaic= 0.63841, mixup= 0.00099, cutmix= 0.00361, copy_paste= 0.00051, close_mosaic= 6, )
Glenn JocherUltralyticsYes — you can load
best_hyperparameters.yamland unpack it directly intomodel.train()instead of copying values by hand; see the Ray Tune integration guide and feel free to keep follow-ups here in Discussions so the Ultralytics team can see them.from pathlib import Path import yaml from ultralytics import YOLO model = YOLO("yolo26n.pt") hyp_path = Path("runs/detect/tune/best_hyperparameters.yaml") with hyp_path.open() as f: hyp = yaml.safe_load(f) model.train( data=str(dataset_yaml), epochs=epochs, imgsz=imgsz, batch=batch, project=project, name=f"fold_{k}", workers=0, patience=100, exist_ok=True, cache=False, device=0, **hyp, )1
Emeyer87
Hello,
I've noticed that every Iteration with use_ray = True is downloading yolo11n.pt. I'm attempting to use this on an existing instance segmentation model I built but wanted to ensure the tuning is running against the model I've assigned, and not a fresh Detection model.
from ultralytics import YOLO from ray import tune
model_path = r"C:/Users/Me/Downloads/NashvilleSegmentation.pt" data_path = r"C:/Users/Me/Downloads/dataset/data.yaml" model=YOLO(model_path)
search_space = { "degrees": tune.uniform(0.0, 12.0) }
results = model.tune( data=data_path, epochs=20, # keep it tiny iterations=20, # exactly one trial optimizer="AdamW", space=search_space, device=0, seed=0, workers=2, amp=True, batch=16, patience=12, plots=False, save=False, project="test_tune", name="degrees_tune_01", lr0=0.00114, use_ray=True, gpu_per_trial=1
)
Emeyer87
Disregard...completely misunderstood what tuning was actually doing.
Glenn JocherUltralyticsGlad it’s sorted—quick tip: to tune your existing segmentation model, load your .pt first (model = YOLO("path/to/your.pt")) and then run model.tune(..., use_ray=True); Ray trials will reuse that same model/task—verify in the logs that task=segment.
Fatima-khanjar
Subject: Questions Regarding Using Ray Tune for YOLOv11 Hyperparameter Tuning
Hello!
I hope this message finds you well.
#hyperparameter tuning using tune() from ray import tune from ray.tune import ResultGrid from ray.tune.examples.mnist_pytorch import train_mnist from ultralytics import YOLO import os import torch import matplotlib.pyplot as plt # Define a YOLO model model = YOLO("yolo11s.pt").to('cuda') tune_dir = 'ray_results' os.makedirs(tune_dir, exist_ok=True) # Tune hyperparameters using ray tune result_grid = model.tune( data= "data.yaml", epochs=10, iterations=10, batch = 16, device = 0, workers=0, use_ray=True, gpu_per_trial =1, name = "tuning", project = tune_dir ) Now, load the results after the tuning experiment is finished exp_name = "tuning" experiment_path = f"{tune_dir}/{exp_name}" # Get the name of the experiment print(f"Loading results from {experiment_path}...") restored_tuner = tune.Tuner.restore(experiment_path, trainable=train_mnist) result_grid = restored_tuner.get_results() # Basic Experiment-Level Analysis: Check for errors if result_grid.errors: print("One or more trials failed!") else: print("No errors!") # Basic Trial-Level Analysis: Print configurations and last reported metrics for each trial for i, result in enumerate(result_grid): print(f"Trial #{i}: Configuration: {result.config}, Last Reported Metrics: {result.metrics}") # Plotting the Entire History of Reported Metrics for a Trial # Assuming "mean_accuracy" is part of the metrics for i, result in enumerate(result_grid): plt.plot( result.metrics_dataframe["training_iteration"], result.metrics_dataframe["mean_accuracy"], # Modify this depending on your metrics label=f"Trial {i}", ) plt.xlabel("Training Iterations") plt.ylabel("Mean Accuracy") plt.legend() plt.show()
#hyperparameter tuning using tuner.fit() import os from ray import tune from ray.tune import ResultGrid from ray.tune.examples.mnist_pytorch import train_mnist from ray.tune import Result from pathlib import Path tune_dir = Path("ray_results").resolve().as_uri() exp_name = "tune_analyzing_results" tuner = tune.Tuner( trainable=train_mnist, param_space={ "lr": tune.uniform(0.001, 0.1), "momentum": tune.uniform(0.1, 0.9), }, run_config=tune.RunConfig( name=exp_name, stop={"training_iteration": 100}, checkpoint_config=tune.CheckpointConfig( checkpoint_score_attribute="mean_accuracy", num_to_keep = 5, ), storage_path=tune_dir, ), tune_config=tune.TuneConfig(mode="max", metric="mean_accuracy", num_samples=3), ) result_grid: ResultGrid = tuner.fit() experiment_path = os.path.join(tune_dir, 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() # Check if there have been errors if result_grid.errors: print("One of the trials failed!") else: print("No errors!") num_results = len(result_grid) print("Number of results:", num_results) # Iterate over results for i, result in enumerate(result_grid): if result.error: print(f"Trial #{i} had an error:", result.error) continue print( f"Trial #{i} finished successfully with a mean accuracy metric of:", result.metrics["mean_accuracy"] ) results_df = result_grid.get_dataframe() results_df[["training_iteration", "mean_accuracy"]] print("Shortest training time:", results_df["time_total_s"].min()) print("Longest training time:", results_df["time_total_s"].max()) best_result_df = result_grid.get_dataframe( filter_metric="mean_accuracy", filter_mode="max" ) best_result_df[["training_iteration", "mean_accuracy"]] # Get the result with the maximum test set `mean_accuracy` best_result: Result = result_grid.get_best_result() # Get the result with the minimum `mean_accuracy` worst_performing_result: Result = result_grid.get_best_result( metric="mean_accuracy", mode="min" ) best_result.config best_result.path # Get the last Checkpoint associated with the best-performing trial best_result.checkpoint # Get the last reported set of metrics best_result.metrics result_df = best_result.metrics_dataframe result_df[["training_iteration", "mean_accuracy", "time_total_s"]] best_result.metrics_dataframe.plot("training_iteration", "mean_accuracy") ax = None for result in result_grid: label = f"lr={result.config['lr']:.3f}, momentum={result.config['momentum']}" if ax is None: ax = result.metrics_dataframe.plot("training_iteration", "mean_accuracy", label=label) else: result.metrics_dataframe.plot("training_iteration", "mean_accuracy", ax=ax, label=label) ax.set_title("Mean Accuracy vs. Training Iteration for All Trials") ax.set_ylabel("Mean Test Accuracy")
I have been following your guide on using Ray Tune for hyperparameter tuning with YOLOv11. I was able to run the experiment using the use_ray=True argument, and it worked successfully—thank you for the helpful explanation!
However, I still have a few questions and points of confusion:
-
Naming the Trials: How can I change or customize the names of the individual trials when using model.tune(..., use_ray=True)? Right now, the trials are auto-named, and I’d like more meaningful names to help keep track of different configurations.
-
Retrieving the Best Hyperparameters: After the tuning process is complete, I would like to extract the best hyperparameter configuration to reuse it for future training. I noticed in other examples (e.g., train_mnist) that you use tuner.fit() to retrieve and analyze results, including the best configuration. So my question is: when using model.tune() directly (as in the case of YOLOv11), is there a method to extract the best hyperparameters without using tuner.fit()? Or is it necessary to re-structure the experiment using tune.Tuner to get access to that kind of detailed analysis?
-
Using tune.Tuner() with YOLOv11: In your other examples, the tuning process is managed using tune.Tuner(...), but I’m not sure how to apply this approach to YOLOv11, since there’s no explicit trainable function like train_mnist. Should we always use model.tune() for YOLO models, or is there a way to integrate YOLOv11 into a Tuner workflow for more advanced customization and analysis?
Thank you so much for your time and support! I would really appreciate any clarification or guidance on these points.
Best regards,
Glenn JocherUltralytics@Fatima-khanjar Thank you for your detailed questions about Ray Tune integration with YOLO11!
-
Naming Trials: Currently, the high-level
model.tune()API doesn't provide direct control over individual trial naming. Ray Tune automatically generates these names. You can use thenameparameter to name the overall experiment (as you've done with "tuning"), but individual trial names remain auto-generated. -
Retrieving Best Hyperparameters: When using
model.tune()with Ray Tune, the best hyperparameters are automatically saved toruns/[task]/tune/best_hyperparameters.yaml. This file contains the optimal configuration and can be loaded for future use. You can also examinetune_results.csvfor all trial results. -
Using tune.Tuner(): While possible, creating a custom trainable function for YOLO with the low-level Ray Tune API requires more work. You'd need to wrap the YOLO training process in a function that configures and trains the model while reporting metrics to Ray Tune. For most users, the high-level
model.tune()API is recommended as it handles this integration automatically.
For more advanced customization, you might consider extending the Ray Tune integration in Ultralytics by referring to the source code in the
ultralytics/utils/tuner.pyfile.-
Fatima-khanjar
Hello! Thank you for your clarification. I will continue using model.tune() and use the following line to retrieve the best hyperparameters, since the best_hyperparameters.yaml file wasn’t automatically saved in the output directory of the Ray tuning:
best_config = analysis.get_best_config(metric="metrics/mAP50(B)",mode="max")`I have a question: I read that Optuna uses the TPE (Tree-structured Parzen Estimator) search algorithm, which is more powerful than the default search algorithms in Ray Tune. Since Ray Tune provides scalability and distributed tuning, is it possible to combine both—using Optuna’s TPE algorithm with Ray Tune while still calling model.tune()? If so, how can I integrate them?
I also have another question that’s unrelated. I noticed that YOLOv11 comes in different versions, from n to xl. I understand that the choice depends on the dataset size and the task complexity. But what are the actual criteria used to determine the complexity of a task?
best regrads,
Glenn JocherUltralytics@Fatima-khanjar
Regarding using TPE with Ray Tune - yes, it's possible! Ray Tune already supports TPE through the HyperOpt integration. You can use it by installing the HyperOpt package and specifying the search algorithm:
pip install hyperopt from ray.tune.search.hyperopt import HyperOptSearch from ray.tune.search import ConcurrencyLimiter hyperopt_search = HyperOptSearch(metric="metrics/mAP50(B)", mode="max") limited_search = ConcurrencyLimiter(hyperopt_search, max_concurrent=4) # Then in your model.tune() call model.tune( data="data.yaml", search_alg=limited_search, use_ray=True, # other parameters )For your question about YOLO11 model size selection, the criteria typically include:
- Computational resources: Larger models (l, x, xl) require more GPU memory and processing power
- Dataset complexity: More complex datasets with small/numerous objects benefit from larger models
- Inference speed requirements: Smaller models (n, s) offer faster inference for real-time applications
- Accuracy needs: Larger models generally provide higher accuracy at the cost of speed
You can check the performance trade-offs in the Ultralytics documentation to make an informed decision based on your specific constraints.
1Fatima-khanjar(изменено)
Hello, I hope this message finds you well.
I followed your instructions to integrate Ray Tune with the TPE algorithm using HyperOpt:
hyperopt_search = HyperOptSearch(metric="metrics/mAP50(B)", mode="max") limited_search = ConcurrencyLimiter(hyperopt_search, max_concurrent=1)Then, I used the following code to tune hyperparameters with Ray Tune:
tuning_results = model.tune( data="data.yaml", epochs=50, # Number of epochs for each tuning iteration iterations=100, # Total number of tuning iterations batch=16, device=0, workers=0, grace_period=30, search_alg=limited_search, use_ray=True, gpu_per_trial=1, project=tune_dir )However, I encountered a syntax error: SyntaxError: 'search_alg' is not a valid YOLO argument. Could you please advise me on how to fix this?
I have another question regarding the output directory of Ray Tune. It shows that inside the runs folder, there are subfolders named train (equal to the number of iterations) and a tune folder that contains subdirectories also equal to the number of iterations.
My question is: should I focus on the train directories? Why are they generated, and what's their purpose?
Also, if I want to monitor the overall progress of the fine-tuning process — for example, in genetic tuning, we usually look at a graph of the fitness score vs. iteration — where should I look for that kind of visualization or information?
best regards,
Glenn JocherUltralytics(изменено)@Fatima-khanjar
Regarding your issues with HyperOptSearch and Ray Tune integration:
-
The
search_algargument is passed throughmodel.tune(use_ray=True). It defaults to"optuna"(TPE) and accepts either a string (such as"optuna","hyperopt","bohb"or"random") or a Ray Tune searcher instance like yourHyperOptSearch, so you do not need to modifyultralytics/utils/tuner.py. -
About the directory structure:
- The
traindirectories (train1, train2, etc.) contain individual training runs for each trial with different hyperparameter sets - The
tunedirectory contains the aggregated results of all trials and should be your primary focus
- The
-
For monitoring progress:
- Check
tune/tune_results.csvfor all trial results - Look for
tune/best_fitness.pngwhich shows fitness score progression over iterations tune/best_hyperparameters.yamlcontains the optimal configuration found
- Check
The plots in the
tunedirectory (especiallytune_scatter_plots.pngif available) provide valuable visualizations of the hyperparameter search space and how different parameters affected model performance.-
-
Fatima-khanjar
Hello!
I hope this message finds you well.I'm trying to use Ray Tune for hyperparameter optimization with the following code:
results = model.tune( data="data.yaml", epochs=30, iterations=150, batch=16, optimizer="AdamW", plots=False, save=False, val=False, device=0, workers=8, use_ray=True, project="ray_results" )However, I'm getting a path-related error that I can't figure out:
FileNotFoundError: [WinError 3] The system cannot find the path specified...It seems to be related to the length of the path Ray is trying to create. Do you know how I can fix this?
Also, I have a question. I came across Ray Tune while working with Genetic Algorithms, and I was wondering: would you recommend using Ray Tune or Genetic Algorithms for hyperparameter optimization? Are they similar in how they work, or are there major differences between them? What advantages does Ray Tune offer over Genetic Algorithms?
Thank you for your help!
Fatima-khanjar
Hello Community!!
Just following up on my own post — I managed to solve the issue on Windows 11.
Here’s what worked for me:
- Opened gpedit.msc as Administrator
- Navigated to: Computer Configuration > Administrative Templates > System > Filesystem
- Enabled the setting “Enable Win32 long paths"
After doing this, the problem was resolved.
Posting this in case it helps someone else!
Glenn JocherUltralytics@Fatima-khanjar Thank you for sharing your solution to the Windows path length issue! This is helpful information that could benefit other users experiencing similar problems.
Regarding your question about Ray Tune versus Genetic Algorithms: They're different approaches to hyperparameter optimization. Ray Tune offers several advantages including:
- Multiple search strategies beyond genetic algorithms (Bayesian optimization, grid search, random search)
- Built-in parallel execution that efficiently utilizes available resources
- Early stopping via ASHA scheduler to terminate underperforming trials
- Distributed computing capabilities for scaling across multiple machines
Ultralytics actually supports both approaches - the internal tuner uses genetic algorithms focusing on mutation, while the Ray Tune integration provides more advanced search strategies and better parallelization. Ray Tune is generally recommended for more complex search spaces and when you have multiple GPUs available.
1
wisrovi
como lo combino con MLFlow?
wisrovi
tambien necesito:
model.add_callback("on_train_start", self.on_train_start) model.add_callback("on_train_end", self.on_train_end)
pero dichas funciones no se disparan
wisrovi
agradezco mucho sus valiosas aportaciones, de verdad que es una funcionalidad increible y magnifica
Glenn JocherUltralytics@wisrovi to integrate MLFlow with Ultralytics YOLO hyperparameter tuning, you'll need to create a custom Ray Tune reporter that logs metrics to MLFlow. While we don't have native MLFlow integration like Weights & Biases, you can implement it by adding MLFlow logging callbacks to your tuning script. The Ray Tune documentation provides guidance on MLFlow integration that you can adapt for YOLO workflows.
NegroAmigo
Which versions of YOLO are supported by Ray Tune? I have project with YOLOv8, will it be suitable to use with Ray Tune?
Glenn JocherUltralytics@NegroAmigo yes, YOLOv8 fully supports Ray Tune integration for hyperparameter tuning. You can use the same
model.tune()method shown in our Ray Tune integration guide by simply loading your YOLOv8 model (YOLO('yolov8n.pt')). The tuning process works identically across supported YOLO versions. For implementation details, see the Ultralytics Ray Tune documentation.
alifazeli00
Why is there no mention of beta 2(Adamw) in ultralithic documents?
Glenn JocherUltralytics@alifazeli00 the documentation currently focuses on the default hyperparameters and their tuning ranges. If you're looking for specific details on beta2 for AdamW, it might not be explicitly covered. For more information on hyperparameter tuning, you can explore the Ray Tune documentation linked in the guide.
alifazeli00
thank you, It has been mentioned that momentum is essentially beta1. Is this the same for beta2?
Glenn JocherUltralyticsBeta2 is not explicitly mentioned in the documentation as it typically defaults to 0.999 in AdamW, which is a common standard setting. For specific adjustments, you may need to modify the optimizer settings directly in your training script.
1
sirtris
Hi, you mention that the
.tune()function integrates well with wandb. Are there any plans to make it work with mlflow as well? When I try to use it now no model metric, parameters or artifacts, etc. are logged. It would also be nice to have one hyperparameter sweep as a parent run and the individual runs as child runs of that parent run. Best,
Glenn JocherUltralytics@sirtris currently, there are no plans to integrate the
.tune()function with MLflow, but we appreciate your feedback and will consider it for future updates.sirtris
Could you point me to some resources so I could maybe look into it doing it myself?
Glenn JocherUltralyticsFor resources on integrating MLflow with Ray Tune, I recommend checking the Ray Tune documentation for any updates or community contributions. This might provide insights into logging metrics and managing runs with MLflow.
sachmatkris
unfortunately that is not the issue because the results are exactly the same for different learning rates - impossible.
On Fri, 27 Sept 2024 at 19:06, Glenn Jocher @.***> wrote:
@sachmatkris https://github.com/sachmatkris it seems like the issue might be with the search space configuration. Ensure that the hyperparameters have enough variability and that the dataset path is correctly set. If the problem persists, consider adjusting the search space or reviewing the dataset configuration. For more details, you can refer to the Ray Tune documentation https://docs.ultralytics.com/integrations/ray-tune/.
— Reply to this email directly, view it on GitHub https://github.com/orgs/ultralytics/discussions/16505#discussioncomment-10777716, or unsubscribe https://github.com/notifications/unsubscribe-auth/A3WH6HFTKYE2WLTJVGR6HWTZYV7A5AVCNFSM6AAAAABO5HD4QCVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTANZXG43TCNQ . You are receiving this because you were mentioned.Message ID: @.*** com>
Glenn JocherUltralytics@sachmatkris if you're seeing identical results for different learning rates, it might be worth checking the hyperparameter search space and ensuring the dataset configuration is correct. Adjusting these settings could help resolve the issue. For further guidance, please refer to the Ray Tune documentation.
sachmatkris
I found out the issue was setting device = 0 in the model.tune() and specifying absolute path for the .data.yaml, which is not the same what YOLO does when started from within an opened folder on VScode.
sachmatkris(изменено)
@sachmatkris it seems like you've identified the issue with the device setting and path specification. If you need further assistance, feel free to ask!
Another issue I have is using the following call all of my experiments with ray_tune return the same metrics:
search_space = { 'lr0': tune.loguniform(1e-5, 1e-1), 'momentum': tune.uniform(0.6, 0.95), }result_grid = model.tune(data = 'C:/Users/Kristijonas/Desktop/Mokslo šaknys karčios/AI/Projects/masinu_numeriai/formated_dataset_new/data.yaml', imgsz = 1280, space = search_space, batch = 16, epochs = 50, patience = 5, use_ray = True, iterations = 20, device='cuda' )e.g.
Glenn JocherUltralytics@sachmatkris it seems like the issue might be with the search space configuration. Ensure that the hyperparameters have enough variability and that the dataset path is correctly set. If the problem persists, consider adjusting the search space or reviewing the dataset configuration. For more details, you can refer to the Ray Tune documentation.