YOLOE: Nhận biết mọi thứ theo thời gian thực

Giới thiệu

YOLOE (Real-Time Seeing Anything) là một tiến bộ mới trong các mô hình YOLO zero-shot, có thể nhắc lệnh, được thiết kế để phát hiện từ vựng mở và phân đoạn. Không giống như các mô hình YOLO trước đây bị giới hạn ở các danh mục cố định, YOLOE sử dụng văn bản, hình ảnh hoặc lời nhắc từ vựng bên trong, cho phép phát hiện thời gian thực của bất kỳ lớp đối tượng nào. Được xây dựng dựa trên YOLOv10 và lấy cảm hứng từ YOLO-World, YOLOE đạt được hiệu suất zero-shot hiện đại với tác động tối thiểu đến tốc độ và độ chính xác.

Xem: Cách sử dụng YOLOE với gói Ultralytics Python: Từ vựng mở & Nhìn mọi thứ theo thời gian thực 🚀

So với các mô hình YOLO trước đây, YOLOE tăng cường đáng kể hiệu quả và độ chính xác. Nó cải thiện +3.5 AP so với YOLO-Worldv2 trên LVIS trong khi chỉ sử dụng một phần ba tài nguyên đào tạo và đạt được tốc độ suy luận nhanh hơn 1.4 lần. Được tinh chỉnh trên COCO, YOLOE-v8-large vượt trội hơn YOLOv8-L khoảng 0.1 mAP, sử dụng thời gian đào tạo ít hơn gần 4 lần. Điều này chứng tỏ sự cân bằng vượt trội giữa độ chính xác, hiệu quả và tính linh hoạt của YOLOE. Các phần dưới đây khám phá kiến trúc, so sánh điểm chuẩn và tích hợp của YOLOE với framework Ultralytics.

Tổng quan về kiến trúc

YOLOE giữ lại cấu trúc YOLO tiêu chuẩn—một backbone tích chập (ví dụ: CSP-Darknet) để trích xuất đặc trưng, một neck (ví dụ: PAN-FPN) để hợp nhất đa tỷ lệ và một anchor-free, decoupled head phát hiện (như trong YOLOv8/YOLO11) dự đoán tính khách quan, các lớp và các hộp một cách độc lập. YOLOE giới thiệu ba mô-đun mới cho phép phát hiện từ vựng mở:

• Căn chỉnh vùng-văn bản có thể tái tham số hóa (RepRTA): Hỗ trợ phát hiện dựa trên văn bản bằng cách tinh chỉnh các embedding văn bản (ví dụ: từ CLIP) thông qua một mạng phụ trợ nhỏ. Tại thời điểm suy luận, mạng này được tích hợp vào mô hình chính, đảm bảo không có chi phí phát sinh. Do đó, YOLOE phát hiện các đối tượng được gắn nhãn văn bản tùy ý (ví dụ: "đèn giao thông" chưa từng thấy) mà không bị phạt về thời gian chạy.

• Bộ mã hóa lời nhắc trực quan được kích hoạt ngữ nghĩa (SAVPE): Cho phép phát hiện dựa trên lời nhắc trực quan thông qua nhánh nhúng nhẹ. Với một hình ảnh tham chiếu, SAVPE mã hóa các đặc trưng ngữ nghĩa và kích hoạt, điều kiện mô hình để phát hiện các đối tượng tương tự về mặt trực quan—một khả năng phát hiện một lần hữu ích cho logo hoặc các bộ phận cụ thể.

• Đối lập vùng gợi ý trì hoãn (LRPC): Ở chế độ không cần gợi ý, YOLOE thực hiện nhận dạng open-set bằng cách sử dụng các embedding bên trong được huấn luyện trên các từ vựng lớn (hơn 1200 danh mục từ LVIS và Objects365). Không cần các gợi ý hoặc bộ mã hóa bên ngoài, YOLOE xác định các đối tượng thông qua tra cứu độ tương đồng embedding, xử lý hiệu quả các không gian nhãn lớn tại thời điểm suy luận.

