File size: 5,905 Bytes
beb4f15 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 | """ONNX Runtime inference wrapper for Fiberpose models."""
from __future__ import annotations
import logging
import os
from typing import Any, Optional
import numpy as np
import onnxruntime as ort
logger = logging.getLogger(__name__)
def get_available_providers() -> list[str]:
"""Return providers reported by the local ONNX Runtime build."""
try:
return list(ort.get_available_providers())
except Exception:
logger.exception("Failed to query ONNX Runtime providers")
return ["CPUExecutionProvider"]
def onnx_cuda_available() -> bool:
"""Return whether ONNX Runtime exposes CUDAExecutionProvider."""
return "CUDAExecutionProvider" in get_available_providers()
def _resolve_providers(device: Optional[str]) -> list[str]:
requested = str(device or "cpu").strip().lower()
available = get_available_providers()
if requested == "cuda":
if "CUDAExecutionProvider" in available:
return ["CUDAExecutionProvider", "CPUExecutionProvider"]
logger.warning("Requested CUDA but CUDAExecutionProvider is unavailable; falling back to CPU.")
return ["CPUExecutionProvider"]
class OnnxFiberposeModel:
"""ONNX-only inference wrapper used by runtime analysis."""
def __init__(
self,
model_path: str,
*,
device: str = "cpu",
nout: int | None = None,
nbase: str = "1,32,64,128,256",
stride: int | None = None,
**_: Any,
):
if not os.path.isfile(model_path):
raise FileNotFoundError(f"Model not found: {model_path}")
providers = _resolve_providers(device)
self.device = "cuda" if providers and providers[0] == "CUDAExecutionProvider" else "cpu"
self.providers = providers
self.session = ort.InferenceSession(model_path, providers=providers)
inputs = self.session.get_inputs()
if not inputs:
raise ValueError(f"ONNX model has no inputs: {model_path}")
self.input_name = str(inputs[0].name)
self.input_channels = self._infer_input_channels(inputs[0].shape)
self.output_name = str(self.session.get_outputs()[0].name)
self.nout = int(nout) if nout is not None else None
self.nbase_str = nbase
self.stride = int(stride) if stride is not None else self._infer_stride_from_nbase(nbase)
logger.info(
"Loaded ONNX model '%s' with providers=%s input='%s' output='%s' stride=%d",
model_path,
providers,
self.input_name,
self.output_name,
self.stride,
)
@staticmethod
def _infer_input_channels(shape: Any) -> int:
if isinstance(shape, (list, tuple)) and len(shape) >= 2:
ch = shape[1]
if isinstance(ch, int) and ch > 0:
return int(ch)
return 1
@staticmethod
def _infer_stride_from_nbase(nbase: str) -> int:
try:
levels = [int(p.strip()) for p in str(nbase).split(",") if p.strip()]
downs = max(0, len(levels) - 1)
return int(2 ** downs)
except Exception:
return 16
def predict(self, img: np.ndarray) -> tuple[np.ndarray, np.ndarray | None]:
"""Return `(dt, foreground_prob)`, with foreground only for `nout == 2`."""
arr = self._prep_input(img, self.input_channels)
x = arr[None, ...].astype(np.float32, copy=False)
outputs = self.session.run([self.output_name], {self.input_name: x})
if not outputs:
raise RuntimeError("ONNX Runtime returned no outputs.")
y = np.asarray(outputs[0])
if y.ndim != 4:
raise ValueError(f"Unexpected ONNX output shape: {y.shape}")
resolved_nout = int(self.nout) if self.nout is not None else int(y.shape[1])
if resolved_nout <= 0:
raise ValueError(f"Unsupported output channel count: nout={resolved_nout}")
dt_channel = 1 if resolved_nout == 2 else resolved_nout - 1
if y.shape[1] <= dt_channel:
raise ValueError(
"Predicted tensor channel count is incompatible with DT channel selection: "
f"got shape={y.shape}, selected_channel={dt_channel}"
)
foreground_prob = None
if resolved_nout == 2:
foreground_prob = np.asarray(y[0, 0], dtype=np.float32)
return np.asarray(y[0, dt_channel], dtype=np.float32), foreground_prob
@staticmethod
def _prep_input(x: np.ndarray, in_channels: int) -> np.ndarray:
if x.ndim == 2:
arr = x.astype(np.float32)[None, ...]
elif x.ndim == 3:
if x.shape[2] == in_channels:
arr = np.transpose(x, (2, 0, 1)).astype(np.float32)
elif in_channels == 1:
if x.shape[2] >= 3:
r, g, b = x[..., 0], x[..., 1], x[..., 2]
gray = 0.2126 * r + 0.7152 * g + 0.0722 * b
arr = gray.astype(np.float32)[None, ...]
else:
arr = x[..., 0:1].astype(np.float32).transpose(2, 0, 1)
elif in_channels == 3:
if x.shape[2] == 1:
arr = np.repeat(x, 3, axis=2).astype(np.float32).transpose(2, 0, 1)
else:
arr = x[..., :3].astype(np.float32).transpose(2, 0, 1)
else:
raise ValueError(
f"Unsupported channel adaptation: in_channels={in_channels}, x.shape={x.shape}"
)
else:
raise ValueError(f"Unsupported input shape: {x.shape}")
vmin = float(np.min(arr))
vmax = float(np.max(arr))
if vmax > vmin:
arr = (arr - vmin) / (vmax - vmin + 1e-12)
else:
arr = np.zeros_like(arr, dtype=np.float32)
return arr.astype(np.float32, copy=False)
|