YOLOE: Her Şeyi Gerçek Zamanlı Görme

Giriş

YOLOE (Real-Time Seeing Anything), açık kelime dağarcığı tespiti ve segmentasyonu için tasarlanmış, sıfır atışlı, yönlendirilebilir YOLO modellerinde yeni bir gelişmedir. Sabit kategorilerle sınırlı önceki YOLO modellerinin aksine, YOLOE metin, görüntü veya dahili kelime istemlerini kullanarak herhangi bir nesne sınıfının gerçek zamanlı olarak algılanmasını sağlar. YOLOv10 üzerine inşa edilen ve YOLO'den ilham alan YOLOE, hız ve doğruluk üzerinde minimum etkiyle son teknoloji sıfır çekim performansına ulaşır.

İzle: Ultralytics Python paketi ile YOLOE nasıl kullanılır: Açık Kelime Dağarcığı ve Gerçek Zamanlı Her Şeyi Görme 🚀

Daha önceki YOLO modelleriyle karşılaştırıldığında, YOLOE verimliliği ve doğruluğu önemli ölçüde artırmaktadır. Eğitim kaynaklarının sadece üçte birini kullanırken ve 1,4 kat daha yüksek çıkarım hızlarına ulaşırken, LVIS üzerinde YOLO'ye göre +3,5 AP iyileştirme sağlıyor. COCO üzerinde ince ayarı yapılan YOLOE-v8-large, neredeyse 4 kat daha az eğitim süresi kullanarak YOLOv8'yi 0,1 mAP ile geçmektedir. Bu, YOLOE'nin olağanüstü doğruluk, verimlilik ve çok yönlülük dengesini göstermektedir. Aşağıdaki bölümlerde YOLOE'nin mimarisi, kıyaslama karşılaştırmaları ve Ultralytics çerçeve.

Mimariye Genel Bakış