Ngoài ra, YOLOE tích hợp phân đoạn thể hiện theo thời gian thực bằng cách mở rộng phần đầu dò với một nhánh dự đoán mặt nạ (tương tự như YOLACT hoặc YOLOv8-Seg), giúp giảm thiểu chi phí.

Điều quan trọng là, các mô-đun open-world của YOLOE không gây ra chi phí suy luận khi được sử dụng như một YOLO closed-set thông thường. Sau khi huấn luyện, các tham số YOLOE có thể được tái tham số hóa thành một YOLO head tiêu chuẩn, giữ nguyên FLOP và tốc độ (ví dụ: khớp chính xác với YOLO11).

Các mô hình hiện có, tác vụ được hỗ trợ và chế độ hoạt động

Phần này trình bày chi tiết các mô hình có sẵn với trọng số đã được huấn luyện trước cụ thể của chúng, các tác vụ chúng hỗ trợ và khả năng tương thích của chúng với các chế độ hoạt động khác nhau như Suy luận, Xác thực, Huấn luyện và Xuất, được biểu thị bằng ✅ cho các chế độ được hỗ trợ và ❌ cho các chế độ không được hỗ trợ.

Các mô hình Lời nhắc Văn bản/Hình ảnh

Các mô hình không cần Prompt

Ví dụ sử dụng

Các mô hình YOLOE rất dễ tích hợp vào các ứng dụng Python của bạn. Ultralytics cung cấp API Python và lệnh CLI thân thiện với người dùng để hợp lý hóa quá trình phát triển.

Sử dụng để huấn luyện

Tinh chỉnh trên bộ dữ liệu tùy chỉnh

Bạn có thể tinh chỉnh bất kỳ mô hình YOLOE được huấn luyện trước nào trên bộ dữ liệu YOLO tùy chỉnh của bạn cho cả tác vụ phát hiện và phân đoạn thể hiện.

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
)

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

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

Sử dụng để dự đoán

YOLOE hỗ trợ cả nhắc lệnh dựa trên văn bản và trực quan. Sử dụng lệnh nhắc rất đơn giản—chỉ cần chuyển chúng qua predict phương pháp như hình dưới đây:

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

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

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

Sử dụng để xác thực

Việc xác thực mô hình trên một tập dữ liệu được thực hiện một cách đơn giản như sau:

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)

Sử dụng Xuất

Quy trình xuất tương tự như các mô hình YOLO khác, với sự linh hoạt bổ sung trong việc xử lý văn bản và lời nhắc trực quan:

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

Huấn luyện các mô hình chính thức

Chuẩn bị bộ dữ liệu

• Dữ liệu huấn luyện

• Dữ liệu Val

Bắt đầu huấn luyện từ đầu

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

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

So sánh hiệu suất YOLOE

YOLOE phù hợp hoặc vượt quá độ chính xác của các mô hình YOLO tập khép kín trên các chuẩn tiêu chuẩn như COCO, mà không ảnh hưởng đến tốc độ hoặc kích thước mô hình. Bảng dưới đây so sánh YOLOE-L (được xây dựng trên YOLO11) với các mô hình YOLOv8 và YOLO11 tương ứng:

^† YOLO11-L và YOLOE-L có kiến trúc giống hệt nhau (các mô-đun nhắc bị tắt trong YOLO11-L), dẫn đến tốc độ suy luận giống hệt nhau và ước tính GFLOP tương tự.

YOLOE-L đạt 52.6% mAP, vượt trội hơn YOLOv8-L (52.9%) với số lượng tham số ít hơn khoảng 40% (26M so với 43.7M). Nó xử lý ảnh 640×640 trong 6.2 ms (161 FPS) so với 9.06 ms (110 FPS) của YOLOv8-L, làm nổi bật hiệu quả của YOLO11. Điều quan trọng là, các mô-đun từ vựng mở của YOLOE không phát sinh chi phí suy luận, thể hiện thiết kế "không có bữa trưa miễn phí".

