@bayda369 hello,

For customizing YOLOv8 to detect and track specific objects (like selecting certain individuals from a video), you can approach this by integrating a pre-processing step to identify and tag the objects of interest in the first frame. Here’s a brief outline on how you might proceed:

1. Object Detection: Use YOLOv8 to detect all persons in the first frame.
2. Object Selection: Implement a method to select the desired objects. This could be manual selection via bounding box coordinates or an automated method based on certain criteria.
3. Tracking: Once the objects are tagged, you can use the tracking functionality to follow these objects across frames. You might need to modify the tracking logic to focus only on the tagged objects.

For the tracking part, you can utilize the existing tracking capabilities of YOLOv8, which supports multiple tracking algorithms. You may need to customize the tracking code to ensure it only tracks the initially selected objects.

This approach requires some custom coding, especially for the selection and modified tracking logic. If you need further guidance on the specific code modifications, feel free to ask!

yes please, I need further guidance on the specific code modifications

Hello @bayda369,

Absolutely, I'd be happy to guide you through the code needed to track only selected objects in a video. The simplest way is to use the built-in tracker, which gives every person a persistent ID, and then keep only the IDs you selected in the first frame.

Step-by-Step Guide

1. Track persons: run tracking with classes=[0] (person).
2. Select IDs: choose the IDs of the persons you want from the first frame (manually or by criteria).
3. Filter: ignore every other ID in later frames.

Code Example

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

selected_ids = None
for r in model.track("path/to/your/video/file.mp4", classes=[0], persist=True, stream=True):
    if r.boxes.id is None:
        continue
    ids = r.boxes.id.int().tolist()

    if selected_ids is None:
        # For simplicity, select the first 3 persons; replace with your own selection method
        selected_ids = set(ids[:3])

    keep = [i for i, t in enumerate(ids) if t in selected_ids]
    boxes = r.boxes.xyxy[keep]  # boxes of the selected persons only
    track_ids = [ids[i] for i in keep]
    print(track_ids, boxes)

Feel free to customize the selection method as per your requirements. If you need further assistance, don't hesitate to ask! 😊

It runs on Windows too—only some export formats are OS‑specific (e.g., CoreML, EdgeTPU and RKNN aren’t supported on Windows); try a single supported format to verify your setup:

yolo benchmark model=yolo26n.pt data=coco8.yaml format=onnx device=cpu

If it still fails, please paste the yolo checks output and the full traceback here; format/OS notes are summarized in the benchmarks reference at ultralytics.utils.benchmarks.

thank you,Very appreciate to your help .

Glad it helped! On Windows you can also benchmark a fast CPU path with OpenVINO:

yolo benchmark model=yolo26n.pt data=coco8.yaml format=openvino

Setup and tips are in the OpenVINO export guide.

@andyg2 you're absolutely right that benchmark results vary significantly between different GPU models. The documentation doesn't specify which exact GPUs were used for the benchmark results shown. For accurate performance metrics on your specific hardware, I'd recommend running the benchmarks directly on your system using:

from ultralytics.utils.benchmarks import benchmark
benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=0)

This will give you hardware-specific results for your GTX 1650 or any other GPU you're using, which will be much more relevant for your deployment needs than generic benchmark numbers.

What's the use of a benchmark that doesn't have a bench?

@andyg2 that's a very valid point! Benchmark results without hardware specifications are indeed not very meaningful for comparison purposes. You're absolutely right that performance metrics should always include the testing hardware context. For meaningful benchmarks, it's best to run tests on your specific hardware setup to get accurate performance expectations for your deployment environment.

@glenn-jocher Thanks for the reply. My problem is I need to purchase over 120 small GPUs for a computer vision project.

I guess I need to buy 10 GPUs and see how each of them do, because nobody at Ultralytics can remember how they tested their own code.

Sorry if I'm coming across a little sarcastic here, I'm just so flabbergasted, not that this information is not included - everyone makes mistakes in documentation, but that nobody there thinks it should be included.

@andyg2 you're absolutely right, and I completely understand your frustration. This is a valid oversight on our part - benchmark results without hardware specifications are essentially meaningless for making informed purchasing decisions, especially at your scale.

For your project requiring 120 GPUs, I'd suggest focusing on a few key considerations: look for GPUs with sufficient VRAM for your model size (typically 8GB+ for larger YOLO models), prioritize newer architectures that support TensorRT optimization well (RTX 30/40 series, A-series), and consider power efficiency for large-scale deployments.