YOLOE standart YOLO yapısını korur-özellik çıkarma için konvolüsyonel omurga (örn. CSP-Darknet), çok ölçekli füzyon için bir boyun (örn. PAN-FPN) ve nesne, sınıf ve kutuları bağımsız olarak tahmin eden çapasız, ayrılmış bir algılama kafası (YOLO11'de olduğu gibi). YOLOE, açık kelime dağarcığı tespitine olanak tanıyan üç yeni modül sunmaktadır:

• Yeniden parametrelendirilebilir Bölge-Metin Hizalama (RepRTA): Küçük bir yardımcı ağ aracılığıyla metin yerleştirmelerini (örneğin, CLIP'den) iyileştirerek metinden yönlendirilen algılamayı destekler. Çıkarım sırasında, bu ağ ana modele katlanarak sıfır ek yük sağlar. YOLOE böylece rastgele metin etiketli nesneleri (örneğin, görülmeyen "trafik ışığı") çalışma zamanı cezası olmadan tespit eder.

• Anlamsal Olarak Etkinleştirilmiş Görsel İpucu Kodlayıcı (SAVPE): Hafif bir gömme dalı aracılığıyla görsel uyarılı algılamayı mümkün kılar. Bir referans görüntü verildiğinde, SAVPE anlamsal ve aktivasyon özelliklerini kodlayarak modeli görsel olarak benzer nesneleri tespit etmeye koşullandırır; bu, logolar veya belirli parçalar için yararlı olan tek seferlik tespit özelliğidir.

• Tembel Bölge-İstem Kontrastı (LRPC): İstemsiz modda YOLOE, büyük kelime dağarcıkları (LVIS ve Objects365'ten 1200'den fazla kategori) üzerinde eğitilmiş dahili katıştırmaları kullanarak açık set tanıma gerçekleştirir. Harici istemler veya kodlayıcılar olmadan, YOLOE nesneleri gömme benzerlik araması yoluyla tanımlar ve çıkarım sırasında büyük etiket alanlarını verimli bir şekilde işler.

Ayrıca YOLOE, algılama kafasını bir maske tahmin dalıyla (YOLACT veya YOLOv8'e benzer) genişleterek gerçek zamanlı örnek segmentasyonunu entegre eder ve minimum ek yük ekler.

En önemlisi, YOLOE'nin açık dünya modülleri, normal bir kapalı set YOLO olarak kullanıldığında hiçbir çıkarım maliyeti getirmez. Eğitim sonrası, YOLOE parametreleri standart bir YOLO kafasında yeniden parametrelendirilebilir, aynı FLOP'lar ve hız korunur (örn. YOLO11 tam olarak).

Mevcut Modeller, Desteklenen Görevler ve Çalışma Modları

Bu bölümde, önceden eğitilmiş belirli ağırlıklarıyla birlikte mevcut modeller, destekledikleri görevler ve desteklenen modlar için ✅ ve desteklenmeyen modlar için ❌ ile gösterilen Çıkarım, Doğrulama, Eğitim ve Dışa Aktarma gibi çeşitli çalışma modlarıyla uyumlulukları ayrıntılı olarak açıklanmaktadır.

Metin/Görsel İpucu modelleri

Ücretsiz modeller isteyin

Kullanım Örnekleri

YOLOE modellerini Python uygulamalarınıza entegre etmek kolaydır. Ultralytics , geliştirmeyi kolaylaştırmak için kullanıcı dostu Python API ve CLI komutları sağlar.

Tren Kullanımı

Özel veri kümesi üzerinde ince ayar

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

Kullanım Tahmini

YOLOE supports both text-based and visual prompting. Using prompts is straightforward—just pass them through the predict yöntemi aşağıda gösterildiği gibi:

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

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

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

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

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 Kullanımı

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

Bir veri kümesi üzerinde model doğrulaması aşağıdaki şekilde kolaylaştırılmıştır:

Resmi Tren Modelleri

Veri kümelerini hazırlayın

• Tren verileri

• Val verileri

Sıfırdan eğitim başlatmak

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",
)

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 Performans Karşılaştırması

YOLOE, hızdan veya model boyutundan ödün vermeden COCO gibi standart kıyaslamalarda kapalı set YOLO modellerinin doğruluğunu eşleştirir veya aşar. Aşağıdaki tablo YOLOE-L'yi ( YOLO11 üzerine inşa edilmiştir) karşılık gelen YOLOv8 ve YOLO11 modelleri:

^† YOLO11 ve YOLOE-L aynı mimarilere sahiptir ( YOLO11'de istem modülleri devre dışı bırakılmıştır), bu da aynı çıkarım hızı ve benzer GFLOPs tahminleri ile sonuçlanır.

YOLOE-L, yaklaşık %40 daha az parametreyle (26M'ye karşı 43,7M) YOLOv8'yi ( %52,9) geçerek%52, 6 mAP elde eder. YOLOv8'nin 9,06 ms 'sine (110 FPS) kıyasla 640×640 görüntüleri 6,2 ms'de (161 FPS) işleyerek YOLO11'in verimliliğini vurgulamaktadır. Daha da önemlisi, YOLOE'nin açık kelime modülleri hiçbir çıkarım maliyetine neden olmaz ve "bedava öğle yemeği takası yok" tasarımını gösterir.

Sıfır atış ve aktarım görevlerinde YOLOE üstündür: LVIS'de YOLOE-small, 3 kat daha az eğitim kaynağı kullanarak YOLO'ye göre +3,5 AP daha iyi performans gösterir. YOLOE-L'nin LVIS'ten COCO'ya ince ayarının yapılması da YOLOv8'ye göre 4 kat daha az eğitim süresi gerektirerek verimliliğinin ve uyarlanabilirliğinin altını çizmiştir. YOLOE, T4 GPU 'da 300+ FPS ve CoreML aracılığıyla iPhone 12'de ~64 FPS elde ederek YOLO'nun ayırt edici hızını daha da koruyor ve uç ve mobil dağıtımlar için ideal.

Önceki Modellerle Karşılaştırma

YOLOE, önceki YOLO modellerine ve açık kelime dedektörlerine göre kayda değer gelişmeler sunar:

• YOLOE vs YOLOv5:
  YOLOv5 iyi bir hız-doğruluk dengesi sunmuş ancak yeni sınıflar için yeniden eğitim gerektirmiş ve çapa tabanlı başlıklar kullanmıştır. Buna karşılık, YOLOE çapasızdır ve yeni sınıfları dinamik olarak tespit eder. YOLOv8'in iyileştirmeleri üzerine inşa edilen YOLOE, daha yüksek doğruluk elde eder ( YOLOv5'in COCO'daki ~%50 mAP'sine karşılık %52,6) ve YOLOv5'ten farklı olarak örnek segmentasyonunu entegre eder.
  

• YOLOE vs YOLOv8:
  YOLOE uzanıyor YOLOv8'nin yeniden tasarlanmış mimarisi ile benzer veya daha üstün doğruluk elde etmiştir(~26M parametre ile %52,6 mAP 'ye karşılık YOLOv8'nin ~44M parametre ile %52,9'u). Daha güçlü ön eğitim sayesinde eğitim süresini önemli ölçüde azaltır. En önemli ilerleme, YOLOv8'in kapalı set tasarımının aksine, YOLOE'nin açık dünya kabiliyetidir ve görünmeyen nesneleri (örneğin,"kuş scooter" veya"barış sembolü") istemler aracılığıyla tespit eder.
  

• YOLOE vs YOLO11:
  YOLO11YOLOv8 'i gelişmiş verimlilik ve daha az parametre (~%22 azalma) ile geliştirir. YOLOE, YOLO11'in çıkarım hızı ve parametre sayısıyla (~26M parametre) eşleşirken, açık kelime tespiti ve segmentasyon ekleyerek bu kazanımları doğrudan devralır. Kapalı set senaryolarında YOLOE, YOLO11 ile eşdeğerdir, ancak önemli ölçüde görünmeyen sınıfları tespit etmek için uyarlanabilirlik ekleyerek hızdan ödün vermeden YOLO11 + açık dünya yeteneğine ulaşır.

• YOLOE ve önceki açık kelime dedektörleri:
  Daha önceki açık kelime modelleri (GLIP, OWL-ViT, YOLO) büyük ölçüde görüntü-dil dönüştürücülerine dayanıyordu ve bu da yavaş çıkarıma yol açıyordu. YOLOE, önemli ölçüde daha düşük eğitim kaynaklarıyla 1,4 kat daha hızlı çalışırken sıfır atış doğruluğunda (örneğin, YOLO'ye kıyasla +3,5 AP) bunları geride bırakıyor. Transformatör tabanlı yaklaşımlarla (örn. GLIP) karşılaştırıldığında, YOLOE büyüklük sırasına göre daha hızlı çıkarım sunarak açık set tespitindeki doğruluk-verimlilik açığını etkili bir şekilde kapatır.

Özetle, YOLOE, YOLO'nun ünlü hızını ve verimliliğini korur, doğrulukta öncekileri aşar, segmentasyonu entegre eder ve güçlü açık dünya algılamasını sunarak onu benzersiz bir şekilde çok yönlü ve pratik hale getirir.

Kullanım Örnekleri ve Uygulamalar

YOLOE'nin açık kelime tespiti ve segmentasyonu, geleneksel sabit sınıf modellerinin ötesinde çeşitli uygulamalara olanak tanır:

• Açık Dünya Nesne Algılama:
  Robotların istemleri kullanarak daha önce görülmemiş nesneleri tanıdığı robotik gibi dinamik senaryolar veya yeniden eğitim almadan yeni tehditlere (örn. tehlikeli maddeler) hızla uyum sağlayan güvenlik sistemleri için idealdir.

• Az Çekimli ve Tek Çekimli Algılama:
  Görsel istemleri (SAVPE) kullanan YOLOE, tek referans görüntülerden yeni nesneleri hızla öğrenir; endüstriyel denetim (parçaları veya kusurları anında tanımlama) veya özel gözetim için mükemmeldir ve minimum kurulumla görsel aramalara olanak tanır.

• Geniş Kelime Dağarcığı ve Uzun Kuyruklu Tanıma:
  1000'den fazla sınıftan oluşan bir kelime dağarcığına sahip olan YOLOE, biyoçeşitlilik izleme (nadir türleri tespit etme), müze koleksiyonları, perakende envanteri veya e-ticaret gibi görevlerde, sınıf başına kapsamlı eğitim olmadan birçok sınıfı güvenilir bir şekilde tanımlayarak öne çıkar.

• Etkileşimli Algılama ve Segmentasyon:
  YOLOE, doğal girdilerle (metin veya görsel istemler) yönlendirilen aranabilir video/görüntü alma, artırılmış gerçeklik (AR) ve sezgisel görüntü düzenleme gibi gerçek zamanlı etkileşimli uygulamaları destekler. Kullanıcılar segmentasyon maskelerini kullanarak nesneleri dinamik olarak izole edebilir, tanımlayabilir veya düzenleyebilir.

• Otomatik Veri Etiketleme ve Bootstrapping:
  YOLOE, ilk sınırlayıcı kutu ve segmentasyon ek açıklamalarını sağlayarak hızlı veri kümesi oluşturmayı kolaylaştırır ve insan etiketleme çabalarını önemli ölçüde azaltır. Özellikle mevcut nesneleri otomatik olarak tanımlayabildiği ve özel modellerin daha hızlı oluşturulmasına yardımcı olduğu büyük medya koleksiyonlarının analizinde değerlidir.

• Herhangi Bir Nesne için Segmentasyon:
  Tıbbi görüntüleme, mikroskopi veya uydu görüntüsü analizi için özellikle yararlı olan segmentasyon yeteneklerini, önceden eğitilmiş özel modeller olmadan yapıları otomatik olarak tanımlayan ve hassas bir şekilde segmente eden istemler aracılığıyla rastgele nesnelere genişletir. gibi modellerin aksine SAMYOLOE aynı anda nesneleri otomatik olarak tanır ve bölümlere ayırır, içerik oluşturma veya sahne anlama gibi görevlere yardımcı olur.

Tüm bu kullanım durumlarında YOLOE'nin temel avantajı çok yönlülüktür ve dinamik senaryolarda algılama, tanıma ve segmentasyon için birleşik bir model sağlar. Verimliliği, robotik, otonom sürüş, savunma ve ötesi için ideal olan kaynak kısıtlı cihazlarda gerçek zamanlı performans sağlar.

Eğitim ve Çıkarım

YOLOE, Ultralytics Python API ile sorunsuz bir şekilde entegre olur ve CLIdiğer YOLO modellerineYOLOv8, YOLO) benzer. İşte hızlı bir şekilde nasıl başlayacağınız:

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

# 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"

Desteklenen Diğer Görevler

• Doğrulama: ile doğruluğu kolayca değerlendirin model.val() veya yolo val.
• İhracat: YOLOE modellerini dışa aktar (model.export()) ONNX, TensorRT vb. sistemlere aktararak dağıtımı kolaylaştırır.
• Takip: YOLOE nesne izlemeyi destekler (yolo track) entegre edildiğinde, videolarda istenen sınıfları izlemek için kullanışlıdır.

Başlarken

Aşağıdaki adımları izleyerek YOLOE'yi Ultralytics ile hızlı bir şekilde kurun:

1. Kurulum: Ultralytics paketini yükleyin veya güncelleyin:

   pip install -U ultralytics
   

2. YOLOE Ağırlıklarını İndirin: Önceden eğitilmiş YOLOE modelleri (örneğin, YOLOE-v8-S/L, YOLOE-11 varyantları) YOLOE GitHub sürümlerinden edinilebilir. İstediğiniz modeli indirmeniz yeterlidir .pt Ultralytics YOLO sınıfına yüklemek için dosya.

3. Donanım Gereksinimleri:

   • Çıkarım: Önerilen GPU NVIDIA ≥4-8GB VRAM ileNVIDIA ). Küçük modeller edge GPU'larda (örn. Jetson) veya CPU'larda daha düşük çözünürlüklerde verimli bir şekilde çalışır.
   • Eğitim: Özel veriler üzerinde YOLOE'ye ince ayar yapmak genellikle sadece bir GPU gerektirir. Yazarlar tarafından kullanılan kapsamlı açık kelime ön eğitimi (LVIS/Objects365) önemli miktarda işlem gerektirmiştir (8× RTX 4090 GPU).

4. Konfigürasyon: YOLOE yapılandırmaları standart Ultralytics YAML dosyalarını kullanır. Varsayılan yapılandırmalar (örn, yoloe-s.yaml) genellikle yeterlidir, ancak omurgayı, sınıfları veya görüntü boyutunu gerektiği gibi değiştirebilirsiniz.

5. YOLOE'yu çalıştırıyorum:

   • Hızlı çıkarım (prompt-free):

     yolo predict model=yoloe-s.pt source="image.jpg"
     

   • İstemli algılama (metin istemi örneği):

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

     Python'da:

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

6. Entegrasyon İpuçları:

   • Sınıf adları: Varsayılan YOLOE çıktıları LVIS kategorilerini kullanır; kullanım set_classes() kendi etiketlerinizi belirtmek için.
   • Hız: İstemler kullanılmadığı sürece YOLOE'nin ek yükü yoktur. Metin istemlerinin etkisi minimumdur; görsel istemlerin etkisi biraz daha fazladır.
   • Toplu çıkarım: Doğrudan desteklenir (model.predict([img1, img2])). Görüntüye özel istemler için görüntüleri ayrı ayrı çalıştırın.

Ultralytics belgeleri daha fazla kaynak sağlar. YOLOE, tanıdık YOLO ekosistemi içinde güçlü açık dünya yeteneklerini kolayca keşfetmenizi sağlar.

Atıflar ve Teşekkür

YOLOE araştırmanıza veya projenize katkıda bulunduysa, lütfen Tsinghua Üniversitesi'nden Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han ve Guiguang Ding tarafından hazırlanan orijinal makaleye atıfta bulunun:

@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},
}

