はじめる

Ultralytics YOLOハイパーパラメーターチューニングガイド

Ultralytics YOLOのハイパーパラメーターチューニングは、学習率、損失の重み、拡張の強度などの設定を自動的かつ反復的に探索し、精度、適合率、再現率などの機械学習モデルの評価指標を最大化します。これらの値を手作業で試す代わりに、Ultralytics YOLOは遺伝的アルゴリズムを用いてハイパーパラメーター空間を探索し、多数の短い学習実行を通じて候補となる設定を変異・評価します。



視聴: モデルの性能を高めるハイパーパラメーター調整方法 🚀

ハイパーパラメータとは何ですか?#

ハイパーパラメータは、アルゴリズムの高レベルな構造設定です。学習フェーズの前に設定し、学習中は固定されます。Ultralytics YOLOでよくチューニングされるハイパーパラメータは次のとおりです。

  • 学習率 lr0: 損失関数の最小値に向かって進む際、各イテレーションでのステップ幅を決定します。
  • バッチサイズ batch: 順伝播で同時に処理される画像の数です。
  • エポック数 epochs: エポックとは、すべての学習例に対して順伝播と逆伝播を1回ずつ完了することです。
  • アーキテクチャの詳細: チャネル数、レイヤー数、活性化関数の種類などです。これらは学習引数ではなく、モデルのYAML設定で定義します。

この4つのうち、デフォルトの探索空間に含まれるのは学習率のみです。batch、epochs、アーキテクチャは固定されています。チューナーは、以下に記載されているスケジュール、損失ゲイン、拡張も変更します。

Hyperparameter optimization search space visualization

遺伝的進化と変異#

Ultralytics YOLOは、ハイパーパラメーターの最適化に、進化的アルゴリズムの一種である遺伝的アルゴリズムを使用します。遺伝的アルゴリズムは、自然選択と遺伝の仕組みに着想を得ています。

  • 選択: 各反復では、適合度に応じて重み付けし、適合度の高い最大9つの設定から1つを選択します。結果が30件に達すると、全結果の上位20%(最大30件)を使ってパラメータの共分散も推定します。この推定の影響は、エリート候補の情報が蓄積するにつれて大きくなります。
  • 変異: 各反復では、パラメータのおよそ半分を、探索範囲で正規化したガウスステップを使って変異させます。共分散が有効になると、最大40%の割合で信頼度に応じた相関ステップを使用し、反射処理によってステップを範囲内に戻すため、クリップされた値が蓄積しません。改善がないまま試行が蓄積すると、25試行にわたってステップサイズを最大20%まで線形に縮小し、新たな最良結果が見つかるとリセットします。反復1には親がなく、デフォルトの学習ハイパーパラメータをベースラインとして使用します。

ハイパーパラメータチューニングの準備#

チューニングを始める前に、次の点が重要です。

  1. 指標の特定: 組み込みチューナー(use_ray=False)はタスクのfitnessスコアに基づいて試行を順位付けし、use_ray=Trueはタスク指標を使用します。AP50やF1スコアなど、確認する副次指標を決めてください。
  2. チューニング予算の設定: 割り当てる計算リソースを決めます。ハイパーパラメーターチューニングは計算負荷が高くなることがあります。

チューニングループの仕組み#

組み込みチューナーは各反復で次のループを繰り返します。

  1. ハイパーパラメータを初期化する — Ultralytics YOLOのデフォルトのハイパーパラメータ、またはドメイン知識や過去の実験に基づく値を使い、妥当なベースラインから開始します。
  2. ハイパーパラメータを変異させる — Tunerクラスが、_mutateメソッドを使って既存の設定から新しいハイパーパラメータ一式を自動生成します。
  3. モデルを学習する — 変異させたハイパーパラメータを使って学習し、選択した指標で学習性能を評価します。
  4. モデルを評価する — 評価プロセスで反復の適合度スコアを算出し、現在のハイパーパラメータが改善しているかどうかを判断するため、過去の反復結果と比較します。
  5. 結果を記録する — 将来参照できるよう、性能指標と対応するハイパーパラメータの両方を記録します。Ultralytics YOLOはこれらの結果をNDJSON形式で自動保存します。
  6. 繰り返す — 設定した反復回数に達するまで続け、各反復では過去の実行で得た知見を活用します。組み込みチューナーはすべてのiterationsを実行します。Ray Tuneは各fitエポック後に指標を報告し、猶予期間が過ぎるとASHAが成績の低い試行を停止できるようにします。

反復回数と母集団サイズ#

組み込みチューナー(use_ray=False)では、iterationsが逐次試行の合計回数を制御し、デフォルトは300です。各試行では、1つのハイパーパラメータ設定で1つのモデルを学習します。たとえば、iterations=40とepochs=50を使用すると、40個の独立した50エポックの学習実行がスケジュールされます。候補を40個別々に用意して1つのモデルを50エポック学習するわけではありません。

組み込みの遺伝的アルゴリズムには、明示的な母集団サイズのパラメータはありません。過去の試行結果が存在する場合、適合度の高い最大9つの設定から選択し、各反復で候補を1つ変異させます。

並列試行や高度な探索戦略を使用するには、use_ray=Trueを設定してRay Tuneを使用します。Ray Tuneもデフォルトで300試行を実行し、iterationsをnum_samplesとして受け取ります。詳細については、Ray Tune統合ガイドをご覧ください。

デフォルトの探索空間#

次の表に、YOLO26のハイパーパラメータチューニングにおけるデフォルトの探索空間パラメータを示します。各パラメータには、タプル(min, max)で定義された値の範囲があります。

