^j8 dZddlmZddlmZmZddlZddlZddlmZde de de fd Z d e e e de e fd Z Gd d Z dde ede dzde fdZejj dde ede dzde fdZ ddejdejdededejf dZ dde eedfde dzdeedffdZde eedfdeedffdZ dde dzdee eedfgeedfffdZy)z8Tensor utilities: NestedTensor, collate_fn, and helpers.)partial)AnyCallableN)Tensorvaluemultiplereturncj|dkrtd||dkrtd|||zdz |z|zS)anRound *value* up to the next multiple of *multiple*. Args: value: Non-negative integer to round. multiple: Positive integer divisor. Returns: The smallest integer greater than or equal to *value* that is an exact multiple of *multiple*. Raises: ValueError: If ``value`` is negative or ``multiple`` is not positive. rz value must be non-negative, got z)multiple must be a positive integer, got ) ValueError)rrs c/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/rfdetr/utilities/tensors.py_round_up_to_multiplersR qy;E7CDD1}DXJOPP X  !h .( ::the_listcn|d}|ddD]'}t|D]\}}t|||||<)|S)zReturn element-wise maximums of a list of lists. Args: the_list: List of integer lists, all of the same length. Returns: List of per-position maximums. rr N) enumeratemax)rmaxessublistindexitems r _max_by_axisr+sU QKEAB<3$W- 3KE4uU|T2E%L 33 LrceZdZdZdededzddfdZdejdeddfd Z d d Z de eedzffd Z de fd Zy) NestedTensorzBatch of tensors with variable spatial sizes, padded to a common size. Stores both the padded tensor and a boolean mask indicating padding positions. tensorsmaskNr c ||_||_yNrr)selfrrs r __init__zNestedTensor.__init__As  rdevicekwargsc |jj|fi|}|j}||J|j|fi|}nd}t||S)zMove tensors and mask to *device*. Args: device: Target device. **kwargs: Additional arguments forwarded to ``Tensor.to``. Returns: New NestedTensor on *device*. N)rtorr)r r"r# cast_tensorr cast_masks r r%zNestedTensor.toEs_&dlloof77 yy  # ##1&1IIK33rct|jj|j|jjSdS)uPin tensor and mask memory for faster CPU→GPU transfer. Returns: New NestedTensor with pinned memory. N)rr pin_memoryrr s r r)zNestedTensor.pin_memoryWsG  LL # # %&*ii&;DII "  AE  rc2|j|jfS)zyReturn ``(tensors, mask)`` tuple. Returns: Tuple of the padded tensor and the boolean mask. rr*s r decomposezNestedTensor.decomposebs ||TYY&&rc,t|jSr)strrr*s r __repr__zNestedTensor.__repr__js4<<  r)r r)__name__ __module__ __qualname____doc__rr!torchr"rr%r)tupler,r.r/rr rr;sn ftm4444$  '5$!67'!#!rr tensor_list block_sizec0|djdk(rhtjr t||St |Dcgc]}t |j c}}|$t|d||d<t|d||d<t|g|z}|\}}}}|dj} |dj} tj|| | } tj|||ftj| } t|| | D]o\}} }| d|j dd|j dd|j dfj!|d|d|j dd|j df<qn t#d t%| | Scc}w) aPad a list of variable-size tensors into a single NestedTensor. Args: tensor_list: List of 3-D tensors (C, H, W) with possibly different H, W. block_size: When set, round the padded ``H`` and ``W`` up to the next multiple of *block_size* before allocating the batch tensor. Used to satisfy backbone divisibility requirements (e.g. windowed-attention backbones require ``H % (patch_size * num_windows) == 0``). The rounded-up strip is explicitly tracked in the ``mask`` as padding. Returns: NestedTensor with all images padded to the maximum spatial dimensions (rounded up to *block_size* when provided). rr8Nr dtyper"Fz not supported)ndim torchvision _is_tracing$_onnx_nested_tensor_from_tensor_listrlistshaperlenr>r"r4zerosonesboolzipcopy_r r)r7r8imgmax_size batch_shapebchwr>r"tensorrpad_imgms r nested_tensor_from_tensor_listrUns$1~a  " " $8 PZ[ [ K HScii HI  !/ ZHHQK/ ZHHQK;'(83  1aA$$Q&&[fEzz1a)5::fE";= 6OC! NciilNNciilNNciilNB C I I# N05An ! nn ! n, - 6))  %%!!IsFc g}t|djD]}tjtj|Dcgc]}|j |c}j tjj tj}|j||Mtj|tj}|d|zdz |z|z|d<|d|zdz |z|z|d<t|}g}g}|D]}t|t|j D cgc] \} } | | z  } } } tjjj|d| dd| dd| df} |j| tj |dtj"|j$} tjjj| d| dd| dfdd}|j|j tj&tj|}tj|}t)||Scc}wcc} } w)aqONNX-tracing-compatible variant of ``nested_tensor_from_tensor_list``. Args: tensor_list: List of 3-D tensors (C, H, W). block_size: When set, round ``H`` and ``W`` up to the next multiple of this value before padding. See :func:`nested_tensor_from_tensor_list`. Returns: Padded NestedTensor suitable for ONNX export. r)r>r r<r=constant)r)rangedimr4rstackrDr%float32int64append as_tensorr5rInn functionalpad zeros_likeintr"rHr)r7r8rLirK max_size_ibs padded_imgs padded_maskss1s2padding padded_imgrT padded_maskrRrs r rBrBsH ;q>%%' ($YYu{{K+PSCIIaL+PQTTUZUbUbcdgghmhshst  #$ __Zu{{ ;  b(1,3r9   b(1,3r9 XH KL8+.xsyy9I+JKRBGKKXX((,,S1gaj!WQZQRT[\]T^2_` :&   SV599SZZ Hhh))--a!WQZGAJ1OQ[]^_ KNN5::678[[ %F ;;| $D T **7,Q Ls I%8I*inputgrid padding_mode align_cornersc ddlmcm}|jjdk7r|j ||d||S|dvrd|d}t ||j\} |jd |jd c|r#|d d z d z zd z }|d d z|d z zd z }n"|d d z zd z d z }|d d z|zd z d z }|jj} |jj} | d z} | d z} || jz j|jjd } || jz j|jjd }| jd}|| z }||z }|dk(rU| jd d z } | jd|d z } | jd d z } | jd|d z } n| dk\| kz}| dk\| kz}| dk\| |kz}| dk\| |kz}| jd d z } | jd|d z } | jd d z } | jd|d z } |j!d dt"j$dt"j$dt"j$f fd }|| | }|| | }|| | }|| | }|dk(r\|zjd z}||zjd z}||zjd z}|||zjd z}||z|z| |z|zz||z|zz| |z|zzS)uBilinear grid sampling compatible with all PyTorch backends including MPS. Drop-in replacement for ``F.grid_sample(input, grid, mode='bilinear', ...)``. On MPS, ``F.grid_sample`` backward (``grid_sampler_2d_backward``) is not yet implemented and silently falls back to CPU. This function uses gather-based index arithmetic — natively supported on every backend — for the MPS path, while delegating to ``F.grid_sample`` on CUDA/CPU where its fused kernel is faster. The two paths are numerically identical, so model accuracy is unaffected. Args: input: Feature map of shape ``(N, C, H, W)``. grid: Sampling grid of shape ``(N, Hg, Wg, 2)`` with values in ``[-1, 1]``. padding_mode: ``"zeros"`` returns 0 for out-of-bounds samples; ``"border"`` clamps to the nearest border pixel. align_corners: If ``True``, grid extremes ``±1`` map to pixel centres at positions ``0`` and ``H-1``/``W-1``. Returns: Sampled tensor of shape ``(N, C, Hg, Wg)``. rNmpsbilinear)moderprq)rFborderzUnsupported padding_mode=zP for manual grid sampling. Only 'zeros' and 'border' are supported in this path.r r<).r).r g?g?rviy_ix_r c|z|zjdjdjd}jd|j S)Nr r<)flatten unsqueezeexpandgatherview) rwrxidx batch_sizechannelsflat grid_height grid_widthwidths r _gatherz&_bilinear_grid_sample.._gathersYU{S ))!,66q9@@XWYZ{{1c"'' Hk:VVrrF)torch.nn.functionalr_r`r"type grid_sampler rDfloorlongfloatr%r>r| new_tensorclampr{r4r)!rnrorprqFmsgheightixiyix0iy0ix1iy1wx1wy1onewx0wy0in_x0in_x1in_y0in_y1rv00v10v01v11rrrrrrs! @@@@@@r _bilinear_grid_samplers.$# ||E!}}UDz dq}rr..' '78D D o*/++'J&%"jjmTZZ]K6lQ519 - 16lQ6A: . 26lQ% '! +c 16lQ& (1 ,s 2 ((*// C ((*// C 'C 'C     , 6 6q 9C     , 6 6q 9C .. C )C )Cxii519%ii6A:&ii519%ii6A:&cEk*cEk*cFl+cFl+ii519%ii6A:&ii519%ii6A:& == DWU\\W WWW #s C #s C #s C #s CwUU]--a00UU]--a00UU]--a00UU]--a00 9s?S3Y_ ,sSy3 >sS PPrbatch.c`tt|}t|d||d<t|S)a`Module-level collate helper used as the base for :func:`make_collate_fn`. Defined at module scope (rather than as a closure inside :func:`make_collate_fn`) so that the resulting :class:`functools.partial` is picklable for multi-process DataLoaders and DDP spawn workers. Args: batch: List of ``(image, target)`` pairs from a dataset. block_size: When set, round batch ``H`` and ``W`` up to the next multiple of this value before padding. See :func:`nested_tensor_from_tensor_list`. Returns: Tuple of ``(NestedTensor_of_images, tuple_of_targets)``. rr;)rCrIrUr5)rr8s r _collate_with_block_sizer*s0" e E-eAh:NE!H <rct|dS)aCollate a list of (image, target) pairs into a batched NestedTensor. Uses :func:`nested_tensor_from_tensor_list` with no ``block_size`` rounding. For DataLoaders that need backbone-aware rounding (e.g. windowed attention requires divisibility by ``patch_size * num_windows``), use :func:`make_collate_fn` instead to obtain a parameterised collate callable. Args: batch: List of ``(image, target)`` pairs from a dataset. Returns: Tuple of ``(NestedTensor_of_images, tuple_of_targets)``. Nr;)r)rs r collate_fnr@s $Ed ;;rc$tt|S)a+Build a collate function that rounds batch ``H``/``W`` up to *block_size*. Used by the training DataModule to ensure that batched inputs satisfy the backbone's spatial divisibility requirement (``patch_size * num_windows``). Passing ``block_size=None`` produces a callable equivalent to :func:`collate_fn`. The returned callable is a :class:`functools.partial`, not a closure, so it is picklable and safe to use with multi-process DataLoaders (``num_workers > 0``) and DDP spawn workers. Args: block_size: When set, batch ``H`` and ``W`` are rounded up to the next multiple of this value before padding. The rounded-up strip is marked as padding in the NestedTensor mask. Returns: A collate callable suitable for ``torch.utils.data.DataLoader``. r;)rrr;s r make_collate_fnrPs& + CCrr)rFF)r3 functoolsrtypingrrr4r@rrcrrCrrrUjitunusedrBr.rHrr5rrrr6rr rs? ;;;;( 4S ? tCy  0!0!j")&f)&d )&)&\"++f++d ++++++b  \Q <<\Q ,,\Q\Q \Q  \\ \QB" c3h d  38_,