Daha fazla okuma için, orijinal YOLOE makalesi arXiv'de mevcuttur. Projenin kaynak koduna ve ek kaynaklara GitHub deposu üzerinden erişilebilir.

SSS

YOLOE'nin YOLO'den farkı nedir?

Hem YOLOE hem de YOLO açık kelime tespitini mümkün kılarken, YOLOE çeşitli avantajlar sunmaktadır. YOLOE, LVIS üzerinde +3,5 AP daha yüksek doğruluk elde ederken 3 kat daha az eğitim kaynağı kullanır ve YOLO'den 1,4 kat daha hızlı çalışır. YOLOE ayrıca üç ipucu modunu (metin, görsel ve dahili kelime bilgisi) desteklerken, YOLO öncelikle metin ipuçlarına odaklanmaktadır. Ayrıca YOLOE, ek yük olmadan algılanan nesneler için piksel hassasiyetinde maskeler sağlayan yerleşik örnek segmentasyon özellikleri içerir.

YOLOE'yi normal bir YOLO modeli olarak kullanabilir miyim?

Evet, YOLOE hiçbir performans kaybı olmadan standart bir YOLO modeli gibi çalışabilir. Kapalı set modunda (istemler olmadan) kullanıldığında, YOLOE'nin açık kelime modülleri standart algılama kafasına yeniden parametrelendirilir ve eşdeğer YOLO11 modelleriyle aynı hız ve doğrulukla sonuçlanır. Bu, YOLOE'yi son derece çok yönlü hale getirir; maksimum hız için geleneksel bir dedektör olarak kullanabilir ve ardından yalnızca gerektiğinde açık kelime moduna geçebilirsiniz.