Đối với các tác vụ zero-shot và chuyển giao, YOLOE vượt trội: trên LVIS, YOLOE-small cải thiện so với YOLO-Worldv2 +3.5 AP khi sử dụng tài nguyên huấn luyện ít hơn 3×. Tinh chỉnh YOLOE-L từ LVIS sang COCO cũng yêu cầu thời gian huấn luyện ít hơn 4× so với YOLOv8-L, nhấn mạnh tính hiệu quả và khả năng thích ứng của nó. YOLOE tiếp tục duy trì tốc độ đặc trưng của YOLO, đạt được 300+ FPS trên GPU T4 và ~64 FPS trên iPhone 12 thông qua CoreML, lý tưởng cho việc triển khai trên thiết bị biên và thiết bị di động.

So sánh với các mô hình trước đây

YOLOE giới thiệu những tiến bộ đáng chú ý so với các mô hình YOLO trước đây và các trình dò tìm từ vựng mở:

• YOLOE so với YOLOv5:
  YOLOv5 cung cấp sự cân bằng tốt giữa tốc độ và độ chính xác nhưng yêu cầu đào tạo lại cho các lớp mới và sử dụng các head dựa trên anchor. Ngược lại, YOLOE không có anchor và dò tìm động các lớp mới. YOLOE, xây dựng dựa trên những cải tiến của YOLOv8, đạt được độ chính xác cao hơn (52.6% so với ~50% mAP của YOLOv5 trên COCO) và tích hợp phân đoạn thể hiện, không giống như YOLOv5.

• YOLOE so với YOLOv8:
  YOLOE mở rộng kiến trúc được thiết kế lại của YOLOv8, đạt được độ chính xác tương đương hoặc cao hơn (52.6% mAP với ~26M tham số so với 52.9% với ~44M tham số của YOLOv8-L). Nó giảm đáng kể thời gian đào tạo do pre-training mạnh hơn. Ưu điểm chính là khả năng open-world của YOLOE, dò tìm các đối tượng chưa thấy (ví dụ: "bird scooter" hoặc "peace symbol") thông qua các prompt, không giống như thiết kế closed-set của YOLOv8.

• YOLOE so với YOLO11:
  YOLO11 cải thiện YOLOv8 với hiệu quả nâng cao và ít tham số hơn (giảm ~22%). YOLOE kế thừa trực tiếp những lợi ích này, phù hợp với tốc độ suy luận và số lượng tham số của YOLO11 (~26M tham số), đồng thời bổ sung khả năng dò tìm và phân đoạn từ vựng mở. Trong các kịch bản closed-set, YOLOE tương đương với YOLO11, nhưng quan trọng là bổ sung khả năng thích ứng để dò tìm các lớp chưa thấy, đạt được YOLO11 + khả năng open-world mà không ảnh hưởng đến tốc độ.

• YOLOE so với các trình dò tìm từ vựng mở trước đây:
  Các mô hình open-vocab trước đây (GLIP, OWL-ViT, YOLO-World) phụ thuộc nhiều vào transformers ngôn ngữ thị giác, dẫn đến suy luận chậm. YOLOE vượt trội hơn những mô hình này về độ chính xác zero-shot (ví dụ: +3.5 AP so với YOLO-Worldv2) trong khi chạy nhanh hơn 1.4 lần với tài nguyên đào tạo thấp hơn đáng kể. So với các phương pháp dựa trên transformer (ví dụ: GLIP), YOLOE cung cấp suy luận nhanh hơn theo cấp số nhân, thu hẹp hiệu quả khoảng cách về độ chính xác-hiệu quả trong dò tìm open-set.

Tóm lại, YOLOE duy trì tốc độ và hiệu quả nổi tiếng của YOLO, vượt trội hơn các phiên bản tiền nhiệm về độ chính xác, tích hợp phân đoạn và giới thiệu khả năng phát hiện open-world mạnh mẽ, làm cho nó trở nên linh hoạt và thiết thực một cách độc đáo.

