^jUdZddlmZddlZddlZddlZddlmZddlm Z m Z m Z ddl Z ddlmZddlmZeZhdZd ed <d Zd ed <ehdZded<dZd ed<d dZd!dZd"dZej8d#dZej8d$dZef d%dZd&dZ ef d'dZ!d(dZ"dddefdd d)dZ#y)*uONNX → TFLite conversion using the ``onnx2tf`` library. ``onnx2tf`` (PINTO0309) converts an ONNX graph to TFLite. **Version 2.4.0 or later is required** — earlier 1.x releases cannot lower three op patterns in the RF-DETR graph (constant Expand, 1-D TopK, rank-3 Tile). Although the onnx2tf 2.x default backend is ``flatbuffer_direct``, RF-DETR unconditionally forces ``tflite_backend="tf_converter"`` to avoid a runtime error in the TFLite TopK_V2 kernel (``flatbuffer_direct`` trips a "k > internal dimension" check at ``AllocateTensors()`` time). ``Erf`` and ``GeLU`` activations are replaced with TFLite-native pseudo-operators (``replace_to_pseudo_operators=["Erf", "GeLU"]``) so the produced model does not require the TensorFlow Flex delegate at inference time. GridSample rewrite ------------------ RF-DETR's deformable cross-attention uses :func:`torch.nn.functional.grid_sample` once per decoder layer (6 calls total). ``onnx2tf``'s built-in GridSample handler lowers the op to ``tf.gather_nd(batch_dims=1)``, which TFLite's ``GatherNd`` kernel does not support — the kernel silently accepts the call during ``AllocateTensors()`` but produces numerically wrong output at inference time, causing all detection scores to collapse from ~0.6 to ~0.1. The ``replace_to_pseudo_operators=["GridSample"]`` pseudo-op path also produces numerically wrong logit magnitudes in both FP32 and FP16 (the pseudo-op itself is broken, not a quantization issue). An earlier ONNX-level rewrite using ``GatherElements(axis=2)`` was lowered to ``tf.gather_nd(batch_dims=2)``, which TFLite does not support and crashes with index out-of-bounds at inference time. Before invoking ``onnx2tf``, :func:`_replace_gridsample_for_tflite` rewrites every ``GridSample`` node in the ONNX graph into an equivalent bilinear sampling subgraph built from ``Gather(axis=0)`` on a transposed and flattened ``(N*(H+2)*(W+2), C)`` image tensor. ``onnx2tf`` lowers ``Gather(axis=0)`` to TFLite's ``GATHER`` op with no ``batch_dims`` — the only TFLite gather path that is unconditionally supported, neither crashing on ``AllocateTensors()`` nor producing wrong values. The converter uses the ``onnx2tf`` Python API directly (rather than shelling out to the CLI) so that we can: * Apply a compatibility shim for older ``onnx2tf`` releases that call :func:`numpy.load` on pickled data without ``allow_pickle=True``. * Redirect ``onnx2tf``'s built-in ``download_test_image_data()`` to use locally-prepared calibration data instead of downloading from GitHub (which can fail in many environments). ``onnx2tf`` calls ``download_test_image_data()`` for its ONNX-vs-TF output validation. ``_patch_validation_download()`` redirects that call to local data, avoiding the network dependency. INT8 quantization ----------------- ``quantization="int8"`` produces a **dynamic-range** INT8 model (INT8 weights, float activations, roughly 4x smaller than FP32, no calibration data needed), built from the ``onnx2tf`` SavedModel. Static (full-integer) INT8 is not supported and raises ``ValueError``: RF-DETR's transformer activations do not survive 8-bit post-training quantization. Note: The resulting ``.tflite`` model expects the same input normalization as the ONNX model: ImageNet mean/std (``mean=[0.485, 0.456, 0.406]``, ``std=[0.229, 0.224, 0.225]``). The caller is responsible for applying this normalization at inference time. Note: Segmentation models additionally emit a ``masks`` output. FP32, FP16, and dynamic-range INT8 all match the PyTorch baseline closely (INT8 mask fidelity is marginally lower). Verified on the non-plus segmentation variants: Nano, Small, Medium, Large, and Preview. ) annotationsN)Path)Any Generatorcast)NDArray) get_logger>Nfp16fp32int8zset[str | None]_VALID_QUANTIZATIONSint_DEFAULT_CALIB_SAMPLES>.bmp.jpg.png.jpeg.webpzfrozenset[str]_IMAGE_EXTENSIONSd_DEFAULT_DIR_CALIB_SAMPLESc z]^_`abcdefghijklmddleddl}ddl`|jd}|jd}|jd}|j j dd}|j j dd}|j j dd} |dk7s |dk7s| dk7rtd |d |d | |jt|jd k7rtd |j|jt|jd k7rtd|jd|idgjejdfd`ijfd kejdfd`eijfd _gddd`dfd gt|jjat|jj} _ej dej d} _ej dej d} _ej dej d} _ejdejdm_ejdejdf_ejdejd}_ejdejd}_dgej d ]_d!gej d"}_d#gej d$ckd%ej d g&}gd'|g|gkd(ej d g&}gd'|g|gd_egkfd) }||dd*}||dd+}||dd,}||d!d-}||dd.}||dd/}kd0ej 1}gd2|| g|gkd3ej 1hgd2|| ghgkd4ej 1}gd5|hg|gkd6ej 1}gd5||g|gkd7ej1}gd8|g|gd9| ikd:ej1}gd8|g|gd9| ikd;ej1}gd8hg|gd9| ikd||g|!gkd?ej1}"gd>||g|"gkd@ej1}#gdA|fg|#gkdBej1}$gdA| fg|$gd]egkfdC }%|%|dD}&|%|dE}'|%|dF}(|%|dG})|%|dH}*kdIej dg&}+gdJ|*|'g|+gdKdikdLej d g&},gdJ|&|(|)|'g|,gdKdi_gdMej dN}-kdO}.gdP||-g|.gkdQ}/gdR|.g|/gdSgdTikdUbgdV|/|+gbgkdW}0gdX|_dgej dY_dgej dZ|g|0gkd[}1gd\|0|g|1gkd]}2gdX|_dgej d^_dgej d_|g|2gkd`}3gd\|2|g|3gkda}4gd2|1fg|4gkdb}5gd5|4|!g|5gkdc}6gdA|5|g|6gkdd}7gd2|3fg|7gkde}8gd5|7|"g|8gkdf}9gdA|8|g|9gkdg}:gdh|6g|:gkdi};gdh|9g|;gkdj}<gd2|:fg|gdA|6|:g|>gkdm}?gdA|9|;g|?gkdn}@gdAf|>g|@gkdo}AgdAf|?g|Agdaefgkmfdp }B|B|:|#dq}C|B|<|#dr}D|B|;|$ds}E|B|=|$dt}Fkduej 1}Ggdv| || g|Ggkdwej 1}Hgd5|G|g|Hg_gdxej dy}Ikdzej 1^gdV|H|Ig^gd^ceghkfd{ }J|J|C|Ed|}K|J|D|Ed}}L|J|C|Fd~}M|J|D|Fd}Ndbgkfd }O|O|Kd|}P|O|Ld}}Q|O|Md~}R|O|Nd}S_d#dgej dldgklfd }T|T|P|@|Ad|}U|T|Q|>|Ad}}V|T|R|@|?d~}W|T|S|>|?d}Xkd}Ygd2|U|Vg|Ygkd}Zgd2|Y|Wg|Zgkd}[gd2|Z|Xg|[gkd}\gdV|[|,g|\ggdR|\g|gdSgdi|jj#|jj#|j$j'dy)uRewrite one GridSample ONNX node into a TFLite-safe bilinear subgraph. Replaces ``GridSample(im, grid)`` with an equivalent bilinear sampling subgraph that performs four ``Gather(axis=0)`` lookups on a transposed and flattened ``(N*(H+2)*(W+2), C)`` image tensor. ``onnx2tf`` lowers ``Gather(axis=0)`` to TFLite's ``GATHER`` op with no ``batch_dims`` — the only TFLite gather path that is unconditionally supported, neither crashing on ``AllocateTensors()`` nor producing wrong values. Per-sample batch offsets are added to the flat index so that a single rank-1 ``Gather`` covers the entire batch. The replacement is mathematically identical to PyTorch's ``F.grid_sample`` for ``mode="bilinear"``, ``padding_mode="zeros"``, ``align_corners=0``. Out-of-bounds sample positions are clamped to the zero-padded border, which has the same effect as PyTorch's zero padding. Shape-dependent values are computed at runtime via ONNX Shape/Gather/ Concat/Cast ops so the subgraph works for any static or dynamic input shape. Args: node: The ``gs.Node`` to replace (must be a ``GridSample`` node). graph: The ``gs.Graph`` that owns *node*. index: Unique integer suffix used to namespace tensor/constant names. Raises: NotImplementedError: If the node has unsupported attributes. ValueError: If ``im`` or ``grid`` are not rank-4 tensors. rNmodebilinear padding_modezeros align_cornerszgGridSample TFLite patch only supports mode='bilinear', padding_mode='zeros', align_corners=0; got mode=z, padding_mode=z, align_corners=z9GridSample TFLite patch requires rank-4 im; got im.shape=z=GridSample TFLite patch requires rank-4 grid; got grid.shape=_gsreplc\dxxdz cc<jddd|||S)Nrr_dtypeshape)Variable)namer%r&gspfxuids j/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/rfdetr/export/_tflite/converter.pyvz%_replace_single_gridsample..vs: A! {{cU!CF81TF35{NNc|dxxdz cc<jddd|j||S)Nrrr#_c_r%)Constantarray)valr%r(r)npr*r+s r,cz%_replace_single_gridsample..csC A! {{cU!CF83tf5xrxx57QRRr.c Vjj||||xsiy)N)opinputsoutputsattrs)appendNode)kindinsoutsr<r)nodess r,r9z&_replace_single_gridsample..ops$ RWWS$ekrWRSr.zero_ione_itwo_igzero_fg?one_fg@two_fg?half_fax0_1dax3_1dneg1_1dim_shaper$Shape grid_shapec |j}d|j|jd|d|g|gddi|S)Nr2Gatherir#axisrint64)shape_taxis_idxr(resultr7r6r9r-s r, gather_dimz._replace_single_gridsample..gather_dims[4rxx( 8gq(!3RXX8*AdV?TUVY_X`ciklbmn r.NCHWH_outW_outpHr2AddpWpH_pWMulN_pH_pWW_fCasttoH_fpW_fpH_fW_halfDivH_halfpW_max_fSubpH_max_fcN|jdg}d|g|g|S)z@Promote a 0-D int64 scalar to a 1-D [1] int64 vector for Concat.rr$ UnsqueezerW)scalar_tr(r[rKr6r9r-s r,unsq0z)_replace_single_gridsample..unsq0s/4rxxs3 ;6*VH5 r.N_1dC_1dH_out_1dW_out_1d N_pH_pW_1d flat_shapeConcatrV nhwc_shape)rrrrrrrrpadsim_padPadim_nhwc Transposeperm)rrErLrim_flatReshapegx_rawSlices0_gxe1_gxgxSqueezegy_raws1_gye2_gygygxp1pxrpxgyp1pyrpyx0_fFloory0_fx1_fy1_fwx1wy1wx0wy0c d|} d|g|g d|} d| |g|g d|j} d|g|gdi|S) Nsh_rdcl_Clipca_r2rjrkrW) coord_f clamp_maxr(shiftedclippedcast_inti64r6rHr9r-rGs r,int_shifted_clampedz7_replace_single_gridsample..int_shifted_clamped4szc$L/ 57E"WI.c$L/ 6GVY/';s4&\2 6G9xj4+6r.x0cx1cy0cy1c batch_rangeRangebatch_offset_flat)rNrrbatch_offset_shape batch_offsetc( d| j} d| g|g d| j} d||g|g d| j} d|g|g d| j} d|g|g|S) Nypw_r2rglocal_rdglob_gidx_rrW) xcycr(ypwlocal global_idxflat1drrOr6r9pW_tr-s r,flat_global_indexz5_replace_single_gridsample..flat_global_indexQs$tf RXX. 52t*se$F4&/2 53)eW%tf~RXX6  55,'*6U4&>2 9z7+fX6 r.aabaabbbc>d|}d|g|gddi|S)Nsamp_rTrVr)gidxr(sampledrr9r-s r, gather_flatz/_replace_single_gridsample..gather_flatcs0eD6N# 8gt_wi&!=r. wflat_shapecd|}d||g|gd|}d| g|gd|}d||g|g|S)Nw2d_rgwflat_rc_r) gatheredwxwyr(w_2dw_flat out_contribr9r-rs r,contribz+_replace_single_gridsample..contribqsp4v 52r(TF#VD6?# 9t[)F84"TF n  58V${m4r.s1s2total total_nhwc)rrLrrE)r(strr%rr&zlist[int] | Nonereturnr)r5rr%rr(rrrN) r?rr@ list[Any]rArr<zdict[str, Any] | NonerNone)rYrrZrr(rrr)rwrr(rrr)rrrrr(rrr)rrrrr(rrr)rrr(rrr) rrrrrrr(rrr)numpyonnxonnx_graphsurgeonr:r;r<getNotImplementedErrorr&len ValueErrorfloat32r TensorProtoINT64FLOATrXclearrBextend)nnodegraphindexrimgridoutrrrf32rCrDrFrIrJrM im_shape_t grid_shape_tr\N_tC_tH_tW_tH_out_tW_out_tpH_tpH_pW_t N_pH_pW_trirlrmrnrorqrrrtrxryrzr{r|r} flat_shape_t nhwc_shape_trrrrrrrrrrrrrrrrrrrrrrrrrrrrrrgidx_aagidx_bagidx_abgidx_bbrsaasbasabsbbrcaacbacabcbbrrrrrKrr7r)rrrOrBr6rHr9rr*r+r-rrGsn @@@@@@@@@@@@@@@@@r,_replace_single_gridsamplerZs 2" QB ;;q>D ,,q/C ::>>&* -D::>>.':LJJNN?A6M z\W4 8J!x|.>>N}o _   xx3rxx=A-TUWU]U]T^_`` zzS_1XY]YcYcXdeff E7 CSC"$**OO"$SSET d$$ %C d$$ %Cxrxx{BHHh /F hbhhqk288W -E hbhhqk288W -E zrzz# H 5F jbjjorzz7 3E jbjjorzz7 3E zrzz# H 5F sBHHh 'F sBHHh 'Fbhh *G :RXXaS9Jwzl#\!=Lw' ZC (C ZC (C ZC (C ZC (Cq'2Gq'2G T "DusElTF# T "DusElTF#rxx(GutTlWI&)288,IusGnyk* E $CvusedC[) E $CvusedC[) V2:: &Dvvvc{+ V2:: &Dvvvc{+ xrzz *FusElVH% xrzz *FusElVH%2::.HutUmhZ(2::.HutUmhZ( f D f DWj)HWj)Hy,/J\!=Lx*d#l^fa[A\!=Lx$(D1L>FA;O %rxx 8D x[Fur4j6(# lG{VHwi&,)?@ lGy7L)G95x[Fwq!bhh0!QC72KVTW]V^_ 4By66"RD) x[Fwq!bhh0!QC72KVTW]V^_ 4By66"RD) V9Dur5kD6" E(CutVnse$ 4BusFmbT" V9Dur5kD6" E(CutVnse$ 4BusFmbT" V9Dwtf V9Dwtf V9DutUmdV$ V9DutUmdV$ E(Cur4j3% E(Cur4j3% E(CuuclSE" E(CuuclSE" dHe 4C dHe 4C dHe 4C dHe 4C M2Kwe${m4-RXX>u{G$'8&9::rxx1EF^2884Ly$&89L>J   S$/GS$/GS$/GS$/G gt $C gt $C gt $C gt $CRGRXX}5K #sC &C #sC &C #sC &C #sC &C 4BusCj2$ 4Bur3i" gJEur3i%!<Jy5,'*6{ZL3%&,)?@ KKLL KKur.c ddl}ddl}ddl}|j t |}|j j|}|j|}|jDcgc]}|jdk(s|}}|stjd|Stjdt|t|D]\} } t!| || |j#j% |j j|j'|} |j(j+| ||j0d zz } |j3| t | tjd | | S#t$r}td|d}~wwxYwcc}w#t,$r}t/d||d}~wwxYw) uRewrite every GridSample node in *onnx_path* to use TFLite-safe ops. ``onnx2tf``'s built-in GridSample handler lowers to ``tf.gather_nd(batch_dims=1)``, which TFLite's ``GatherNd`` kernel does not support — the kernel silently accepts the model during ``AllocateTensors()`` but produces numerically wrong output at inference time. The ``replace_to_pseudo_operators=["GridSample"]`` pseudo-op path also produces wrong logit magnitudes in both FP32 and FP16 (the pseudo-op itself is broken, independent of quantization). This function rewrites the ONNX graph *before* calling ``onnx2tf.convert()``, replacing each ``GridSample`` node with an equivalent bilinear subgraph that performs four ``Gather(axis=0)`` lookups on a transposed and flattened ``(N*(H+2)*(W+2), C)`` image tensor. ``onnx2tf`` lowers ``Gather(axis=0)`` to TFLite's ``GATHER`` op with no ``batch_dims`` — the only TFLite gather path that is unconditionally supported. Only ``mode="bilinear"``, ``padding_mode="zeros"``, ``align_corners=0`` nodes are patched — the only variant emitted by RF-DETR's exporter. Args: onnx_path: Path to the source ``.onnx`` file. output_dir: Directory where the patched ``.onnx`` is written. Must already exist. Returns: Path to the patched ``.onnx`` file if any ``GridSample`` nodes were found; *onnx_path* unchanged if the graph contains no such nodes. Raises: ImportError: If ``onnx`` or ``onnx_graphsurgeon`` are not available. NotImplementedError: If a ``GridSample`` node has unsupported attrs. RuntimeError: If the patched graph fails ONNX shape-inference or model validation. rNzwonnx and onnx_graphsurgeon are required for the GridSample TFLite patch. Install with: pip install rfdetr[onnx,tflite] GridSamplez6No GridSample nodes found; skipping TFLite-safe patch.uGPatching %d GridSample node(s) → TFLite-safe Gather(axis=0) subgraph.)rz1GridSample ONNX patch produced an invalid graph: z_gs_patched.onnxz$GridSample-patched ONNX saved to: %s)ronnx.shape_inferencer ImportErrorloadrshape_inference infer_shapes import_onnxrBr9loggerdebuginfor enumeratercleanuptoposort export_onnxchecker check_model Exception RuntimeErrorstemsave) onnx_path output_dirrr)excmodelrngs_nodesrUrpatchedout_paths r,_replace_gridsample_for_tfliter.s<#& IIc)n %E  - -e 4E NN5 !E ;;?a!$$,*>?H?  MN KKQ H X&94"4a89 MMO_&&33BNN54IJ   )Y^^.@@AHIIgs8}% LL7B OC  D  @" _NseTU[^^_s< E?"F7F5AF!? F FF! F>*F99F>c ddl}ddlm}ddlm}ddl}ddlm} |d}|J|||d krtd |d y#t$r}td|d}~wwxYw#|$rt|dd}|YyYZwxYw) uIVerify that a compatible ``onnx2tf`` package is importable. onnx2tf 2.4.0 or later is required — earlier 1.x releases cannot lower the constant ``Expand``, 1-D ``TopK``, and rank-3 ``Tile`` ops present in RF-DETR's ONNX graph. Raises: ImportError: If ``onnx2tf`` cannot be imported or is below 2.4.0. rNzonnx2tf is not installed. TFLite export requires both ONNX and TFLite export dependencies. Install them with: pip install rfdetr[onnx,tflite])PackageNotFoundError)version)Versiononnx2tf __version__z2.4.0zonnx2tf z is installed but RF-DETR requires >= 2.4.0. Earlier 1.x releases cannot lower the Expand, TopK, and Tile ops in RF-DETR's ONNX graph. Upgrade with: pip install 'onnx2tf>=2.4.0')r3rimportlib.metadatar0r1packaging.versionr2getattr)r3r( _PkgNotFound _pkg_version _onnx2tf_mod_Version installeds r,_check_onnx2tf_availabler=sH:"5 ,Y 7     Xg..yk"R R  /1  .    L->     s(A A' A$ AA$'B?Bc#Ktjdfd }|t_ dt_y#t_wxYww)uTemporarily patch :func:`numpy.load` to set ``allow_pickle=True``. ``onnx2tf`` 1.x calls ``np.load()`` on its bundled calibration data without passing ``allow_pickle=True``. NumPy ≥ 1.16.3 defaults that flag to ``False`` and raises :class:`ValueError` for pickled files. This context manager monkey-patches ``np.load`` for the duration of the ``onnx2tf`` conversion and restores the original afterwards. c8|jdd|i|S)N allow_pickleT) setdefault)argskwargs_original_loads r, _patched_loadz*_numpy_allow_pickle.._patched_loads#.$/t.v..r.N)rBrrCrrr)r6r)rErDs @r,_numpy_allow_picklerFs6WWN/BG!  .s"A6 A AAc#Kdfd }i}ddg}|D]M}tjj|}|s%t|ds2t |d||<t |d|O d|j D]4\}}tjj|}|s(t |d|6y#|j D]4\}}tjj|}|s(t |d|6wxYww)urRedirect ``download_test_image_data()`` to use local calibration data. ``onnx2tf`` calls ``download_test_image_data()`` during conversion to fetch test images from GitHub. The function is called in two places: 1. **Validation** — compares ONNX-vs-TF outputs (all conversions). 2. **INT8 calibration** — builds a representative dataset when ``output_integer_quantized_tflite=True``. This download can fail in many environments (firewalls, CI, air-gapped systems, or when the upstream file is unavailable). This context manager monkey-patches the function in all known module locations to return the data from the calibration ``.npy`` file we already prepared. We intentionally do **not** use ``custom_input_op_name_np_data_path`` because that code path triggers a ``tf.tile`` rank mismatch in onnx2tf 1.x when processing models with DINOv2-style embeddings and N > 1 calibration samples. Patching the download function achieves the same goal without that issue. Args: npy_path: Path to the ``.npy`` file containing calibration data in NHWC format. c\ttttjdS)NF)r@)rrrr6r)npy_pathsr, _replacementz0_patch_validation_download.._replacement2s! GCL"''("GHHr.zonnx2tf.utils.common_functionszonnx2tf.onnx2tfdownload_test_image_dataN)rz NDArray[Any])sysmodulesrhasattrr7setattritems)rIrJ originalsrMmod_namemodoriginals` r,_patch_validation_downloadrUs2I!#I(GCkkooh' 73 :;")#/I"JIh  C3\ B C C "+//"3 C Hh++//(+C7B C)//"3 C Hh++//(+C7B Cs43C; C;C;#B/'7C;C;/8C8(C88C;c Xddlm}|jstd|t d|j D}|std|dt t |d|}tjdt|d |d |d |d g}|D]} |j|jd j||f}tj|tj} | tjdz} |j!| |std|tjdt|dtj&|j)tjdS#t"$rtj%d|YwxYw)aLoad images from a directory and prepare them for calibration. Images are loaded, resized to ``(height, width)``, converted to ``float32`` in ``[0, 1]``, and stacked into an NHWC array. Args: image_dir: Directory containing image files (JPEG, PNG, etc.). height: Target image height matching the model input. width: Target image width matching the model input. max_images: Maximum number of images to load. Files are sorted alphabetically and the first *max_images* are used. Returns: A ``float32`` NumPy array of shape ``(N, height, width, 3)`` with pixel values in ``[0, 1]``. Raises: FileNotFoundError: If *image_dir* does not exist or contains no supported image files. r)Imagez'Calibration image directory not found: c3bK|]'}|jjtvs$|)ywr)suffixlowerr).0ps r, z+_load_calibration_images..ks#aq188>>;KO`;`as%//z"No supported image files found in z. Supported extensions: NzLoading z calibration images from z (resizing to x)RGBr2go@zSkipping unreadable image: zNo readable images found in zLoaded z calibration imagesF)copy)PILrWis_dirFileNotFoundErrorsortediterdirrrrropenconvertresizer6asarrayrr=r"rstackastype) image_dirheightwidth max_imagesrW image_pathsarraysimg_pathimg image_arrays r,_load_calibration_imagesrvMs2    "I) UVVaI$5$5$7aaK 0 ;STZ[lTmSn o  kz*K KK(3{+,,Ei[P^_e^ffghmgnnopq(*F **X&..u5<yk JKK KK'#f+&9:; 88F  " "2::E " ::  LL6xjA B  sA?F!F)(F)cX ddl}|jt|}|jj d}|j }|jjjjDcgc]}|j}}||fS#t$r}td|d}~wwxYwcc}w)zRead the first input tensor's name and shape from an ONNX model. Args: onnx_path: Path to the ``.onnx`` file. Returns: A ``(name, dims)`` tuple where *dims* is the NCHW shape list, e.g. ``("input", [1, 3, 560, 560])``. rNzonnx is not installed. TFLite export requires both ONNX and TFLite export dependencies. Install them with: pip install rfdetr[onnx,tflite]) rrrrrinputr(type tensor_typer&dim dim_value)r&rr(r)inpr(ddimss r,_get_onnx_input_infors IIc)n %E ++  A C 88D!$!5!5!;!;!?!? @AAKK @D @ :  .    AsB 1B' B$ BB$c||dk(rtjdt|\}}|\}}}} tjj t || |jtj} |dz } tjt| | tjd| jd| | St|tjrH|dz } tjt| |tjd|j| St!|} | j#rot|\}}|\}} }} t%| || |} |dz } tjt| | tjd| jd| | S| j'r| } tjd | | St)d | ) uzPrepare calibration data as a ``.npy`` file for ``onnx2tf``. The returned path points to a ``.npy`` file containing an NHWC float32 array with pixel values in ``[0, 1]``. This file is loaded by the ``_patch_validation_download()`` context manager, which replaces ``onnx2tf``'s built-in ``download_test_image_data()`` call. ``onnx2tf`` uses this data for both ONNX-vs-TF output validation and (when INT8 is requested) as a representative calibration dataset. Args: onnx_path: Path to the source ``.onnx`` file (used to read the input tensor NCHW shape for random data generation and for determining the target resolution when loading images from a directory). calibration_data: One of: * ``None`` — generate random calibration data. Sufficient for fp32/fp16 but emits a warning for int8. * A **directory path** containing JPEG/PNG images — images are loaded, resized to the model input resolution, and converted to the correct format automatically. * A path to a ``.npy`` file containing an array of shape ``(N, H, W, 3)``, dtype float32, values in ``[0, 1]``. * A :class:`numpy.ndarray` with the same constraints. output_dir: Directory where a temporary ``.npy`` file may be written when *calibration_data* is ``None``, a directory, or an ndarray. quantization: The requested quantization mode (used only to decide whether to emit a warning). max_images: Maximum number of images to load when *calibration_data* is a directory path. Ignored for other calibration data formats. Returns: Path to the ``.npy`` calibration data file. Raises: FileNotFoundError: If *calibration_data* is a path that does not exist, or a directory with no supported images. r uNo calibration_data provided for INT8 quantization. Using random data — this will produce poor quantization accuracy. For best results, pass calibration_data with representative images from your dataset.z_rfdetr_calib_data.npyz)Generated random calibration data: shape=z , saved to z(Using provided calibration array: shape=)rnrorpz6Prepared calibration data from image directory: shape=zUsing calibration data from: z!Calibration data path not found: )rwarningrr6randomrandrrlrr%rrr& isinstancendarrayrrrcrvis_filerd)r&calibration_datar' quantizationrpr# input_dimsr7hwcalibrI data_path_cs r,_prepare_calibration_datarsR 6 ! NN,  -Y7 : 1a 5q!Q?FFrzzR 88 H u% @ [YaXbcd* O) $bjj 1 88 H /0 >?O?U?U>VWX" O)*    0;MAz$KAr1a,YqV`aE!$<= 2.4.0``. Uses the Python API with a NumPy compatibility shim. Args: onnx_path: Path to the source ``.onnx`` file. output_dir: Directory where TFLite artifacts will be written. ``onnx2tf`` creates ``{stem}_float32.tflite`` and ``{stem}_float16.tflite``. When ``quantization="int8"`` a ``{stem}_dynamic_range_quant.tflite`` is additionally written. quantization: Quantization mode. * ``None`` / ``"fp32"`` / ``"fp16"`` — FP32 + FP16 output (``onnx2tf`` always emits both). * ``"int8"`` — additionally produce a dynamic-range INT8 model (INT8 weights, float activations, ~4x smaller than FP32). Static / full-integer INT8 is not supported. calibration_data: Representative data used by ``onnx2tf`` for its ONNX-vs-TF output validation. Accepts: * ``None`` — auto-generate random data. * A **directory path** containing JPEG/PNG images — images are loaded, resized, and converted automatically. * A path to a ``.npy`` file — shape ``(N, H, W, 3)``, dtype float32, pixel values in ``[0, 1]``. * A :class:`numpy.ndarray` with the same format. Dynamic-range INT8 needs no calibration data, so this argument does not affect the quantized weights — it only feeds onnx2tf's internal validation pass. verbosity: Log verbosity passed to ``onnx2tf``. One of ``"debug"``, ``"info"``, ``"warn"``, ``"error"`` (default). max_images: Maximum number of images to load when *calibration_data* is a directory path. Defaults to 100. Ignored for other calibration data formats. verbose: When ``True``, stream ``onnx2tf`` per-node progress — useful for monitoring long conversions (5–15 min on transformer-based models). Defaults to ``False`` (silent). Returns: Path to the primary artifact. ``onnx2tf`` always writes both ``{stem}_float32.tflite`` and ``{stem}_float16.tflite`` to *output_dir*; ``quantization="int8"`` adds ``{stem}_dynamic_range_quant.tflite``. The returned path is the dynamic-range file for ``int8``, otherwise the float32 file. Raises: FileNotFoundError: If *onnx_path* does not exist or *calibration_data* points to a missing file. ImportError: If ``onnx2tf`` is not installed. ValueError: If *quantization* is not a recognized mode. RuntimeError: If the conversion fails. Note: This function is **not thread-safe**. It globally monkey-patches :func:`numpy.load` (via :func:`_numpy_allow_pickle`) and ``onnx2tf.download_test_image_data`` (via :func:`_patch_validation_download`) for the duration of the conversion. Concurrent calls from multiple threads will interfere with each other. Run conversion in a subprocess if isolation is required. ``tf_converter`` backend is forced unconditionally (overriding onnx2tf's 2.x ``flatbuffer_direct`` default) to avoid a runtime error in the TFLite TopK_V2 kernel. ``Erf`` and ``GeLU`` ops are substituted with TFLite-native pseudo-operators to avoid a missing TensorFlow Flex delegate at inference time. Segmentation models additionally emit a ``masks`` output, decoded by :func:`rfdetr.export._tflite.inference._run_inference`. Verified on the non-plus segmentation variants (Nano, Small, Medium, Large, Preview). zONNX model not found: zUnsupported quantization mode z. Choose from: c3&K|] }|| ywrr)r[qs r,r]z export_tflite..Us"Tam1"TszG. Static / full-integer INT8 is not supported; 'int8' is dynamic-range.rNT)parentsexist_okuGridSample TFLite patch skipped — onnx/onnx_graphsurgeon not available (%s). TFLite inference may produce incorrect scores if the model contains GridSample nodes. Install with: pip install rfdetr[onnx,tflite])rpu)Converting ONNX → TFLite (quantization=z , verbosity=z): )rhErfGeLU)input_onnx_file_pathoutput_folder_pathoutput_signaturedefs non_verbose verbosityreplace_to_pseudo_operatorstflite_backend tf_converteruonnx2tf does not support tflite_backend= — proceeding with default backend. If TFLite inference produces wrong results, upgrade to onnx2tf>=2.4.0.zonnx2tf conversion failed: r zTFLite model exported to: z_float32.tflitez _*.tflitezExpected TFLite output z not found; searched for 'z_*.tflite' in z and using z\ instead. The returned model may have a different dtype (e.g. int8) than the caller expects.z0onnx2tf completed but no .tflite file matching 'z_*.tflite' was found in r)rrrdr rrer=onnx2tf.onnx2tfr3onnx2tf.utils.common_functionsutilscommon_functionsmkdirr.rrrrrrFrUrrh TypeErrorr"rr#r$rglobr()r&r'rrrrprr:_onnx2tf_commonr(calib_npy_pathrhconvert_kwargsrprimary tflite_filess r, export_tflitersNYIj!J    "8 DEE//,\,<=""T.B"TTUVT T   +<<oTD1 29jI /#Z*N KK;L;K': ;& * (),I&)*o(,#*{&16v .N0 *H.HH?& *& *^Jv)*jA 0 :;j\99G ?? joo I.FGH "1oG NN)**_7U*U)VW!!+ N:,kRYR^R^Q_`ee  B:,Nfgqfrs  KK,WI67 NU   <     ~ *1 ).)  *A& *& *& *& *P I 23%898>?SHIs~ G? I3I&,%I H,I&&I3? H)H$$H),&IIIII# I&&I0+I33 J(<'J##J()rrrrrrrr)r&rr'rrr)rr)rGenerator[None, None, None])rIrrr) rmrrnrrorrprrzNDArray[np.float32])r&rrztuple[str, list[int]]) r&rr*str | os.PathLike[str] | np.ndarray | Noner'rr str | Nonerprrr)rrrrrr)r&str | os.PathLike[str]r'rrrrrrrrprrboolrr)$__doc__ __future__r contextlibosrLpathlibrtypingrrrrr6 numpy.typingrrfdetr.utilities.loggerr rr __annotations__r frozensetrrrr.r=contextmanagerrFrUrvrrrrrr.r,rs 6p# '' . )GoF! %..X$Y>Y#&C%tn CL( V !!, 0C0Cn1 7;7; 7; 7; 7;  7;t<1 MM@MM M  M  M`0 $CG0 SS%S&SSA S  S  SS Sr.