Object detection model, used with openvino.
Model Intel/object-detection, read from Hugging Face 18 h ago.
Intel/object-detection is a model on Hugging Face by Intel. Object detection model, used with openvino. It declares the mit license on Hugging Face. It has 6 likes and last changed on 2026-11-19. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from Hugging Face on 2026-11-21.
The author's own card, shown from Hugging Face. Take My Repo does not keep a copy.
| Property | Value |
|---|---|
| Category | General Object Detection (80-class COCO) |
| Base Model | YOLO26 (Ultralytics, default) or DETR (Facebook, alternative) |
| Source Framework | PyTorch (Ultralytics, Hugging Face Transformers) |
| Supported Precisions | FP32, FP16, INT8 (mixed-precision) |
| Inference Engine | OpenVINO |
| Hardware | CPU, GPU, NPU |
| Detected Class(es) | All 80 COCO classes |
Object Detection is a Metro Analytics use case that detects and classifies objects across the full 80-class COCO taxonomy (person, vehicle, animal, everyday objects, etc.). It is built on YOLO26, a state-of-the-art real-time object detector, quantized to INT8 for efficient inference on Intel hardware. Unlike the specialized person or vehicle detectors, this model keeps all 80 classes active, making it suitable for general-purpose scene understanding.
Typical Metro deployments include:
Available variants: yolo26n, yolo26s, yolo26m, yolo26l.
Smaller variants (yolo26n, yolo26s) are recommended for high-FPS edge deployment; larger variants improve recall for small objects.
DETR (DEtection TRansformer) is available as an alternative to YOLO26.
DETR is a transformer-based, NMS-free detector trained on COCO and released under the Apache-2.0 license.
The export script embeds DETR normalization, box decoding, and the class remap into the OpenVINO IR, so the DETR model produces the same output layout and class ids as YOLO26.
The same OpenVINO and DLStreamer samples run either model; select one with the MODEL constant at the top of each sample.
| Model | Variants | Input Size | Output | License |
|---|---|---|---|---|
| YOLO26 (default) | yolo26n, yolo26s, yolo26m, yolo26l |
640 x 640 | [1, 300, 6] |
AGPL-3.0 |
| DETR | detr-resnet-50 |
800 x 800 | [1, 100, 6] |
Apache-2.0 |
Choose YOLO26 for maximum throughput on edge devices. Choose DETR when a permissively licensed transformer detector is preferred; it is heavier and runs at a lower frame rate.
See the released runtime setup and device support matrix before choosing a runtime. The previous validation used the RC1 development stack.
Create and activate a Python virtual environment before running the scripts:
python3 -m venv .venv --system-site-packages
source .venv/bin/activate
Note: The
--system-site-packagesflag is required so the virtual environment can access the system-installed OpenVINO and DLStreamer Python packages.
Run the provided script to download, export to OpenVINO IR, and optionally quantize:
wget https://huggingface.co/Intel/object-detection/resolve/main/export_and_quantize.sh
chmod +x export_and_quantize.sh
./export_and_quantize.sh
This exports the default yolo26n model in FP16 precision.
./export_and_quantize.sh yolo26n FP32 # full-precision
./export_and_quantize.sh yolo26n INT8 # quantized
./export_and_quantize.sh yolo26s # larger variant, default FP16
./export_and_quantize.sh detr-resnet-50 # DETR alternative, default FP16
./export_and_quantize.sh detr-resnet-50 INT8 # DETR quantized
The first argument selects the model: any YOLO26 variant (yolo26n, yolo26s, yolo26m, yolo26l) or DETR (detr-resnet-50).
The second argument selects the precision (FP32, FP16, INT8); the default is FP16.
The script performs the following steps:
openvino, ultralytics for YOLO26 or transformers, torch for DETR; adds nncf for INT8).test.jpg) and a sample test video (test_video.mp4).Output files (replace yolo26n with the selected model, for example detr-resnet-50):
yolo26n_openvino_model/ -- FP32 or FP16 OpenVINO IR model directory.yolo26n_objdet_int8.xml / yolo26n_objdet_int8.bin -- INT8 quantized model (only when INT8 is selected).| Precision | CPU | GPU | NPU |
|---|---|---|---|
| FP32 | Yes | Yes | No |
| FP16 | Yes | Yes | Yes |
| INT8 | Yes | Yes | Yes |
Note: The INT8 calibration uses the bundled sample image. For production accuracy, replace it with a representative set of frames from the target deployment site.
The sample below runs YOLO26 inference on all 80 COCO classes and prints every detected object with its class name and confidence.
YOLO26 is end-to-end (NMS-free), so no manual non-maximum suppression is needed.
Change the device string to run on CPU, GPU, or NPU.
The full sample is in openvino_sample.py; run it with python3 openvino_sample.py or copy the code below.
# SPDX-License-Identifier: MIT
# Copyright (C) Intel Corporation
#
# Object Detection: OpenVINO Runtime sample.
# See README.md for prerequisites and inputs. Run: python3 openvino_sample.py
import cv2
import numpy as np
import openvino as ov
CONF_THRESHOLD = 0.4
# Select the model: "yolo26n" (default) or "detr-resnet-50".
MODEL = "yolo26n"
INPUT_SIZE = 800 if MODEL.startswith("detr") else 640
core = ov.Core()
model = core.read_model(f"{MODEL}_openvino_model/{MODEL}.xml")
# YOLO26 embeds the 80 COCO class names in rt_info -- read them instead of
# hardcoding the list. Ultralytics separates multi-word names with
# underscores (e.g. "traffic_light"), so restore spaces for display.
COCO_NAMES = [
name.replace("_", " ")
for name in model.get_rt_info()["model_info"]["labels"].value.split()
]
# Change device to "GPU" or "NPU" to run on integrated GPU or NPU.
compiled = core.compile_model(model, "CPU")
image = cv2.imread("test.jpg")
h0, w0 = image.shape[:2]
blob = cv2.resize(image, (INPUT_SIZE, INPUT_SIZE))
blob = cv2.cvtColor(blob, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
blob = blob.transpose(2, 0, 1)[np.newaxis, ...] # NCHW
# End-to-end output: [1, N, 6] = [x1, y1, x2, y2, confidence, class_id]
# (N = 300 for YOLO26, 100 for DETR)
output = compiled([blob])[compiled.output(0)][0]
mask = output[:, 4] >= CONF_THRESHOLD
dets = output[mask]
sx, sy = w0 / INPUT_SIZE, h0 / INPUT_SIZE
print(f"Total detections: {len(dets)}")
colors = np.random.RandomState(42).randint(0, 255, (80, 3)).tolist()
for det in dets:
x1 = int(det[0] * sx)
y1 = int(det[1] * sy)
x2 = int(det[2] * sx)
y2 = int(det[3] * sy)
cid = int(det[5])
conf = float(det[4])
label = f"{COCO_NAMES[cid]} {conf:.2f}"
color = colors[cid]
cv2.rectangle(image, (x1, y1), (x2, y2), color, 2)
cv2.putText(image, label, (x1, y1 - 5),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
print(f" {label} at ({x1},{y1})-({x2},{y2})")
cv2.imwrite("output_openvino.jpg", image)
Device targets:
"CPU" -- default, works on all Intel platforms."GPU" -- Intel integrated or discrete GPU."NPU" -- Intel NPU (validate with benchmark_app -d NPU).The export_and_quantize.sh script downloads test.jpg automatically.
Re-run the OpenVINO sample above.
The script reads test.jpg, prints each detected object to the console, and writes the annotated frame to output_openvino.jpg.
Expected console output (representative):
Total detections: 5
person 0.92 at (49,396)-(236,904)
bus 0.92 at (0,229)-(804,744)
person 0.91 at (670,393)-(809,880)
person 0.90 at (223,403)-(345,862)
person 0.50 at (0,553)-(68,869)

The pipeline below runs the FP16 YOLO26 detector on the sample video via
gvadetect, overlays bounding boxes, saves the annotated result to
output_dlstreamer.mp4, and prints all detections per frame.
Notes on running this sample:
Use the FP16 IR (
yolo26n_openvino_model/yolo26n.xmlordetr-resnet-50_openvino_model/detr-resnet-50.xml). Class names are read automatically from the model's embeddedmetadata.yamlby DLStreamer 2026.0+ -- no externallabels-fileis required.Export
PYTHONPATHso the DLStreamer Python module is importable:source /opt/intel/openvino_2026/setupvars.sh source /opt/intel/dlstreamer/scripts/setup_dls_env.sh export PYTHONPATH=/opt/intel/dlstreamer/python:\ /opt/intel/dlstreamer/gstreamer/lib/python3/dist-packages:${PYTHONPATH:-}
The full sample is in dlstreamer_sample.py; run it with python3 dlstreamer_sample.py or copy the code below.
# SPDX-License-Identifier: MIT
# Copyright (C) Intel Corporation
#
# Object Detection: DLStreamer pipeline sample.
# See README.md for prerequisites and inputs. Run: python3 dlstreamer_sample.py
import gi
gi.require_version("Gst", "1.0")
gi.require_version("GstAnalytics", "1.0")
from gi.repository import Gst, GLib, GstAnalytics
Gst.init([])
INPUT_VIDEO = "test_video.mp4"
# Select the model: "yolo26n" (default) or "detr-resnet-50".
MODEL = "yolo26n"
# For CPU: change device=GPU to device=CPU.
# For NPU: change device=GPU to device=NPU (batch-size=1, nireq=4 recommended).
pipeline_str = (
f"filesrc location={INPUT_VIDEO} ! decodebin3 ! "
"videoconvert ! "
f"gvadetect model={MODEL}_openvino_model/{MODEL}.xml "
"device=GPU "
"threshold=0.4 ! queue ! "
"gvawatermark ! videoconvert ! video/x-raw,format=I420 ! "
"openh264enc ! h264parse ! "
"mp4mux ! filesink name=sink location=output_dlstreamer.mp4"
)
pipeline = Gst.parse_launch(pipeline_str)
def on_buffer(pad, info):
buf = info.get_buffer()
rmeta = GstAnalytics.buffer_get_analytics_relation_meta(buf)
if rmeta is None:
return Gst.PadProbeReturn.OK
idx = 1
while True:
ok, od = rmeta.get_od_mtd(idx)
if not ok:
break
label = GLib.quark_to_string(od.get_obj_type())
_, x, y, w, h, conf = od.get_location()
print(f" {label} at ({int(x)},{int(y)})", flush=True)
idx += 1
return Gst.PadProbeReturn.OK
sink = pipeline.get_by_name("sink")
sink_pad = sink.get_static_pad("sink")
sink_pad.add_probe(Gst.PadProbeType.BUFFER, on_buffer)
pipeline.set_state(Gst.State.PLAYING)
bus = pipeline.get_bus()
bus.timed_pop_filtered(
Gst.CLOCK_TIME_NONE,
Gst.MessageType.EOS | Gst.MessageType.ERROR,
)
pipeline.set_state(Gst.State.NULL)

Device targets:
device=GPU -- default in the sample code.device=CPU -- change device=GPU to device=CPU.device=NPU -- change device=GPU to device=NPU; use batch-size=1 and nireq=4 for best NPU utilization.Licensed under the MIT License. See LICENSE for details.
Intel/object-detection is a model on Hugging Face by Intel. Object detection model, used with openvino.
It declares the mit license on Hugging Face.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on Hugging Face was on 2026-11-19. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Object detection model, used with transformers.
Sentence similarity model, used with sentence-transformers.
Image text to text model, used with transformers.
Object detection model, used with ultralytics.
Text generation model, used with transformers.
Track, rank and evaluate open LLMs and chatbots
Runs in the browser on Hugging Face
Depth estimation model, used with transformers.
Text generation model, used with transformers.