コンテンツにスキップ

YOLOE：リアルタイムな物体検出

はじめに

YOLOEのプロンプトオプション

YOLOE (Real-Time Seeing Anything)は、オープンボキャブラリーの検出とセグメンテーションのために設計された、ゼロショットでプロンプト可能な新しいYOLOモデルの進化形です。固定されたカテゴリに限定されていた従来のYOLOモデルとは異なり、YOLOEはテキスト、画像、または内部語彙プロンプトを使用し、あらゆるオブジェクトクラスのリアルタイム検出を可能にします。YOLOv10をベースとし、YOLO-Worldに触発されたYOLOEは、速度と精度への影響を最小限に抑えながら、最先端のゼロショット性能を実現します。



見る: Ultralytics python パッケージで YOLOE を使用する方法: Open Vocabulary & Real-Time Seeing Anything 🚀

以前のYOLOモデルと比較して、YOLOEは効率と精度を大幅に向上させます。LVISでは、YOLO-Worldv2と比較して+3.5 AP向上し、トレーニングリソースはわずか3分の1で、推論速度は1.4倍高速です。COCOで微調整されたYOLOE-v8-largeは、YOLOv8-Lを0.1 mAP上回り、トレーニング時間はほぼ4分の1です。これは、YOLOEの精度、効率、汎用性の優れたバランスを示しています。以下のセクションでは、YOLOEのアーキテクチャ、ベンチマーク比較、およびUltralyticsフレームワークとの統合について説明します。

アーキテクチャの概要

YOLOEアーキテクチャ

YOLOEは、標準的なYOLOの構造を保持しています。特徴抽出のための畳み込みバックボーン（例：CSP-Darknet）、マルチスケール融合のためのネック（例：PAN-FPN）、そしてオブジェクトネス、クラス、ボックスを独立して予測するアンカーフリー、デカップルド検出ヘッド（YOLOv8/YOLO11と同様）です。YOLOEは、オープンボキャブラリー検出を可能にする3つの新しいモジュールを導入しています。

  • 再パラメータ化可能な領域-テキストアライメント（RepRTA）: 小さな補助ネットワークを介してテキスト埋め込み（例えば、CLIPから）を改良することにより、テキストプロンプトによる検出をサポートします。推論時には、このネットワークはメインモデルに組み込まれ、オーバーヘッドをゼロにします。したがって、YOLOEは、実行時のペナルティなしに、任意のテキストラベル付きオブジェクト（例えば、未知の「交通信号」）を検出します。

  • セマンティック活性化ビジュアルプロンプトエンコーダー（SAVPE）：軽量な埋め込みブランチを介してビジュアルプロンプト検出を可能にします。参照画像が与えられた場合、SAVPEはセマンティックおよび活性化特徴をエンコードし、視覚的に類似したオブジェクトを検出するようにモデルを調整します。これは、ロゴや特定のパーツに役立つワンショット検出機能です。

  • Lazy Region-Prompt Contrast (LRPC): プロンプトフリーモードでは、YOLOEは、大規模な語彙（LVISおよびObjects365の1200以上のカテゴリ）でトレーニングされた内部埋め込みを使用して、オープンセット認識を実行します。外部プロンプトやエンコーダーなしで、YOLOEは埋め込み類似度検索によってオブジェクトを識別し、推論時に大規模なラベル空間を効率的に処理します。

さらに、YOLOEは、マスク予測ブランチ（YOLACTまたはYOLOv8-Segと同様）で検出ヘッドを拡張することにより、リアルタイムのインスタンスセグメンテーションを統合し、オーバーヘッドを最小限に抑えます。

重要なこととして、YOLOEのオープンワールドモジュールは、通常のクローズドセットYOLOとして使用する場合、推論コストを発生させません。トレーニング後、YOLOEのパラメータは標準のYOLOヘッドに再パラメータ化でき、同一のFLOPと速度を維持します（例えば、YOLO11と完全に一致します）。

利用可能なモデル、サポートされているタスク、および動作モード

このセクションでは、利用可能なモデルと、特定の事前学習済みウェイト、サポートするタスク、および推論、検証、トレーニング、エクスポートなどのさまざまな動作モードとの互換性について詳しく説明します。サポートされているモードは✅で、サポートされていないモードは❌で示されています。

テキスト/ビジュアルプロンプトモデル

モデルの種類 事前学習済み重み サポートされているタスク 推論 検証 学習 エクスポート
YOLOE-11S yoloe-11s-seg.pt インスタンスセグメンテーション ✅ ✅ ✅ ✅
YOLOE-11M yoloe-11m-seg.pt インスタンスセグメンテーション ✅ ✅ ✅ ✅
YOLOE-11L yoloe-11l-seg.pt インスタンスセグメンテーション ✅ ✅ ✅ ✅
YOLOE-v8S yoloe-v8s-seg.pt インスタンスセグメンテーション ✅ ✅ ✅ ✅
YOLOE-v8M yoloe-v8m-seg.pt インスタンスセグメンテーション ✅ ✅ ✅ ✅
YOLOE-v8L yoloe-v8l-seg.pt インスタンスセグメンテーション ✅ ✅ ✅ ✅

プロンプトフリーモデル

