Sync crowd-detection from metro-analytics-catalog

LICENSE

@@ -29,17 +29,17 @@ MIT License.
     THE SOFTWARE.
 
 
-YOLO11 Model
+YOLO26 Model
 ------------
 
-The YOLO11 model weights and the Ultralytics framework are developed by
+The YOLO26 model weights and the Ultralytics framework are developed by
 Ultralytics and licensed under the GNU Affero General Public License v3.0
 (AGPL-3.0).
 
     Source:  https://github.com/ultralytics/ultralytics
     License: https://github.com/ultralytics/ultralytics/blob/main/LICENSE
-    Docs:    https://docs.ultralytics.com/models/yolo11/
+    Docs:    https://docs.ultralytics.com/models/yolo26/
 
 Users must comply with the AGPL-3.0 license terms when using, modifying,
-or distributing the YOLO11 model weights or Ultralytics software.
+or distributing the YOLO26 model weights or Ultralytics software.
 For commercial licensing options, see https://www.ultralytics.com/license.

README.md

@@ -1,14 +1,12 @@
-# Crowd Detection -- Person Counting on Intel Hardware
+# Crowd Detection
 
-> **Reference notebook:** [yolov11-object-detection.ipynb](https://github.com/openvinotoolkit/openvino_notebooks/blob/latest/notebooks/yolov11-optimization/yolov11-object-detection.ipynb)
->
-> **Validated with:** OpenVINO 2026.0.0, NNCF 3.0.0, Ultralytics 8.3.0, Python 3.11+
+> **Validated with:** OpenVINO 2026.0.0, NNCF 3.0.0, DLStreamer 2026.0, Ultralytics 8.3.0, Python 3.11+
 
 | Property | Value |
 |---|---|
 | **Category** | Object Detection (Crowd / Person Counting) |
 | **Source Framework** | PyTorch (Ultralytics) |
-| **Supported Precisions** | FP16, FP16-INT8 |
+| **Supported Precisions** | FP32, FP16, FP16-INT8 |
 | **Inference Engine** | OpenVINO |
 | **Hardware** | CPU, GPU, NPU |
 | **Detected Class** | `person` (COCO class 0) |
@@ -18,7 +16,7 @@
 ## Overview
 
 Crowd Detection is a Metro Analytics use case that detects and counts people in video streams to estimate occupancy and identify crowd build-up.
-It is built on [YOLO11](https://docs.ultralytics.com/models/yolo11/), a real-time object detector trained on the COCO dataset, filtered at runtime to the `person` class.
+It is built on [YOLO26](https://docs.ultralytics.com/models/yolo26/), a real-time object detector trained on the COCO dataset, filtered at runtime to the `person` class.
 Typical Metro deployments include:
 
 - **Platform Occupancy** -- count waiting passengers on station platforms.
@@ -26,15 +24,23 @@ Typical Metro deployments include:
 - **Crowd Build-up Alerts** -- trigger notifications when person counts cross a threshold.
 - **Public Safety Analytics** -- support situational awareness in transit hubs and venues.
 
-Available variants: `yolo11n`, `yolo11s`, `yolo11m`, `yolo11l`, `yolo11x`.
-Smaller variants (`yolo11n`, `yolo11s`) are recommended for high-FPS edge deployment; larger variants improve recall in dense crowds.
+Available variants: `yolo26n`, `yolo26s`, `yolo26m`, `yolo26l`, `yolo26x`.
+Smaller variants (`yolo26n`, `yolo26s`) are recommended for high-FPS edge deployment; larger variants improve recall in dense crowds.
 
 ---
 
 ## Prerequisites
 
+- Python 3.11+
 - [Install OpenVINO 2026.0.0](https://docs.openvino.ai/2026/get-started/install-openvino.html)
-- [Install Intel DLStreamer](https://dlstreamer.github.io/get_started/install/install-guide-ubuntu.html)
+- [Install Intel DLStreamer](https://docs.openedgeplatform.intel.com/2026.0/edge-ai-libraries/dlstreamer/get_started/install/install_guide_ubuntu.html)
+
+Create and activate a Python virtual environment before running the scripts:
+
+```bash
+python3 -m venv .venv --system-site-packages
+source .venv/bin/activate
+```
 
 ---
 
@@ -42,26 +48,37 @@ Smaller variants (`yolo11n`, `yolo11s`) are recommended for high-FPS edge deploy
 
 ### Download and Quantize Model
 
-Run the provided script to download, export to OpenVINO IR (FP16), and quantize to INT8:
+Run the provided script to download, export to OpenVINO IR, and optionally quantize:
 
 ```bash
 chmod +x export_and_quantize.sh
-./export_and_quantize.sh yolo11n
+./export_and_quantize.sh yolo26n        # default: FP16
+./export_and_quantize.sh yolo26n FP32   # full-precision
+./export_and_quantize.sh yolo26n INT8   # quantized
 ```
 
-Replace `yolo11n` with any variant (`yolo11s`, `yolo11m`, `yolo11l`, `yolo11x`).
+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`, `nncf`, `ultralytics`).
-2. Downloads the PyTorch weights and exports to OpenVINO IR with `half=True`.
-3. Quantizes the model to INT8 using NNCF post-training quantization.
-4. Runs `benchmark_app` to validate throughput.
+1. Installs dependencies (`openvino`, `ultralytics`; adds `nncf` for INT8).
+2. Downloads a sample test image (`test.jpg`).
+3. Downloads the PyTorch weights and exports to OpenVINO IR.
+4. *(INT8 only)* Quantizes the model using NNCF post-training quantization.
 
 Output files:
 
-- `yolo11n_openvino_model/` -- FP16 OpenVINO IR model directory.
-- `yolo11n_crowd_int8.xml` / `yolo11n_crowd_int8.bin` -- INT8 quantized model.
+- `yolo26n_openvino_model/` -- FP32 or FP16 OpenVINO IR model directory.
+- `yolo26n_crowd_int8.xml` / `yolo26n_crowd_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:** For production accuracy, replace the random calibration tensors in
 > `export_and_quantize.sh` with a representative sample of frames from the
@@ -69,7 +86,7 @@ Output files:
 
 ### OpenVINO Sample
 
-The sample below runs YOLO11 inference, filters to the `person` class, applies
+The sample below runs YOLO26 inference, filters to the `person` class, applies
 non-maximum suppression, and reports the crowd count for a single image.
 
 ```python
@@ -79,11 +96,10 @@ import openvino as ov
 
 PERSON_CLASS_ID = 0
 CONF_THRESHOLD = 0.4
-IOU_THRESHOLD = 0.5
 INPUT_SIZE = 640
 
 core = ov.Core()
-model = core.read_model("yolo11n_crowd_int8.xml")
+model = core.read_model("yolo26n_openvino_model/yolo26n.xml")
 compiled = core.compile_model(model, "CPU")  # or "GPU", "NPU"
 
 image = cv2.imread("test.jpg")
@@ -94,87 +110,60 @@ 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
 
-# Infer. YOLO11 raw output shape: [1, 84, 8400] (xywh + 80 class scores).
-output = compiled([blob])[compiled.output(0)]
-preds = output[0].T  # [8400, 84]
-
-boxes_xywh = preds[:, :4]
-class_scores = preds[:, 4:]
-class_ids = class_scores.argmax(axis=1)
-confidences = class_scores.max(axis=1)
-
-mask = (class_ids == PERSON_CLASS_ID) & (confidences >= CONF_THRESHOLD)
-boxes_xywh = boxes_xywh[mask]
-confidences = confidences[mask]
+# YOLO26 end-to-end output: [1, 300, 6] = [x1, y1, x2, y2, confidence, class_id]
+# No NMS is needed -- YOLO26 is natively end-to-end.
+output = compiled([blob])[compiled.output(0)][0]
+mask = (output[:, 4] >= CONF_THRESHOLD) & (output[:, 5].astype(int) == PERSON_CLASS_ID)
+dets = output[mask]
 
-# Convert xywh (center) to xyxy in original image coordinates.
 sx, sy = w0 / INPUT_SIZE, h0 / INPUT_SIZE
-xyxy = np.empty_like(boxes_xywh)
-xyxy[:, 0] = (boxes_xywh[:, 0] - boxes_xywh[:, 2] / 2) * sx
-xyxy[:, 1] = (boxes_xywh[:, 1] - boxes_xywh[:, 3] / 2) * sy
-xyxy[:, 2] = (boxes_xywh[:, 0] + boxes_xywh[:, 2] / 2) * sx
-xyxy[:, 3] = (boxes_xywh[:, 1] + boxes_xywh[:, 3] / 2) * sy
-
-# Apply NMS to deduplicate overlapping detections.
-keep = cv2.dnn.NMSBoxes(
-    bboxes=[[float(x1), float(y1), float(x2 - x1), float(y2 - y1)]
-            for x1, y1, x2, y2 in xyxy],
-    scores=confidences.tolist(),
-    score_threshold=CONF_THRESHOLD,
-    nms_threshold=IOU_THRESHOLD,
-)
-
-crowd_count = len(keep)
+crowd_count = len(dets)
 print(f"Detected persons: {crowd_count}")
 
-for i in np.array(keep).flatten():
-    x1, y1, x2, y2 = xyxy[i].astype(int)
+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"Crowd count: {crowd_count}", (10, 30),
     cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 0), 2,
 )
-cv2.imwrite("crowd_output.jpg", image)
+cv2.imwrite("output.jpg", image)
 ```
 
 ### Try It on a Sample Image
 
-Download a public sample image that contains several people:
-
-```bash
-wget -O test.jpg https://ultralytics.com/images/bus.jpg
-```
-
+The `export_and_quantize.sh` script downloads `test.jpg` automatically.
 Re-run the OpenVINO sample above.
-The script reads `test.jpg`, prints the crowd count to the console, and writes the annotated frame to `crowd_output.jpg`.
+The script reads `test.jpg`, prints the crowd count to the console, and writes the annotated frame to `output.jpg`.
 
-Expected console output (when running against the INT8 model produced by the script with the default random calibration tensors):
+Expected console output:
 
 ```text
-Detected persons: 3
+Detected persons: 4
 ```
 
-`crowd_output.jpg` is the same image with a green bounding box drawn around each detected person and the text `Crowd count: 3` overlaid in the top-left corner.
-
-The reference image actually contains four people; the FP16 IR (`yolo11n_openvino_model/yolo11n.xml`) detects all four.
-The INT8 model produced with random calibration data in `export_and_quantize.sh` typically detects three.
-Replace the random calibration tensors with representative frames from your deployment site to recover the missing detection.
+`output.jpg` is the same image with a green bounding box drawn around each detected person and the text `Crowd count: 4` overlaid in the top-left corner.
 
 ### DLStreamer Sample
 
-The pipeline below runs the FP16 YOLO11 detector on a video file via
+The pipeline below runs the FP16 YOLO26 detector on a test image via
 `gvadetect`, filters detections to the `person` class in a buffer probe using
 the DLStreamer Python bindings (`gstgva.VideoFrame`), overlays bounding boxes,
-and prints the per-frame crowd count.
+saves the annotated result to `output.jpg`, and prints the crowd count.
 
 > **Notes on running this sample:**
 >
-> - Use the FP16 IR (`yolo11n_openvino_model/yolo11n.xml`).
+> - Use the FP16 IR (`yolo26n_openvino_model/yolo26n.xml`).
 >   On DLStreamer 2026.0.0, `gvadetect` cannot auto-derive a YOLO post-processor
 >   from the INT8 model produced by the bundled script.
 >   To use the INT8 model, supply a matching `model-proc` JSON.
-> - `gvadetect` requires `labels-file=` to map class indices to names.
+> - Class names are read automatically from the model's embedded
+>   `metadata.yaml` by DLStreamer 2026.0+ -- no external `labels-file` is
+>   required.
 > - Filtering with `object-class=person` directly on `gvadetect` is rejected
 >   when `inference-region` is `full-frame` (the default), so the sample
 >   filters by `region.label()` in the buffer probe instead.
@@ -186,9 +175,6 @@ and prints the per-frame crowd count.
 >   export PYTHONPATH=/opt/intel/dlstreamer/python:\
 >   /opt/intel/dlstreamer/gstreamer/lib/python3/dist-packages:${PYTHONPATH:-}
 >   ```
->
-> Create `coco.txt` once with the 80 COCO class names in COCO order, one per
-> line (see the loitering-detection README for a ready-to-paste snippet).
 
 ```python
 import gi
@@ -201,14 +187,18 @@ from gstgva import VideoFrame
 Gst.init(None)
 
 pipeline_str = (
-    "filesrc location=test_video.mp4 ! decodebin ! videoconvert ! "
+    "filesrc location=test.jpg ! jpegdec ! videoconvert ! "
     "video/x-raw,format=BGR ! "
-    "gvadetect model=yolo11n_openvino_model/yolo11n.xml "
-    "labels-file=coco.txt device=CPU threshold=0.4 ! queue ! "
-    "gvawatermark ! videoconvert ! autovideosink name=sink sync=false"
+    "gvadetect model=yolo26n_openvino_model/yolo26n.xml "
+    "device=CPU threshold=0.4 ! queue ! "
+    "gvawatermark ! videoconvert ! jpegenc ! "
+    "filesink name=sink location=output.jpg"
 )
 pipeline = Gst.parse_launch(pipeline_str)
 
+sink = pipeline.get_by_name("sink")
+sink_pad = sink.get_static_pad("sink")
+
 
 def on_buffer(pad, info):
     buf = info.get_buffer()
@@ -216,12 +206,10 @@ def on_buffer(pad, info):
     frame = VideoFrame(buf, caps=caps)
     crowd_count = sum(1 for r in frame.regions() if r.label() == "person")
     if crowd_count:
-        print(f"Crowd count (frame): {crowd_count}", flush=True)
+        print(f"Crowd count: {crowd_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)
@@ -233,6 +221,10 @@ bus.timed_pop_filtered(
 pipeline.set_state(Gst.State.NULL)
 ```
 
+To run on integrated GPU, change `device=CPU` to `device=GPU` and add
+`vapostproc` after `jpegdec` for zero-copy color conversion.
+For NPU, change `device=CPU` to `device=NPU`.
+
 ---
 
 ## License
@@ -242,9 +234,9 @@ Licensed under the MIT License. See [LICENSE](LICENSE) for details.
 
 ## References
 
-- [YOLO11 Documentation](https://docs.ultralytics.com/models/yolo11/)
-- [OpenVINO YOLO11 Notebook](https://github.com/openvinotoolkit/openvino_notebooks/blob/latest/notebooks/yolov11-optimization/yolov11-object-detection.ipynb)
+- [YOLO26 Documentation](https://docs.ultralytics.com/models/yolo26/)
+- [OpenVINO YOLO26 Notebook](https://github.com/openvinotoolkit/openvino_notebooks/blob/latest/notebooks/yolov26-optimization/yolov26-object-detection.ipynb)
 - [COCO Dataset](https://cocodataset.org/)
 - [OpenVINO Documentation](https://docs.openvino.ai/)
 - [NNCF Post-Training Quantization](https://docs.openvino.ai/latest/nncf_ptq_introduction.html)
-- [Intel DLStreamer](https://dlstreamer.github.io/)
+- [Intel DLStreamer](https://docs.openedgeplatform.intel.com/2026.0/edge-ai-libraries/dlstreamer/index.html)

export_and_quantize.sh

@@ -2,28 +2,68 @@
 # SPDX-License-Identifier: MIT
 # Copyright (C) Intel Corporation
 #
-# Export a YOLO11 person detector for crowd detection and quantize to INT8.
-# Usage: ./export_and_quantize.sh [MODEL_VARIANT]
-# Example: ./export_and_quantize.sh yolo11n
+# Export a YOLO26 person detector for crowd detection to OpenVINO IR.
+# Usage: ./export_and_quantize.sh [MODEL_VARIANT] [PRECISION]
+# Example: ./export_and_quantize.sh yolo26n FP16
+#
+# Supported precisions:
+#   FP32  -- Full-precision floating-point weights
+#   FP16  -- Half-precision floating-point weights (default)
+#   INT8  -- Quantized 8-bit integer weights (requires NNCF)
+#
+# Precision / device compatibility:
+#   | Precision | CPU | GPU | NPU |
+#   |-----------|-----|-----|-----|
+#   | FP32      | Yes | Yes | No  |
+#   | FP16      | Yes | Yes | Yes |
+#   | INT8      | Yes | Yes | Yes |
 
 set -euo pipefail
 
-MODEL_NAME="${1:-yolo11n}"
+MODEL_NAME="${1:-yolo26n}"
+PRECISION="${2:-FP16}"
+PRECISION="$(echo "${PRECISION}" | tr '[:lower:]' '[:upper:]')"
+
+if [[ "${PRECISION}" != "FP32" && "${PRECISION}" != "FP16" && "${PRECISION}" != "INT8" ]]; then
+    echo "ERROR: unsupported precision '${PRECISION}'. Choose FP32, FP16, or INT8." >&2
+    exit 1
+fi
 
 echo "--- Installing dependencies ---"
-pip install -qU "openvino>=2026.0.0" "nncf>=3.0.0" ultralytics
+if [[ "${PRECISION}" == "INT8" ]]; then
+    pip install -qU "openvino>=2026.0.0" "nncf>=3.0.0" ultralytics
+else
+    pip install -qU "openvino>=2026.0.0" ultralytics
+fi
+
+echo "--- Downloading sample test image ---"
+if [[ ! -f test.jpg ]]; then
+    wget -q -O test.jpg https://ultralytics.com/images/bus.jpg
+    echo "Downloaded: test.jpg"
+else
+    echo "Already present: test.jpg"
+fi
 
-echo "--- Exporting ${MODEL_NAME} to OpenVINO IR (FP16) ---"
+if [[ "${PRECISION}" == "FP32" ]]; then
+    HALF_FLAG="False"
+    EXPORT_LABEL="FP32"
+else
+    HALF_FLAG="True"
+    EXPORT_LABEL="FP16"
+fi
+
+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=True, dynamic=False, imgsz=640)
+model.export(format='openvino', half=${HALF_FLAG}, dynamic=False, imgsz=640)
 print('Export complete: ${MODEL_NAME}_openvino_model/')
 "
 
-echo "--- Quantizing to INT8 with NNCF ---"
-python3 -c "
+if [[ "${PRECISION}" == "INT8" ]]; then
+    echo "--- Quantizing to INT8 with NNCF ---"
+    python3 -c "
 import nncf
 import openvino as ov
 import numpy as np
@@ -46,8 +86,5 @@ quantized = nncf.quantize(
 ov.save_model(quantized, '${MODEL_NAME}_crowd_int8.xml')
 print('Quantization complete: ${MODEL_NAME}_crowd_int8.xml')
 "
-
-echo "--- Benchmarking ---"
-benchmark_app -m "${MODEL_NAME}_crowd_int8.xml" -d CPU -niter 50 -api async
-
+fi
 echo "--- Done ---"