oriented-det 0.1.0__py3-none-any.whl

export/__init__.py

@@ -0,0 +1,9 @@
+"""Export utilities for converting OrientedDet models to other runtimes.
+
+This package is used by the `odet export-onnx` CLI command.
+"""
+
+from __future__ import annotations
+
+__all__ = []
+

export/ort_runtime.py

@@ -0,0 +1,67 @@
+"""ONNX Runtime device selection and session cache for TF export inference."""
+
+from __future__ import annotations
+
+import os
+from typing import Dict, List, Optional, Tuple
+
+_ORT_DEVICE_OVERRIDE: Optional[str] = None
+_SESSION_CACHE: Dict[Tuple[str, Tuple[str, ...]], object] = {}
+
+
+def set_ort_device(device: Optional[str]) -> None:
+    """Set runtime ORT device for this process (``cpu``, ``cuda``, ``auto``)."""
+    global _ORT_DEVICE_OVERRIDE
+    _ORT_DEVICE_OVERRIDE = device.lower().strip() if device else None
+
+
+def get_ort_device() -> str:
+    """Resolved ORT device string (override, env, or default ``cpu``)."""
+    if _ORT_DEVICE_OVERRIDE:
+        return _ORT_DEVICE_OVERRIDE
+    return (os.environ.get("ORIENTED_DET_ORT_DEVICE") or "cpu").lower().strip()
+
+
+def ort_providers_for_device(device: Optional[str] = None) -> List[str]:
+    """Map device string to ONNX Runtime ``providers`` list."""
+    import onnxruntime as ort
+
+    d = (device if device is not None else get_ort_device()).lower().strip()
+    if d in ("cuda", "gpu"):
+        if "CUDAExecutionProvider" not in ort.get_available_providers():
+            raise RuntimeError(
+                "ORT device=cuda requested but CUDAExecutionProvider is not available. "
+                "Install onnxruntime-gpu matching your CUDA driver."
+            )
+        return ["CUDAExecutionProvider", "CPUExecutionProvider"]
+    if d == "auto":
+        if "CUDAExecutionProvider" in ort.get_available_providers():
+            return ["CUDAExecutionProvider", "CPUExecutionProvider"]
+        return ["CPUExecutionProvider"]
+    if d != "cpu":
+        raise ValueError(f"Unknown ORT device {device!r}; use cpu, cuda, or auto.")
+    return ["CPUExecutionProvider"]
+
+
+def configure_ort_device(device: Optional[str]) -> List[str]:
+    """Apply device override and return the provider list that will be used."""
+    if device is not None:
+        set_ort_device(device)
+    providers = ort_providers_for_device()
+    return providers
+
+
+def clear_ort_session_cache() -> None:
+    """Drop cached ORT sessions (tests)."""
+    _SESSION_CACHE.clear()
+
+
+def get_ort_session(onnx_path: str, device: Optional[str] = None):
+    """Return a cached ``onnxruntime.InferenceSession`` for ``onnx_path``."""
+    import onnxruntime as ort
+
+    providers = ort_providers_for_device(device)
+    key = (str(onnx_path), tuple(providers))
+    if key not in _SESSION_CACHE:
+        _SESSION_CACHE[key] = ort.InferenceSession(onnx_path, providers=providers)
+    return _SESSION_CACHE[key]

export/postprocess.py