モデルの種類 事前学習済み重み サポートされているタスク 推論 検証 学習 エクスポート
YOLOE-11S-PF yoloe-11s-seg-pf.pt インスタンスセグメンテーション ✅ ✅ ✅ ✅
YOLOE-11M-PF yoloe-11m-seg-pf.pt インスタンスセグメンテーション ✅ ✅ ✅ ✅
YOLOE-11L-PF yoloe-11l-seg-pf.pt インスタンスセグメンテーション ✅ ✅ ✅ ✅
YOLOE-v8S-PF yoloe-v8s-seg-pf.pt インスタンスセグメンテーション ✅ ✅ ✅ ✅
YOLOE-v8M-PF yoloe-v8m-seg-pf.pt インスタンスセグメンテーション ✅ ✅ ✅ ✅
YOLOE-v8L-PF yoloe-v8l-seg-pf.pt インスタンスセグメンテーション ✅ ✅ ✅ ✅

使用例

YOLOEモデルは、pythonアプリケーションに簡単に統合できます。Ultralyticsは、開発を効率化するためのユーザーフレンドリーなPython APIとCLIコマンドを提供します。

学習の使用法

カスタムデータセットでのファインチューニング

検出とインスタンスセグメンテーションの両方のタスクにおいて、カスタムYOLOデータセットで事前学習済みのYOLOEモデルをファインチューニングできます。

例

インスタンスセグメンテーション

YOLOEの事前学習済みチェックポイントのファインチューニングは、ほとんどの場合、 標準的なYOLOトレーニング手順に従います。主な違いは、明示的に以下を渡すことです。 YOLOEPESegTrainer としての trainer パラメータを model.train():

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEPESegTrainer

model = YOLOE("yoloe-11s-seg.pt")

# Fine-tune on your segmentation dataset
results = model.train(
    data="coco128-seg.yaml",  # Segmentation dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPESegTrainer,  # <- Important: use segmentation trainer
)

物体検出

すべて 事前学習済みのYOLOEモデル は、デフォルトでインスタンスセグメンテーションを実行します。これらの事前学習済みチェックポイントを検出モデルのトレーニングに使用するには、YAML構成を使用して検出モデルをゼロから初期化し、同じスケールの事前学習済みセグメンテーションチェックポイントをロードします。ここでは、 YOLOEPETrainer の代わりに YOLOEPESegTrainer を使用していることに注意してください。これは、検出モデルをトレーニングしているためです。

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEPETrainer

# Initialize a detection model from a config
model = YOLOE("yoloe-11s.yaml")

# Load weights from a pretrained segmentation checkpoint (same scale)
model.load("yoloe-11s-seg.pt")

# Fine-tune on your detection dataset
results = model.train(
    data="coco128.yaml",  # Detection dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPETrainer,  # <- Important: use detection trainer
)

線形プロービングは、モデルの残りの部分をフリーズしたまま、分類ブランチのみをファインチューニングします。このアプローチは、以前に学習した特徴を活用して分類ヘッドのみを適応させることで、過学習を防ぐため、限られたデータで作業する場合に役立ちます。

インスタンスセグメンテーション

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEPESegTrainer

# Load a pretrained segmentation model
model = YOLOE("yoloe-11s-seg.pt")

# Identify the head layer index
head_index = len(model.model.model) - 1

# Freeze all backbone and neck layers (i.e. everything before the head)
freeze = [str(i) for i in range(0, head_index)]

# Freeze parts of the segmentation head, keeping only the classification branch trainable
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

# Freeze detection branch components
freeze.extend(
    [
        f"{head_index}.cv3.0.0",
        f"{head_index}.cv3.0.1",
        f"{head_index}.cv3.1.0",
        f"{head_index}.cv3.1.1",
        f"{head_index}.cv3.2.0",
        f"{head_index}.cv3.2.1",
    ]
)

# Train only the classification branch
results = model.train(
    data="coco128-seg.yaml",  # Segmentation dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPESegTrainer,  # <- Important: use segmentation trainer
    freeze=freeze,
)

物体検出

物体検出タスクの場合、トレーニングプロセスは上記のインスタンスセグメンテーションの例とほぼ同じですが、 YOLOEPETrainer の代わりに YOLOEPESegTrainerを使用し、YAMLを使用して物体検出モデルを初期化し、事前学習済みのインスタンスセグメンテーションチェックポイントから重みをロードします。

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEPETrainer

# Initialize a detection model from a config
model = YOLOE("yoloe-11s.yaml")

# Load weights from a pretrained segmentation checkpoint (same scale)
model.load("yoloe-11s-seg.pt")

# Identify the head layer index
head_index = len(model.model.model) - 1

# Freeze all backbone and neck layers (i.e. everything before the head)
freeze = [str(i) for i in range(0, head_index)]

# Freeze parts of the segmentation head, keeping only the classification branch trainable
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

# Freeze detection branch components
freeze.extend(
    [
        f"{head_index}.cv3.0.0",
        f"{head_index}.cv3.0.1",
        f"{head_index}.cv3.1.0",
        f"{head_index}.cv3.1.1",
        f"{head_index}.cv3.2.0",
        f"{head_index}.cv3.2.1",
    ]
)

# Train only the classification branch
results = model.train(
    data="coco128.yaml",  # Detection dataset
    epochs=80,
    patience=10,
    trainer=YOLOEPETrainer,  # <- Important: use detection trainer
    freeze=freeze,
)