パラメーター種類値の範囲説明
lr0float(1e-5, 1e-2)学習開始時の初期学習率です。値を小さくすると学習は安定しますが、収束は遅くなります。
lrffloat(0.01, 1.0)lr0に対する割合として表される最終学習率の係数です。学習中に学習率をどの程度下げるかを制御します。
momentumfloat(0.7, 0.98)SGDのモメンタム係数です。値を大きくすると勾配の方向が安定しやすくなり、収束が速くなる場合があります。
weight_decayfloat(0.0, 0.001)過学習を防ぐためのL2正則化係数です。値を大きくすると、より強い正則化が適用されます。
warmup_epochsfloat(0.0, 5.0)線形学習率ウォームアップのエポック数です。学習初期の不安定さを抑えます。
warmup_momentumfloat(0.0, 0.95)ウォームアップ中の初期モメンタムです。最終モメンタム値まで徐々に増加します。
boxfloat(1.0, 20.0)全体の損失関数におけるバウンディングボックス損失の重みです。ボックス回帰と分類のバランスを調整します。
clsfloat(0.1, 4.0)全体の損失関数における分類損失の重みです。値を大きくすると、正しいクラス予測をより重視します。
cls_pwfloat(0.0, 1.0)クラス不均衡に対処するためのクラス重み付けの指数です。値を大きくすると、出現頻度の低いクラスの重みが増します。
dflfloat(0.4, 12.0)ボックス距離回帰項の重みです。DFLを使用しないYOLO26では、このゲインが正規化されたボックス距離に対するL1損失に適用されます。値を大きくすると、より正確な位置特定を重視します。
hsv_hfloat(0.0, 0.1)HSV色空間におけるランダムな色相データ拡張の範囲です。色の変化に対するモデルの汎化性能を高めます。
hsv_sfloat(0.0, 0.9)HSV空間におけるランダムな彩度データ拡張の範囲です。さまざまな照明条件をシミュレートします。
hsv_vfloat(0.0, 0.9)ランダムな明度(輝度)データ拡張の範囲です。さまざまな露出レベルへの対応に役立ちます。
degreesfloat(0.0, 45.0)回転データ拡張の最大角度です。物体の向きに対する不変性を高めます。
translatefloat(0.0, 0.9)画像サイズに対する割合で示す、平行移動データ拡張の最大値です。物体の位置に対するロバスト性を高めます。
scalefloat(0.0, 0.95)ランダムなスケーリングデータ拡張の範囲です。さまざまなサイズの物体を検出できるようにします。
shearfloat(0.0, 10.0)せん断データ拡張の最大角度です。学習画像に遠近法のような歪みを加えます。
perspectivefloat(0.0, 0.001)ランダムな遠近法データ拡張の範囲です。さまざまな視点をシミュレートします。
flipudfloat(0.0, 1.0)学習中に画像を垂直反転する確率です。俯瞰画像や航空画像に役立ちます。
fliplrfloat(0.0, 1.0)画像を水平反転する確率です。物体の向きに対する不変性を高めます。
bgrfloat(0.0, 1.0)色チャンネルを入れ替えるBGRデータ拡張を使用する確率です。色に対する不変性の向上に役立つ場合があります。
mosaicfloat(0.0, 1.0)4枚の画像を組み合わせるモザイクデータ拡張を使用する確率です。小物体検出に特に有効です。
mixupfloat(0.0, 1.0)2枚の画像を混合するMixUpデータ拡張を使用する確率です。モデルのロバスト性を高める場合があります。
cutmixfloat(0.0, 1.0)CutMixデータ拡張を使用する確率です。局所的な特徴を保ちながら画像領域を組み合わせます。
copy_pastefloat(0.0, 1.0)flipモードでは対象オブジェクトのうちコピーする割合を示し、mixupモードでは適用する確率も示します。
close_mosaicint(0.0, 10.0)学習完了前に安定化させるため、最後のNエポックではモザイクを無効にします。float値として変異させた後、整数のエポック数に丸めます。

カスタム探索空間の例#

以下の例では、探索空間を定義してmodel.tune()を呼び出します。この処理ではTunerクラスが実行され、YOLO26nをCOCO8でAdamWオプティマイザーを使い、30エポックにわたってチューニングします。チューニングを高速化するため、プロット、チェックポイント保存、最終エポック以外の検証はスキップされます。

警告

この例はデモンストレーションのみを目的としています。短時間または小規模なチューニング実行で得たハイパーパラメータが、実際の学習に最適であることはほとんどありません。信頼性が高く、他の条件にも適用できる結果を得るには、実際には、データセット、エポック数、データ拡張などを本番の学習に近い条件にしてチューニングしてください。短時間のチューニングでは、汎化しない高速収束や短期的な検証性能の向上にパラメータが偏る場合があります。

例
from ultralytics import YOLO

# YOLOモデルを初期化
model = YOLO("yolo26n.pt")

# 探索空間を定義
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# COCO8で30エポックのハイパーパラメータをチューニング
model.tune(
    data="coco8.yaml",
    epochs=30,
    iterations=300,
    optimizer="AdamW",
    space=search_space,
    plots=False,
    save=False,
    val=False,
)

中断したハイパーパラメータチューニングセッションの再開#

resume=Trueを渡すと、中断したハイパーパラメータチューニングセッションを再開できます。再開対象として、runs/{task}の下で使用されるディレクトリnameを任意で指定できます。nameを指定しない場合、直近に実行したセッションではなく、デフォルト名のtuneというディレクトリをそのまま再開します。そのため、カスタム名で開始した実行を再開する場合はnameを渡してください。また、data、epochs、iterations、spaceを含む、以前の学習引数をすべて指定する必要があります。

`model.tune()`を使用した`resume=True`
from ultralytics import YOLO

# YOLOモデルを定義
model = YOLO("yolo26n.pt")

# 探索空間を定義
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# 前回の実行を再開
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, resume=True)

# 名前'tune_exp'でチューニング実行を再開
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, name="tune_exp", resume=True)

結果#

ハイパーパラメータチューニングが正常に完了すると、チューニング結果をまとめた複数のファイルとディレクトリが作成されます。それぞれについて、以下で説明します。

ファイル構成#

結果のディレクトリ構成は次のとおりです。multitrain/やmultitrain-2/などのスイープディレクトリには、個々のチューニング反復が保存されます。各反復では、1つのデータセットに対し、1組のハイパーパラメータで1つのモデルを学習し、データセット名のサブディレクトリに格納します。ストレージを節約するため、チューナーは現在の最良結果ではない反復のデータセットごとの実行ディレクトリを削除します。tune/ディレクトリには、個々のモデル学習のチューニング結果がすべて含まれます。

runs/
└── detect/
    ├── multitrain/
    │   └── coco8/
    ├── multitrain-2/
    ├── ...
    └── tune/
        ├── best_hyperparameters.yaml
        ├── tune_fitness.png
        ├── tune_results.ndjson
        ├── tune_scatter_plots.png
        └── weights/
            ├── last.pt
            └── best.pt

ファイルの説明#

best_hyperparameters.yaml#

このYAMLファイルには、チューニング中に見つかった最も性能の高いハイパーパラメータが含まれています。このファイルを使って最適化済みの設定で今後の学習を開始できます。

  • 形式: YAML

  • 用途: ハイパーパラメータの結果

  • 例:

    # 558/900 iterations complete ✅ (45536.81s)
    # Results saved to /usr/src/ultralytics/runs/detect/tune
    # Best fitness=0.64297 observed at iteration 498
    # Best fitness metrics are {'metrics/precision(B)': 0.87247, 'metrics/recall(B)': 0.71387, 'metrics/mAP50(B)': 0.79106, 'metrics/mAP50-95(B)': 0.62651, 'val/box_loss': 2.79884, 'val/cls_loss': 2.72386, 'val/l1_loss': 0.68503, 'fitness': 0.64297}
    # Best fitness model is /usr/src/ultralytics/runs/detect/tune/weights
    # Best fitness hyperparameters are printed below.
    
    lr0: 0.00269
    lrf: 0.00288
    momentum: 0.73375
    weight_decay: 0.00015
    warmup_epochs: 1.22935
    warmup_momentum: 0.1525
    box: 18.27875
    cls: 1.32899
    dfl: 0.56016
    hsv_h: 0.01148
    hsv_s: 0.53554
    hsv_v: 0.13636
    degrees: 0.0
    translate: 0.12431
    scale: 0.07643
    shear: 0.0
    perspective: 0.0
    flipud: 0.0
    fliplr: 0.08631
    mosaic: 0.42551
    mixup: 0.0
    copy_paste: 0.0

