Intel/object-classification

Object Classification

Property	Value
Category	Object Classification (Traffic Categorization: People / Vehicles)
Base Model	YOLO26 (Ultralytics)
Source Framework	PyTorch (Ultralytics)
Supported Precisions	FP32, FP16, INT8 (mixed-precision)
Inference Engine	OpenVINO
Hardware	CPU, GPU, NPU
Detected Class(es)	person and vehicle classes grouped into People and Vehicles

---

Overview

Object Classification is a Metro Analytics use case that detects objects with YOLO26 and then categorizes each detection into higher-level city-operations groups. It is built on the state-of-the-art YOLO26 real-time detector, quantized to INT8 for efficient inference on Intel hardware. Where the general object-detection use case reports every one of the 80 COCO classes individually, this use case rolls the traffic-relevant classes up into two semantic categories, People and Vehicles, so operators get an at-a-glance picture of a scene.

The traffic categories are:

• People -- the COCO person class.
• Vehicles -- the COCO bicycle, car, motorcycle, bus, train, and truck classes.

Objects outside these categories are ignored to keep the output focused on traffic situational awareness.

Typical Metro deployments include:

• Situational Awareness -- summarize each camera feed as live People and Vehicles counts.
• Automated City Operations -- feed category counts into signal timing, congestion, and dispatch logic.
• Intersection and Roundabout Monitoring -- track the mix of pedestrians and vehicles at busy junctions.
• Trend Analytics -- aggregate category counts over time to understand traffic patterns.

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

---

Prerequisites

• 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 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

Replace yolo26n with any variant (yolo26s, yolo26m, yolo26l, yolo26x). The second argument selects the precision (FP32, FP16, INT8); the default is FP16.

The script performs the following steps:

1. Installs dependencies (openvino, ultralytics; adds nncf for INT8).
2. Downloads a sample traffic video (test_video.mp4) of an urban roundabout at low resolution (640x360).
3. Downloads the PyTorch weights and exports to OpenVINO IR.
4. (INT8 only) Quantizes the model using NNCF post-training quantization.

Output files:

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

Precision / Device Compatibility

Precision	CPU	GPU	NPU
FP32	Yes	Yes	No
FP16	Yes	Yes	Yes
INT8	Yes	Yes	Yes

Note: The INT8 calibration uses a frame from the bundled sample video. For production accuracy, replace it with a representative set of frames from the target deployment site.

OpenVINO Sample

The sample below runs YOLO26 inference on the sample traffic video, maps each detection into the People or Vehicles category, draws boxes colored per category, overlays live category counts, and writes the annotated result to output_openvino.mp4. 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.

import cv2
import numpy as np
import openvino as ov

CONF_THRESHOLD = 0.4
INPUT_SIZE = 640

# Map the traffic-relevant COCO class ids into higher-level city categories.
# People and Vehicles are the two categories tracked for situational awareness.
CATEGORY_BY_CLASS_ID = {
    0: "People",      # person
    1: "Vehicles",    # bicycle
    2: "Vehicles",    # car
    3: "Vehicles",    # motorcycle
    5: "Vehicles",    # bus
    6: "Vehicles",    # train
    7: "Vehicles",    # truck
}
# BGR overlay colors for each category.
CATEGORY_COLORS = {
    "People": (0, 200, 0),
    "Vehicles": (255, 128, 0),
}

core = ov.Core()
model = core.read_model("yolo26n_openvino_model/yolo26n.xml")

# YOLO26 embeds the 80 COCO class names in rt_info. Ultralytics separates
# multi-word names with underscores (e.g. "traffic_light"), so restore spaces.
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")
output_port = compiled.output(0)

cap = cv2.VideoCapture("test_video.mp4")
fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
writer = cv2.VideoWriter(
    "output_openvino.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (width, height)
)

