Person Detection

---

Overview

Person Detection is a Metro Analytics use case that detects and localizes people in images and video streams. It is built on YOLO26, a state-of-the-art real-time object detector trained on the COCO dataset, quantized to INT8 and filtered at runtime to the person class. The quantized INT8 model delivers high throughput on Intel CPUs, GPUs, and NPUs while maintaining strong detection accuracy.

Typical Metro deployments include:

• Occupancy Counting -- count people on platforms, in lobbies, or at transit stops.
• Pedestrian Flow Analysis -- measure directional foot traffic at gates and corridors.
• Access Control -- detect unauthorized presence in restricted zones.
• Public Safety -- support situational awareness in transit hubs and venues.

Available variants: yolo26n, yolo26s, yolo26m, yolo26l. Smaller variants (yolo26n, yolo26s) are recommended for high-FPS edge deployment; larger variants improve recall in dense scenes.

Model Selection

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.

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.

---

Prerequisites

Target stack: Intel DLStreamer 2026.3.0 RC1 with the matching OpenVINO GenAI bundle 2026.5.0.0.dev20261030 (OpenVINO Runtime 2026.5.0.dev20261030). Use the native RC1 setup before running these samples; this is a development stack, not a stable release. See the device validation matrix for measured CPU, GPU, and NPU results.

• Python 3.11+
• Install OpenVINO (latest version)
• Install Intel DLStreamer (latest version)

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-packages flag is required so the virtual environment can access the system-installed OpenVINO and DLStreamer Python packages.

---

Getting Started

Download and Quantize Model

Run the provided script to download, export to OpenVINO IR, and optionally quantize:

chmod +x export_and_quantize.sh
./export_and_quantize.sh

This exports the default yolo26n model in FP16 precision.

Optional: Select a Different Model, Variant, or 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:

1. Installs dependencies (openvino, ultralytics for YOLO26 or transformers, torch for DETR; adds nncf for INT8).
2. Downloads a sample test image (test.jpg) and a sample test video (test_video.mp4).
3. Downloads the PyTorch weights and exports to OpenVINO IR.
4. (INT8 only) Quantizes the model using NNCF post-training quantization.

Output files (replace yolo26n with the selected model, for example detr-resnet-50):

• yolo26n_openvino_model/ -- FP32 or FP16 OpenVINO IR model directory.
• yolo26n_person_int8.xml / yolo26n_person_int8.bin -- INT8 quantized model (only when INT8 is selected).

Precision / Device Compatibility

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.

OpenVINO Sample

The sample below runs YOLO26 or DETR inference, filters to the person class, and reports the person count for a single image. Both models are end-to-end (NMS-free), so no manual non-maximum suppression is needed. Set MODEL to the model exported by export_and_quantize.sh. 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
#
# Person detection with YOLO26 or DETR using OpenVINO Runtime.
# Run: python3 openvino_sample.py (expects test.jpg and the exported model).

import cv2
import numpy as np
import openvino as ov

# Select the model: "yolo26n" (default) or "detr-resnet-50".
MODEL = "yolo26n"

PERSON_CLASS_ID = 0
CONF_THRESHOLD = 0.4
INPUT_SIZE = 800 if MODEL.startswith("detr") else 640

core = ov.Core()
model = core.read_model(f"{MODEL}_openvino_model/{MODEL}.xml")

# 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) & (output[:, 5].astype(int) == PERSON_CLASS_ID)
dets = output[mask]

sx, sy = w0 / INPUT_SIZE, h0 / INPUT_SIZE
person_count = len(dets)
print(f"Detected persons: {person_count}")

for det in dets:
    x1 = int(det[0] * sx)
    y1 = int(det[1] * sy)
    x2 = int(det[2] * sx)
    y2 = int(det[3] * sy)
    cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)

cv2.putText(
    image, f"Persons: {person_count}", (10, 30),
    cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 0), 2,
)
cv2.imwrite("output_openvino.jpg", image)

Device targets:

• "CPU" -- default, works on all Intel platforms.
• "GPU" -- Intel integrated or discrete GPU.
• "NPU" -- Intel NPU (different throughput profile; validate with benchmark_app -d NPU).

Try It on a Sample Image

The export_and_quantize.sh script downloads test.jpg automatically. Re-run the OpenVINO sample above. The script reads test.jpg, prints the person count to the console, and writes the annotated frame to output_openvino.jpg.

Expected console output:

Detected persons: 2

output_openvino.jpg shows a green bounding box around each detected person and the text Persons: 2 in the top-left corner.

Expected Output

DLStreamer Sample

The pipeline below runs the FP16 YOLO26 or DETR detector (selected with MODEL) on the sample video via gvadetect, filters detections to the person class in a buffer probe using the GStreamer Analytics metadata API (GstAnalytics), overlays bounding boxes, saves the annotated result to output_dlstreamer.mp4, and prints the person count per frame.

Notes on running this sample:

• Use the FP16 IR (yolo26n_openvino_model/yolo26n.xml or detr-resnet-50_openvino_model/detr-resnet-50.xml). The DETR IR carries the same model_info metadata as YOLO26, so gvadetect uses the same YOLO26 post-processor for both models. gvadetect selects the YOLO26 post-processor from the metadata.yaml file stored next to the model. To use the INT8 model, place it in a directory together with that file, for example mkdir int8 && cp yolo26n_person_int8.* yolo26n_openvino_model/metadata.yaml int8/, and set model=int8/yolo26n_person_int8.xml.

• Class names are read automatically from the model's embedded metadata.yaml by DLStreamer 2026.0+ -- no external labels-file is required.

• Export PYTHONPATH so 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
#
# Person detection with YOLO26 or DETR using a DLStreamer pipeline.
# Run: python3 dlstreamer_sample.py (expects test_video.mp4 and the exported model).

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 displ-cfg=show-roi=person ! "
    "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
    person_count = 0
    idx = 1
    while True:
        ok, od = rmeta.get_od_mtd(idx)
        if not ok:
            break
        if GLib.quark_to_string(od.get_obj_type()) == "person":
            person_count += 1
        idx += 1
    if person_count:
        print(f"Person count: {person_count}", flush=True)
    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)

Expected Output

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.

---

License

Licensed under the MIT License. See LICENSE for details.

References

• YOLO26 Documentation
• DETR Model Card (facebook/detr-resnet-50)
• End-to-End Object Detection with Transformers (DETR paper)
• OpenVINO YOLO26 Notebook
• COCO Dataset
• OpenVINO Documentation
• NNCF Post-Training Quantization
• Intel DLStreamer