^j5dZddlmZddlmZddlmZddlZddl m Z ddl m Z ddlmZeZd dd Z d dd Z d dd Z d dd Zy)u-ONNX Runtime inference helpers for RF-DETR exported models. These functions handle session creation, image preprocessing, and detection decoding without requiring PyTorch or the RF-DETR training stack — only ``onnxruntime``, ``numpy``, ``supervision``, and ``Pillow`` are needed at inference time. ) annotations)Path)AnyN)Image) Detections) get_loggerc ddl}|Kddg}|j}|Dcgc] }||vs| c}xsdg}|ddk(rtj d|j t ||}tjd|j|jD]8}tjd |j|j|j:|jD]8} tjd | j| j| j:|S#t$r}td|d}~wwxYwcc}w) u^Load an ONNX model and create an ONNX Runtime inference session. Imports ``onnxruntime`` at call time so that the rest of the package remains usable without it installed. Input and output names / shapes are logged at DEBUG level for troubleshooting. When ``providers`` is ``None``, the session auto-selects the best available backend: CUDA if ``onnxruntime-gpu`` is installed, otherwise CPU (with a warning). Pass an explicit list to pin the backend — useful for benchmarking CPU vs CUDA side-by-side. Args: model_path: Path to the ``.onnx`` model file. providers: Ordered list of ORT execution providers, e.g. ``["CUDAExecutionProvider", "CPUExecutionProvider"]``. When ``None`` (default), the best available provider is selected automatically. Returns: An ``onnxruntime.InferenceSession`` ready for inference. Raises: ImportError: If ``onnxruntime`` is not installed. Examples: .. code-block:: python sess = _create_onnx_session("model.onnx") print(sess.get_inputs()[0].name) rNzTONNX Runtime inference requires 'onnxruntime'. Install it: `pip install onnxruntime`CUDAExecutionProviderCPUExecutionProvideruCUDAExecutionProvider not available — running ONNX inference on CPU. Install onnxruntime-gpu for GPU acceleration: `pip install onnxruntime-gpu` providersz!ONNX Runtime providers in use: %sz#Input : name=%s shape=%s type=%sz#Output : name=%s shape=%s type=%s) onnxruntime ImportErrorget_available_providersloggerwarningInferenceSessionstrdebug get_providers get_inputsnameshapetype get_outputs) model_pathr ortexc _preferred _availablepsessioninpouts h/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/rfdetr/export/_onnx/inference.py_create_onnx_sessionr&sB8! -/EF 002 *>1a:oQ>ZCYBZ Q<1 1 NN^ ""3z?i"HG LL4g6K6K6MN!!#[ :CHHciiQTQYQYZ[""$[ :CHHciiQTQYQYZ[ N)  b  ?s!D+ EE+ E4 EEcgd}gd}tjt|Dcgc] }||dz c}tj}tjt|Dcgc] }||dz c}tj}|dk(rdnd} tj|j | j ||ft jjtjdz } | jd k(r| d d d d tjf} | |z |z } | jd d d} tj| d jtjScc}wcc}w) uResize and normalise a PIL image to an ``(1, C, H, W)`` float32 NCHW tensor. Resizes using ``BILINEAR`` to match ``torchvision.transforms.functional.resize()`` (PIL's default is ``BICUBIC`` which produces slightly different values and can lower confidence scores). Normalises with ImageNet statistics: ``mean=[0.485, 0.456, 0.406]``, ``std=[0.229, 0.224, 0.225]``. Args: image: Input PIL image; any mode — converted to ``"RGB"`` (3-channel) or ``"L"`` (1-channel) internally. height: Target spatial height expected by the model. width: Target spatial width expected by the model. channels: Number of channels the model expects (``1`` for grayscale, ``3`` for RGB). Returns: Float32 ndarray of shape ``(1, channels, height, width)``. Examples: .. code-block:: python inp = _preprocess_pil_to_nchw(image, height=640, width=640) )g ףp= ?gv/?gCl?)gZd;O?gy&1?g?dtypeLRGBgo@Nraxis)nparrayrangefloat32convertresizePILImage ResamplingBILINEARndimnewaxis transpose expand_dimsastype) imageheightwidthchannels_imagenet_mean _imagenet_stdimeanstdpil_modearrs r%_preprocess_pil_to_nchwrJOs+4+N)M 88E(ODq^AE*DBJJ WD ((%/BQM!a%(B"** UC!msH  MM( # * *E6?H>#A & - -bjj 99EBs E/'E4c |j}|j}|dj}|dj\}}}} t j |} t | || |} |jd|| i} |D cgc]} | j}} tdt|Dd}tdt|Dd}||tjd|t| Dcgc]*\}}|jdk(s|jddk(s)|,}}}t| Dcgc]*\}}|jdk(s|jddk7s)|,}}}t|d k(rt|d k(r |d}|d}nXt| d k(rtjd d}d }n0| Dcgc]}t|j}}td || |d}| |dddddf}tj!d |jt#|j%t#|j't#|j)t+j,d |j.}||t+j0|j3dd zz }|j'd}|j5d}tj!dt#|j%t#|j'|t7||kDj9||kD}||j:\}}}} | j<\}!}"t+j>||d z z || d z z ||d z z|| d z zgd }#|#t+j@|!|"|!|"gt*jBz}#tE|#||||jGt6| fScc} wcc}}wcc}}wcc}w)uPreprocess one image, run ONNX Runtime inference, and decode detections. Reads input shape from the session (NCHW ``float32``), resizes and normalises the image with ImageNet statistics, invokes the model, then decodes the ``dets`` / ``labels`` output tensors into a :class:`supervision.Detections` object with pixel-space ``xyxy`` boxes. **Input contract** (must match ``RFDETR.predict()`` preprocessing exactly): - Image is opened as-is and converted to ``"RGB"`` (3-channel) or ``"L"`` (1-channel greyscale) depending on the model's channel count. - Resize uses ``PIL.Image.Resampling.BILINEAR`` — matching ``torchvision.transforms.functional.resize()`` which defaults to ``InterpolationMode.BILINEAR``. Using PIL's default (``BICUBIC``) would produce slightly different pixel values and can degrade confidence. - Pixel values are scaled to ``[0, 1]`` then normalised with ImageNet statistics: ``mean=[0.485, 0.456, 0.406]``, ``std=[0.229, 0.224, 0.225]``. - The tensor is kept as ``[1, C, H, W]`` (NCHW) — unlike the TFLite helper which uses NHWC because ``onnx2tf`` transposes at export time. ONNX RT consumes the native ONNX NCHW layout directly. Args: session: ONNX Runtime ``InferenceSession`` returned by ``_create_onnx_session``. image_path: Path to the input image (any format supported by Pillow). RGB images are used as-is; RGBA / palette images are converted. threshold: Confidence threshold; detections below this are discarded. Returns: A tuple of ``(detections, pil_img)`` where ``detections`` contains pixel-space ``xyxy`` boxes and ``pil_img`` is the original PIL image at its original resolution. Examples: .. code-block:: python sess = _create_onnx_session("model.onnx") dets, img = _run_inference(sess, "photo.jpg", threshold=0.3) print(dets.confidence) rNc30K|]\}}d|vs |yw)detsN.0rErs r% z!_run_inference..sQGAt&D.aQ c30K|]\}}d|vs |yw)labelsNrNrOs r%rQz!_run_inference..sTWQ8tCSqTrRzcName-based ONNX output matching failed (available names: %s). Falling back to shape-based matching.r(r+r.a2Shape-based ONNX output matching is ambiguous (both outputs have last dim==4, which happens when num_classes==3). Falling back to positional order: output 0 = boxes ('dets'), output 1 = logits ('labels'). If detections look wrong, inspect output names with _create_onnx_session() and set LOG_LEVEL=DEBUG.zShape-based ONNX output matching failed. Expected exactly one rank-3 tensor with last dim == 4 (boxes) and one rank-3 tensor with last dim != 4 (logits). Available output shapes: z2Logits stats: shape=%s min=%.3f max=%.3f mean=%.3fr)iXr/uGScores stats: min=%.3f max=%.3f — detections above threshold %.2f: %d)xyxy confidenceclass_id)$rrrrr7openrJrunnext enumeraterrr:lenlist ValueErrorrfloatminmaxrFr1asarrayr*expclipargmaxintsumTsizestackr2r4rr>)$r" image_path thresholdinputsoutputs input_name_rBr@rApil_img inp_tensor raw_outputsr$ output_names boxes_idx logits_idxrEarr_outshape_boxes_candidatesshape_logits_candidatesavailable_shapes boxes_cwhlogitsone scores_allscoresclskeepcxcybwbhowohrXs$ r%_run_inferencer}sT   !F!!#GJ!'AxmmJ'G(&%JJ++dZ$<=K)00CHH0L0Qy'>QSWXIT ,(?TVZ[JJ. q  !*+ 6" !W',,!:KPWP]P]^`PaefPfA" " !*+ 6# !W',,!:KPWP]P]^`PaefPfA# #  % &! +4K0LPQ0Q.q1I03J   " NN+ IJCNOW]] 3O O,,<+=?  I&q)I $Q3B3Y /F LL<  fjjl fjjl fkkm  **Qfll +Cbfffkk#r&:%:;;  Y ?D    !! $F 1!)A,!11RSYR\]E E  "1%J!+!1!1Ax !% AC OOS !D 6] tG 4[<     t))+b0F:;< HHW E'')!,445H"MN  eiik 2N BB)N)r str | Pathr zlist[str] | Nonereturnr)r() r?PILImage.Imager@rirArirBrirz np.ndarray)g333333?)r"rrnrrorbrz!tuple[Detections, PILImage.Image])d) rz Path | strr?rr z list[str]rrirrirztuple[float, float, str])__doc__ __future__rpathlibrtypingrnumpyr1PILrr7 supervisionrrfdetr.utilities.loggerrrr&rJrrrNrr%rs  #!". 2r +: +: +: +: +:  +:b|c |c|c|c' |cH 6C6C 6C6C  6C  6C  6Cr