Các trường hợp và ứng dụng sử dụng

Khả năng phân đoạn và phát hiện từ vựng mở của YOLOE cho phép các ứng dụng đa dạng vượt ra ngoài các mô hình lớp cố định truyền thống:

• Phát hiện đối tượng trong môi trường mở:
  Lý tưởng cho các tình huống động như robotics, nơi robot nhận dạng các đối tượng chưa từng thấy trước đây bằng cách sử dụng các lệnh hoặc hệ thống an ninh nhanh chóng thích ứng với các mối đe dọa mới (ví dụ: các vật phẩm nguy hiểm) mà không cần đào tạo lại.

• Phát hiện Few-Shot và One-Shot:
  Sử dụng dấu nhắc trực quan (SAVPE), YOLOE nhanh chóng học các đối tượng mới từ các hình ảnh tham chiếu đơn lẻ—hoàn hảo cho kiểm tra công nghiệp (xác định các bộ phận hoặc khuyết tật ngay lập tức) hoặc giám sát tùy chỉnh, cho phép tìm kiếm trực quan với thiết lập tối thiểu.

• Nhận dạng từ vựng lớn & Long-Tail:
  Được trang bị vốn từ vựng gồm hơn 1000 lớp, YOLOE vượt trội trong các tác vụ như giám sát đa dạng sinh học (phát hiện các loài quý hiếm), bộ sưu tập bảo tàng, kiểm kê bán lẻ hoặc thương mại điện tử, xác định một cách đáng tin cậy nhiều lớp mà không cần đào tạo chuyên sâu cho mỗi lớp.

• Phát hiện và phân đoạn tương tác:
  YOLOE hỗ trợ các ứng dụng tương tác theo thời gian thực như truy xuất video/hình ảnh có thể tìm kiếm, thực tế tăng cường (AR) và chỉnh sửa hình ảnh trực quan, được điều khiển bởi các đầu vào tự nhiên (văn bản hoặc lời nhắc trực quan). Người dùng có thể tự động cô lập, xác định hoặc chỉnh sửa các đối tượng một cách chính xác bằng cách sử dụng mặt nạ phân đoạn.

• Gán nhãn và Bootstrapping dữ liệu tự động:
  YOLOE tạo điều kiện tạo tập dữ liệu nhanh chóng bằng cách cung cấp các chú thích hộp giới hạn và phân đoạn ban đầu, giảm đáng kể nỗ lực gán nhãn thủ công. Đặc biệt có giá trị trong phân tích các bộ sưu tập phương tiện lớn, nơi nó có thể tự động xác định các đối tượng hiện có, hỗ trợ xây dựng các mô hình chuyên dụng nhanh hơn.

• Phân đoạn cho mọi đối tượng:
  Mở rộng khả năng phân đoạn cho các đối tượng tùy ý thông qua các lệnh nhắc—đặc biệt có lợi cho chẩn đoán hình ảnh y tế, kính hiển vi hoặc phân tích ảnh vệ tinh, tự động xác định và phân đoạn chính xác các cấu trúc mà không cần các mô hình được đào tạo trước chuyên biệt. Không giống như các mô hình như SAM, YOLOE đồng thời nhận dạng và phân đoạn các đối tượng một cách tự động, hỗ trợ các tác vụ như tạo nội dung hoặc hiểu cảnh.

Trong tất cả các trường hợp sử dụng này, ưu điểm cốt lõi của YOLOE là tính linh hoạt, cung cấp một mô hình thống nhất để phát hiện, nhận dạng và phân đoạn trong các tình huống động. Tính hiệu quả của nó đảm bảo hiệu suất thời gian thực trên các thiết bị có tài nguyên hạn chế, lý tưởng cho robot, lái xe tự động, quốc phòng và hơn thế nữa.

Huấn luyện và Suy luận

YOLOE tích hợp liền mạch với Ultralytics Python API và CLI, tương tự như các mô hình YOLO khác (YOLOv8, YOLO-World). Dưới đây là cách nhanh chóng bắt đầu:

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

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