予測の使用方法

YOLOEは、テキストベースと視覚的なプロンプトの両方をサポートしています。プロンプトの使用は簡単で、単にそれらを介して渡すだけです。 predict メソッドを以下に示します。

例

テキストプロンプトを使用すると、テキストによる説明を通じて検出したいクラスを指定できます。次のコードは、YOLOE を使用して画像内の人物とバスを検出する方法を示しています:

from ultralytics import YOLOE

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")  # or select yoloe-11s/m-seg.pt for different sizes

# Set text prompt to detect person and bus. You only need to do this once after you load the model.
names = ["person", "bus"]
model.set_classes(names, model.get_text_pe(names))

# Run detection on the given image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

ビジュアルプロンプトを使用すると、テキストで記述する代わりに、ターゲットクラスのビジュアルな例を示すことでモデルをガイドできます。

The visual_prompts 引数は、次の2つのキーを持つ辞書を取ります。 bboxes および clsの各バウンディングボックスは bboxes モデルに検出させたいオブジェクトの例を正確に囲み、対応するエントリは cls そのボックスのクラスラベルを指定します。この組み合わせは、モデルに「これがクラスXの見え方です。これに似たものをさらに見つけてください」と伝えます。

クラスID（cls) 内。 visual_prompts は、各バウンディングボックスをプロンプト内の特定のカテゴリに関連付けるために使用されます。これらは固定されたラベルではなく、各例に割り当てる一時的な識別子です。唯一の要件は、クラスIDが0から始まる連続した番号でなければならないことです。これにより、モデルは各ボックスをそれぞれのクラスに正しく関連付けることができます。

推論を実行するのと同じ画像内で、視覚的なプロンプトを直接提供できます。例：

import numpy as np

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")

# Define visual prompts using bounding boxes and their corresponding class IDs.
# Each box highlights an example of the object you want the model to detect.
visual_prompts = dict(
    bboxes=np.array(
        [
            [221.52, 405.8, 344.98, 857.54],  # Box enclosing person
            [120, 425, 160, 445],  # Box enclosing glasses
        ],
    ),
    cls=np.array(
        [
            0,  # ID to be assigned for person
            1,  # ID to be assigned for glassses
        ]
    ),
)

