YOLO26 model object detection support

[IAmStiven]

Would like to see the YOLO26 models, I have my own tuned model for YOLO26 and it performs better in my tests than yolo v9.

[brainstormi]

I was able to compile and download the model using ultralytics collab notebooks appearing in their doc. Unfortunately in my case it isn't working in Frigate, model it isn't reporting any detection, it doesn't matter if I export it as onnx or openvino and the latency it's basically double of what I have with yolov11m in Frigate, moving from 20ms to 40ms with yolo26m (Intel igpu xe 1135g7)

[nrlcode]

Would like to see the YOLO26 models, I have my own tuned model for YOLO26 and it performs better in my tests than yolo v9.

How did you get yolo26 working? Did you ever have any errors when first creating it? Or do you mind sharing your model?

I was getting errors when I made a yolo26 export in the same way I did for yolo11

[hawkeye217]

Frigate is not not able to officially support Ultralytics models at this time, see #10717 for more context.

[xavan83]

I think the output format of openvino detection has change. Inference with my custom model is working fine using ultralytics api but openvino results in frigate are crazy (i.e. 10000% of confidence for a bike in the sky)

[jsapede]

here's the code i generated using gemini :

export_model.py :

import argparse
import os
import shutil
from pathlib import Path
from ultralytics import YOLO

def export_yolo26_openvino_fp16(weights_name, imgsz, outdir):
    print(f"🚀 Loading YOLO26: {weights_name}")
    model = YOLO(weights_name)
    
    # Export to Native OpenVINO format (avoiding the ONNX cast error)
    print(f"📦 Exporting to Native OpenVINO IR FP16 (imgsz={imgsz})...")
    export_path_str = model.export(
        format="openvino",
        imgsz=imgsz,
        half=True,       # Required for iGPU speed
        simplify=True,
    )
    
    origin_dir = Path(export_path_str)
    dest_folder = Path(outdir) / f"yolo26s_vino_{imgsz}"
    
    if dest_folder.exists():
        shutil.rmtree(dest_folder)
    
    print(f"🚚 Moving model files to {dest_folder}...")
    shutil.move(str(origin_dir), str(dest_folder))
    
    print(f"\n✅ SUCCESS!")
    print(f"📍 Model Folder: {dest_folder}")
    print(f"👉 Copy the .xml AND .bin files to your Frigate model_cache.")

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--weights", type=str, default="yolo26s.pt")
    parser.add_argument("--imgsz", type=int, default=256) # Updated to 256
    parser.add_argument("--outdir", type=str, default="/output")
    args = parser.parse_args()

    export_yolo26_openvino_fp16(args.weights, args.imgsz, args.outdir)

and Dockerfile :

FROM python:3.11-slim

RUN apt-get update && apt-get install -y --no-install-recommends \
    libgl1 \
    libglib2.0-0 \
    && rm -rf /var/lib/apt/lists/*

# Install dependencies
RUN pip install --no-cache-dir \
    ultralytics \
    onnx \
    onnxslim

WORKDIR /app

# Create the config directory Ultralytics wants and set the ENV variable
RUN mkdir -p /tmp/Ultralytics
ENV YOLO_CONFIG_DIR=/tmp/Ultralytics

COPY export_model.py .
RUN mkdir /output

ENTRYPOINT ["python", "export_model.py"]

this build a .xml/.bin with FP16 precision and 256 imgsz that loads in frigate using yolo-generic :

##########
# YOLO26  # 
##########
detectors:
  ov_0:
    type: openvino
    device: GPU
  ov_1:
    type: openvino
    device: GPU
  ov_2:
    type: openvino
    device: GPU
model:
   model_type: yolo-generic
   width: 256 # <--- should match the imgsize set during model export
   height: 256 # <--- should match the imgsize set during model export
   input_tensor: nchw
   input_dtype: float
   path: /config/models/yolo26s.xml
   labelmap_path: /labelmap/coco-80.txt

[netrunnereve]

yolo26 works fine with Frigate if you export it without end2end/NMS, there's no need to run that script. In my case it's faster than yolo9 and 11, and if I quantize it to int8 its almost as fast as the default fp16 Mobilenet model.

With 26n accuracy seems similar to 9t or 11n on my cameras but it's faster and that's what matters since I run it on CPU. It's certainly better than the Mobilenet in terms of false positives.

from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.export(format="onnx", imgsz=320, end2end=False)

[xavan83]

I think the end2end parameter was not available in the first versions of ultralytics 8.4.
On my side I run yolo26s quantized to int8 and it has the same inference time than the yolo26n exported with half=True (FP16) but with better accuracy.
I compare both yolo26s exported models against my test data and there are only a few missing boxes ( for a 1000 images dataset)

[netrunnereve]

Interesting. For me with CPU yolo26s in int8 is like 40% slower than the fp32 26n and around the same speed as the fp32 9t. Unfortunately that isn't fast enough at night with all those headlights and reflections.

[xavan83]

You don't use the igpu?

[jsapede]

built Yolo26 fp16 to test with iGPU openvino but got higher inferences times ont my i5-9500T han with yolo11s (~10ms)

[xavan83]

Mine using a core i3 12100 yolo11n against yolo26n may be 10% more 11ms instead of 10ms

[jsapede]

looks like newer processors dont suffer same struggles as mine
will have a test on a n100

[thelovemyth]

Is it nano/small version?

[jsapede]

all are s versions, 11 and 26

[thelovemyth]

I'm running nano version, 8100T it s running slightly lighter 10% than your small version.