YOLOE ile ne tür istemler kullanabilirim?

YOLOE üç tür komut istemini destekler:

1. Metin istemleri: Doğal dil kullanarak nesne sınıflarını belirtin (örneğin, "kişi", "trafik ışığı", "kuş scooter")
2. Görsel yönlendirmeler: Tespit etmek istediğiniz nesnelerin referans görüntülerini sağlayın
3. Dahili kelime bilgisi: YOLOE'nin 1200'den fazla kategoriden oluşan dahili kelime dağarcığını harici yönlendirmeler olmadan kullanın

Bu esneklik, YOLOE'yi modeli yeniden eğitmeden çeşitli senaryolara uyarlamanıza olanak tanıyarak algılama gereksinimlerinin sık sık değiştiği dinamik ortamlar için özellikle kullanışlı hale getirir.

YOLOE örnek segmentasyonunu nasıl ele alıyor?

YOLOE, algılama kafasını bir maske tahmin dalı ile genişleterek örnek segmentasyonunu doğrudan mimarisine entegre eder. Bu yaklaşım YOLOv8'e benzer ancak istenilen herhangi bir nesne sınıfı için çalışır. Segmentasyon maskeleri otomatik olarak çıkarım sonuçlarına dahil edilir ve şu yolla erişilebilir results[0].masks. Bu birleşik yaklaşım, ayrı algılama ve segmentasyon modellerine olan ihtiyacı ortadan kaldırarak piksel hassasiyetinde nesne sınırları gerektiren uygulamalar için iş akışlarını kolaylaştırır.

YOLOE özel istemlerle çıkarımı nasıl ele alır?

YOLO'e benzer şekilde YOLOE, verimliliği artırmak için çevrimdışı bir kelime dağarcığı kullanan bir "sor-sonra-algıla" stratejisini destekler. Altyazılar veya belirli nesne kategorileri gibi özel istemler önceden kodlanır ve çevrimdışı kelime dağarcığı katıştırmaları olarak saklanır. Bu yaklaşım, yeniden eğitim gerektirmeden tespit sürecini kolaylaştırır. Bu istemleri, belirli algılama görevlerine uyarlamak için model içinde dinamik olarak ayarlayabilirsiniz:

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 ay önce oluşturuldu ✏️ 2 gün önce güncellendi

Yorumlar