# Run inference on an image, using the provided visual prompts as guidance
results = model.predict(
    "ultralytics/assets/bus.jpg",
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

または、を使用して、別の参照画像から例を提供できます。 refer_image 引数を使用します。その場合、 bboxes および cls で visual_prompts 予測対象の画像ではなく、参照画像内のオブジェクトを記述する必要があります。

注

もし source がビデオまたはストリームの場合、モデルは自動的に最初のフレームを refer_imageは、あなたの visual_prompts がその初期フレームに適用され、モデルがビデオの残りの部分で何を探すべきかを理解するのに役立ちます。または、特定のフレームを明示的に refer_image モデルが参照として使用する視覚的な例を制御するには。

import numpy as np

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")

# Define visual prompts based on a separate reference image
visual_prompts = dict(
    bboxes=np.array([[221.52, 405.8, 344.98, 857.54]]),  # Box enclosing person
    cls=np.array([0]),  # ID to be assigned for person
)

# Run prediction on a different image, using reference image to guide what to look for
results = model.predict(
    "ultralytics/assets/zidane.jpg",  # Target image for detection
    refer_image="ultralytics/assets/bus.jpg",  # Reference image used to get visual prompts
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

使用 refer_image また、クラスを永続的に設定するため、同じ視覚的なプロンプトを再度指定しなくても予測を実行でき、エクスポート後も同じクラスを検出できる機能を保持したままモデルをエクスポートできます。 

# After making prediction with `refer_image`, you can run predictions without passing visual_prompts again and still get the same classes back
results = model("ultralytics/assets/bus.jpg")

# Or export it to a different format while retaining the classes
model.export(format="onnx")

複数のターゲット画像を渡して、予測を実行することもできます。

import numpy as np

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")

# Define visual prompts using bounding boxes and their corresponding class IDs.
# Each box highlights an example of the object you want the model to detect.
visual_prompts = dict(
    bboxes=[
        np.array(
            [
                [221.52, 405.8, 344.98, 857.54],  # Box enclosing person
                [120, 425, 160, 445],  # Box enclosing glasses
            ],
        ),
        np.array([[150, 200, 1150, 700]]),
    ],
    cls=[
        np.array(
            [
                0,  # ID to be assigned for person
                1,  # ID to be assigned for glasses
            ]
        ),
        np.array([0]),
    ],
)

# Run inference on multiple image, using the provided visual prompts as guidance
results = model.predict(
    ["ultralytics/assets/bus.jpg", "ultralytics/assets/zidane.jpg"],
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

YOLOEには、組み込みの語彙が付属するプロンプトフリーのバリアントも含まれています。これらのモデルはプロンプトを必要とせず、従来のYOLOモデルのように機能します。ユーザーが提供するラベルや視覚的な例に頼る代わりに、Recognize Anything Model Plus (RAM++)で使用されているタグセットに基づいて、定義済みの4,585クラスのリストからオブジェクトを検出します。

from ultralytics import YOLOE

# Initialize a YOLOE model
model = YOLOE("yoloe-11l-seg-pf.pt")

# Run prediction. No prompts required.
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

Val の使用法

データセットに対するモデルの検証は、次のように効率化されています。

例

from ultralytics import YOLOE

# Create a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")  # or select yoloe-11s/m-seg.pt for different sizes

# Conduct model validation on the COCO128-seg example dataset
metrics = model.val(data="coco128-seg.yaml")

デフォルトでは、提供されたデータセットを使用して、各カテゴリの視覚的埋め込みを抽出します。

from ultralytics import YOLOE

# Create a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")  # or select yoloe-11s/m-seg.pt for different sizes

# Conduct model validation on the COCO128-seg example dataset
metrics = model.val(data="coco128-seg.yaml", load_vp=True)

あるいは、別のデータセットをリファレンスデータセットとして使用し、各カテゴリの視覚的埋め込みを抽出することもできます。このリファレンスデータセットは、提供されたデータセットと完全に同じカテゴリを持つ必要があります。

from ultralytics import YOLOE

# Create a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")  # or select yoloe-11s/m-seg.pt for different sizes

# Conduct model validation on the COCO128-seg example dataset
metrics = model.val(data="coco128-seg.yaml", load_vp=True, refer_data="coco.yaml")

from ultralytics import YOLOE

# Create a YOLOE model
model = YOLOE("yoloe-11l-seg-pf.pt")  # or select yoloe-11s/m-seg-pf.pt for different sizes

# Conduct model validation on the COCO128-seg example dataset
metrics = model.val(data="coco128-seg.yaml", single_cls=True)

エクスポートの使用法

エクスポートのプロセスは他のYOLOモデルと同様ですが、テキストとビジュアルプロンプトを処理できる柔軟性が追加されています。

例

from ultralytics import YOLOE

# Select yoloe-11s/m-seg.pt for different sizes
model = YOLOE("yoloe-11l-seg.pt")

# Configure the set_classes() before exporting the model
names = ["person", "bus"]
model.set_classes(names, model.get_text_pe(names))

export_model = model.export(format="onnx")
model = YOLOE(export_model)

# Run detection on the given image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

公式モデルの学習

データセットの準備

注

公式のYOLOEモデルをトレーニングするには、トレーニングデータ用のセグメントアノテーションが必要です。詳細はこちら。 公式チームが提供するスクリプト によってデータセットをセグメントアノテーションに変換します。 SAM2.1モデルまたは、提供されているものを直接ダウンロードすることもできます。 Processed Segment Annotations 公式チームが提供する以下の表に記載されています。

  • 学習データ
データセット 種類 サンプル ボックス 生の検出アノテーション 処理されたセグメントアノテーション
Objects365v1 検出 609k 9621k objects365_train.json objects365_train_segm.json
GQA Grounding 621k 3681k final_mixed_train_no_coco.json final_mixed_train_no_coco_segm.json
Flickr30k Grounding 149k 641k final_flickr_separateGT_train.json final_flickr_separateGT_train_segm.json
  • Valデータ
データセット 種類 アノテーションファイル
LVIS minival 検出 minival.txt

トレーニングを最初から開始する

注

Visual Prompt モデルは、十分にトレーニングされたものに基づいて微調整されます Text Prompt モデル。

例

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOESegTrainerFromScratch

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="flickr/full_images/",
                json_file="flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="mixed_grounding/gqa/images",
                json_file="mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

model = YOLOE("yoloe-11l-seg.yaml")
model.train(
    data=data,
    batch=128,
    epochs=30,
    close_mosaic=2,
    optimizer="AdamW",
    lr0=2e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOESegTrainerFromScratch,
    device="0,1,2,3,4,5,6,7",
)

以降 SAVPE モジュールはトレーニング中に更新する必要があります。 トレーニング済みのテキストプロンプトモデルを検出モデルに変換し、トレーニングコストを削減して検出パイプラインを採用します。 このステップはオプションであり、セグメンテーションから直接開始することもできます。

from ultralytics import YOLOE
from ultralytics.utils.patches import torch_load

det_model = YOLOE("yoloe-11l.yaml")
state = torch_load("yoloe-11l-seg.pt")
det_model.load(state["model"])
det_model.save("yoloe-11l-seg-det.pt")

学習開始:

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOESegVPTrainer

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="flickr/full_images/",
                json_file="flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="mixed_grounding/gqa/images",
                json_file="mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

model = YOLOE("yoloe-11l-seg.pt")
# replace to yoloe-11l-seg-det.pt if converted to detection model
# model = YOLOE("yoloe-11l-seg-det.pt")

# freeze every layer except of the savpe module.
head_index = len(model.model.model) - 1
freeze = list(range(0, head_index))
for name, child in model.model.model[-1].named_children():
    if "savpe" not in name:
        freeze.append(f"{head_index}.{name}")

model.train(
    data=data,
    batch=128,
    epochs=2,
    close_mosaic=2,
    optimizer="AdamW",
    lr0=16e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOESegVPTrainer,  # use YOLOEVPTrainer if converted to detection model
    device="0,1,2,3,4,5,6,7",
    freeze=freeze,
)

トレーニング後にセグメンテーションモデルに戻します。トレーニング前にセグメンテーションモデルを検出モデルに変換した場合にのみ必要です。

from copy import deepcopy

from ultralytics import YOLOE

model = YOLOE("yoloe-11l-seg.yaml")
model.load("yoloe-11l-seg.pt")

vp_model = YOLOE("yoloe-11l-vp.pt")
model.model.model[-1].savpe = deepcopy(vp_model.model.model[-1].savpe)
model.eval()
model.save("yoloe-11l-seg.pt")

視覚的なプロンプトトレーニングと同様に、プロンプトフリーモデルの場合、トレーニング中に更新する必要があるのは、特殊なプロンプト埋め込みだけです。 トレーニング済みのテキストプロンプトモデルを検出モデルに変換し、トレーニングコストを抑えて検出パイプラインを採用します。 このステップはオプションであり、セグメンテーションから直接開始することもできます。

from ultralytics import YOLOE
from ultralytics.utils.patches import torch_load

det_model = YOLOE("yoloe-11l.yaml")
state = torch_load("yoloe-11l-seg.pt")
det_model.load(state["model"])
det_model.save("yoloe-11l-seg-det.pt")
学習開始: 
from ultralytics import YOLOE

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="flickr/full_images/",
                json_file="flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="mixed_grounding/gqa/images",
                json_file="mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            ),
        ],
    ),
    val=dict(yolo_data=["lvis.yaml"]),
)

