コンテンツへスキップ

YOLOE：リアルタイムで何でも見える

はじめに

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

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



見るんだ： YOLOEとUltralytics Python パッケージの使い方：Open Vocabulary & Real-Time Seeing Anything 🚀（オープン・ボキャブラリー＆リアルタイム・シーイング・エニシング

初期のYOLO モデルと比較して、YOLOEは効率と精度を大幅に向上させた。LVIS上ではYOLO AP+3.5向上し、学習リソースは3分の1、推論速度は1.4倍高速化した。COCO上で微調整されたYOLOE-v8-largeは、YOLOv8 0.1mAP上回り、4倍近い学習時間を削減した。これは、YOLOEの精度、効率性、汎用性の卓越したバランスの良さを証明しています。以下のセクションでは、YOLOEのアーキテクチャ、ベンチマーク比較、および Ultralyticsフレームワークとの統合について説明する。

アーキテクチャの概要

YOLOEアーキテクチャー

YOLOEは、特徴抽出のための畳み込みバックボーン（CSP-Darknetなど）、マルチスケールフュージョンのためのネック（PAN-FPNなど）、物体らしさ、クラス、ボックスを独立に予測するアンカーフリーの非連結検出ヘッド（YOLO11 YOLOv8同様）といった標準的なYOLO 構造を維持している。YOLOEは、オープン語彙検出を可能にする3つの新しいモジュールを導入している：

  • Re-parameterizable Region-Text Alignment (RepRTA):小さな補助ネットワークを介して（例えばCLIPからの）テキスト埋め込みを改良することで、テキストによるプロンプト検出をサポート。推論時、このネットワークはメインモデルに折り畳まれ、オーバーヘッドをゼロにする。YOLOEはこのようにして、任意のテキストラベル付きオブジェクト（例えば、未見の「信号機」）を、実行時のペナルティなしに検出する。

  • Semantic-Activated Visual Prompt Encoder (SAVPE)：軽量な埋め込みブランチを介して視覚的プロンプト検出を可能にします。参照画像が与えられると、SAVPEは意味と活性化の特徴をエンコードし、視覚的に類似したオブジェクトを検出するようにモデルを調整する。

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

さらに、YOLOEは、マスク予測ブランチ（YOLACTやYOLOv8同様）で検出ヘッドを拡張することで、リアルタイムのインスタンス分割を統合し、オーバーヘッドを最小限に抑えている。

重要なのは、YOLOEのオープンワールドモジュールは、通常のクローズドセットYOLO使用する場合、推論コストを発生させないことである。トレーニング後、YOLOEのパラメータを標準的なYOLO ヘッドに再パラメータ化することができ、同一のFLOPと速度を維持することができる（例えば、以下のようなマッチングが可能）。 YOLO11と正確に一致する)。

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

このセクションでは、特定の事前訓練された重み、サポートするタスク、推論、検証、トレーニング、エクスポートなどの様々な動作モードとの互換性と共に利用可能なモデルの詳細を説明します（サポートされるモードは✅、サポートされないモードは❌で示されます）。

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

モデルタイプ 事前に訓練されたウェイト 対応タスク 推論 バリデーション トレーニング 輸出
YOLOE-11S ヨロエ-11s-seg.pt インスタンスのセグメンテーション ✅ ✅ ✅ ✅
YOLOE-11M ヨロエ-11M-SEG.pt インスタンスのセグメンテーション ✅ ✅ ✅ ✅
YOLOE-11L ヨロエ-11L-セグ.pt インスタンスのセグメンテーション ✅ ✅ ✅ ✅
YOLOE-v8S ヨロエ-V8S-SEG.PT インスタンスのセグメンテーション ✅ ✅ ✅ ✅
YOLOE-v8M ヨロエ-v8m-seg.pt インスタンスのセグメンテーション ✅ ✅ ✅ ✅
YOLOE-v8L ヨローV8L-SEG.pt インスタンスのセグメンテーション ✅ ✅ ✅ ✅

プロンプト・フリーモデル