totals = {"People": 0, "Vehicles": 0}
frame_idx = 0
while True:
    ok, frame = cap.read()
    if not ok:
        break
    frame_idx += 1

    blob = cv2.resize(frame, (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

    # YOLO26 end-to-end output: [1, 300, 6] = [x1, y1, x2, y2, confidence, class_id].
    output = compiled([blob])[output_port][0]

    sx, sy = width / INPUT_SIZE, height / INPUT_SIZE
    counts = {"People": 0, "Vehicles": 0}
    for x1, y1, x2, y2, conf, class_id in output:
        if conf < CONF_THRESHOLD:
            continue
        category = CATEGORY_BY_CLASS_ID.get(int(class_id))
        if category is None:
            continue  # not a traffic-relevant object
        counts[category] += 1
        totals[category] += 1
        color = CATEGORY_COLORS[category]
        px1, py1 = int(x1 * sx), int(y1 * sy)
        px2, py2 = int(x2 * sx), int(y2 * sy)
        label = f"{category}: {COCO_NAMES[int(class_id)]} {conf:.2f}"
        cv2.rectangle(frame, (px1, py1), (px2, py2), color, 2)
        cv2.putText(frame, label, (px1, py1 - 5),
                    cv2.FONT_HERSHEY_SIMPLEX, 2.0, color, 2)

    # Overlay the per-category counts for this frame.
    banner = f"People: {counts['People']}  Vehicles: {counts['Vehicles']}"
    cv2.rectangle(frame, (0, 0), (width, 60), (0, 0, 0), -1)
    cv2.putText(frame, banner, (15, 45),
                cv2.FONT_HERSHEY_SIMPLEX, 2.0, (255, 255, 255), 2)

    if frame_idx % 30 == 0:
        print(f"frame {frame_idx}: {banner}", flush=True)

    writer.write(frame)

cap.release()
writer.release()
print(f"Summary: People={totals['People']} Vehicles={totals['Vehicles']}")
print("Saved: output_openvino.mp4")

Device targets:

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

Try It on a Sample Video

The export_and_quantize.sh script downloads test_video.mp4 automatically. Re-run the OpenVINO sample above. The script reads test_video.mp4, prints the running People and Vehicles counts to the console, and writes the annotated video to output_openvino.mp4.

Expected console output (representative):

frame 30: People: 4  Vehicles: 6
frame 60: People: 3  Vehicles: 7
frame 90: People: 5  Vehicles: 5
Summary: People=372 Vehicles=548
Saved: output_openvino.mp4

Expected Output

DLStreamer Sample

The pipeline below runs the FP16 YOLO26 detector on the sample video via gvadetect, overlays bounding boxes with gvawatermark for the traffic-relevant classes only (non-traffic detections such as handbag are filtered out via show-roi), saves the annotated result to output_dlstreamer.mp4, and prints the People and Vehicles category counts per frame from the detection metadata.

Notes on running this sample:

• Use the FP16 IR (yolo26n_openvino_model/yolo26n.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:-}
  

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"

# Traffic-relevant COCO labels grouped into higher-level city categories.
CATEGORY_BY_LABEL = {
    "person": "People",
    "bicycle": "Vehicles",
    "car": "Vehicles",
    "motorcycle": "Vehicles",
    "bus": "Vehicles",
    "train": "Vehicles",
    "truck": "Vehicles",
}

# For CPU: change device=GPU to device=CPU.
# For NPU: change device=GPU to device=NPU (batch-size=1, nireq=4 recommended).
# gvawatermark displ-cfg:
#   show-roi=... draws only the traffic-relevant classes (person + vehicles),
#     so non-traffic detections such as handbag/backpack are not boxed.
#   font-scale=1.5 enlarges the label text for better visualization.
pipeline_str = (
    f"filesrc location={INPUT_VIDEO} ! decodebin3 ! "
    "videoconvert ! "
    "gvadetect model=yolo26n_openvino_model/yolo26n.xml "
    "device=GPU "
    "threshold=0.4 ! queue ! "
    "gvawatermark "
    "displ-cfg=show-roi=person:bicycle:car:motorcycle:bus:train:truck,font-scale=2.5 ! "
    "videoconvert ! video/x-raw,format=I420 ! "
    "openh264enc ! h264parse ! "
    "mp4mux ! filesink name=sink location=output_dlstreamer.mp4"
)
pipeline = Gst.parse_launch(pipeline_str)

totals = {"People": 0, "Vehicles": 0}


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
    counts = {"People": 0, "Vehicles": 0}
    idx = 1
    while True:
        ok, od = rmeta.get_od_mtd(idx)
        if not ok:
            break
        label = GLib.quark_to_string(od.get_obj_type())
        category = CATEGORY_BY_LABEL.get(label)
        if category is not None:
            counts[category] += 1
            totals[category] += 1
        idx += 1
    if counts["People"] or counts["Vehicles"]:
        print(f"frame: People={counts['People']} Vehicles={counts['Vehicles']}",
              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)
print(f"Summary: People={totals['People']} Vehicles={totals['Vehicles']}")

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
• OpenVINO YOLO26 Notebook
• Sample video: Urban roundabout with cars and pedestrian (Pexels)
• OpenVINO Documentation
• NNCF Post-Training Quantization
• Intel DLStreamer