model = YOLOE("yoloe-11l-seg.pt")
# replace to yoloe-11l-seg-det.pt if converted to detection model
# model = YOLOE("yoloe-11l-seg-det.pt")

# freeze layers.
head_index = len(model.model.model) - 1
freeze = [str(f) for f in range(0, head_index)]
for name, child in model.model.model[-1].named_children():
    if "cv3" not in name:
        freeze.append(f"{head_index}.{name}")

freeze.extend(
    [
        f"{head_index}.cv3.0.0",
        f"{head_index}.cv3.0.1",
        f"{head_index}.cv3.1.0",
        f"{head_index}.cv3.1.1",
        f"{head_index}.cv3.2.0",
        f"{head_index}.cv3.2.1",
    ]
)

model.train(
    data=data,
    batch=128,
    epochs=1,
    close_mosaic=1,
    optimizer="AdamW",
    lr0=2e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOEPEFreeTrainer,
    device="0,1,2,3,4,5,6,7",
    freeze=freeze,
    single_cls=True,  # this is needed
)

トレーニング後にセグメンテーションモデルに戻します。トレーニング前にセグメンテーションモデルを検出モデルに変換した場合にのみ必要です。

from copy import deepcopy

from ultralytics import YOLOE

model = YOLOE("yoloe-11l-seg.pt")
model.eval()

pf_model = YOLOE("yoloe-11l-seg-pf.pt")
names = ["object"]
tpe = model.get_text_pe(names)
model.set_classes(names, tpe)
model.model.model[-1].fuse(model.model.pe)

model.model.model[-1].cv3[0][2] = deepcopy(pf_model.model.model[-1].cv3[0][2]).requires_grad_(True)
model.model.model[-1].cv3[1][2] = deepcopy(pf_model.model.model[-1].cv3[1][2]).requires_grad_(True)
model.model.model[-1].cv3[2][2] = deepcopy(pf_model.model.model[-1].cv3[2][2]).requires_grad_(True)
del model.model.pe
model.save("yoloe-11l-seg-pf.pt")

YOLOEの性能比較

YOLOEは、速度やモデルサイズを損なうことなく、COCOのような標準的なベンチマークにおいて、クローズドセットのYOLOモデルの精度と同等か、それ以上の精度を達成しています。以下の表は、YOLOE-L（YOLO11をベースに構築）と、対応するYOLOv8およびYOLO11モデルとの比較を示しています。

モデル COCO mAP50-95 推論速度（T4） パラメータ GFLOPs (640px)
YOLOv8-L (closed-set) 52.9% 9.06 ms (110 FPS) 43.7 M 165.2 B
YOLO11-L (クローズドセット) 53.5% 6.2 ms (130 FPS) 26.2 M 86.9 B
YOLOE-L (オープンボキャブラリー) 52.6% 6.2 ms (130 FPS) 26.2 M 86.9 B†

† YOLO11-LとYOLOE-Lは同一のアーキテクチャを持ち（YOLO11-Lではプロンプトモジュールが無効）、推論速度は同一で、GFLOPsの推定値も類似しています。

YOLOE-Lは52.6% mAPを達成し、YOLOv8-L（52.9%）を約40%少ないパラメータ（26M対43.7M）で上回っています。YOLOv8-Lの9.06 ms (110 FPS)と比較して、6.2 ms (161 FPS)で640x640の画像を処理し、YOLO11の効率性を示しています。重要なことに、YOLOEのオープンボキャブラリーモジュールは推論コストを発生させません。これは「no free lunch trade-off」設計を示しています。

ゼロショットおよび転送タスクでは、YOLOEが優れています。LVISでは、YOLOE-smallはYOLO-Worldv2よりも+3.5 AP向上し、3倍少ないトレーニングリソースを使用しています。LVISからCOCOへのYOLOE-Lの微調整も、YOLOv8-Lよりも4倍少ないトレーニング時間で済み、その効率と適応性を強調しています。YOLOEはさらに、YOLOの特徴である速度を維持し、T4 GPUで300+ FPS、CoreML経由でiPhone 12で~64 FPSを達成し、エッジおよびモバイルデプロイメントに最適です。