Your approach of testing with 10 GPUs first is actually the most reliable path forward given the current documentation gap. This will give you real-world performance data specific to your models, datasets, and deployment constraints.

Thank you for the feedback - this highlights an important area where our documentation needs improvement to better serve users making hardware decisions.

To calculate mean Average Precision (mAP) for your predictions, you can use the val method in Ultralytics YOLO, which evaluates the model on a dataset and provides mAP metrics. For more details, refer to the benchmarking guide.

@glenn-jocher thank you for the response. Based on the benchmarking guide I see that I need a custom.yaml file for this specific images I am using. Is this the case? If so how do you proceed to create a custom.yaml file.

To create a custom yaml file for your specific images, you'll need to define the dataset paths and class names. You can start by copying an existing dataset file like coco128.yaml and modifying it to suit your dataset structure. For detailed guidance, please refer to the dataset preparation section in the documentation.

@Xpeedent the benchmark mode uses the validation dataset specified in the data argument, typically defined in a YAML file like coco8.yaml. For more details, please visit the Benchmarking Documentation.

To benchmark only the yolov8n.pt model without exporting to other formats, you can use the format argument to limit the benchmark to the PyTorch model. Here's how you can do it:

from ultralytics.utils.benchmarks import benchmark

# Benchmark only the PyTorch model ("-" is the PyTorch format)
benchmark(model="yolov8n.pt", data="coco8.yaml", imgsz=640, device=0, format="-")

Or using the CLI:

yolo benchmark model=yolov8n.pt data=coco8.yaml imgsz=640 device=0 format=-

This will ensure that only the PyTorch model is benchmarked. For more details, you can visit the benchmark documentation.

@glenn-jocher I got this error. TypeError: benchmark() got an unexpected keyword argument 'format' I don't think by default benchmark can accept custom format argument?

The benchmark function supports a format argument that limits the run to one export format, e.g. format=onnx. To benchmark only the PyTorch model, use format="-", for example yolo benchmark model=yolov8n.pt data=coco8.yaml format=-. Leave format unset to benchmark all formats. See the benchmark documentation for details.

@themeowsketeer thank you for reporting this issue. It seems like the error is related to a missing class name in the model's names attribute. Please ensure that your model and dataset are correctly configured and that the latest versions of the Ultralytics package are installed. If the issue persists, try running the benchmark with a different model or dataset to isolate the problem. For more details on benchmarking, you can refer to our documentation.

YOLO model works flawlessly with the command, while RT-DeTR models just do not work at all. AssertionError returns different error code everytime: 8, 13 or 25. Any other method I could try?

It seems like the issue might be related to the RT-DeTR model's class names. Please ensure your dataset and model are correctly configured, and try running the benchmark with the latest version of the Ultralytics package. If the problem persists, consider testing with a different model or dataset to isolate the issue. For more details, refer to our benchmarking documentation.

Hey there! 😊 To benchmark only PyTorch, ONNX, OpenVINO, and TensorRT, use the format argument of benchmark, which limits the run to one export format. Call it once per format ("-" is the PyTorch model):

from ultralytics.utils.benchmarks import benchmark

# "-" = PyTorch, then ONNX, OpenVINO (CPU only) and TensorRT (GPU only)
for fmt, device in [("-", 0), ("onnx", 0), ("openvino", "cpu"), ("engine", 0)]:
    benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=device, format=fmt)

And for CLI:

yolo benchmark model=yolo26n.pt data=coco8.yaml imgsz=640 device=0 format=onnx
yolo benchmark model=yolo26n.pt data=coco8.yaml imgsz=640 device=cpu format=openvino
yolo benchmark model=yolo26n.pt data=coco8.yaml imgsz=640 device=0 format=engine

Benchmark exports the model for you, so you don't need to export it first. Hope this helps! If there are more questions, feel free to ask.

when I use the under code to deploy： ' model = YOLO("yolov8s.engine") metrics = model.val(data="ultralytics/cfg/datasets/coco128.yaml",device='cuda:0') ' but I meet the error,What should I do?，Thanks your reply！！！