モデルタイプ 事前に訓練されたウェイト 対応タスク 推論 バリデーション トレーニング 輸出
YOLOE-11S-PF ヨロエ-11s-seg-pt.pt インスタンスのセグメンテーション ✅ ✅ ✅ ✅
YOLOE-11M-PF ヨロエ-11M-SEG-PF.PT インスタンスのセグメンテーション ✅ ✅ ✅ ✅
YOLOE-11L-PF ヨロエ-11L-セグ-PF.PT インスタンスのセグメンテーション ✅ ✅ ✅ ✅
YOLOE-v8S-PF ヨロエ-V8S-SEG-PF.PT インスタンスのセグメンテーション ✅ ✅ ✅ ✅
YOLOE-v8M-PF ヨロエ-V8M-SEG-PF.PT インスタンスのセグメンテーション ✅ ✅ ✅ ✅
YOLOE-v8L-PF ヨローV8L-SEG-PF.PT インスタンスのセグメンテーション ✅ ✅ ✅ ✅

使用例

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

列車の利用

カスタムデータセットでの微調整

例

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

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

model.train(
    data="coco128-seg.yaml",
    epochs=80,
    close_mosaic=10,
    batch=128,
    optimizer="AdamW",
    lr0=1e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    device="0",
    trainer=YOLOEPESegTrainer,
)

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

model = YOLOE("yoloe-11s-seg.pt")
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="coco128-seg.yaml",
    epochs=2,
    close_mosaic=0,
    batch=16,
    optimizer="AdamW",
    lr0=1e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    device="0",
    trainer=YOLOEPESegTrainer,
    freeze=freeze,
)

利用状況を予測する

YOLOE supports both text-based and visual prompting. Using prompts is straightforward—just pass them through the predict メソッドを使用する：

例

Text prompts allow you to specify the classes that you wish to detect through textual descriptions. The following code shows how you can use YOLOE to detect people and buses in an image:

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()

Visual prompts allow you to guide the model by showing it visual examples of the target classes, rather than describing them in text.

について visual_prompts argument takes a dictionary with two keys: bboxes そして cls. Each bounding box in bboxes should tightly enclose an example of the object you want the model to detect, and the corresponding entry in cls specifies the class label for that box. This pairing tells the model, "This is what class X looks like—now find more like it."

Class IDs (cls) in visual_prompts are used to associate each bounding box with a specific category within your prompt. They aren't fixed labels, but temporary identifiers you assign to each example. The only requirement is that class IDs must be sequential, starting from 0. This helps the model correctly associate each box with its respective class.

You can provide visual prompts directly within the same image you want to run inference on. For example:

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()

Or you can provide examples from a separate reference image using the refer_image argument. In that case, the bboxes そして cls で visual_prompts should describe objects in the reference image, not the target image you're making predictions on:

注

もし source is a video or stream, the model automatically uses the first frame as the refer_image. This means your visual_prompts are applied to that initial frame to help the model understand what to look for in the rest of the video. Alternatively, you can explicitly pass any specific frame as the refer_image to control which visual examples the model uses as reference.

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()

You can also pass multiple target images to run prediction on:

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 also includes prompt-free variants that come with a built-in vocabulary. These models don't require any prompts and work like traditional YOLO models. Instead of relying on user-provided labels or visual examples, they detect objects from a predefined list of 4,585 classes based on the tag set used by the Recognize Anything Model Plus (RAM++).

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()

バルの使用

例

from ultralytics import YOLOE

# Create a YOLOE model
model = YOLOE("yoloe-11l-seg.pt")  # or select yoloe-m/l-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-m/l-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-m/l-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.pt")  # or select yoloe-m/l-seg.pt for different sizes

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

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

鉄道公式モデル

データセットを準備する

注

公式YOLOEモデルのトレーニングには、トレーニングデータのセグメントアノテーションが必要である。 公式チームが提供するスクリプト によってデータセットをセグメント注釈に変換する。 SAM2.1モデル.または、提供されている Processed Segment Annotations オフィシャル・チームが提供した以下の表のとおりである。

  • 列車データ