注

ベンチマーク条件: YOLOEの結果は、Objects365、GoldG、LVISで事前トレーニングされたモデルを、COCOでファインチューニングまたは評価したものです。YOLOEがYOLOv8よりもわずかにmAPで優位なのは、広範な事前トレーニングによるものです。このオープンボキャブラリトレーニングがなければ、YOLOEは同サイズのYOLOモデルと同等であり、性能を損なうことなく、そのSOTA精度とオープンワールドの柔軟性を証明しています。

以前のモデルとの比較

YOLOEは、従来のYOLOモデルおよびオープンボキャブラリー検出器に比べて、注目すべき進化を遂げています。

  • YOLOEとYOLOv5の比較:
    YOLOv5は、優れた速度と精度のバランスを提供しましたが、新しいクラスのために再トレーニングが必要であり、アンカーベースのヘッドを使用していました。対照的に、YOLOEはアンカーフリーであり、新しいクラスを動的に検出します。YOLOEは、YOLOv8の改善に基づいて、より高い精度（COCOでYOLOv5の約50% mAPに対して52.6%）を達成し、YOLOv5とは異なり、インスタンスセグメンテーションを統合します。

  • YOLOEとYOLOv8の比較:
    YOLOEはYOLOv8の再設計されたアーキテクチャを拡張し、同等またはそれ以上の精度（約26Mパラメータで52.6% mAP、YOLOv8-Lの約44Mパラメータで52.9%）を達成します。より強力な事前トレーニングにより、トレーニング時間を大幅に短縮します。主な進歩は、YOLOEのオープンワールド機能であり、YOLOv8のクローズドセット設計とは異なり、プロンプトを介して未知のオブジェクト（例："bird scooter"または"peace symbol"）を検出します。

  • YOLOEとYOLO11の比較:
    YOLO11は、効率の向上とパラメータの削減（約22%削減）により、YOLOv8を改良しています。YOLOEはこれらの利点を直接受け継ぎ、YOLO11の推論速度とパラメータ数（約26Mパラメータ）に匹敵しながら、オープンボキャブラリー検出とセグメンテーションを追加します。クローズドセットのシナリオでは、YOLOEはYOLO11と同等ですが、重要なことに、YOLO11の速度を損なうことなく、YOLO11 + オープンワールド機能を実現し、未知のクラスを検出する適応性を追加します。

  • YOLOEと従来のオープンボキャブラリー検出器との比較:
    以前のオープンボキャブラリーモデル（GLIP、OWL-ViT、YOLO-World）は、ビジョン-言語transformersに大きく依存していたため、推論が遅くなっていました。YOLOEは、ゼロショット精度でこれらを上回り（例：YOLO-Worldv2と比較して+3.5 AP）、トレーニングリソースを大幅に削減しながら1.4倍高速に動作します。transformerベースのアプローチ（GLIPなど）と比較して、YOLOEは桁違いに高速な推論を提供し、オープンセット検出における精度と効率のギャップを効果的に埋めます。

要するに、YOLOE は YOLO の有名な速度と効率を維持し、精度で前任者を上回り、セグメンテーションを統合し、強力なオープンワールド検出を導入し、ユニークな汎用性と実用性を提供します。

ユースケースと応用

YOLOEのオープンボキャブラリー検出とセグメンテーションは、従来の固定クラスモデルを超えた多様なアプリケーションを可能にします。

  • オープンワールド物体検出:
    ロボティクスのような動的なシナリオに最適です。ロボットはプロンプトを使用して以前に見られなかったオブジェクトを認識したり、セキュリティシステムは再トレーニングなしで新しい脅威（危険物など）に迅速に適応したりできます。

  • Few-ShotおよびOne-Shot検出:
    YOLOEは、視覚的なプロンプト（SAVPE）を使用することで、単一の参照画像から新しいオブジェクトを迅速に学習します。これは、産業検査（部品や欠陥を即座に識別）やカスタム監視に最適で、最小限のセットアップで視覚的な検索を可能にします。

  • 大規模な語彙とロングテール認識:
    1000以上のクラスの語彙を備えたYOLOEは、生物多様性モニタリング（希少種の検出）、美術館のコレクション、小売在庫、またはeコマースなどのタスクに優れており、クラスごとの広範なトレーニングなしに、多くのクラスを確実に識別します。

  • インタラクティブな検出とセグメンテーション：
    YOLOEは、自然な入力（テキストまたは視覚的なプロンプト）によって駆動される、検索可能なビデオ/画像検索、拡張現実（AR）、直感的な画像編集などのリアルタイムインタラクティブアプリケーションをサポートします。ユーザーは、セグメンテーションマスクを使用して、オブジェクトを動的に分離、識別、または正確に編集できます。

  • 自動データラベリングとブートストラップ：
    YOLOEは、初期のバウンディングボックスとセグメンテーションのアノテーションを提供することで、迅速なデータセット作成を促進し、人間のラベリング作業を大幅に削減します。特に大規模なメディアコレクションの分析において、存在するオブジェクトを自動的に識別し、特殊なモデルをより迅速に構築するのに役立ちます。

  • あらゆるオブジェクトのセグメンテーション:
    プロンプトを通じてセグメンテーション機能を任意のオブジェクトに拡張します。特に医療画像処理、顕微鏡、または衛星画像解析に役立ち、特殊な事前学習済みモデルなしで構造を自動的に識別して正確にセグメント化します。SAMのようなモデルとは異なり、YOLOEはオブジェクトを自動的に認識してセグメント化し、コンテンツ作成やシーン理解のようなタスクを支援します。

