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)