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スケジューラーの猶予期間です。スケジューラーは、このエポック数(上限は 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のハイパーパラメータチューニングにおけるデフォルトの探索空間パラメーターを示します。各パラメーターの値の範囲は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) | 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) | 4枚の画像を1つのトレーニングサンプルに結合する、モザイク拡張の確率です。 |
mixup | tune.uniform(0.0, 1.0) | 2枚の画像とそれぞれのラベルを混合する、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,
)上記のコードスニペットでは、事前学習済みのYOLO26n重みからYOLOモデルを作成し、データセット設定coco8.yamlを指定してtune()メソッドを呼び出します。初期学習率lr0には、キー"lr0"と値tune.uniform(1e-5, 1e-2)を持つ辞書として、カスタム探索空間を指定します。最後に、エポック数などの追加の学習引数を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セッションを再開できます。任意で、再開するセッションのディレクトリnameを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)
# 名前'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)平行移動拡張の範囲 これらのハイパーパラメータは、特定のニーズに合わせてカスタマイズできます。全項目と詳細については、ハイパーパラメータチューニングガイドをご覧ください。
Ultralytics YOLO26のチューニングプロセスにWeights & Biases (W&B)を統合するには、次の手順に従ってください。
-
W&Bをインストールします:
pip install wandb wandb login yolo settings wandb=True -
チューナーを実行します:
from ultralytics import YOLO # YOLOモデルを読み込む model = YOLO("yolo26n.pt") # 各Rayトライアルは、このプロジェクトで独自のW&B runを作成します 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.