これらのすべてのユースケースにおいて、YOLOEの主な利点は汎用性であり、動的なシナリオ全体で検出、認識、セグメンテーションのための統一されたモデルを提供します。その効率性により、リソースが限られたデバイス上でのリアルタイムパフォーマンスが保証され、ロボット工学、自動運転、防衛などに最適です。

ヒント

ニーズに基づいてYOLOEのモードを選択してください。

  • Closed-set mode: 固定クラスのタスク向け（最高の速度と精度）。
  • プロンプトモード: テキストまたはビジュアルプロンプトを介して新しいオブジェクトをすばやく追加します。
  • プロンプトフリーのオープンセットモード: 多くのカテゴリにわたる一般的な検出（カタログ作成や発見に最適）。

多くの場合、プロンプトなしの検出に続いてターゲットを絞ったプロンプトを使用するなど、モードを組み合わせることで、YOLOEの可能性を最大限に引き出すことができます。

学習と推論

YOLOEは、他のYOLOモデル（YOLOv8、YOLO-World）と同様に、Ultralytics Python APIおよびCLIとシームレスに統合されます。以下に、すぐに始める方法を示します。

YOLOEによる学習と推論

from ultralytics import YOLO

# Load pre-trained YOLOE model and train on custom data
model = YOLO("yoloe-11s-seg.pt")
model.train(data="path/to/data.yaml", epochs=50, imgsz=640)

# Run inference using text prompts ("person", "bus")
model.set_classes(["person", "bus"])
results = model.predict(source="test_images/street.jpg")
results[0].save()  # save annotated output