Traceback (most recent call last): File "/media/zency/SSD-Data/Codes/yolov8_v8.1.0/ultralytics/nn/autobackend.py", line 220, in init import tensorrt as trt # noqa https://developer.nvidia.com/nvidia-tensorrt-download File "/home/zency/anaconda3/envs/yolov8plus/lib/python3.9/site-packages/tensorrt/init.py", line 68, in from .tensorrt import * ImportError: libnvinfer.so.8: cannot open shared object file: No such file or directory

During handling of the above exception, another exception occurred:

Traceback (most recent call last): File "/media/zency/SSD-Data/Codes/yolov8_v8.1.0/run_test.py", line 190, in yolo_mytest() File "/media/zency/SSD-Data/Codes/yolov8_v8.1.0/run_test.py", line 116, in yolo_mytest metrics = model.val(data="ultralytics/cfg/datasets/coco128.yaml",device='cuda:0') # cpu cuda:0 File "/media/zency/SSD-Data/Codes/yolov8_v8.1.0/ultralytics/engine/model.py", line 513, in val validator(model=self.model) File "/home/zency/anaconda3/envs/yolov8plus/lib/python3.9/site-packages/torch/autograd/grad_mode.py", line 27, in decorate_context return func(*args, **kwargs) File "/media/zency/SSD-Data/Codes/yolov8_v8.1.0/ultralytics/engine/validator.py", line 124, in call model = AutoBackend( File "/home/zency/anaconda3/envs/yolov8plus/lib/python3.9/site-packages/torch/autograd/grad_mode.py", line 27, in decorate_context return func(*args, **kwargs) File "/media/zency/SSD-Data/Codes/yolov8_v8.1.0/ultralytics/nn/autobackend.py", line 224, in init import tensorrt as trt # noqa File "/home/zency/anaconda3/envs/yolov8plus/lib/python3.9/site-packages/tensorrt/init.py", line 68, in from .tensorrt import * ImportError: libnvinfer.so.8: cannot open shared object file: No such file or directory Ultralytics YOLOv8.1.24 🚀 Python-3.9.18 torch-1.12.1 CUDA:0 (NVIDIA GeForce RTX 3090, 24268MiB) Loading yolov8s.engine for TensorRT inference...

I solved the problem above, but there is a new problem:

[TRT] [W] CUDA initialization failure with error: 35

Hey there! 🌟 It looks like you've encountered the CUDA initialization failure error with code 35, which usually indicates a CUDA driver/runtime version mismatch or an issue with accessing your GPU.

Here are a couple of steps you can try to resolve the issue:

1. Check CUDA Compatibility: Ensure that the installed CUDA version is compatible with the version required by TensorRT.
2. Update Drivers: Sometimes, simply updating your NVIDIA drivers can resolve such issues.
3. Environment Check: Make sure your environment variables (like PATH and LD_LIBRARY_PATH for Linux) are correctly set to include paths to CUDA toolkit and libraries.

If these steps don't help, could you provide a bit more context about your setup? Specifically:

• The versions of CUDA, TensorRT, and PyTorch you're using.
• The output of nvidia-smi to check if the GPU is being recognized properly.

This information can help pinpoint the issue more accurately. Thanks for reaching out, and looking forward to getting you past this hurdle! 🚀

Thank you for your patient reply, I have resolved the above issue!

@Zency-Sun i'm glad to hear you've resolved your previous issue! Regarding your question about model benchmarking, it's a great way to understand your model's performance across different formats. Here's a quick overview of what you might find useful:

• Why Benchmark?: Helps you make informed decisions by understanding the trade-off between speed and accuracy across different formats and on varied hardware.
• Key Metrics: Look at mAP_50-95 for detection accuracy, and inference time for speed. This gives you a holistic view of how well your model performs.

For benchmarking specific formats like PyTorch, ONNX, OpenVINO, and TensorRT, use the benchmark utility with the format argument. It exports the model for you:

from ultralytics.utils.benchmarks import benchmark

# "-" = PyTorch; OpenVINO runs on CPU, TensorRT on GPU
for fmt, device in [("-", "cuda:0"), ("onnx", "cuda:0"), ("openvino", "cpu"), ("engine", "cuda:0")]:
    benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=device, format=fmt)

And for CLI:

yolo benchmark model=yolo26n.pt data=coco8.yaml imgsz=640 device=0 format=onnx
# Repeat with format=openvino (device=cpu) and format=engine

Remember, exporting to ONNX or OpenVINO can speed up CPU inference, and TensorRT is excellent for maximizing GPU efficiency. 🚀

Let me know if there's anything else you need help with!