tune_fitness.png#

このプロットは、反復回数に対する適合度を示します。遺伝的アルゴリズムの経時的な性能を視覚的に確認できます。

  • 形式: PNG
  • 用途: 性能の可視化

Hyperparameter Tuning Fitness vs Iteration

プロットには次の内容が含まれます。

  • データセットごと、反復ごとに1つのマーカー。単一データセットの実行では反復ごとに1点、複数データセットの実行ではデータセットごと、反復ごとに1点が表示されます。
  • 点線の「平滑化平均」線。反復ごとの最上位の適合度値に対してガウス平滑化(sigma=3)を適用して算出されます。

tune_results.ndjson#

各チューニング反復の詳細な結果を含むNDJSONファイルです。各行には、集約適合度、チューニングされたハイパーパラメータ、データセットごとの指標を含むJSONオブジェクトが1つ記録されます。単一データセットと複数データセットのチューニングでは、同じファイル形式を使用します。

  • 形式: NDJSON
  • 用途: 反復ごとの結果の追跡。
  • 例:

読みやすさのために整形した例を以下に示します。実際の.ndjsonファイルでは、各オブジェクトは1行で保存されます。

{
    "iteration": 1,
    "fitness": 0.48628,
    "hyperparameters": {
        "lr0": 0.01,
        "lrf": 0.01,
        "momentum": 0.937,
        "weight_decay": 0.0005
    },
    "datasets": {
        "coco8": {
            "metrics/precision(B)": 0.65666,
            "metrics/recall(B)": 0.85,
            "metrics/mAP50(B)": 0.85086,
            "metrics/mAP50-95(B)": 0.64104,
            "val/box_loss": 1.57958,
            "val/cls_loss": 1.04986,
            "val/l1_loss": 1.32641,
            "fitness": 0.64104
        },
        "coco8-grayscale": {
            "metrics/precision(B)": 0.6582,
            "metrics/recall(B)": 0.51667,
            "metrics/mAP50(B)": 0.59106,
            "metrics/mAP50-95(B)": 0.33152,
            "val/box_loss": 1.95424,
            "val/cls_loss": 1.64059,
            "val/l1_loss": 1.70226,
            "fitness": 0.33152
        }
    },
    "save_dirs": {
        "coco8": "runs/detect/multitrain/coco8",
        "coco8-grayscale": "runs/detect/multitrain/coco8-grayscale"
    }
}

トップレベルのfitnessは、データセットごとのfitness値の算術平均です。単一データセットのチューニングでは、datasets辞書にエントリが1つ含まれ、そのfitnessはトップレベルのfitnessと一致します。完了した反復ごとにJSONオブジェクトが1つ記録されます。実際のsave_dirsのパスは絶対パスですが、読みやすさのため、上記では省略しています。

tune_scatter_plots.png#

このファイルには、tune_results.ndjsonから生成された散布図が含まれており、さまざまなハイパーパラメータと性能指標の関係を視覚的に確認できます。変異では各ハイパーパラメータに設定された範囲を使用するため、degreesやshearのようにデフォルト値が0の値も変化します。

  • 形式: PNG
  • 用途: 探索的データ分析

Hyperparameter tuning results scatter plot analysis

weights/#

このディレクトリには、チューニング実行で適合度が最も高かった反復から保存されたPyTorchモデルが含まれます。両方のファイルは同じ反復から生成されています。

  • last.pt: そのイテレーションの学習実行における最終エポックの重みです。
  • best.pt: そのイテレーションの学習実行で、最も高い適合度を達成したエポックの重みです。

これらの結果を活用すると、今後のモデル学習や分析において、より適切な判断ができます。

結論#

Ultralytics YOLOのハイパーパラメータチューニングは、簡単に開始できる一方で、内部では適応度に基づく選択と範囲正規化された突然変異を遺伝的アルゴリズムで活用する強力な仕組みです。このガイドで説明するループに従うと、モデルを体系的にチューニングして性能を向上させ、その結果得られたbest_hyperparameters.yamlを再利用して今後のトレーニングを初期化できます。並列試行や高度な探索アルゴリズムを使ってチューニングを拡張するには、Ray Tune統合ガイドをご覧ください。または、クラウドトレーニングを通じてUltralytics Platformで、設定可能なハイパーパラメータとリアルタイムのメトリクス追跡を備えたマネージドジョブを実行できます。

レイヤーごとの学習率やカスタム適応度メトリクスなど、引数で指定できない設定には、代わりにトレーナーをサブクラス化してください。さらに詳しく知るには、Tunerクラスのソースコードをご覧ください。ご質問や機能リクエストがある場合は、GitHubまたはDiscordでお問い合わせください。

よくある質問#

  • lr0パラメーターで初期値を設定します。一般的な値は0.001から0.01の範囲です。その後、チューニングによって値を変化させ、最適値を見つけます。model.tune()メソッドを使って自動化できます。例:

    例
    from ultralytics import YOLO
    
    # YOLOモデルを初期化
    model = YOLO("yolo26n.pt")
    
    # COCO8で30エポックのハイパーパラメータをチューニング
    model.tune(data="coco8.yaml", epochs=30, iterations=300, optimizer="AdamW", plots=False, save=False, val=False)

    詳しくは、Ultralytics YOLOの設定ページをご確認ください。

  • 遺伝的アルゴリズムを使うと、手作業で試行錯誤せずに、Ultralytics YOLO26でハイパーパラメーター空間を効果的に探索できます。主なメリットは次のとおりです。

    • 効率的な探索:適応度に基づく選択で優れた構成を維持しながら、範囲正規化された突然変異で新しい候補を探索します。
    • 局所最小値の回避: ランダムな変異により、貪欲法だけの探索では抜け出せない局所最小値から探索を脱出できます。
    • 性能指標: タスク固有の適応度スコア(検出ではmAP50-95)に基づいて適応します。

    遺伝的アルゴリズムによるハイパーパラメータの最適化については、ハイパーパラメータ進化ガイドをご覧ください。

  • Ultralytics YOLOのハイパーパラメータチューニングにかかる時間は、データセットのサイズ、モデルアーキテクチャの複雑さ、反復回数、利用可能な計算リソースなど、いくつかの要因に大きく左右されます。たとえば、COCO8のようなデータセットでYOLO26nを30エポックチューニングする場合、ハードウェアによっては数時間から数日かかることがあります。

    チューニング時間を効果的に管理するには、ハイパーパラメータチューニングの準備で説明しているように、事前に明確なチューニング予算を設定してください。これにより、リソースの割り当てと最適化の目標のバランスを取れます。

  • YOLOのハイパーパラメータチューニング中にモデルの性能を評価するには、いくつかの主要なメトリクスを使用できます。

    • AP50: IoUしきい値0.50での平均適合率です。
    • F1スコア:適合率と再現率の調和平均です。
    • 適合率と再現率:真陽性と偽陽性、偽陰性を識別するモデルの精度を示す個別のメトリクスです。

    これらの指標は、モデルの性能のさまざまな側面を理解するのに役立ちます。

  • はい。Ultralytics YOLO26は、高度なハイパーパラメーター最適化を行うRay Tuneと統合できます。Ray Tuneは、ベイズ最適化やHyperbandなどの探索アルゴリズムに加え、チューニングを高速化する並列実行機能を提供します。

    YOLO26でRay Tuneを使用するには、model.tune()メソッドの呼び出しでuse_ray=Trueパラメーターを設定します。