ここで、YOLOEはデフォルトでは標準の検出器のように動作しますが、クラスを指定することで、プロンプトによる検出に簡単に切り替えることができます(set_classes）結果には、バウンディングボックス、マスク、およびラベルが含まれます。

# Training YOLOE on custom dataset
yolo train model=yoloe-11s-seg.pt data=path/to/data.yaml epochs=50 imgsz=640

# Inference with text prompts
yolo predict model=yoloe-11s-seg.pt source="test_images/street.jpg" classes="person,bus"

CLI プロンプト (classes）ガイドは、python の YOLOE と同様です set_classes。ビジュアルプロンプト（画像ベースのクエリ）は現在、Python APIが必要です。

その他のサポートされているタスク

  • 検証： 精度を容易に評価 model.val() または yolo val.
  • エクスポート: YOLOEモデルのエクスポート（model.export()）をONNX、TensorRTなどに変換することで、デプロイメントを容易にします。
  • トラッキング: YOLOEは、オブジェクト追跡をサポートしています(yolo track）を統合すると、動画内でプロンプトされたクラスの追跡に役立ちます。

注

YOLOEは自動的に以下を含みます セグメンテーションマスク 推論結果（results[0].masks）により、個別のモデルを必要とせずに、オブジェクトの抽出や測定などのピクセル単位の精密なタスクを簡素化します。

はじめに

以下の手順に従って、Ultralytics で YOLOE を迅速にセットアップします。

  1. インストール： Ultralyticsパッケージをインストールまたは更新します。

    pip install -U ultralytics

  2. YOLOEの重みをダウンロード： 学習済みのYOLOEモデル（YOLOE-v8-S/L、YOLOE-11バリアントなど）は、YOLOE GitHubリリースから入手できます。必要なものをダウンロードしてください。 .pt Ultralytics YOLO クラスにロードするファイル。

  3. ハードウェア要件:

    • 推論: 推奨GPU（≥4-8GB VRAMを搭載したNVIDIA）。小型モデルは、エッジGPU（例：Jetson）または低解像度のCPU上で効率的に動作します。
    • トレーニング：カスタムデータでのYOLOEの微調整には、通常、1つのGPUのみが必要です。作成者が使用した広範なオープンボキャブラリーの事前トレーニング（LVIS/Objects365）には、かなりの計算量（8× RTX 4090 GPU）が必要でした。

  4. 構成： YOLOEの設定は、標準のUltralytics YAMLファイルを使用します。デフォルト設定（例： yoloe-11s-seg.yaml）で通常は十分ですが、必要に応じてバックボーン、クラス、または画像サイズを変更できます。

  5. YOLOEの実行:

    • 迅速な推論 （プロンプト不要）： 
      yolo predict model=yoloe-11s-seg-pf.pt source="image.jpg"

    • プロンプトを使用した検出 (テキストプロンプトの例):

      from ultralytics import YOLO

model = YOLO("yoloe-11s-seg.pt")
names = ["bowl", "apple"]
model.set_classes(names, model.get_text_pe(names))
results = model.predict("kitchen.jpg")
results[0].save()

  6. 統合のヒント：

    • クラス名: デフォルトのYOLOE出力はLVISカテゴリを使用します。以下を使用してください set_classes() 独自のラベルを指定します。
    • 速度: YOLOEは、プロンプトを使用しない限りオーバーヘッドはありません。テキストプロンプトの影響は最小限で、ビジュアルプロンプトはわずかに大きくなります。
    • バッチ推論: 直接サポート (model.predict([img1, img2])）画像固有のプロンプトの場合は、画像を個別に実行してください。

Ultralyticsドキュメントには、さらに多くのリソースが用意されています。YOLOEを使用すると、使い慣れたYOLOエコシステム内で強力なオープンワールド機能を簡単に探索できます。

ヒント

プロからのアドバイス: YOLOEのzero-shot精度を最大化するには、スクラッチからトレーニングするのではなく、提供されているチェックポイントからファインチューンしてください。検出精度を向上させるために、一般的なトレーニングラベル（LVISカテゴリを参照）に合わせたプロンプトワードを使用してください。

引用と謝辞

YOLOEがあなたの研究またはプロジェクトに貢献した場合、清華大学のAo Wang、Lihao Liu、Hui Chen、Zijia Lin、Jungong Han、Guiguang Dingによる原著論文を引用してください。

@misc{wang2025yoloerealtimeseeing,
      title={YOLOE: Real-Time Seeing Anything},
      author={Ao Wang and Lihao Liu and Hui Chen and Zijia Lin and Jungong Han and Guiguang Ding},
      year={2025},
      eprint={2503.07465},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2503.07465},
}

さらに詳しく知りたい場合は、オリジナルのYOLOE論文がarXivで入手できます。プロジェクトのソースコードと追加のリソースは、GitHubリポジトリからアクセスできます。

よくある質問

YOLOEはYOLO-Worldとどう違いますか？

YOLOEとYOLO-Worldはどちらもオープンボキャブラリ検出を可能にしますが、YOLOEにはいくつかの利点があります。YOLOEは、YOLO-Worldv2よりも3倍少ないトレーニングリソースを使用し、1.4倍高速に実行しながら、LVISで+3.5 AP高い精度を実現します。YOLOEは、3つのプロンプトモード（テキスト、ビジュアル、および内部語彙）もサポートしていますが、YOLO-Worldは主にテキストプロンプトに焦点を当てています。さらに、YOLOEには組み込みのインスタンスセグメンテーション機能が含まれており、追加のオーバーヘッドなしで、検出されたオブジェクトのピクセル精度のマスクを提供します。

YOLOEを通常のYOLOモデルとして使用できますか？

はい、YOLOEは、パフォーマンスの低下なしに、標準的なYOLOモデルとまったく同じように機能します。クローズドセットモード（プロンプトなし）で使用すると、YOLOEのオープンボキャブラリ モジュールは標準の検出ヘッドに再パラメータ化され、同等のYOLO11モデルと同一の速度と精度が得られます。これにより、YOLOEは非常に汎用性が高くなります。最大の速度を得るために従来の検出器として使用し、必要な場合にのみオープンボキャブラリ モードに切り替えることができます。

YOLOEではどのような種類のプロンプトを使用できますか？

YOLOEは3種類のプロンプトをサポートしています。

  1. テキストプロンプト: 自然言語を使用してオブジェクトクラスを指定します（例：「人」、「信号」、「鳥のスクーター」）
  2. ビジュアルプロンプト: 検出したいオブジェクトの参照画像を提供します
  3. 内部語彙：外部プロンプトなしで、YOLOEの1200以上のカテゴリの組み込み語彙を使用します

この柔軟性により、モデルを再トレーニングすることなく、さまざまなシナリオにYOLOEを適応させることができます。これは、検出要件が頻繁に変化する動的な環境で特に役立ちます。

YOLOEはインスタンスセグメンテーションをどのように処理しますか？

YOLOEは、マスク予測ブランチで検出ヘッドを拡張することにより、インスタンスセグメンテーションをアーキテクチャに直接統合します。このアプローチはYOLOv8-Segに似ていますが、プロンプトされた任意のオブジェクトクラスに対して機能します。セグメンテーションマスクは推論結果に自動的に含まれ、以下を介してアクセスできます。 results[0].masks。この統一されたアプローチにより、個別の検出モデルやセグメンテーションモデルは不要となり、ピクセル単位で正確なオブジェクト境界を必要とするアプリケーションのワークフローを効率化できます。

YOLOEはカスタムプロンプトで推論をどのように処理しますか？

YOLO-Worldと同様に、YOLOEは、効率を高めるためにオフラインの語彙を利用する「プロンプト・アンド・ディテクト」戦略をサポートしています。キャプションや特定のオブジェクトカテゴリのようなカスタムプロンプトは、事前にエンコードされ、オフラインの語彙埋め込みとして保存されます。このアプローチは、再トレーニングを必要とせずに検出プロセスを効率化します。モデル内でこれらのプロンプトを動的に設定して、特定の検出タスクに合わせて調整できます。

from ultralytics import YOLO

# Initialize a YOLOE model
model = YOLO("yoloe-11s-seg.pt")

# Define custom classes
names = ["person", "bus"]
model.set_classes(names, model.get_text_pe(names))

# Execute prediction on an image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()


📅 5か月前に作成 ✏️ 11日前に更新
RizwanMunawar Y-T-G Laughing-q glenn-jocher ShuaiLYU picsalex willie.maddox@gmail.com JShengP leonnil

コメント