Update native RC1 samples and supported device documentation

README.md

@@ -8,6 +8,7 @@ tags:
   - intel
   - yolo
   - yolo26
+  - detr
   - object-classification
   - classification
   - smart-city
@@ -25,8 +26,8 @@ language:
 | Property | Value |
 |---|---|
 | **Category** | Object Classification (Traffic Categorization: People / Vehicles) |
-| **Base Model** | [YOLO26](https://docs.ultralytics.com/models/yolo26/) (Ultralytics) |
-| **Source Framework** | PyTorch (Ultralytics) |
+| **Base Model** | [YOLO26](https://docs.ultralytics.com/models/yolo26/) (Ultralytics, default) or [DETR](https://huggingface.co/facebook/detr-resnet-50) (Facebook, alternative) |
+| **Source Framework** | PyTorch (Ultralytics, Hugging Face Transformers) |
 | **Supported Precisions** | FP32, FP16, INT8 (mixed-precision) |
 | **Inference Engine** | OpenVINO |
 | **Hardware** | CPU, GPU, NPU |
@@ -54,16 +55,35 @@ Typical Metro deployments include:
 - **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`.
+Available variants: `yolo26n`, `yolo26s`, `yolo26m`, `yolo26l`.
 Smaller variants (`yolo26n`, `yolo26s`) are recommended for high-FPS edge deployment; larger variants improve recall for small objects.
 
+### Model Selection
+
+[DETR](https://huggingface.co/facebook/detr-resnet-50) (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.
+
 ---
 
 ## 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](../README.md#native-rc1-runtime) before running these samples; this is a development stack, not a stable release.
+See the [device validation matrix](../DEVICE_SUPPORT_MATRIX.md) for measured CPU, GPU, and NPU results.
+
 - Python 3.11+
 - [Install OpenVINO](https://docs.openvino.ai/2026/get-started/install-openvino.html) (latest version)
-- [Install Intel DLStreamer](https://docs.openedgeplatform.intel.com/2026.0/edge-ai-libraries/dlstreamer/get_started/install/install_guide_ubuntu.html) (latest version)
+- [Install Intel DLStreamer](https://docs.openedgeplatform.intel.com/dev/edge-ai-libraries/dlstreamer/get_started/install/install_guide_ubuntu.html) (latest version)
 
 Create and activate a Python virtual environment before running the scripts:
 
@@ -91,25 +111,27 @@ chmod +x export_and_quantize.sh
 
 This exports the default **yolo26n** model in **FP16** precision.
 
-#### Optional: Select a Different Variant or Precision
+#### Optional: Select a Different Model, Variant, or Precision
 
 ```bash
-./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 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
 ```
 
-Replace `yolo26n` with any variant (`yolo26s`, `yolo26m`, `yolo26l`, `yolo26x`).
+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`; adds `nncf` for INT8).
+1. Installs dependencies (`openvino`, `ultralytics` for YOLO26 or `transformers`, `torch` for DETR; 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:
+Output files (replace `yolo26n` with the selected model, for example `detr-resnet-50`):
 
 - `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)*.
@@ -135,13 +157,24 @@ category, overlays live category counts, and writes the annotated result to
 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](openvino_sample.py); run it with `python3 openvino_sample.py` or copy the code below.
+
+<!-- sample: openvino_sample.py -->
 ```python
+# SPDX-License-Identifier: MIT
+# Copyright (C) Intel Corporation
+#
+# Object Classification: 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
-INPUT_SIZE = 640
+# Select the model: "yolo26n" (default) or "detr-resnet-50".
+MODEL = "yolo26n"
+INPUT_SIZE = 800 if MODEL.startswith("detr") else 640
 
 # Map the traffic-relevant COCO class ids into higher-level city categories.
 # People and Vehicles are the two categories tracked for situational awareness.
@@ -161,7 +194,7 @@ CATEGORY_COLORS = {
 }
 
 core = ov.Core()
-model = core.read_model("yolo26n_openvino_model/yolo26n.xml")
+model = core.read_model(f"{MODEL}_openvino_model/{MODEL}.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.
@@ -194,7 +227,8 @@ while True:
     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].
+    # End-to-end output: [1, N, 6] = [x1, y1, x2, y2, confidence, class_id].
+    # (N = 300 for YOLO26, 100 for DETR)
     output = compiled([blob])[output_port][0]
 
     sx, sy = width / INPUT_SIZE, height / INPUT_SIZE
@@ -231,6 +265,7 @@ writer.release()
 print(f"Summary: People={totals['People']} Vehicles={totals['Vehicles']}")
 print("Saved: output_openvino.mp4")
 ```
+<!-- /sample -->
 
 **Device targets:**
 
@@ -268,7 +303,7 @@ classes only (non-traffic detections such as `handbag` are filtered out via
 
 > **Notes on running this sample:**
 >
-> - Use the FP16 IR (`yolo26n_openvino_model/yolo26n.xml`). Class names are
+> - Use the FP16 IR (`yolo26n_openvino_model/yolo26n.xml` or `detr-resnet-50_openvino_model/detr-resnet-50.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:
@@ -280,7 +315,16 @@ classes only (non-traffic detections such as `handbag` are filtered out via
 >   /opt/intel/dlstreamer/gstreamer/lib/python3/dist-packages:${PYTHONPATH:-}
 >   ```
 
+The full sample is in [dlstreamer_sample.py](dlstreamer_sample.py); run it with `python3 dlstreamer_sample.py` or copy the code below.
+
+<!-- sample: dlstreamer_sample.py -->
 ```python
+# SPDX-License-Identifier: MIT
+# Copyright (C) Intel Corporation
+#
+# Object Classification: DLStreamer pipeline sample.
+# See README.md for prerequisites and inputs. Run: python3 dlstreamer_sample.py
+
 import gi
 
 gi.require_version("Gst", "1.0")
@@ -302,6 +346,9 @@ CATEGORY_BY_LABEL = {
     "truck": "Vehicles",
 }
 
+# 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).
 # gvawatermark displ-cfg:
@@ -311,7 +358,7 @@ CATEGORY_BY_LABEL = {
 pipeline_str = (
     f"filesrc location={INPUT_VIDEO} ! decodebin3 ! "
     "videoconvert ! "
-    "gvadetect model=yolo26n_openvino_model/yolo26n.xml "
+    f"gvadetect model={MODEL}_openvino_model/{MODEL}.xml "
     "device=GPU "
     "threshold=0.4 ! queue ! "
     "gvawatermark "
@@ -361,6 +408,7 @@ bus.timed_pop_filtered(
 pipeline.set_state(Gst.State.NULL)
 print(f"Summary: People={totals['People']} Vehicles={totals['Vehicles']}")
 ```
+<!-- /sample -->
 
 #### Expected Output
 
@@ -381,8 +429,10 @@ Licensed under the MIT License. See [LICENSE](LICENSE) for details.
 ## References
 
 - [YOLO26 Documentation](https://docs.ultralytics.com/models/yolo26/)
+- [DETR Model Card (facebook/detr-resnet-50)](https://huggingface.co/facebook/detr-resnet-50)
+- [End-to-End Object Detection with Transformers (DETR paper)](https://arxiv.org/abs/2005.12872)
 - [OpenVINO YOLO26 Notebook](https://github.com/openvinotoolkit/openvino_notebooks/blob/latest/notebooks/yolov26-optimization/yolov26-object-detection.ipynb)
 - [Sample video: Urban roundabout with cars and pedestrian (Pexels)](https://www.pexels.com/video/urban-roundabout-with-cars-and-pedestrian-30119018/)
 - [OpenVINO Documentation](https://docs.openvino.ai/)
 - [NNCF Post-Training Quantization](https://docs.openvino.ai/latest/nncf_ptq_introduction.html)
-- [Intel DLStreamer](https://docs.openedgeplatform.intel.com/2026.0/edge-ai-libraries/dlstreamer/index.html)
+- [Intel DLStreamer](https://docs.openedgeplatform.intel.com/dev/edge-ai-libraries/dlstreamer/index.html)

config.json

@@ -3,8 +3,8 @@
   "library_name": "openvino",
   "pipeline_tag": "object-detection",
   "category": "Object Classification (Traffic Categorization: People / Vehicles)",
-  "base_model": "YOLO26 (Ultralytics)",
-  "source_framework": "PyTorch (Ultralytics)",
+  "base_model": "YOLO26 (Ultralytics, default) or DETR facebook/detr-resnet-50 (alternative)",
+  "source_framework": "PyTorch (Ultralytics, Hugging Face Transformers)",
   "supported_precisions": [
     "FP32",
     "FP16",
@@ -18,5 +18,13 @@
   ],
   "detected_classes": "`person` and vehicle classes grouped into `People` and `Vehicles`",
   "hf_repo_id": "Intel/object-classification",
-  "description": "Object classification use case using YOLO26 to categorize detections into People and Vehicles for traffic situational awareness"
+  "description": "Object classification use case using YOLO26 (default) or DETR to categorize detections into People and Vehicles for traffic situational awareness",
+  "selectable_models": [
+    "yolo26n",
+    "yolo26s",
+    "yolo26m",
+    "yolo26l",
+    "detr-resnet-50"
+  ],
+  "default_model": "yolo26n"
 }

dlstreamer_sample.py

@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: MIT
+# Copyright (C) Intel Corporation
+#
+# Object Classification: 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"
+
+# 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",
+}
+
+# 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).
+# 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 ! "
+    f"gvadetect model={MODEL}_openvino_model/{MODEL}.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']}")

export_and_quantize.sh

@@ -2,11 +2,21 @@
 # SPDX-License-Identifier: MIT
 # Copyright (C) Intel Corporation
 #
-# Export a YOLO26 detector to OpenVINO IR for the object-classification use case.
+# Export a YOLO26 or DETR detector to OpenVINO IR for the object-classification use case.
 # The accompanying samples group detected objects into higher-level city
 # categories (People, Vehicles) for traffic situational awareness.
 # Usage: ./export_and_quantize.sh [MODEL_VARIANT] [PRECISION]
 # Example: ./export_and_quantize.sh yolo26n FP16
+# Example: ./export_and_quantize.sh detr-resnet-50 FP16
+#
+# Supported model variants:
+#   yolo26n, yolo26s, yolo26m, yolo26l           -- Ultralytics YOLO26 (default)
+#   detr-resnet-50                               -- Facebook DETR (Hugging Face)
+#
+# DETR is exported end-to-end: ImageNet normalization, softmax,
+# box decoding, and the COCO-91 to COCO-80 class remap are embedded in the
+# graph, so the IR produces the same [1, N, 6] output layout and class ids as
+# YOLO26 and runs with the same OpenVINO and DLStreamer samples.
 #
 # Supported precisions:
 #   FP32  -- Full-precision floating-point weights
@@ -31,12 +41,20 @@ if [[ "${PRECISION}" != "FP32" && "${PRECISION}" != "FP16" && "${PRECISION}" !=
     exit 1
 fi
 
-echo "--- Installing dependencies ---"
-if [[ "${PRECISION}" == "INT8" ]]; then
-    pip install -qU openvino nncf ultralytics
-else
-    pip install -qU openvino ultralytics
-fi
+case "${MODEL_NAME}" in
+    yolo26n|yolo26s|yolo26m|yolo26l)
+        MODEL_FAMILY="yolo"
+        INPUT_SIZE=640
+        ;;
+    detr-resnet-50)
+        MODEL_FAMILY="detr"
+        INPUT_SIZE=800
+        ;;
+    *)
+        echo "ERROR: unsupported model '${MODEL_NAME}'. Choose yolo26[n|s|m|l] or detr-resnet-50." >&2
+        exit 1
+        ;;
+esac
 
 # Ask for approval before downloading models and sample files
 echo ""
@@ -62,6 +80,17 @@ else
 fi
 
 echo ""
+echo "--- Installing dependencies ---"
+if [[ "${MODEL_FAMILY}" == "detr" ]]; then
+    DEPS=(openvino transformers torch pyyaml opencv-python)
+else
+    DEPS=(openvino ultralytics)
+fi
+if [[ "${PRECISION}" == "INT8" ]]; then
+    DEPS+=(nncf)
+fi
+pip install -qU "${DEPS[@]}"
+
 echo "--- Downloading sample test video (urban roundabout) ---"
 if [[ ! -f test_video.mp4 ]]; then
     wget -q -O test_video.mp4 \
@@ -79,14 +108,92 @@ else
     EXPORT_LABEL="FP16"
 fi
 
-echo "--- Exporting ${MODEL_NAME} to OpenVINO IR (${EXPORT_LABEL}) ---"
-python3 -c "
+if [[ "${MODEL_FAMILY}" == "yolo" ]]; then
+    echo "--- Exporting ${MODEL_NAME} to OpenVINO IR (${EXPORT_LABEL}) ---"
+    python3 -c "
 from ultralytics import YOLO
 
 model = YOLO('${MODEL_NAME}.pt')
-model.export(format='openvino', half=${HALF_FLAG}, dynamic=False, imgsz=640)
+model.export(format='openvino', half=${HALF_FLAG}, dynamic=False, imgsz=${INPUT_SIZE}, nms=False)
 print('Export complete: ${MODEL_NAME}_openvino_model/')
 "
+else
+    echo "--- Exporting facebook/${MODEL_NAME} to OpenVINO IR (${EXPORT_LABEL}) ---"
+    python3 - "${MODEL_NAME}" "${HALF_FLAG}" "${INPUT_SIZE}" <<'PYEXPORT'
+import sys
+from pathlib import Path
+
+import openvino as ov
+import torch
+import yaml
+from transformers import DetrForObjectDetection
+
+model_name, half_flag, size = sys.argv[1], sys.argv[2] == "True", int(sys.argv[3])
+model_id = f"facebook/{model_name}"
+
+# The "no_timm" revision uses the transformers ResNet backbone (no timm dependency).
+detr = DetrForObjectDetection.from_pretrained(model_id, revision="no_timm").eval()
+id2label = detr.config.id2label
+# DETR predicts 91 COCO category ids (with "N/A" gaps) plus a no-object class.
+# Keep the 80 real categories so class ids match YOLO26 (person = 0).
+coco80 = [k for k in sorted(id2label) if id2label[k] != "N/A"]
+assert len(coco80) == 80, f"unexpected label map with {len(coco80)} classes"
+
+
+class DetrEndToEnd(torch.nn.Module):
+    """Input: RGB [0, 1] NCHW. Output: [1, 100, 6] = [x1, y1, x2, y2, conf, class_id] in input pixels."""
+
+    def __init__(self, model: torch.nn.Module) -> None:
+        super().__init__()
+        self.model = model
+        self.register_buffer("mean", torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1))
+        self.register_buffer("std", torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1))
+        self.register_buffer("coco80", torch.tensor(coco80))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        out = self.model(pixel_values=(x - self.mean) / self.std, return_dict=True)
+        probs = out.logits.softmax(-1).index_select(-1, self.coco80)
+        conf, cls = probs.max(-1)
+        cx, cy, w, h = (out.pred_boxes * size).unbind(-1)
+        return torch.stack([cx - w / 2, cy - h / 2, cx + w / 2, cy + h / 2, conf, cls.float()], -1)
+
+
+ov_model = ov.convert_model(
+    DetrEndToEnd(detr), example_input=torch.zeros(1, 3, size, size), input=[1, 3, size, size]
+)
+ov_model.outputs[0].get_tensor().set_names({"output0"})
+
+names = {i: id2label[k] for i, k in enumerate(coco80)}
+# DLStreamer reads preprocessing and the post-processor type from model_info.
+model_info = {
+    "model_type": "YOLO",
+    "labels": " ".join(n.replace(" ", "_") for n in names.values()),
+    "resize_type": "standard",
+    "reverse_input_channels": "YES",
+    "scale_values": "255",
+    "iou_threshold": "0.7",
+}
+for key, value in model_info.items():
+    ov_model.set_rt_info(value, ["model_info", key])
+
+out_dir = Path(f"{model_name}_openvino_model")
+out_dir.mkdir(exist_ok=True)
+ov.save_model(ov_model, out_dir / f"{model_name}.xml", compress_to_fp16=half_flag)
+metadata = {
+    "description": f"{model_id} exported end-to-end with YOLO26-compatible output",
+    "license": "Apache-2.0",
+    "task": "detect",
+    "batch": 1,
+    "imgsz": [size, size],
+    "names": names,
+    "channels": 3,
+    "end2end": True,
+}
+with open(out_dir / "metadata.yaml", "w", encoding="utf-8") as f:
+    yaml.safe_dump(metadata, f, sort_keys=False)
+print(f"Export complete: {out_dir}/")
+PYEXPORT
+fi
 
 if [[ "${PRECISION}" == "INT8" ]]; then
     echo "--- Quantizing to INT8 with NNCF ---"
@@ -105,7 +212,7 @@ ok, frame = cap.read()
 cap.release()
 if not ok:
     raise SystemExit('Could not read a calibration frame from test_video.mp4')
-img = cv2.resize(frame, (640, 640))
+img = cv2.resize(frame, (${INPUT_SIZE}, ${INPUT_SIZE}))
 img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
 img = img.transpose(2, 0, 1)[np.newaxis, ...]  # NCHW
 
@@ -119,6 +226,7 @@ quantized = nncf.quantize(
     calibration_dataset,
     preset=nncf.QuantizationPreset.MIXED,
     subset_size=300,
+    model_type=nncf.ModelType.TRANSFORMER if '${MODEL_FAMILY}' == 'detr' else None,
 )
 
 ov.save_model(quantized, '${MODEL_NAME}_objcls_int8.xml')

openvino_sample.py

@@ -0,0 +1,103 @@
+# SPDX-License-Identifier: MIT
+# Copyright (C) Intel Corporation
+#
+# Object Classification: 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
+
+# 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(f"{MODEL}_openvino_model/{MODEL}.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
+
+    # End-to-end output: [1, N, 6] = [x1, y1, x2, y2, confidence, class_id].
+    # (N = 300 for YOLO26, 100 for DETR)
+    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")