Update native RC1 samples and supported device documentation

README.md

@@ -8,6 +8,7 @@ tags:
   - intel
   - yolo
   - yolo26
+  - detr
   - object-counting
   - coco
   - edge-ai
@@ -22,8 +23,8 @@ language:
 | Property | Value |
 |---|---|
 | **Category** | Object Detection + Counting (80-class COCO) |
-| **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 |
@@ -50,19 +51,38 @@ Typical Metro deployments include:
 - **Inventory Counting** -- count bags, bottles, or other items in a zone.
 - **Throughput Metrics** -- aggregate per-frame counts into time series.
 
-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 or distant objects.
 
 For line-crossing counts (directional entry/exit), see the
 [vehicle-entry-exit-logging](../vehicle-entry-exit-logging/) use case.
 
+### 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:
 
@@ -90,20 +110,22 @@ 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 test image (`test.jpg`) and a sample test video
    (`test_video.mp4`, the
    [`person-bicycle-car-detection.mp4`](https://github.com/intel-iot-devkit/sample-videos/blob/master/person-bicycle-car-detection.mp4)
@@ -111,7 +133,7 @@ The script performs the following steps:
 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_objcount_int8.xml` / `yolo26n_objcount_int8.bin` -- INT8 quantized model *(only when `INT8` is selected)*.
@@ -135,7 +157,16 @@ per-class count and a total count for a single image.
 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 Counting: OpenVINO Runtime sample.
+# See README.md for prerequisites and inputs. Run: python3 openvino_sample.py
+
 from collections import Counter
 
 import cv2
@@ -143,10 +174,12 @@ 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
 
 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 -- read them instead of
 # hardcoding the list. Ultralytics separates multi-word names with
@@ -166,7 +199,8 @@ 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
 
-# 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])[compiled.output(0)][0]
 dets = output[output[:, 4] >= CONF_THRESHOLD]
 
@@ -192,6 +226,7 @@ cv2.putText(image, summary[:60], (10, 30),
             cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
 cv2.imwrite("output_openvino.jpg", image)
 ```
+<!-- /sample -->
 
 **Device targets:**
 
@@ -231,7 +266,7 @@ three classes counted below.
 
 > **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:
@@ -243,7 +278,16 @@ three classes counted below.
 >   /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 Counting: DLStreamer pipeline sample.
+# See README.md for prerequisites and inputs. Run: python3 dlstreamer_sample.py
+
 from collections import Counter
 
 import gi
@@ -260,12 +304,15 @@ INPUT_VIDEO = "test_video.mp4"
 # a cyclist, and cars.
 CLASSES_OF_INTEREST = {"person", "bicycle", "car"}
 
+# 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 ! "
-    "gvadetect model=yolo26n_openvino_model/yolo26n.xml "
+    f"gvadetect model={MODEL}_openvino_model/{MODEL}.xml "
     "device=GPU "
     "threshold=0.4 ! queue ! "
     "gvawatermark ! videoconvert ! video/x-raw,format=I420 ! "
@@ -307,6 +354,7 @@ bus.timed_pop_filtered(
 )
 pipeline.set_state(Gst.State.NULL)
 ```
+<!-- /sample -->
 
 **Device targets:**
 
@@ -327,8 +375,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)
 - [Ultralytics Object Counting Guide](https://docs.ultralytics.com/guides/object-counting/)
-- [Intel DLStreamer gvadetect](https://docs.openedgeplatform.intel.com/2026.0/edge-ai-libraries/dlstreamer/elements/gvadetect.html)
+- [Intel DLStreamer gvadetect](https://docs.openedgeplatform.intel.com/dev/edge-ai-libraries/dlstreamer/elements/gvadetect.html)
 - [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 Detection + Counting (80-class COCO)",
-  "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": "All 80 COCO classes (counted per class)",
   "hf_repo_id": "Intel/object-counting",
-  "description": "Object counting use case using YOLO26 INT8 to detect and report per-class counts across all 80 COCO classes"
+  "description": "Object counting use case using YOLO26 (default) or DETR to detect and report per-class counts across all 80 COCO classes",
+  "selectable_models": [
+    "yolo26n",
+    "yolo26s",
+    "yolo26m",
+    "yolo26l",
+    "detr-resnet-50"
+  ],
+  "default_model": "yolo26n"
 }

dlstreamer_sample.py

@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: MIT
+# Copyright (C) Intel Corporation
+#
+# Object Counting: DLStreamer pipeline sample.
+# See README.md for prerequisites and inputs. Run: python3 dlstreamer_sample.py
+
+from collections import Counter
+
+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"
+
+# Only these classes are counted; the sample video contains pedestrians,
+# a cyclist, and cars.
+CLASSES_OF_INTEREST = {"person", "bicycle", "car"}
+
+# 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
+    counts = Counter()
+    idx = 1
+    while True:
+        ok, od = rmeta.get_od_mtd(idx)
+        if not ok:
+            break
+        label = GLib.quark_to_string(od.get_obj_type())
+        if label in CLASSES_OF_INTEREST:
+            counts[label] += 1
+        idx += 1
+    if counts:
+        summary = ", ".join(f"{n} {name}" for name, n in counts.items())
+        print(f"Object counts: {summary}", flush=True)
+    return Gst.PadProbeReturn.OK
+
+
+sink = pipeline.get_by_name("sink")
+sink.get_static_pad("sink").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)

export_and_quantize.sh

@@ -2,9 +2,19 @@
 # SPDX-License-Identifier: MIT
 # Copyright (C) Intel Corporation
 #
-# Export a YOLO26 detector to OpenVINO IR for the object-counting use case.
+# Export a YOLO26 or DETR detector to OpenVINO IR for the object-counting use case.
 # 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
@@ -29,12 +39,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 ""
@@ -59,6 +77,17 @@ else
     echo "WARNING: HuggingFace tracking ping failed (offline?); continuing." >&2
 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 image ---"
 if [[ ! -f test.jpg ]]; then
     wget -q -O test.jpg https://ultralytics.com/images/bus.jpg
@@ -84,14 +113,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 ---"
@@ -106,7 +213,7 @@ model = core.read_model('${MODEL_NAME}_openvino_model/${MODEL_NAME}.xml')
 
 # Use the downloaded test image for calibration instead of random noise.
 img = cv2.imread('test.jpg')
-img = cv2.resize(img, (640, 640))
+img = cv2.resize(img, (${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
 
@@ -120,6 +227,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}_objcount_int8.xml')

openvino_sample.py

@@ -0,0 +1,64 @@
+# SPDX-License-Identifier: MIT
+# Copyright (C) Intel Corporation
+#
+# Object Counting: OpenVINO Runtime sample.
+# See README.md for prerequisites and inputs. Run: python3 openvino_sample.py
+
+from collections import Counter
+
+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]
+dets = output[output[:, 4] >= CONF_THRESHOLD]
+
+sx, sy = w0 / INPUT_SIZE, h0 / INPUT_SIZE
+counts = Counter(COCO_NAMES[int(d[5])] for d in dets)
+
+print(f"Total objects: {len(dets)}")
+print("Object counts:")
+for name, n in sorted(counts.items(), key=lambda kv: (-kv[1], kv[0])):
+    print(f"  {name}: {n}")
+
+colors = np.random.RandomState(42).randint(0, 255, (80, 3)).tolist()
+for det in dets:
+    x1, y1, x2, y2 = (int(det[0] * sx), int(det[1] * sy),
+                      int(det[2] * sx), int(det[3] * sy))
+    cid = int(det[5])
+    cv2.rectangle(image, (x1, y1), (x2, y2), colors[cid], 2)
+    cv2.putText(image, COCO_NAMES[cid], (x1, y1 - 5),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.6, colors[cid], 2)
+
+summary = ", ".join(f"{n} {name}" for name, n in counts.items())
+cv2.putText(image, summary[:60], (10, 30),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+cv2.imwrite("output_openvino.jpg", image)