データ集合 タイプ サンプル ボックス 生の検出注釈 処理済みセグメント注釈
オブジェクト365v1 検出 609k 9621k objects365_train.json objects365_train_segm.json
GQA 接地 621k 3681k final_mixed_train_no_coco.json final_mixed_train_no_coco_segm.json
Flickr30k 接地 149k 641k final_flickr_separateGT_train.json final_flickr_separateGT_train_segm.json
  • バルデータ
データ集合 タイプ 注釈ファイル
LVISミニヴァル 検出 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="../datasets/flickr/full_images/",
                json_file="../datasets/flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="../datasets/mixed_grounding/gqa/images",
                json_file="../datasets/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 モジュールを学習中に更新する必要がある。 学習されたText-promptモデルを検出モデルに変換し、少ない学習コストで検出パイプラインを採用する。 このステップはオプションであり、セグメンテーションから直接始めることもできます。

import torch

from ultralytics import YOLOE

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 YOLOEVPTrainer

data = dict(
    train=dict(
        yolo_data=["Objects365.yaml"],
        grounding_data=[
            dict(
                img_path="../datasets/flickr/full_images/",
                json_file="../datasets/flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="../datasets/mixed_grounding/gqa/images",
                json_file="../datasets/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=YOLOEVPTrainer,
    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")

視覚的プロンプトの学習と同様に、プロンプトフリーモデルでは、学習中にプロンプトに特化した埋め込みを更新するだけでよい。 学習されたプロンプトモデルを検出モデルに変換し、検出パイプラインを採用することで、学習コストを抑えることができます。 このステップはオプションであり、直接セグメンテーションから始めることもできる。

import torch

from ultralytics import YOLOE

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="../datasets/flickr/full_images/",
                json_file="../datasets/flickr/annotations/final_flickr_separateGT_train_segm.json",
            ),
            dict(
                img_path="../datasets/mixed_grounding/gqa/images",
                json_file="../datasets/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 モデルと比較しています：

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

† YOLO11YOLOE-Lは同一のアーキテクチャ（YOLO11プロンプトモジュールは無効）であるため、推論速度は同一であり、GFLOPsも同程度と推定される。

YOLOE-Lは、約40%少ないパラメータ（26M対43.7M）で、YOLOv8（52.9%）を上回る52.6%のmAPを達成した。YOLO11 YOLOv8 9.06ミリ秒（110FPS）に対し、640×640の画像を6.2ミリ秒（161FPS）で処理し、YOLO11効率性を際立たせている。重要なのは、YOLOEのオープン語彙モジュールには推論コストがかからないことで、「タダ飯のトレードオフがない」設計が実証されている。

LVIS上では、YOLOE-smallはYOLO 3 .5AP向上し、3倍少ないトレーニング・リソースを使用した。YOLOE-LをLVISからCOCOに微調整するのに必要な訓練時間も、YOLOv8 4倍短く、その効率性と適応性が明らかになった。YOLOEはさらに、YOLO特徴であるスピードを維持し、T4GPU 300 FPS以上、CoreMLiPhone 12で64 FPS以上を達成しました。

注

ベンチマーク条件：YOLOEの結果は、Objects365、GoldG、LVISで事前に訓練されたモデルを、COCOで微調整または評価したものである。YOLOEのYOLOv8 mAPのわずかな優位性は、広範な事前トレーニングによるものである。このオープンボカブトレーニングを行わなかった場合、YOLOEは同規模のYOLO モデルに匹敵し、性能上のペナルティなしにSOTA精度とオープンワールドの柔軟性を確認することができる。

従来モデルとの比較

YOLOEは、以前のYOLO モデルやオープンボキャブラリー検出器に比べ、注目すべき進歩を導入している：

  • YOLOE対YOLOv5：
    YOLOv5はスピードと精度のバランスに優れていたが、新しいクラスに対して再トレーニングが必要で、アンカーベースのヘッドを使用していた。対照的に、YOLOEはアンカーを使わず、動的に新しいクラスを検出する。YOLOEは、YOLOv88の改良をベースに、YOLOv5異なり、より高い精度（52.6%対YOLOv55のCOCOでのmAP～50%）を達成し、インスタンスのセグメンテーションを統合している。

  • YOLOE vsYOLOv8：
    YOLOEが伸びる YOLOv8YOLOv88の再設計されたアーキテクチャを拡張し、同等以上の精度を達成した（～26Mのパラメータで52.6%のmAPに対し、YOLOv8 ～44Mのパラメータで52.9%）。また、事前学習が強化されているため、学習時間が大幅に短縮されている。重要な進歩は、YOLOEのオープンワールド機能であり、YOLOv88のクローズドセット設計とは異なり、プロンプトを介して未見のオブジェクト（例えば、「鳥スクーター」や「平和のシンボル」）を検出する。

  • YOLOE対YOLO11：
    YOLO11は、YOLOv8 改良し、効率を高め、パラメーターを減らした（～22%削減）。YOLOEはこれらの利点をそのまま継承し、YOLO11推論速度とパラメータ数（～26Mパラメータ）に匹敵する一方、オープン語彙検出とセグメンテーションを追加した。クローズドセットのシナリオでは、YOLOEはYOLO11同等であるが、未知のクラスを検出する適応性が追加され、速度を損なうことなく、YOLO11 ＋オープンワールドの機能を実現する。

  • YOLOEと以前のオープン語彙検出器との比較：
    以前のオープン語彙モデル（GLIP、OWL-ViT、YOLO）は、視覚言語変換に大きく依存していたため、推論に時間がかかっていた。YOLOEは、ゼロショット精度（例えば、AP+3.5対YOLO）でこれらを上回ると同時に、大幅に少ない学習リソースで1.4倍高速に動作する。変換器ベースのアプローチ（GLIPなど）と比較して、YOLOEは桁外れに高速な推論を提供し、オープンセット検出における精度と効率のギャップを効果的に埋める。

要約すると、YOLOEは、YOLO定評あるスピードと効率性を維持し、精度で先行製品を上回り、セグメンテーションを統合し、強力なオープンワールド検出を導入することで、他に類を見ない多用途かつ実用的なものとなっている。

ユースケースとアプリケーション

YOLOEのオープン語彙検出とセグメンテーションは、従来の固定クラスモデルを超える多様なアプリケーションを可能にする：

  • オープンワールド物体検出：
    ロボットがプロンプトを使用して以前に見たことのない物体を認識するロボット工学や、再トレーニングなしで新しい脅威（危険物など）に素早く適応するセキュリティシステムのようなダイナミックなシナリオに最適。

  • 少数ショットおよびワンショット検出：
    視覚的プロンプト（SAVPE）を使用して、YOLOEは1枚の参照画像から新しいオブジェクトを迅速に学習します。工業検査（部品や欠陥を即座に特定）やカスタム監視に最適で、最小限のセットアップで視覚的検索が可能です。

  • 大語彙とロングテール認識：
    1000クラス以上の語彙を持つYOLOEは、生物多様性のモニタリング（希少種の検出）、博物館のコレクション、小売店の在庫管理、eコマースなどのタスクに優れています。

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

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

  • あらゆるオブジェクトのセグメンテーション：
    特に、医療画像、顕微鏡、衛星画像の解析に有益で、特別な事前訓練されたモデルなしで、構造を自動的に識別し、正確にセグメンテーションします。以下のようなモデルとは異なります。 SAMのようなモデルとは異なり、YOLOE はオブジェクトの認識とセグメンテーションを同時に自動で行い、コンテンツ作成やシーン理解のようなタスクを支援します。

これらすべてのユースケースにおいて、YOLOEの核となる利点は汎用性であり、動的なシナリオ全体にわたって検出、認識、セグメンテーションのための統一モデルを提供する。その効率性は、リソースに制約のあるデバイス上でリアルタイムのパフォーマンスを保証し、ロボット工学、自律走行、防衛、そしてそれ以外の分野にも理想的です。

チップ

ニーズに合わせてYOLOEのモードを選んでください：

  • クローズドセットモード：固定クラスのタスク用（最高速度と精度）。
  • プロンプトモード：テキストまたは視覚的なプロンプトを使用して新しいオブジェクトをすばやく追加します。
  • プロンプトなしのオープンセットモード：多くのカテゴリーにまたがる一般的な検出（カタログやディスカバリーに最適）。

多くの場合、プロンプトのないディスカバリーの後に的を絞ったプロンプトを出すなど、モードを組み合わせることで、YOLOEの潜在能力を最大限に活用することができる。

トレーニングと推論

YOLOEは、Ultralytics Python APIとシームレスに統合されています。 CLI他のYOLO モデルYOLOv8、YOLO）と同様です。ここでは、すぐに始める方法を説明します：

YOLOEによるトレーニングと推論

from ultralytics import YOLO

# Load pre-trained YOLOE model and train on custom data
model = YOLO("yoloe-11s.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.pt data=path/to/data.yaml epochs=50 imgsz=640

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

CLI プロンプト (classes)は、YOLOEをPython 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-v8-S/L、YOLOE-11亜種）は、YOLOE GitHubリリースから入手可能です。ご希望の .pt ファイルをUltralytics YOLO クラスにロードします。

  3. ハードウェア要件：

    • 推論：推奨GPU NVIDIA 、VRAM4～8GB以上）。小さなモデルはエッジGPU（Jetsonなど）または低解像度のCPUで効率的に実行。
    • トレーニング：カスタムデータでYOLOEを微調整するには、通常GPU1つあればよい。著者らが使用した広範なオープン語彙の事前学習（LVIS/Objects365）は、かなりの計算（8×RTX 4090 GPU）を必要とした。

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

  5. YOLOEを走る：

    • 迅速な推論 (プロンプト・フリー）： 
      yolo predict model=yoloe-s.pt source="image.jpg"

    • プロンプト検出（テキストプロンプトの例）：

      yolo predict model=yoloe-s.pt source="kitchen.jpg" classes="bowl,apple"

      Python：

      from ultralytics import YOLO

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

  6. 統合のヒント

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

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

チップ

プロのアドバイス YOLOEのゼロ・ショット精度を最大にするには、ゼロからトレーニングするのではなく、提供されたチェックポイントから微調整を行う。検出精度を向上させるには、一般的なトレーニング・ラベル（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違いは？

YOLOEとYOLOどちらもオープン語彙検出を可能にするが、YOLOEにはいくつかの利点がある。YOLOEは、YOLO3倍少ない学習リソースで、1.4倍高速に動作しながら、LVISにおいて+3.5AP高い精度を達成した。また、YOLOYOLO主にテキスト・プロンプトに焦点を当てているのに対し、YOLOEは3つのプロンプト・モード（テキスト、視覚、内部語彙）をサポートしている。さらに、YOLOEはインスタンス・セグメンテーション機能を内蔵しており、検出されたオブジェクトに対して、追加のオーバーヘッドなしにピクセル精度のマスクを提供する。

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

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

YOLOEで使えるプロンプトの種類は？

YOLOEは3種類のプロンプトをサポートしている：

  1. テキストプロンプト：自然言語を使ったオブジェクトクラスの指定（例："人"、"信号"、"鳥スクーター"）
  2. 視覚的なプロンプト：検出したい物体の参考画像を提供する。
  3. 内蔵語彙：外部プロンプトなしで、1200以上のカテゴリーからなるYOLOEの内蔵語彙を使う

この柔軟性により、モデルを再トレーニングすることなく様々なシナリオにYOLOEを適応させることができ、検出要件が頻繁に変化するダイナミックな環境で特に有用である。

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

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

YOLOEはカスタムプロンプトによる推論をどのように扱うのか？

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

from ultralytics import YOLO

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

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

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

# Show results
results[0].show()
📅作成：1ヶ月前 ✏️更新 3日前
グレン・ヨッハー Y-T-G リズワン・ムナワール 笑q JShengP レオニル

コメント