コメント152

質問したり、結果を共有したり、ほかの人をサポートしたりできます。

  1. GengBin414GitHub(編集済み)

    I tuned my defect detection dataset ,which are composed of 8000+ images, this is my tune code: model.tune( data="../data/data20260420_line_scan_merged_6ch.yaml", epochs=300, iterations=300, #space=search_space, #optimizer="AdamW", optimizer="MuSGD", lr0=0.01, momentum=0.9, shear=1, degrees=1, perspective=0.0001, mixup=0.1, cutmix=0.1, batch=20 )

    I got the best mAP 0.586 at iteration 5 after tuned 30+ iterations, then I retrain the dataset with the following code: model.train( data="../data/data20260420_line_scan_merged_6ch.yaml", epochs=300, batch=20, imgsz=640, device=0, workers=16, optimizer="MuSGD", lr0=0.00721, lrf=0.01267, momentum=0.81816, weight_decay=0.00077, warmup_epochs=3.31429, warmup_momentum=0.95, box=7.11682, cls=0.48318, dfl=0.9397, hsv_h=0.00364, hsv_s=0.9, hsv_v=0.29751, degrees=0.99922, translate=0.07662, scale=0.51303, shear=0.76723, perspective=0.0, flipud=0.00019, fliplr=0.57639, bgr=0.00634, mosaic=0.62424, mixup=0.11307, cutmix=0.13007, copy_paste=0.00583, close_mosaic=10 #cfg="best_hyperparameters_map0.586.yaml" )

    I copied the hyperparameters from best_hyperparameters_map0.586.yaml, but I got the best mAP 0.568, what cause the discrepancy?Can sb help me out? Thanks.

    1. Glenn JocherUltralytics

      A small gap like 0.586 -> 0.568 is usually expected because tune() saves the best single stochastic run, while your later train() is a fresh run with different randomness and augmentation order; please first validate the tuning checkpoint runs/detect/tune/weights/best.pt, then retrain with the exact same args plus seed=0 and deterministic=True, and make sure you are comparing the same metric (fitness/mAP50-95) described in the Hyperparameter Tuning guide. If the gap still looks too large, please share the text output from validating that checkpoint and the matching row from tune_results.ndjson here in Discussions so the team can compare them directly.

    2. GengBin414GitHub(編集済み)

      Thank you for your timely reply, I validated the tuning checkpoint, here is the text output from validating that checkpoint: (yolo26) ps@ps:~/Desktop/GB/ultralytics$ python val.py Ultralytics 8.4.26 🚀 Python-3.11.15 torch-2.5.1 CUDA:0 (NVIDIA GeForce RTX 4090 D, 24208MiB) YOLO26x summary (fused): 190 layers, 55,645,380 parameters, 0 gradients, 193.9 GFLOPs val: Fast image access ✅ (ping: 0.0±0.0 ms, read: 10744.4±1424.6 MB/s, size: 734.1 KB) val: Scanning /home/ps/Desktop/GB/ultralytics/datasets/Merged_6Chanel_20260420/imagesH/val.cache... 786 images, 47 backgrounds, 0 corrupt: 100% ━━━━━━━━━━━━ 786/786 412.1Mit/s 0.0s Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 50/50 6.9it/s 7.2s all 786 1363 0.843 0.69 0.765 0.585 black 45 47 0.914 0.677 0.828 0.648 crack 120 145 0.681 0.517 0.55 0.334 edge 184 195 0.916 0.899 0.94 0.833 line 116 147 0.809 0.646 0.736 0.544 pit 73 89 0.775 0.543 0.642 0.447 raw 279 318 0.861 0.745 0.81 0.644 white 95 106 0.9 0.623 0.712 0.46 yellow 299 316 0.884 0.873 0.9 0.773 Speed: 0.9ms preprocess, 7.3ms inference, 0.0ms loss, 0.0ms postprocess per image Results saved to /home/ps/Desktop/GB/ultralytics/runs/detect/val81

      I checked my retrain args, it show that seed=0 and deterministic=True already set: python train.py New https://pypi.org/project/ultralytics/8.4.53 available 😃 Update with 'pip install -U ultralytics' Ultralytics 8.4.26 🚀 Python-3.11.15 torch-2.5.1 CUDA:0 (NVIDIA GeForce RTX 4090 D, 24208MiB) engine/trainer: agnostic_nms=False, amp=True, angle=1.0, augment=False, auto_augment=randaugment, batch=20, bgr=0.00634, box=7.11682, cache=False, cfg=None, classes=None, close_mosaic=10, cls=0.48318, compile=False, conf=None, copy_paste=0.00583, copy_paste_mode=flip, cos_lr=False, cutmix=0.13007, data=../data/data20260420_line_scan_merged_6ch.yaml, degrees=0.99922, deterministic=True, device=0, dfl=0.9397, dnn=False, dropout=0.0, dynamic=False, embed=None, end2end=None, epochs=500, erasing=0.4, exist_ok=False, fliplr=0.57639, flipud=0.00019, format=torchscript, fraction=1.0, freeze=None, half=False, hsv_h=0.00364, hsv_s=0.9, hsv_v=0.29751, imgsz=640, int8=False, iou=0.7, keras=False, kobj=1.0, line_width=None, lr0=0.00721, lrf=0.01267, mask_ratio=4, max_det=300, mixup=0.11307, mode=train, model=yolo26x.pt, momentum=0.81816, mosaic=0.62424, multi_scale=0.0, name=train137, nbs=64, nms=False, opset=None, optimize=False, optimizer=MuSGD, overlap_mask=True, patience=100, perspective=0.0, plots=True, pose=12.0, pretrained=True, profile=False, project=None, rect=False, resume=False, retina_masks=False, rle=1.0, save=True, save_conf=False, save_crop=False, save_dir=/home/ps/Desktop/GB/ultralytics/runs/detect/train137, save_frames=False, save_json=False, save_period=-1, save_txt=False, scale=0.51303, seed=0, shear=0.76723, show=False, show_boxes=True, show_conf=True, show_labels=True, simplify=True, single_cls=False, source=None, split=val, stream_buffer=False, task=detect, time=None, tracker=botsort.yaml, translate=0.07662, val=True, verbose=True, vid_stride=1, visualize=False, warmup_bias_lr=0.1, warmup_epochs=3.31429, warmup_momentum=0.95, weight_decay=0.00077, workers=16, workspace=None

      And here is the train output: Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size 260/300 20.8G 0.4503 0.4947 0.004246 50 640: 100% ━━━━━━━━━━━━ 354/354 2.7it/s 2:10 Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 20/20 4.5it/s 4.4s all 786 1363 0.841 0.682 0.751 0.564 EarlyStopping: Training stopped early as no improvement observed in last 100 epochs. Best results observed at epoch 160, best model saved as best.pt. To update EarlyStopping(patience=100) pass a new patience value, i.e. patience=300 or use patience=0 to disable EarlyStopping.

      260 epochs completed in 9.792 hours. Optimizer stripped from /home/ps/Desktop/GB/ultralytics/runs/detect/train138/weights/last.pt, 118.4MB Optimizer stripped from /home/ps/Desktop/GB/ultralytics/runs/detect/train138/weights/best.pt, 118.4MB

      Validating /home/ps/Desktop/GB/ultralytics/runs/detect/train138/weights/best.pt... Ultralytics 8.4.26 🚀 Python-3.11.15 torch-2.5.1 CUDA:0 (NVIDIA GeForce RTX 4090 D, 24208MiB) YOLO26x summary (fused): 190 layers, 55,645,380 parameters, 0 gradients, 193.9 GFLOPs Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 20/20 4.9it/s 4.1s all 786 1363 0.826 0.685 0.758 0.568 black 45 47 0.882 0.634 0.773 0.579 crack 120 145 0.675 0.559 0.577 0.314 edge 184 195 0.925 0.885 0.949 0.824 line 116 147 0.785 0.667 0.714 0.52 pit 73 89 0.84 0.528 0.662 0.447 raw 279 318 0.812 0.72 0.804 0.638 white 95 106 0.802 0.611 0.674 0.434 yellow 299 316 0.888 0.877 0.911 0.787 Speed: 0.1ms preprocess, 4.4ms inference, 0.0ms loss, 0.0ms postprocess per image Results saved to /home/ps/Desktop/GB/ultralytics/runs/detect/train138

      And I don't know where to find tune_results.ndjson mentioned in your reply. I guess you mean the matching row from tune_results.csv then here is: fitness lr0 lrf momentum weight_decay warmup_epochs warmup_momentum box cls dfl hsv_h hsv_s hsv_v degrees translate scale shear perspective flipud fliplr bgr mosaic mixup cutmix copy_paste close_mosaic 0.58582 0.00721 0.01267 0.81816 0.00077 3.31429 0.95 7.11682 0.48318 0.9397 0.00364 0.9 0.29751 0.99922 0.07662 0.51303 0.76723 0 0.00019 0.57639 0.00634 0.62424 0.11307 0.13007 0.00583 10

    3. Glenn JocherUltralytics

      The main issue I see is that your retrain is not matching the tuned trial: the runtime log shows epochs=500 rather than 300, so the schedule driven by lr0 and lrf is different and that alone can explain 0.585 -> 0.568; the current Hyperparameter Tuning guide writes tune_results.ndjson under runs/detect/tune/, but in your older 8.4.26 install the equivalent may be tune_results.csv, so please rerun with the exact runtime args from the best trial, especially epochs=300 and the same patience, and if it still prints epochs=500 then another override is being applied.

    4. GengBin414GitHub(編集済み)

      Sorry, after hyperparameter tuning, I retrained first with epochs=500, observed mAP=0.57, then I changed epochs=300, observed mAP=0.568. In the previous reply, I mistakenly copied the retrain args from the epochs=500 run. But the train output is correctly copied from the epochs=300 run, you can tell this out from the EarlyStopping output: Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size 260/300 20.8G 0.4503 0.4947 0.004246 50 640: 100% ━━━━━━━━━━━━ 354/354 2.7it/s 2:10 Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 20/20 4.5it/s 4.4s all 786 1363 0.841 0.682 0.751 0.564 EarlyStopping: Training stopped early as no improvement observed in last 100 epochs. Best results observed at epoch 160, best model saved as best.pt. To update EarlyStopping(patience=100) pass a new patience value, i.e. patience=300 or use patience=0 to disable EarlyStopping.

      And the retrain args of the epochs=300 run, it shows that seed=0 and deterministic=True already set: python train.py New https://pypi.org/project/ultralytics/8.4.53 available 😃 Update with 'pip install -U ultralytics' Ultralytics 8.4.26 🚀 Python-3.11.15 torch-2.5.1 CUDA:0 (NVIDIA GeForce RTX 4090 D, 24208MiB) engine/trainer: agnostic_nms=False, amp=True, angle=1.0, augment=False, auto_augment=randaugment, batch=20, bgr=0.00634, box=7.11682, cache=False, cfg=None, classes=None, close_mosaic=10, cls=0.48318, compile=False, conf=None, copy_paste=0.00583, copy_paste_mode=flip, cos_lr=False, cutmix=0.13007, data=../data/data20260420_line_scan_merged_6ch.yaml, degrees=0.99922, deterministic=True, device=0, dfl=0.9397, dnn=False, dropout=0.0, dynamic=False, embed=None, end2end=None, epochs=300, erasing=0.4, exist_ok=False, fliplr=0.57639, flipud=0.00019, format=torchscript, fraction=1.0, freeze=None, half=False, hsv_h=0.00364, hsv_s=0.9, hsv_v=0.29751, imgsz=640, int8=False, iou=0.7, keras=False, kobj=1.0, line_width=None, lr0=0.00721, lrf=0.01267, mask_ratio=4, max_det=300, mixup=0.11307, mode=train, model=yolo26x.pt, momentum=0.81816, mosaic=0.62424, multi_scale=0.0, name=train138, nbs=64, nms=False, opset=None, optimize=False, optimizer=MuSGD, overlap_mask=True, patience=100, perspective=0.0, plots=True, pose=12.0, pretrained=True, profile=False, project=None, rect=False, resume=False, retina_masks=False, rle=1.0, save=True, save_conf=False, save_crop=False, save_dir=/home/ps/Desktop/GB/ultralytics/runs/detect/train138, save_frames=False, save_json=False, save_period=-1, save_txt=False, scale=0.51303, seed=0, shear=0.76723, show=False, show_boxes=True, show_conf=True, show_labels=True, simplify=True, single_cls=False, source=None, split=val, stream_buffer=False, task=detect, time=None, tracker=botsort.yaml, translate=0.07662, val=True, verbose=True, vid_stride=1, visualize=False, warmup_bias_lr=0.1, warmup_epochs=3.31429, warmup_momentum=0.95, weight_decay=0.00077, workers=16, workspace=None

    5. Murat Raimbekov

      quick check on what is likely going on, framed generally: tune saves the best of N stochastic trials, and a single retrain is one new stochastic draw with the same hyperparameters. bit-exact reproduction between the two is not guaranteed even with seed=0, deterministic=True. our init_seeds(deterministic=True) sets torch.use_deterministic_algorithms(True, warn_only=True) in ultralytics/utils/torch_utils.py, matching the pytorch reproducibility notes - cuda ops without a deterministic alternative still run non-deterministically with just a warning. over many epochs on a real dataset that variance can compound.

      a few practical takeaways before assuming the gap is a tuning bug:

      • your trial weights at runs/detect/tune/weights/best.pt already validate to 0.585, so the trial result is real and reusable - if you need exactly that performance for deployment, use that checkpoint directly.
      • the recommended way to reuse tuned hyperparameters in a fresh train run is cfg="runs/detect/tune/best_hyperparameters.yaml" (the commented-out line in your script). that file contains the exact values the trial used and matches the workflow described in the hyperparameter tuning guide.
      • to bound run-to-run variance, retrain a few times with seed=0, seed=1, seed=2 and compare the mean against the tune's reported best, not a single retrain.

      unrelated, you are on ultralytics 8.4.26 and the current release is 8.4.53; for new tuning runs it is worth updating.

  2. User

    Hi, I have a question about Hyperparameter Tuning. What value of epochs and iterations should I pass to model.tune(). Default value of epochs is 100, and iterations is 10. Are the default values OK, or should I change them ? My dataset is about 10,000 images.

    1. Glenn JocherUltralytics

      For a 10k-image dataset, the defaults are fine for a quick sanity check, but for useful tuning you should set epochs close to your real training length because epochs is per trial, while iterations is how many different trials are tested; a practical starting point is epochs=50 to 100 with iterations=30 to 100 depending on your compute budget, then retrain once with the best settings from best_hyperparameters.yaml as shown in the Hyperparameter Tuning guide.

      1
    2. User

      Thank you very much ! I will try to search the best hyperparameters !

    3. Glenn JocherUltralytics

      You're welcome — sounds good; if anything looks off during tuning, please share your model.tune() call plus the resulting best_hyperparameters.yaml or tune_results.ndjson here, and we can help compare it against the expected outputs in the Hyperparameter Tuning guide.

  3. harunemrekiran61GitHub

    You’ve shown the box range as 0.02 to 0.2, but the default value appears to be 7.5. Is there a mistake here? Could you please check?

  4. Larry-zhaiGitHub

    How can I directly apply the optimized best_hyperparameters.yaml to my training? In fact, when I use code similar to the following: from ultralytics import YOLO model = YOLO("yolov8n.pt") model.train(data="data.yaml", hyp="hyp.yaml") an error occurs: SyntaxError: 'hyp' is not a valid YOLO argument.

  5. J.Q. Pan

    Hi I have used the above code to apply the tuning but neither the diagram nor the models will be saved. I only get a single tune folder with all tuning details. I may ask if someone else has also the same problem.

  6. BrianNieuwenhuisGitHub

    When running the code below the model.tune() call does not recognize my model specification. Could someone explain to me what I am doing wrong. I am using model.overrides so that I can also tune the shear and perspective parameters that are otherwise initialized at 0.

    from ultralytics import YOLO import wandb from ultralytics import settings settings.update({"wandb": True})

    import argparse

    def main(): # parse command-line args if needed parser = argparse.ArgumentParser() parser.add_argument("--gpus", type=int, default=1) parser.add_argument("--workers", type=int, default=4) args = parser.parse_args()

    # Define a YOLO model
    model = YOLO("yolo11x.pt")
    
    # Dynamically assign GPUs based on --gpus argument
    device = list(range(args.gpus))  # e.g., [0, 1, 2, 3] if args.gpus = 4
    
    # Define search space
    search_space = {
        "lr0": (1e-5, 1e-1),
        "lrf": (0.01, 1.0),
        "momentum": (0.6, 0.98),
        "weight_decay": (0.0, 0.001),
        "warmup_epochs": (0, 5),
        "warmup_momentum": (0.0,0.95),
        "box": (0.02, 0.2),
        "cls": (0.2, 4.0),
        "hsv_h": (0.0, 0.1),
        "hsv_s": (0.0, 0.9),
        "hsv_v": (0.0, 0.9),
        "translate":(0.0, 0.9),
        "scale": (0.0, 0.9),
        "shear": (0.0, 10.0),
        "perspective": (0.0, 0.001),
        "mosaic": (0.0,1.0),
        "mixup": (0.0, 1.0),
        "copy_paste": (0.0, 1.0)
    }
    
    # Manually initialize certain hperparameters that would not be tuned otherwise
    model.overrides = {
        'shear': 1,
        'perspective': 0.001,
        'mixup': 0.01,
        'copy_paste' : 0.01,
    
    }
    
    # tune the model
    results = model.tune(project='./tune/crop1344',name="tune_default_batch16_v100", use_ray = False,
        data="data.yaml", 
        #hyp="custom_hyp.yaml", # this does not seem to work work for tune scripts!!
        batch = 16,
        imgsz = 1344,    
        device = device,
        workers = args.workers,
    
        degrees = 180, #these parameters are fixed in the model tune
        flipud = 0.5,
        fliplr = 0.5,
        bgr = 0,
        auto_augment = None,
        #erasing = 0,
        
        epochs = 100,
        iterations=10, 
        space=search_space,
        optimizer="AdamW", 
        resume=False,  #start over or resume previous checkpoint
        plots=False,  # don't make plots etc to save time until last timepoint
        save=False,
        val=False,
        verbose=False)

    if name == "main": main()

  7. yyagmurkyaaGitHub

    Hello again, I have trained new models using the parameters you provided and by organizing my datasets. However, a common issue across all of them is that the models mistakenly classify objects like myself or nearby computer screens as the traffic sign "turn right ahead" (which is one of the labeled classes in my dataset). I have checked my dataset and confirmed that there are no such unrelated objects in the background.

    Additionally, the models sometimes confuse left and right directional signs.

    Why might these errors be occurring, and how can I fix them? Thank you in advance for your help.

    1. Glenn JocherUltralytics(編集済み)

      @Fatima-khanjar to balance precision and recall in your over-predicting model, try these adjustments:

      1. Increase confidence threshold during inference (not training) to filter out low-confidence predictions
      2. Adjust IoU threshold in NMS to reduce duplicate detections
      3. Increase classification loss weight with cls=1.0 or higher to improve class discrimination
      4. Check annotation quality in your dataset, especially for small or ambiguous objects
      5. Add hard negative examples to your dataset - images with objects similar to your classes but not actually part of them

      These changes should help improve precision without significantly sacrificing your excellent recall. For implementation details, see our NMS documentation for confidence thresholding examples.

      @yyagmurkyaa for your traffic sign confusion issues:

      1. For the model detecting unrelated objects as "turn right ahead" signs:

        • Add "hard negative" examples to your training set (images with computers, people, but no traffic signs)
        • Increase cls=1.0 or higher to improve classification accuracy
        • Check if the "turn right ahead" sign has visual similarities to these false positives
      2. For left/right confusion:

        • Create specific augmentations for directional signs without flipping (as you noted)
        • Ensure balanced examples of both directional types
        • Consider using a slightly larger model like YOLO26m for better feature discrimination

      These targeted adjustments should help address the specific confusion patterns you're seeing.

    2. Fatima-khanjarGitHub

      Hello again!!

      First of all, thank you so much for your help @glenn-jocher __ you've truly helped me a lot, and I really appreciate it!

      I have a question regarding fine-tuning a pre-trained YOLO model (e.g., trained on the COCO dataset) for my custom use case. My dataset includes a combination of both new classes (not present in COCO) and some of the existing COCO classes , but with different layouts or contexts.

      What I’d like to do is the following:

      Add my new classes starting from index 80, while still leveraging the pre-trained weights for the existing COCO classes.

      Ideally, I want to preserve the learned knowledge for the COCO classes (especially the ones shared with my dataset), and only train the model further on the new classes.

      Is it possible to:

      Fine-tune the model in such a way that it uses the pre-trained weights for the common classes, and only learns new classes from scratch starting from a different index?

      Retain and benefit from the original COCO knowledge while introducing and training on new class definitions?

      Also, I’ve noticed that when I fine-tune a pre-trained model and define my own data.yaml file — completely different from coco.yaml — I redefine the class names and indexes based on my custom dataset, completely removing the COCO classes not present in my data. In this case, what really happens during fine-tuning or transfer learning under the hood? Is the model discarding unused class weights? Are shared class weights still used effectively?

      I'd greatly appreciate any clarification or guidance on how to approach this setup properly.

      Best regards,

    3. Glenn JocherUltralytics

      @Fatima-khanjar great question about fine-tuning with mixed COCO and custom classes!

      Yes, you can leverage pre-trained COCO weights while adding new classes. Here's how:

      1. When fine-tuning a YOLO model, the model's detection head is automatically resized to accommodate your new class count. The weights for existing classes are preserved where possible.

      2. For classes that overlap with COCO, the model will leverage transfer learning from those pre-trained weights, while new classes will be initialized with random weights.

      3. You don't need to explicitly start from index 80 - just define your classes in your data.yaml file, and the model will handle the mapping automatically.

      4. During fine-tuning, the model doesn't discard unused class weights but rather reshapes the classification head to match your class count. Weights for classes that exist in both datasets are transferred and further optimized for your specific data.

      For best results with mixed classes, I recommend using a smaller learning rate initially (e.g., lr0=0.001) to preserve the knowledge in the pre-trained weights while allowing the model to adapt to your new classes.

    4. Fatima-khanjarGitHub

      Hello! @glenn-jocher thank you so much for your explanation!

      I have a follow-up question regarding class index matching. Let's say the person class in the COCO dataset is indexed as 0, but in my data.yaml file, I assign person to index 5. In this case, the model will not treat the person at index 5 as the same class as COCO’s index 0, correct?

      So, to benefit from the pretrained weights of shared classes, do the class indices in my custom dataset need to match the COCO indices exactly?

      Best regards,

    5. Glenn JocherUltralytics(編集済み)

      @Fatima-khanjar you're asking a crucial question about class mapping during transfer learning!

      You no longer need to keep COCO's class indices. With cls_remap=True (the default), training copies the pretrained classification-head rows by class name, so a class such as person keeps its pretrained weights at whatever index it has in your dataset, while new classes such as traffic_sign start from fresh weights. Training prints Remapped N/M cls head rows from pretrained weights by class name when rows are copied, and cls_remap=False disables it. For example, this data.yaml works:

      names:
        0: person
        1: car
        2: traffic_sign

      Just make sure the shared classes use the same names as in COCO. See the Fine-Tuning Guide for details.

    6. Fatima-khanjarGitHub

      @glenn-jocher Hello again!!!

      Thank you so much for your clarification! I have a quick follow-up question.

      Let’s say the COCO dataset defines the following class indices in its YAML file: 0: person, 2: car, 3: cat.

      In my own dataset, I share only the person and car classes with COCO — I don’t want to include cat. If I define my shared classes using the same indices as COCO (i.e., 0: person, 2: car), but then replace the COCO class cat at index 3 with a new class (e.g., 3: animal), will I still benefit from the pretrained weights for the shared classes (person and car)?

      Or will assigning a new class at an index previously used by COCO (like 3) cause any issues?

      best regards,

    7. Glenn JocherUltralytics(編集済み)

      @Fatima-khanjar great question about reusing COCO indices for new classes!

      With cls_remap=True (the default), pretrained classification-head rows are matched by class name, not by index. Shared classes such as person and car keep their pretrained weights wherever they sit in your dataset. A new class like "animal" at index 3 does not inherit the pretrained "cat" row, because the names do not match, so it starts from fresh weights. Reusing a COCO index therefore neither helps nor hurts the shared classes.

      If a new class is close to a pretrained one, give it that class's name so its row is copied. Using a lower learning rate initially (e.g., lr0=0.001) also helps preserve the pretrained features while the model adapts to your new classes.

      1
  8. yyagmurkyaaGitHub

    Thank you for your feedback. I trained my dataset using YOLOv11s. Although I didn’t experience severe overfitting with the current parameters, I couldn’t achieve optimal performance either. Some traffic signs were misclassified or not detected at all.

    While searching for the best hyperparameters, I realized that I hadn't applied data augmentation—except for the flip parameter. I have an example parameter file, and I plan to include all relevant augmentation options except for flipping.

    I would really appreciate your help in finding the most suitable parameters for my dataset, as I’m planning to participate in a competition soon. I need to enhance my model by adjusting the parameters properly to achieve the best possible performance.

    Thank you in advance for your support.

    On Sun, Apr 20, 2025 at 1:51 PM phatima khanjar @.***> wrote:

    Hello,

    I hope this message finds you well.

    image.png (view on web) https://github.com/user-attachments/assets/be6db84b-fe0d-4356-ba77-9b4426c253ee

    I fine-tuned YOLOv11s on my custom dataset, which is relatively small (1,156 images split into 75% training, 15% validation, and 10% test). The dataset consists of 41 classes, with each class containing between 200 and 300 images. I experimented with three different sets of hyperparameters: the default values, those optimized using Ray Tune, and others obtained through a Genetic Algorithm. In all cases, I observed oscillations in the validation dfl and box losses, which may indicate signs of overfitting. I would appreciate any suggestions or insights on how to address this issue, particularly given the small size of the dataset, and how to improve model generalization.

    best regards,

    — Reply to this email directly, view it on GitHub https://github.com/orgs/ultralytics/discussions/9536#discussioncomment-12889695, or unsubscribe https://github.com/notifications/unsubscribe-auth/BPQ7ZLAQ2G7ZL434FN3WFYD22N345AVCNFSM6AAAAABFVXPSL2VHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTEOBYHE3DSNI . You are receiving this because you were mentioned.Message ID: @.*** com>

    1. Glenn JocherUltralytics(編集済み)

      @yyagmurkyaa for traffic sign detection and classification with YOLO26s, I recommend focusing on these specific augmentation and training parameters:

      from ultralytics import YOLO
      
      model = YOLO("yolo26s.pt")
      model.train(
          data="your_traffic_signs.yaml",
          epochs=100,
          patience=25,
          batch=16,
          imgsz=640,  # Consider 800+ for small traffic signs
          hsv_h=0.015,  # Color augmentation helps with varying lighting conditions
          hsv_s=0.7,
          hsv_v=0.4,
          scale=0.5,  # Scale augmentation critical for varying distances
          translate=0.1,  # Helps with signs at different positions
          mosaic=1.0,  # Excellent for object detection tasks
          mixup=0.1,  # Light mixup can help with generalization
          perspective=0.0005,  # Slight perspective change for different viewing angles
          weight_decay=0.0005,  # Regularization to reduce overfitting
          optimizer="AdamW",
          lr0=0.001,
          lrf=0.01,
          cos_lr=True  # Cosine learning rate scheduler
      )

      For traffic sign detection specifically:

      1. Increase image size to better detect small signs
      2. Focus on color-preserving augmentations as colors are critical for traffic signs
      3. Use perspective transformations to simulate different viewing angles
      4. Enable strong scale/translate augmentations to handle varying distances

      Consider running model.tune() with these parameters as starting points to find the optimal configuration for your competition. You might also need to address class imbalance if some signs appear less frequently in your dataset.

    2. yyagmurkyaaGitHub

      You're very welcome! I wasn't expecting such a quick response either. I'm excited to hear that you'll be training with these parameters and look forward to seeing the results as soon as possible. Thank you again for your support!

    3. Glenn JocherUltralytics(編集済み)

      @Fatima-khanjar for a small dataset (1,156 images) with 41 classes, oscillations in validation losses often indicate overfitting. Here are specific recommendations to improve generalization:

      1. Strengthen regularization:

        • Increase weight_decay to 0.001-0.003
        • Add dropout with dropout=0.1 to reduce co-adaptation
      2. Enhance data augmentation:

        • Maximize augmentations: mosaic=1.0, mixup=0.2, copy_paste=0.1
        • Use strong geometric transforms: translate=0.2, scale=0.5
      3. Training modifications:

        • Reduce model complexity by using YOLO26n instead of YOLO26s
        • Implement gradual unfreezing (freeze layers at first)
        • Enable cos_lr=True for smoother learning rate decay
      4. Consider transfer learning modifications:

        • Start with a model pre-trained on a domain similar to yours
        • Use fewer epochs with higher patience for early stopping

      With 41 classes and limited samples per class, these techniques should help stabilize training and improve generalization. You might also benefit from training ensembles of multiple models if computational resources allow. For more details, refer to our Model Training Tips.

    4. Fatima-khanjarGitHub(編集済み)

      Hello,

      Thank you for your advice! Your instructions have improved my model’s performance compared to before. I have now achieved the following metrics:

      Mean Precision: 0.794 Mean Recall: 0.99 Mean F1 Score: 0.881 mAP@0.5: 0.938 mAP@0.5-0.95: 0.827

      After analyzing these results, it seems that the model is over-predicting. Do you have any suggestions on how I can better balance precision and recall?

      best regards,

  9. Fatima-khanjarGitHub

    Hello,

    I hope this message finds you well.

    image

    I fine-tuned YOLOv11s on my custom dataset, which is relatively small (1,156 images split into 75% training, 15% validation, and 10% test). The dataset consists of 41 classes, with each class containing between 200 and 300 images. I experimented with three different sets of hyperparameters: the default values, those optimized using Ray Tune, and others obtained through a Genetic Algorithm. In all cases, I observed oscillations in the validation dfl and box losses, which may indicate signs of overfitting. I would appreciate any suggestions or insights on how to address this issue, particularly given the small size of the dataset, and how to improve model generalization.

    best regards,

  10. yyagmurkyaaGitHub

    Hello, I am training a model using YOLOv11, and the dataset consists of traffic signs. There are 22 classes, and each class has 400 labeled images. I’m not sure what parameters I should use for training. What parameters should I set to prevent overfitting, and what are the correct values? Could you help me with this?

    1. Glenn JocherUltralytics(編集済み)

      @yyagmurkyaa your dataset of 22 classes with 400 images per class should provide a good foundation for traffic sign detection. To prevent overfitting with YOLO26, I'd recommend:

      1. Start with hyperparameter tuning using the model.tune() method to find optimal values:
      from ultralytics import YOLO
      
      model = YOLO("yolo26n.pt")  # Start with a smaller model for faster tuning
      model.tune(
          data="your_traffic_signs.yaml",
          epochs=30,
          iterations=100,
          weight_decay=0.0005,  # Try higher values like 0.001-0.005 to increase regularization
          patience=15,  # Early stopping
          val=True
      )
      1. Key hyperparameters to prevent overfitting:

        • Increase weight_decay (0.001-0.005)
        • Enable strong data augmentation (hsv_h, hsv_s, translate, scale, fliplr, mosaic)
        • Use early stopping with reasonable patience
        • Consider reducing model capacity (use n or s model variants)
      2. Monitor validation metrics to detect overfitting (when training accuracy continues improving but validation metrics plateau or decline)

      The automated tuning process should help identify the optimal parameter values for your specific dataset. For more details, check out our Hyperparameter Tuning Guide.

    2. yyagmurkyaaGitHub

      Thank you for your feedback. I trained my dataset using YOLOv11s. Although I didn’t experience severe overfitting with the current parameters, I couldn’t achieve optimal performance either. Some traffic signs were misclassified or not detected at all.

      While searching for the best hyperparameters, I realized that I hadn't applied data augmentation—except for the flip parameter. I have an example parameter file, and I plan to include all relevant augmentation options except for flipping.

      I would really appreciate your help in finding the most suitable parameters for my dataset, as I’m planning to participate in a competition soon. I need to enhance my model by adjusting the parameters properly to achieve the best possible performance.

      Thank you in advance for your support.