@@ -0,0 +1,151 @@
+"""Post-NMS detection finalization for TF export (exact CPU rotated NMS + score filter)."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+
+try:
+    import torch
+except Exception:  # pragma: no cover
+    torch = None  # type: ignore
+
+from export.ort_runtime import get_ort_device, get_ort_session
+from oriented_det.models.faster_rcnn_inference import PreNmsDetections, apply_final_rotated_nms
+from oriented_det.train.utils import effective_score_threshold_for_class_name
+
+
+class _NmsConfigView:
+    """Minimal attribute bag for :func:`apply_final_rotated_nms`."""
+
+    def __init__(
+        self,
+        *,
+        nms_class_agnostic: bool,
+        final_nms_iou_threshold: float,
+        max_detections_per_image: Optional[int],
+        final_nms_use_cpu: bool,
+    ) -> None:
+        self.nms_class_agnostic = nms_class_agnostic
+        self.final_nms_iou_threshold = final_nms_iou_threshold
+        self.max_detections_per_image = max_detections_per_image
+        self.final_nms_use_cpu = final_nms_use_cpu
+
+
+def finalize_detections_numpy(
+    pre_nms_boxes: np.ndarray,
+    pre_nms_scores: np.ndarray,
+    pre_nms_labels: np.ndarray,
+    pre_nms_count: int,
+    *,
+    nms_class_agnostic: bool,
+    final_nms_iou_threshold: float,
+    max_detections_per_image: Optional[int],
+    final_nms_use_cpu: bool,
+    score_threshold: float,
+    per_class_score_threshold: Optional[Dict[str, float]],
+    class_id_to_name: Dict[int, str],
+    max_output_slots: int,
+) -> Tuple[np.ndarray, int]:
+    """Run rotated NMS + production score filter; return padded ``[max_output_slots, 7]``."""
+    if torch is None:
+        raise RuntimeError("torch is required for finalize_detections_numpy")
+
+    out = np.zeros((max_output_slots, 7), dtype=np.float32)
+    n = int(pre_nms_count)
+    if n <= 0:
+        return out, 0
+
+    boxes_t = torch.from_numpy(np.asarray(pre_nms_boxes[:n], dtype=np.float32))
+    scores_t = torch.from_numpy(np.asarray(pre_nms_scores[:n], dtype=np.float32))
+    labels_t = torch.from_numpy(np.asarray(pre_nms_labels[:n], dtype=np.int64))
+
+    nms_view = _NmsConfigView(
+        nms_class_agnostic=nms_class_agnostic,
+        final_nms_iou_threshold=final_nms_iou_threshold,
+        max_detections_per_image=max_detections_per_image,
+        final_nms_use_cpu=final_nms_use_cpu,
+    )
+    final = apply_final_rotated_nms(nms_view, PreNmsDetections(boxes_t, scores_t, labels_t))
+
+    if final.boxes.numel() == 0:
+        return out, 0
+
+    keep_mask = torch.ones(final.scores.shape[0], dtype=torch.bool)
+    if per_class_score_threshold or score_threshold is not None:
+        keep_list = []
+        for i in range(int(final.scores.shape[0])):
+            lid = int(final.labels[i].item())
+            cname = class_id_to_name.get(lid, f"class_{lid}")
+            thr = effective_score_threshold_for_class_name(
+                cname, score_threshold, per_class_score_threshold
+            )
+            keep_list.append(float(final.scores[i].item()) >= thr)
+        keep_mask = torch.tensor(keep_list, dtype=torch.bool)
+
+    final_boxes = final.boxes[keep_mask]
+    final_scores = final.scores[keep_mask]
+    final_labels = final.labels[keep_mask]
+
+    m = min(int(final_boxes.shape[0]), max_output_slots)
+    if m == 0:
+        return out, 0
+
+    det = np.column_stack(
+        [
+            final_boxes[:m].cpu().numpy(),
+            final_scores[:m].cpu().numpy().reshape(-1, 1),
+            final_labels[:m].cpu().numpy().astype(np.float32).reshape(-1, 1),
+        ]
+    )
+    out[:m] = det
+    return out, m
+
+
+def build_class_id_to_name(class_names: List[str]) -> Dict[int, str]:
+    """Map 1-based foreground label id to class name."""
+    return {i + 1: name for i, name in enumerate(class_names)}
+
+
+def ort_pre_nms_to_detections(
+    images: "np.ndarray",
+    onnx_path: str,
+    ort_output_names: List[str],
+    finalize_kwargs: Dict[str, Any],
+) -> Tuple["np.ndarray", int]:
+    """ONNX Runtime forward + finalize (for TF ``numpy_function`` / Keras bundle)."""
+    import numpy as np
+
+    img = np.asarray(images, dtype=np.float32)
+    if img.ndim == 3:
+        img = img[np.newaxis, ...]
+    sess = get_ort_session(onnx_path)
+    input_name = sess.get_inputs()[0].name
+    outs = sess.run(ort_output_names, {input_name: img})
+    name_to_val = dict(zip(ort_output_names, outs))
+    detections, num = finalize_detections_numpy(
+        name_to_val["pre_nms_boxes"],
+        name_to_val["pre_nms_scores"],
+        name_to_val["pre_nms_labels"],
+        int(np.asarray(name_to_val["pre_nms_count"]).reshape(-1)[0]),
+        **finalize_kwargs,
+    )
+    return detections, int(num)
+
+
+def meta_to_finalize_kwargs(meta: Dict[str, Any]) -> Dict[str, Any]:
+    """Extract finalize_detections_numpy kwargs from export meta JSON."""
+    prod = meta.get("production") or {}
+    class_names: List[str] = list(meta.get("class_names") or [])
+    max_det = int(prod.get("max_detections_per_image") or meta.get("max_detections_per_image") or 3000)
+    return {
+        "nms_class_agnostic": bool(prod.get("nms_class_agnostic", False)),
+        "final_nms_iou_threshold": float(prod.get("final_nms_iou_threshold", 0.1)),
+        "max_detections_per_image": max_det,
+        "final_nms_use_cpu": bool(prod.get("final_nms_use_cpu", True)),
+        "score_threshold": float(prod.get("score_threshold", 0.05)),
+        "per_class_score_threshold": prod.get("per_class_score_threshold"),
+        "class_id_to_name": build_class_id_to_name(class_names),
+        "max_output_slots": max_det,
+    }

export/scripts/__init__.py

@@ -0,0 +1,6 @@
+"""Export scripts used by the `odet` CLI."""
+
+from __future__ import annotations
+
+__all__ = []
+

export/scripts/build_faster_rcnn_savedmodel.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Build e2e Faster R-CNN SavedModel (Keras + ORT core + exact rotated NMS)."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Optional
+
+_REPO_ROOT = Path(__file__).resolve().parents[2]
+if str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+from export.postprocess import meta_to_finalize_kwargs  # noqa: E402
+from export.tf_serving_model import FasterRCNNDetectLayer, save_keras_detect_bundle  # noqa: E402
+
+
+def _load_meta(meta_path: Path) -> dict:
+    return json.loads(meta_path.read_text(encoding="utf-8"))
+
+
+def _resolve_onnx_path(meta: dict, meta_path: Path, onnx_path: Optional[Path]) -> Path:
+    if onnx_path is not None and onnx_path.is_file():
+        return onnx_path
+    if meta.get("onnx_path"):
+        p = Path(meta["onnx_path"])
+        if p.is_file():
+            return p
+    candidate = meta_path.with_suffix("").with_suffix(".onnx")
+    if candidate.is_file():
+        return candidate
+    raise FileNotFoundError(
+        "ONNX file not found; pass --onnx or ensure meta onnx_path / sibling .onnx exists."
+    )
+
+
+def build_savedmodel(
+    output_path: Path,
+    meta_path: Path,
+    *,
+    onnx_path: Optional[Path] = None,
+) -> None:
+    import tensorflow as tf
+
+    meta = _load_meta(meta_path)
+    finalize_kwargs = meta_to_finalize_kwargs(meta)
+    onnx_file = _resolve_onnx_path(meta, meta_path, onnx_path)
+
+    h = int(meta["input"]["shape"][2])
+    w = int(meta["input"]["shape"][3])
+    inputs = tf.keras.Input(shape=(3, h, w), batch_size=1, name="images")
+    layer = FasterRCNNDetectLayer(
+        onnx_path=str(onnx_file.resolve()),
+        ort_output_names=list(meta.get("output_names") or []),
+        finalize_kwargs=finalize_kwargs,
+        max_output_slots=int(finalize_kwargs["max_output_slots"]),
+    )
+    layer_out = layer(inputs)
+    model = tf.keras.Model(
+        inputs=inputs,
+        outputs=[layer_out["detections"], layer_out["num_detections"]],
+    )
+
+    full_meta = dict(meta)
+    full_meta["core_backend"] = "onnxruntime_keras"
+    full_meta["onnx_path"] = str(onnx_file)
+    full_meta["savedmodel_outputs"] = {
+        "detections": {
+            "shape": [finalize_kwargs["max_output_slots"], 7],
+            "layout": "cx,cy,w,h,angle,score,label",
+        },
+        "num_detections": {"dtype": "int32"},
+    }
+
+    keras_path = save_keras_detect_bundle(model, output_path, full_meta)
+    print(f"Wrote detect bundle: {output_path} (keras: {keras_path.name}, core: onnxruntime)")
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description="Build e2e Faster R-CNN SavedModel.")
+    p.add_argument(
+        "--tf-core",
+        type=Path,
+        default=None,
+        help="Ignored (kept for CLI compatibility with README pipeline).",
+    )
+    p.add_argument("--meta", type=Path, required=True, help="*.export_meta.json from export_onnx.py.")
+    p.add_argument("--onnx", type=Path, default=None, help="ONNX file (default: from meta / sibling).")
+    p.add_argument("--output", type=Path, required=True, help="Output SavedModel directory.")
+    args = p.parse_args()
+
+    try:
+        import tensorflow as tf  # noqa: F401
+    except ImportError as e:
+        print("Install TensorFlow: pip install -r export/requirements-export.txt", file=sys.stderr)
+        raise SystemExit(1) from e
+
+    build_savedmodel(args.output, args.meta, onnx_path=args.onnx)
+
+
+if __name__ == "__main__":
+    main()

export/scripts/export_onnx.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""Export a tensor-only subgraph from oriented-det to ONNX.
+
+See export/README.md and export/contract.json for supported modes.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+import torch
+
+_REPO_ROOT = Path(__file__).resolve().parents[2]
+_EXPORT_DIR = _REPO_ROOT / "export"
+if str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+if str(_EXPORT_DIR) not in sys.path:
+    sys.path.insert(0, str(_EXPORT_DIR))
+
+import wrappers as _wrappers  # noqa: E402
+from oriented_det.models.oriented_rcnn import RotatedFasterRCNN  # noqa: E402
+from oriented_det.models.rotated_retinanet import RotatedRetinaNet  # noqa: E402
+from oriented_det.runtime.checkpoint import load_model_from_checkpoint  # noqa: E402
+
+BackboneExportWrapper = _wrappers.BackboneExportWrapper
+RetinaNetBackboneHeadExportWrapper = _wrappers.RetinaNetBackboneHeadExportWrapper
+RotatedFasterRCNNPreNmsExportWrapper = _wrappers.RotatedFasterRCNNPreNmsExportWrapper
+
+FASTER_RCNN_PRE_NMS_OUTPUTS = (
+    "pre_nms_boxes",
+    "pre_nms_scores",
+    "pre_nms_labels",
+    "pre_nms_count",
+)
+
+
+def _build_wrapper(
+    model: torch.nn.Module,
+    mode: str,
+    height: int,
+    width: int,
+) -> torch.nn.Module:
+    mt = type(model).__name__
+    if mode == "backbone":
+        if not hasattr(model, "backbone"):
+            raise ValueError(f"Model {mt} has no 'backbone' attribute.")
+        return BackboneExportWrapper(model.backbone)
+    if mode == "retinanet_heads":
+        if not isinstance(model, RotatedRetinaNet):
+            raise ValueError(
+                f"retinanet_heads mode requires RotatedRetinaNet, got {mt}. "
+                "Use --mode backbone for two-stage models."
+            )
+        return RetinaNetBackboneHeadExportWrapper(model)
+    if mode == "faster_rcnn_pre_nms":
+        if not isinstance(model, RotatedFasterRCNN):
+            raise ValueError(
+                f"faster_rcnn_pre_nms requires RotatedFasterRCNN, got {mt}."
+            )
+        return RotatedFasterRCNNPreNmsExportWrapper(model, height=height, width=width)
+    raise ValueError(f"Unknown mode: {mode}")
+
+
+def _output_names_for_wrapper(
+    wrapper: torch.nn.Module,
+    mode: str,
+    device: torch.device,
+    height: int,
+    width: int,
+) -> list[str]:
+    if mode == "faster_rcnn_pre_nms":
+        return list(FASTER_RCNN_PRE_NMS_OUTPUTS)
+
+    dummy = torch.zeros(1, 3, 128, 128, dtype=torch.float32, device=device)
+    with torch.no_grad():
+        out = wrapper(dummy)
+    names: list[str] = []
+    if mode == "backbone":
+        for i in range(len(out)):
+            names.append(f"fpn_level_{i}")
+        return names
+    if mode == "retinanet_heads":
+        for i in range(len(out) // 2):
+            names.append(f"level{i}_cls_logits")
+            names.append(f"level{i}_bbox_pred")
+        return names
+    return [f"out_{i}" for i in range(len(out))]
+
+
+def _production_dict(config: Any) -> dict | None:
+    prod = getattr(config, "production", None)
+    if prod is None:
+        return None
+    if hasattr(prod, "__dataclass_fields__"):
+        return asdict(prod)
+    if isinstance(prod, dict):
+        return prod
+    return None
+
+
+def _validate_onnx_ort(onnx_path: Path, dummy: torch.Tensor, output_names: list[str]) -> None:
+    try:
+        import onnx
+        import onnxruntime as ort
+    except ImportError:
+        print("Skipping ORT validation (install onnx and onnxruntime).")
+        return
+
+    onnx.checker.check_model(onnx.load(str(onnx_path)))
+    sess = ort.InferenceSession(str(onnx_path), providers=["CPUExecutionProvider"])
+    feeds = {"images": dummy.detach().cpu().numpy()}
+    outs = sess.run(output_names, feeds)
+    print(f"ORT smoke OK: {len(outs)} outputs")
+    for name, arr in zip(output_names, outs):
+        print(f"  {name}: shape={arr.shape} dtype={arr.dtype}")
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description="Export oriented-det subgraph to ONNX.")
+    p.add_argument("--config", type=Path, required=True, help="Training JSON config path.")
+    p.add_argument("--checkpoint", type=Path, required=True, help="Weights .pth path.")
+    p.add_argument("--output", type=Path, required=True, help="Output .onnx file path.")
+    p.add_argument("--height", type=int, default=1024)
+    p.add_argument("--width", type=int, default=1024)
+    p.add_argument(
+        "--mode",
+        choices=("backbone", "retinanet_heads", "faster_rcnn_pre_nms"),
+        default="backbone",
+        help="backbone | retinanet_heads | faster_rcnn_pre_nms (Rotated Faster R-CNN detect).",
+    )
+    p.add_argument("--opset", type=int, default=17)
+    p.add_argument(
+        "--dynamic-batch",
+        action="store_true",
+        help="Allow dynamic batch size (N) on input images; H and W stay fixed.",
+    )
+    p.add_argument(
+        "--skip-ort",
+        action="store_true",
+        help="Skip onnxruntime validation after export.",
+    )
+    p.add_argument("--device", default="cpu", help="Device to trace on (cpu recommended for reproducibility).")
+    args = p.parse_args()
+
+    model, config, class_names = load_model_from_checkpoint(
+        str(args.checkpoint),
+        str(args.config),
+        device=args.device,
+    )
+    h, w = int(args.height), int(args.width)
+    wrapper = _build_wrapper(model, args.mode, h, w)
+    wrapper.eval()
+    wrapper.to(args.device)
+
+    dev = torch.device(args.device)
+    out_names = _output_names_for_wrapper(wrapper, args.mode, dev, h, w)
+    dummy = torch.zeros(1, 3, h, w, dtype=torch.float32, device=dev)
+
+    dynamic_axes = None
+    if args.dynamic_batch:
+        dynamic_axes = {"images": {0: "batch"}}
+        for name in out_names:
+            dynamic_axes[name] = {0: "batch"}
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    torch.onnx.export(
+        wrapper,
+        dummy,
+        str(args.output),
+        input_names=["images"],
+        output_names=out_names,
+        dynamic_axes=dynamic_axes,
+        opset_version=int(args.opset),
+        do_constant_folding=True,
+    )
+
+    meta: dict[str, Any] = {
+        "mode": args.mode,
+        "input": {"name": "images", "shape": [1, 3, h, w], "dtype": "float32"},
+        "output_names": out_names,
+        "opset": args.opset,
+        "dynamic_batch": args.dynamic_batch,
+        "config": str(args.config),
+        "checkpoint": str(args.checkpoint),
+        "class_names": class_names or [],
+        "num_classes": int(getattr(config, "num_classes", 0) or 0),
+        "production": _production_dict(config),
+    }
+    if args.mode == "faster_rcnn_pre_nms" and isinstance(wrapper, RotatedFasterRCNNPreNmsExportWrapper):
+        meta["max_pre_nms_candidates"] = wrapper.max_candidates
+        prod = meta.get("production") or {}
+        meta["max_detections_per_image"] = prod.get("max_detections_per_image")
+
+    meta["onnx_path"] = str(args.output.resolve())
+    meta_path = args.output.with_suffix(".export_meta.json")
+    meta_path.write_text(json.dumps(meta, indent=2), encoding="utf-8")
+    print(f"Wrote ONNX: {args.output}")
+    print(f"Wrote meta: {meta_path}")
+
+    if not args.skip_ort:
+        _validate_onnx_ort(args.output, dummy, out_names)
+
+
+if __name__ == "__main__":
+    main()

export/scripts/onnx_to_savedmodel.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""Convert ONNX to TensorFlow SavedModel using onnx2tf."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+def _find_onnx2tf() -> list[str]:
+    exe = shutil.which("onnx2tf")
+    if exe:
+        return [exe]
+    return [sys.executable, "-m", "onnx2tf"]
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description="ONNX → SavedModel via onnx2tf.")
+    p.add_argument("--onnx", type=Path, required=True)
+    p.add_argument("--output", type=Path, required=True, help="Output directory for SavedModel.")
+    args = p.parse_args()
+
+    # tf_converter can fail on some ops (e.g. ScatterND); flatbuffer_direct still useful for TFLite.
+    # build_faster_rcnn_savedmodel.py falls back to ONNX Runtime when no saved_model.pb is found.
+    cmd = _find_onnx2tf() + ["-i", str(args.onnx), "-o", str(args.output), "-osd"]
+    print("Running:", " ".join(cmd))
+    subprocess.run(cmd, check=True)
+    print(f"SavedModel directory: {args.output}")
+
+
+if __name__ == "__main__":
+    main()

export/scripts/predict_savedmodel.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Smoke-test an export detect bundle (keras_model.keras) or legacy TF SavedModel."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+_REPO_ROOT = Path(__file__).resolve().parents[2]
+if str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+
+def _run_keras_bundle(bundle_dir: Path, height: int, width: int, ort_device: str | None) -> None:
+    import tensorflow as tf
+
+    from export.ort_runtime import configure_ort_device, get_ort_device
+    from export.tf_serving_model import load_keras_detect_model
+
+    providers = configure_ort_device(ort_device)
+    print(f"  ort_device: {get_ort_device()}  providers: {providers}")
+
+    keras_path = bundle_dir / "keras_model.keras"
+    if not keras_path.is_file():
+        raise FileNotFoundError(f"Missing {keras_path}")
+    model = load_keras_detect_model(keras_path)
+    x = tf.zeros([1, 3, height, width], dtype=tf.float32)
+    detections, num_detections = model(x, training=False)
+    print(f"  detections: shape={detections.shape} dtype={detections.dtype}")
+    print(f"  num_detections: {int(num_detections.numpy())}")
+    meta_path = bundle_dir / "export_meta.json"
+    if meta_path.is_file():
+        meta = json.loads(meta_path.read_text(encoding="utf-8"))
+        print(f"  core_backend: {meta.get('core_backend', 'unknown')}")
+
+
+def _run_saved_model(sm_dir: Path, height: int, width: int) -> None:
+    import tensorflow as tf
+
+    sm = tf.saved_model.load(str(sm_dir))
+    sigs = list(getattr(sm, "signatures", {}).keys())
+    print("Signatures:", sigs)
+    name = "serving_default" if "serving_default" in sigs else sigs[0]
+    fn = sm.signatures[name]
+
+    kwargs = {}
+    _pos, kw = fn.structured_input_signature
+    if kw:
+        for key, spec in kw.items():
+            if spec.dtype.is_floating and spec.shape.rank == 4:
+                shape = [1, 3, height, width]
+                kwargs[key] = tf.zeros(shape, dtype=spec.dtype)
+    if not kwargs:
+        raise SystemExit("Could not infer image input from SavedModel signature.")
+    out = fn(**kwargs)
+    for k, v in out.items():
+        print(f"  {k}: shape={v.shape} dtype={v.dtype}")
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description="Smoke-test export detect bundle or SavedModel.")
+    p.add_argument(
+        "--saved-model",
+        type=Path,
+        required=True,
+        help="Directory with keras_model.keras (+ export_meta.json) or TF SavedModel.",
+    )
+    p.add_argument("--height", type=int, default=1024)
+    p.add_argument("--width", type=int, default=1024)
+    p.add_argument(
+        "--ort-device",
+        default=None,
+        choices=("cpu", "cuda", "auto"),
+        help="ONNX Runtime EP for keras bundle (default: cpu or ORIENTED_DET_ORT_DEVICE).",
+    )
+    args = p.parse_args()
+
+    try:
+        import tensorflow as tf  # noqa: F401
+    except ImportError as e:
+        print("Install TensorFlow: pip install -r export/requirements-export.txt", file=sys.stderr)
+        raise SystemExit(1) from e
+
+    bundle = args.saved_model
+    if (bundle / "keras_model.keras").is_file():
+        _run_keras_bundle(bundle, args.height, args.width, args.ort_device)
+    else:
+        _run_saved_model(bundle, args.height, args.width)
+
+
+if __name__ == "__main__":
+    main()