使用 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")
# 在 COCO8 数据集上开始调优 YOLO26n 训练的超参数
result_grid = model.tune(data="coco8.yaml", use_ray=True)tune() 方法参数#
YOLO26 中的 tune() 方法提供了一个易于使用的接口,可通过 Ray Tune 调优超参数。该方法接受多个参数,你可以用它们自定义调优过程。下面详细介绍各个参数:
| 参数 | 类型 | 说明 | 默认值 |
|---|---|---|---|
data | str or list | 用于运行调优器的数据集 YAML 文件,其中指定训练和验证数据路径以及其他数据集专属设置。分类任务则使用数据集目录或内置数据集名称(例如 imagenet10)。使用列表时,每个试验都会在列表中的所有数据集上训练,并报告任务指标的平均值。 | |
space | dict, optional | 用于定义 Ray Tune 超参数搜索空间的字典。每个键对应一个超参数名称,值则指定调优时要探索的取值范围。如果未提供,YOLO26 会使用包含多种超参数的默认搜索空间。 | |
grace_period | int, optional | Ray Tune 中 ASHA 调度器的宽限期,以 epoch 为单位。达到此 epoch 数之前,调度器不会终止任何试验(上限为 epochs)。与 search_alg="bohb" 不同时使用。 | 10 |
gpu_per_trial | int, optional | Ray 为每次试验分配的 GPU 数量。要使用 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"。默认策略使用 Optuna 多变量 TPE,并提供适用于并行处理的建议。 | "optuna" |
**train_args | dict, optional | 调优期间传递给 train() 方法的其他参数。这些参数可包括训练轮数、批量大小以及其他特定于训练的配置。 | {} |
通过自定义这些参数,你可以根据自己的具体需求和可用计算资源,微调超参数优化过程。
默认搜索空间说明#
下表列出了使用 Ray Tune 调优 YOLO26 时的默认搜索空间参数。除 close_mosaic 使用 tune.randint() 外,每个参数都由 tune.uniform() 定义了特定的取值范围。
| 参数 | 范围 | 说明 |
|---|---|---|
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) | 透视增强范围,用于模拟 3D 视角变化。 |
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) | Mosaic 增强的概率,可将四张图像合并为一个训练样本。 |
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 个轮次中禁用 Mosaic,以便在训练结束前稳定训练过程。 |
自定义搜索空间示例#
此示例展示了如何使用自定义搜索空间,借助 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,
)上方代码片段使用预训练的 YOLO26n 权重创建 YOLO 模型,然后调用 tune() 方法,并使用数据集配置 coco8.yaml。代码将初始学习率 lr0 作为字典中的自定义搜索空间,键为 "lr0",值为 tune.uniform(1e-5, 1e-2)。最后,代码会将 epoch 数等其他训练参数作为 epochs=50 直接传递给 tune 方法。
搜索算法示例#
你可以按名称选择 Ray Tune 搜索策略。对于基于字符串的搜索算法,Ultralytics 会自动使用当前任务的默认优化指标和 mode="max"。如果未提供 search_alg,Ultralytics 会使用 Optuna 多变量 TPE,并提供适用于并行处理的建议。
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 恢复中断的超参数调优会话#
传入 resume=True 即可恢复中断的 Ray Tune 会话。你可以选择传入 Ray Tune 在 runs/{task} 下使用的目录 name 来恢复会话。否则,系统会恢复上一次中断的会话。你无需再次提供 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)
# 恢复名为 'tune_exp_2' 的 Ray Tune 运行
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()总结#
本指南介绍了使用 Ultralytics 和 Ray Tune 运行实验后分析结果的常见工作流程。关键步骤包括从目录加载实验结果、进行基本的实验级和试验级分析,以及绘制指标图表。
你可以进一步查看 Ray Tune 的分析结果文档,充分利用超参数调优实验。
常见问题#
要使用 Ray Tune 调优 Ultralytics YOLO26 模型的超参数,请按以下步骤操作:
-
安装所需的软件包:
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 的搜索策略和并行处理,高效优化模型的超参数。
-
Ultralytics YOLO26 使用以下默认超参数,通过 Ray Tune 进行调优:
参数 取值范围 说明 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 已通过
model.tune(use_ray=True)内置于 Ultralytics YOLO26 中。要使用 Ray Tune 为 YOLO26 超参数调优定义自定义搜索空间:
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.