Các Tác Vụ Được Hỗ Trợ Khác

• Validation (Kiểm định): Đánh giá độ chính xác dễ dàng với model.val() hoặc yolo val.
• Xuất: Xuất các mô hình YOLOE (model.export()) sang ONNX, TensorRT, v.v., tạo điều kiện thuận lợi cho việc triển khai.
• Theo dõi: YOLOE hỗ trợ theo dõi đối tượng (yolo track) khi được tích hợp, hữu ích để theo dõi các lớp được nhắc trong video.

Bắt đầu

Thiết lập nhanh YOLOE với Ultralytics bằng cách làm theo các bước sau:

1. Cài đặt: Cài đặt hoặc cập nhật gói Ultralytics:

   pip install -U ultralytics
   

2. Tải xuống Trọng số YOLOE: Các mô hình YOLOE đã được huấn luyện trước (ví dụ: YOLOE-v8-S/L, các biến thể YOLOE-11) có sẵn từ các bản phát hành YOLOE trên GitHub. Chỉ cần tải xuống mô hình bạn muốn .pt tệp để tải vào lớp Ultralytics YOLO.

3. Yêu Cầu Phần Cứng:

   • Suy luận: Nên dùng GPU (NVIDIA với VRAM ≥4-8GB). Các mô hình nhỏ chạy hiệu quả trên các GPU biên (ví dụ: Jetson) hoặc CPU ở độ phân giải thấp hơn.
   • Huấn luyện: Tinh chỉnh YOLOE trên dữ liệu tùy chỉnh thường chỉ yêu cầu một GPU. Việc huấn luyện trước từ vựng mở rộng (LVIS/Objects365) được các tác giả sử dụng đòi hỏi tính toán đáng kể (8× RTX 4090 GPU).

4. Cấu hình: Cấu hình YOLOE sử dụng các tệp YAML Ultralytics tiêu chuẩn. Các cấu hình mặc định (ví dụ: yoloe-11s-seg.yaml) thường là đủ, nhưng bạn có thể sửa đổi backbone, các lớp hoặc kích thước hình ảnh khi cần.

5. Đang chạy YOLOE:

   • Suy luận nhanh (không cần nhắc):

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

   • Phát hiện có nhắc (ví dụ về lời nhắc bằng văn bản):

     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. Mẹo tích hợp:

   • Tên lớp: Đầu ra YOLOE mặc định sử dụng các danh mục LVIS; sử dụng set_classes() để chỉ định nhãn của riêng bạn.
   • Tốc độ: YOLOE không có chi phí phát sinh trừ khi sử dụng lời nhắc. Lời nhắc văn bản có tác động tối thiểu; lời nhắc trực quan có tác động nhiều hơn một chút.
   • Suy luận hàng loạt: Được hỗ trợ trực tiếp (model.predict([img1, img2])). Đối với các prompt cụ thể cho từng ảnh, hãy chạy từng ảnh riêng lẻ.

Tài liệu Ultralytics cung cấp thêm tài nguyên. YOLOE cho phép bạn dễ dàng khám phá các khả năng open-world mạnh mẽ trong hệ sinh thái YOLO quen thuộc.

Trích dẫn và ghi nhận

Nếu YOLOE đã đóng góp vào nghiên cứu hoặc dự án của bạn, vui lòng trích dẫn bài báo gốc của Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han và Guiguang Ding từ Đại học Thanh Hoa:

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

Để đọc thêm, bài báo YOLOE gốc có sẵn trên arXiv. Mã nguồn của dự án và các tài nguyên bổ sung có thể được truy cập thông qua kho lưu trữ GitHub của họ.

Câu hỏi thường gặp

YOLOE khác với YOLO-World như thế nào?

