@camstack/addon-pipeline 1.2.622 → 1.2.624

package/python/accelerator_facts.py

@@ -0,0 +1,275 @@
+"""Per-accelerator compute the Auto tune estimate scales from (D930).
+
+OpenVINO devices are enumerated here — the same place the pool already asks
+`available_devices` — and an AMD WebGPU adapter is read when the plugin
+exposes one. A query that fails is ``None``, never ``0`` (D393): zero would
+scale the device as if it had no compute.
+
+The pool publishes the list to the temp file the platform probe reads back
+onto ``HardwareInfo.accelerators``. Importing this module does not import
+OpenVINO or ONNX Runtime.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import tempfile
+from typing import Any, Optional
+
+# One file per host. The inference worker writes it; platform-probe reads it.
+# Two pools (GPU and NPU) merge by deviceKey.
+FACTS_FILENAME = "camstack-accelerator-facts.json"
+
+_GOPS_INT8 = ("i8", "int8", "u8", "bin")
+_GOPS_FP16 = ("f16", "fp16", "bf16")
+_CLOCK_PROPERTIES = (
+    "GPU_DEVICE_MAX_FREQUENCY",
+    "GPU_MAX_FREQUENCY",
+    "GPU_FREQUENCY",
+)
+_TOPS_PROPERTIES = ("NPU_MAX_TOPS", "DEVICE_TOPS")
+_CU_ATTRIBUTES = ("compute_units", "cu_count", "max_compute_units")
+_VENDOR_ATTRIBUTES = ("vendor", "vendor_name", "vendorName")
+_ARCH_ATTRIBUTES = ("architecture", "arch")
+_DEVICE_ATTRIBUTES = ("device", "device_name", "name", "description")
+
+
+def facts_path() -> str:
+    return os.path.join(tempfile.gettempdir(), FACTS_FILENAME)
+
+
+def _positive(value: Any) -> Optional[float]:
+    """A reported number, or None when the query failed or answered <= 0."""
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    number = float(value)
+    if number <= 0 or number != number:  # NaN
+        return None
+    return number
+
+
+def _text(value: Any) -> Optional[str]:
+    if not isinstance(value, str):
+        return None
+    stripped = value.strip()
+    return stripped or None
+
+
+def _blank(device_key: str) -> dict:
+    return {
+        "deviceKey": device_key,
+        "fullDeviceName": None,
+        "executionUnits": None,
+        "clockMHz": None,
+        "gops": None,
+        "architecture": None,
+        "npuName": None,
+        "tops": None,
+        "vendor": None,
+        "webgpuArchitecture": None,
+        "webgpuDevice": None,
+        "computeUnits": None,
+    }
+
+
+def _property(core: Any, device: str, name: str) -> Any:
+    try:
+        return core.get_property(device, name)
+    except Exception:
+        return None
+
+
+def _first_property(core: Any, device: str, names: tuple) -> Any:
+    for name in names:
+        value = _property(core, device, name)
+        if value is not None:
+            return value
+    return None
+
+
+def _gops(raw: Any) -> Optional[dict]:
+    """``DEVICE_GOPS`` as ``{int8, fp16}``. None when the query itself failed."""
+    if raw is None:
+        return None
+    try:
+        items = list(raw.items())
+    except Exception:
+        return None
+    int8 = None
+    fp16 = None
+    for key, value in items:
+        name = str(key).lower().rsplit(".", 1)[-1]
+        if name in _GOPS_INT8:
+            int8 = _positive(value)
+        elif name in _GOPS_FP16:
+            fp16 = _positive(value)
+    return {"int8": int8, "fp16": fp16}
+
+
+def _device_key(ov_name: str, index: int) -> Optional[str]:
+    upper = ov_name.upper()
+    if "NPU" in upper:
+        kind = "npu"
+    elif "GPU" in upper:
+        kind = "gpu"
+    else:
+        return None
+    if index == 0:
+        return f"openvino:{kind}"
+    return f"openvino:{kind}:{index}"
+
+
+def collect_openvino_device_facts(core: Any) -> Optional[list]:
+    """One record per GPU and NPU. None when the device list itself failed."""
+    try:
+        available = list(core.available_devices)
+    except Exception:
+        return None
+    seen = {"gpu": 0, "npu": 0}
+    facts: list = []
+    for ov_name in available:
+        upper = str(ov_name).upper()
+        if "NPU" in upper:
+            kind = "npu"
+        elif "GPU" in upper:
+            kind = "gpu"
+        else:
+            continue
+        key = _device_key(str(ov_name), seen[kind])
+        seen[kind] += 1
+        if key is None:
+            continue
+        record = _blank(key)
+        name = _text(_property(core, ov_name, "FULL_DEVICE_NAME"))
+        record["fullDeviceName"] = name
+        record["architecture"] = _text(_property(core, ov_name, "DEVICE_ARCHITECTURE"))
+        record["gops"] = _gops(_property(core, ov_name, "DEVICE_GOPS"))
+        if kind == "gpu":
+            record["executionUnits"] = _positive(
+                _property(core, ov_name, "GPU_EXECUTION_UNITS_COUNT")
+            )
+            record["clockMHz"] = _positive(_first_property(core, ov_name, _CLOCK_PROPERTIES))
+        else:
+            record["npuName"] = name
+            record["tops"] = _positive(_first_property(core, ov_name, _TOPS_PROPERTIES))
+        facts.append(record)
+        sys.stderr.write(
+            f"accelerator facts: {key} name={name} "
+            f"eu={record['executionUnits']} clockMHz={record['clockMHz']} "
+            f"gops={record['gops']} arch={record['architecture']} tops={record['tops']}\n"
+        )
+        sys.stderr.flush()
+    return facts
+
+
+def _attr(obj: Any, names: tuple) -> Any:
+    if obj is None:
+        return None
+    if isinstance(obj, dict):
+        for name in names:
+            if name in obj and obj[name] is not None:
+                return obj[name]
+        return None
+    for name in names:
+        if hasattr(obj, name):
+            value = getattr(obj, name)
+            if value is not None:
+                return value
+    return None
+
+
+def webgpu_facts_from_device(device: Any) -> Optional[dict]:
+    """Adapter fields off an ORT / Dawn device. None when there is no device."""
+    if device is None:
+        return None
+    record = _blank("onnx:webgpu")
+    record["vendor"] = _text(_attr(device, _VENDOR_ATTRIBUTES))
+    record["webgpuArchitecture"] = _text(_attr(device, _ARCH_ATTRIBUTES))
+    record["webgpuDevice"] = _text(_attr(device, _DEVICE_ATTRIBUTES))
+    record["computeUnits"] = _positive(_attr(device, _CU_ATTRIBUTES))
+    return record
+
+
+def publish_accelerator_facts(facts: list, path: Optional[str] = None) -> None:
+    """Merge ``facts`` into the published file by deviceKey. Atomic replace."""
+    target = path if path is not None else facts_path()
+    current: list = []
+    try:
+        with open(target, "r", encoding="utf-8") as handle:
+            payload = json.load(handle)
+        if isinstance(payload, dict) and isinstance(payload.get("accelerators"), list):
+            current = [row for row in payload["accelerators"] if isinstance(row, dict)]
+    except (OSError, ValueError):
+        current = []
+    by_key = {row.get("deviceKey"): row for row in current if isinstance(row.get("deviceKey"), str)}
+    for row in facts:
+        key = row.get("deviceKey")
+        if isinstance(key, str):
+            by_key[key] = row
+    merged = [by_key[key] for key in sorted(by_key)]
+    tmp = f"{target}.tmp-{os.getpid()}"
+    with open(tmp, "w", encoding="utf-8") as handle:
+        json.dump({"accelerators": merged}, handle)
+    os.replace(tmp, target)
+
+
+def facts_for_runtime(runtime: str, runtime_lib: Any, device: str) -> Optional[list]:
+    """Facts for the runtime this pool just initialised. None when it cannot ask."""
+    if runtime == "openvino":
+        return collect_openvino_device_facts(runtime_lib)
+    if runtime == "onnxruntime" and device.strip().lower() == "webgpu":
+        one = _probe_webgpu_adapter()
+        return None if one is None else [one]
+    return None
+
+
+def _probe_webgpu_adapter() -> Optional[dict]:
+    """Best-effort adapter read. None when the plugin or the device is absent."""
+    try:
+        import onnxruntime as ort
+        import onnxruntime_ep_webgpu as webgpu_ep
+    except Exception:
+        return None
+    try:
+        ep_name = webgpu_ep.get_ep_name()
+        device = next(
+            (item for item in ort.get_ep_devices() if getattr(item, "ep_name", None) == ep_name),
+            None,
+        )
+    except Exception:
+        return None
+    return webgpu_facts_from_device(device)
+
+
+def _probe_openvino() -> Optional[list]:
+    try:
+        from openvino import Core
+    except Exception as exc:
+        sys.stderr.write(f"accelerator facts: OpenVINO unavailable ({exc})\n")
+        sys.stderr.flush()
+        return None
+    try:
+        return collect_openvino_device_facts(Core())
+    except Exception as exc:
+        sys.stderr.write(f"accelerator facts: OpenVINO probe failed ({exc})\n")
+        sys.stderr.flush()
+        return None
+
+
+def main() -> int:
+    """Print ``{"accelerators": ...}``. ``null`` when nothing could be asked."""
+    ov = _probe_openvino()
+    web = _probe_webgpu_adapter()
+    if ov is None and web is None:
+        sys.stdout.write(json.dumps({"accelerators": None}) + "\n")
+        return 0
+    facts = [] if ov is None else list(ov)
+    if web is not None:
+        facts.append(web)
+    sys.stdout.write(json.dumps({"accelerators": facts}) + "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/python/inference_pool.py

@@ -3150,7 +3150,21 @@ async def _run() -> None:
     )
     sys.stderr.flush()
 
-    await writer.send(req_id, {
+    # Compute the estimate scales from (D930). A failed probe is omitted —
+    # never a row of zeros — and must not delay `ready`.
+    accelerator_facts = None
+    try:
+        from accelerator_facts import facts_for_runtime, publish_accelerator_facts
+
+        accelerator_facts = facts_for_runtime(runtime, _runtime_lib, pool_device)
+        if accelerator_facts:
+            publish_accelerator_facts(accelerator_facts)
+    except Exception as exc:
+        sys.stderr.write(f"accelerator facts: probe failed ({exc})\n")
+        sys.stderr.flush()
+        accelerator_facts = None
+
+    ready_payload = {
         "status": "ready",
         "models": loaded_count,
         "total": len(models),
@@ -3161,7 +3175,10 @@ async def _run() -> None:
         # the same min() against what it declared, so both ends derive the
         # identical effective version (D350).
         "protocolVersion": PROTOCOL_VERSION,
-    })
+    }
+    if accelerator_facts is not None:
+        ready_payload["acceleratorFacts"] = accelerator_facts
+    await writer.send(req_id, ready_payload)
 
     # ── Window accumulator (per-model) ──────────────────────────────
     #

package/python/postprocessors/ssd.py

@@ -6,7 +6,9 @@ SSD MobileNet V2 and EfficientDet-Lite detectors. Those models embed the
 decoded (boxes + per-box class + score, post-NMS):
 
     output 0  boxes    [1, N, 4]  (ymin, xmin, ymax, xmax) normalised 0..1
-    output 1  classes  [1, N]     float class indices (COCO 90-class map)
+    output 1  classes  [1, N]     float class indices (COCO 90-class map,
+                                     or the model's own label list when the
+                                     descriptor carries one)
     output 2  scores   [1, N]     float 0..1
     output 3  count    [1]        number of valid detections
 
@@ -118,8 +120,10 @@ def _split_outputs(predictions: dict) -> tuple:
     return boxes, classes, scores, count
 
 
-def label_for_class(cls: int) -> str:
-    """COCO-90 label of a raw class index; ``"n/a"`` for a gap, ``str`` if outside."""
+def label_for_class(cls: int, labels: list | None = None) -> str:
+    """Class name for a raw index; default map is COCO-90 when labels is absent/empty."""
+    if labels:
+        return labels[cls] if 0 <= cls < len(labels) else str(cls)
     return COCO_90[cls] if 0 <= cls < len(COCO_90) else str(cls)
 
 
@@ -134,6 +138,10 @@ def postprocess_ssd(
     """Decode SSD/EfficientDet postprocess outputs to original-frame detections."""
     conf_threshold = float(config.get("confidence", 0.4) or 0.4)
     input_size = int(config.get("inputSize", 300) or 300)
+    raw_labels = config.get("labels")
+    label_map: list | None = (
+        list(raw_labels) if isinstance(raw_labels, list) and len(raw_labels) > 0 else None
+    )
 
     boxes, classes, scores, count = _split_outputs(predictions)
     if boxes is None or scores is None:
@@ -172,7 +180,7 @@ def postprocess_ssd(
         y2 = max(0.0, min(y2, orig_h))
         if x2 <= x1 or y2 <= y1:
             continue
-        label = label_for_class(int(classes[i]))
+        label = label_for_class(int(classes[i]), label_map)
         if label == "n/a":
             continue
         detections.append({

package/python/postprocessors/test_ssd.py

@@ -189,6 +189,70 @@ class ScoreCeilingTest(unittest.TestCase):
         self.assertEqual(len([d for d in _decode(STREET, confidence=0.65) if d["class"] == "person"]), 3)
 
 
+class ConfigLabelsTest(unittest.TestCase):
+    """Custom label maps from the pool; absent labels keep COCO-90 in Python."""
+
+    _SYNTH = {
+        "0": [[[0.1, 0.1, 0.5, 0.5]]],
+        "1": [[3.0]],
+        "2": [[0.9]],
+        "3": [1.0],
+    }
+
+    def test_custom_labels_name_classes(self) -> None:
+        # Index 3 is dog and index 29 is car — the Plus map the COCO-90 table misnames.
+        labels = ["person", "bicycle", "x", "dog"] + ["pad"] * 25 + ["car"]
+        self.assertEqual(labels[3], "dog")
+        self.assertEqual(labels[29], "car")
+        dog = postprocess_ssd(
+            self._SYNTH,
+            {"confidence": 0.4, "inputSize": 100, "labels": labels},
+            100,
+            100,
+            1.0,
+            (0, 0),
+        )["detections"]
+        self.assertEqual(len(dog), 1)
+        self.assertEqual(dog[0]["class"], "dog")
+        car_out = dict(self._SYNTH)
+        car_out["1"] = [[29.0]]
+        car = postprocess_ssd(
+            car_out,
+            {"confidence": 0.4, "inputSize": 100, "labels": labels},
+            100,
+            100,
+            1.0,
+            (0, 0),
+        )["detections"]
+        self.assertEqual(len(car), 1)
+        self.assertEqual(car[0]["class"], "car")
+
+    def test_no_labels_key_uses_coco90_and_skips_na(self) -> None:
+        out = dict(self._SYNTH)
+        out["1"] = [[29.0]]
+        dets = postprocess_ssd(
+            out,
+            {"confidence": 0.4, "inputSize": 100},
+            100,
+            100,
+            1.0,
+            (0, 0),
+        )["detections"]
+        self.assertEqual(dets, [])
+        out2 = dict(self._SYNTH)
+        out2["1"] = [[3.0]]
+        dets2 = postprocess_ssd(
+            out2,
+            {"confidence": 0.4, "inputSize": 100},
+            100,
+            100,
+            1.0,
+            (0, 0),
+        )["detections"]
+        self.assertEqual(len(dets2), 1)
+        self.assertEqual(dets2[0]["class"], "motorcycle")
+
+
 class NumpyInputTest(unittest.TestCase):
     """The pool hands ndarrays; they must decode exactly like the lists above."""
 

package/python/test_accelerator_facts.py

@@ -0,0 +1,105 @@
+"""Unit tests for accelerator compute facts (D930). No OpenVINO import."""
+import json
+import os
+import tempfile
+import unittest
+
+import accelerator_facts as facts
+
+
+class _Core:
+    def __init__(self, devices, props):
+        self.available_devices = devices
+        self._props = props
+        self.failed = set()
+
+    def get_property(self, device, name):
+        if (device, name) in self.failed:
+            raise RuntimeError(f"probe failed {device} {name}")
+        device_props = self._props.get(device, {})
+        if name not in device_props:
+            raise KeyError(name)
+        return device_props[name]
+
+
+class OpenVinoFactsTest(unittest.TestCase):
+    def test_reports_gpu_and_npu_and_null_for_a_failed_query(self):
+        core = _Core(
+            ["CPU", "GPU", "NPU"],
+            {
+                "GPU": {
+                    "FULL_DEVICE_NAME": "Intel(R) Graphics",
+                    "GPU_EXECUTION_UNITS_COUNT": 32,
+                    "GPU_DEVICE_MAX_FREQUENCY": 1250,
+                    "DEVICE_GOPS": {"i8": 400, "f16": 200},
+                    "DEVICE_ARCHITECTURE": "Xe",
+                },
+                "NPU": {
+                    "FULL_DEVICE_NAME": "Intel AI Boost",
+                    "DEVICE_ARCHITECTURE": "NPU",
+                    "NPU_MAX_TOPS": 10,
+                },
+            },
+        )
+        core.failed.add(("GPU", "DEVICE_ARCHITECTURE"))
+        rows = facts.collect_openvino_device_facts(core)
+        self.assertEqual([row["deviceKey"] for row in rows], ["openvino:gpu", "openvino:npu"])
+        gpu = rows[0]
+        self.assertEqual(gpu["executionUnits"], 32)
+        self.assertEqual(gpu["clockMHz"], 1250)
+        self.assertEqual(gpu["gops"], {"int8": 400, "fp16": 200})
+        self.assertIsNone(gpu["architecture"])
+        self.assertEqual(rows[1]["npuName"], "Intel AI Boost")
+        self.assertEqual(rows[1]["tops"], 10)
+        self.assertIsNone(rows[1]["executionUnits"])
+
+    def test_a_zero_eu_count_is_null(self):
+        core = _Core(
+            ["GPU"],
+            {"GPU": {"FULL_DEVICE_NAME": "Intel", "GPU_EXECUTION_UNITS_COUNT": 0}},
+        )
+        rows = facts.collect_openvino_device_facts(core)
+        self.assertIsNone(rows[0]["executionUnits"])
+        self.assertIsNone(rows[0]["gops"])
+
+    def test_a_failed_device_list_is_none(self):
+        class Boom:
+            @property
+            def available_devices(self):
+                raise RuntimeError("no core")
+
+        self.assertIsNone(facts.collect_openvino_device_facts(Boom()))
+
+
+class WebGpuFactsTest(unittest.TestCase):
+    def test_reads_adapter_fields_and_leaves_a_missing_cu_null(self):
+        row = facts.webgpu_facts_from_device(
+            {"vendor": "amd", "architecture": "rdna3", "device": "gfx1103"}
+        )
+        self.assertEqual(row["deviceKey"], "onnx:webgpu")
+        self.assertEqual(row["vendor"], "amd")
+        self.assertEqual(row["webgpuArchitecture"], "rdna3")
+        self.assertEqual(row["webgpuDevice"], "gfx1103")
+        self.assertIsNone(row["computeUnits"])
+        self.assertIsNone(facts.webgpu_facts_from_device(None))
+
+
+class PublishTest(unittest.TestCase):
+    def test_merges_by_device_key(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = os.path.join(directory, "facts.json")
+            facts.publish_accelerator_facts(
+                [facts.webgpu_facts_from_device({"vendor": "amd", "compute_units": 12})],
+                path,
+            )
+            gpu = facts._blank("openvino:gpu")
+            gpu["executionUnits"] = 24
+            facts.publish_accelerator_facts([gpu], path)
+            with open(path, "r", encoding="utf-8") as handle:
+                payload = json.load(handle)
+            keys = [row["deviceKey"] for row in payload["accelerators"]]
+            self.assertEqual(keys, ["onnx:webgpu", "openvino:gpu"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/webgpu_isolated.py

@@ -139,6 +139,24 @@ def _read_msg(stream: BinaryIO) -> Any:
     return pickle.loads(data)
 
 
+def _publish_webgpu_facts(device: Any) -> None:
+    """Record adapter compute for the estimate. A failure leaves the session up."""
+    try:
+        from accelerator_facts import publish_accelerator_facts, webgpu_facts_from_device
+
+        row = webgpu_facts_from_device(device)
+        if row is not None:
+            publish_accelerator_facts([row])
+            sys.stderr.write(
+                f"ONNX WebGPU: adapter vendor={row['vendor']} arch={row['webgpuArchitecture']} "
+                f"device={row['webgpuDevice']} cu={row['computeUnits']}\n"
+            )
+            sys.stderr.flush()
+    except Exception as exc:
+        sys.stderr.write(f"ONNX WebGPU: adapter facts unavailable ({exc})\n")
+        sys.stderr.flush()
+
+
 def load_onnx_webgpu_session(
     ort: Any,
     path: str,
@@ -194,6 +212,7 @@ def load_onnx_webgpu_session(
     sess_options.add_provider_for_devices([webgpu_device], {})
     session = ort.InferenceSession(path, sess_options=sess_options)
     active = list(session.get_providers())
+    _publish_webgpu_facts(webgpu_device)
     sys.stderr.write(
         f"ONNX WebGPU: providers={active} ep={ep_name} device=webgpu "
         f"render-node=ok {_identity()}\n"