Trong khi cả YOLOE và YOLO-World đều cho phép phát hiện từ vựng mở, YOLOE mang lại một số lợi thế. YOLOE đạt độ chính xác cao hơn +3.5 AP trên LVIS trong khi sử dụng tài nguyên huấn luyện ít hơn 3 lần và chạy nhanh hơn 1.4 lần so với YOLO-Worldv2. YOLOE cũng hỗ trợ ba chế độ nhắc (văn bản, hình ảnh và từ vựng nội bộ), trong khi YOLO-World chủ yếu tập trung vào lời nhắc văn bản. Ngoài ra, YOLOE bao gồm các khả năng phân đoạn thể hiện tích hợp, cung cấp mặt nạ chính xác đến từng pixel cho các đối tượng được phát hiện mà không cần thêm chi phí.

Tôi có thể sử dụng YOLOE như một mô hình YOLO thông thường không?

Có, YOLOE có thể hoạt động chính xác như một mô hình YOLO tiêu chuẩn mà không bị giảm hiệu suất. Khi được sử dụng ở chế độ closed-set (không có lời nhắc), các mô-đun open-vocabulary của YOLOE được tham số hóa lại thành đầu dò tiêu chuẩn, dẫn đến tốc độ và độ chính xác giống hệt như các mô hình YOLO11 tương đương. Điều này làm cho YOLOE cực kỳ linh hoạt — bạn có thể sử dụng nó như một máy dò truyền thống để có tốc độ tối đa và sau đó chuyển sang chế độ open-vocabulary chỉ khi cần thiết.

Tôi có thể sử dụng những loại lời nhắc nào với YOLOE?

YOLOE hỗ trợ ba loại lời nhắc:

1. Lời nhắc văn bản: Chỉ định các class đối tượng bằng ngôn ngữ tự nhiên (ví dụ: "người", "đèn giao thông", "xe tay ga bird")
2. Lời nhắc trực quan: Cung cấp hình ảnh tham khảo về các đối tượng bạn muốn phát hiện
3. Từ vựng nội bộ: Sử dụng vốn từ vựng tích hợp sẵn gồm hơn 1200 danh mục của YOLOE mà không cần lời nhắc bên ngoài

Tính linh hoạt này cho phép bạn điều chỉnh YOLOE cho nhiều tình huống khác nhau mà không cần huấn luyện lại mô hình, điều này đặc biệt hữu ích cho các môi trường động, nơi các yêu cầu phát hiện thay đổi thường xuyên.

YOLOE xử lý phân đoạn thể hiện (instance segmentation) như thế nào?

YOLOE tích hợp trực tiếp phân đoạn thể hiện (instance segmentation) vào kiến trúc của nó bằng cách mở rộng phần đầu dò (detection head) với một nhánh dự đoán mặt nạ (mask prediction branch). Cách tiếp cận này tương tự như YOLOv8-Seg nhưng hoạt động cho bất kỳ lớp đối tượng được nhắc nào. Mặt nạ phân đoạn (Segmentation masks) được tự động đưa vào kết quả suy luận và có thể được truy cập thông qua results[0].masks. Cách tiếp cận thống nhất này loại bỏ nhu cầu về các mô hình phát hiện và phân đoạn riêng biệt, hợp lý hóa quy trình làm việc cho các ứng dụng yêu cầu ranh giới đối tượng chính xác đến từng pixel.

YOLOE xử lý suy luận với các prompt tùy chỉnh như thế nào?

Tương tự như YOLO-World, YOLOE hỗ trợ chiến lược "prompt-then-detect" sử dụng từ vựng ngoại tuyến để nâng cao hiệu quả. Các prompt tùy chỉnh như chú thích hoặc các danh mục đối tượng cụ thể được mã hóa trước và lưu trữ dưới dạng các embedding từ vựng ngoại tuyến. Cách tiếp cận này giúp đơn giản hóa quy trình phát hiện mà không cần đào tạo lại. Bạn có thể đặt các prompt này một cách linh hoạt trong mô hình để điều chỉnh nó cho các tác vụ phát hiện cụ thể:

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

📅 Tạo cách đây 5 tháng ✏️ Cập nhật cách đây 11 ngày

Bình luận