§
    9²¸jøJ  ã                  óî   — d Z ddlmZ ddlZddlmc mZ ddlm	Z	 ddl
mZ ddlmZ  ej        e¦  «        Z	 d2d3d„Z	 	 d2d4d„Z	 	 d2d5d„Z	 d6d7d„Z	 d8d9d&„Z	 	 	 	 	 d:d;d)„Z	 	 d<d=d+„Z	 d6d>d.„Z	 d6d?d1„ZdS )@uÿ  Vision utility functions for pre-computing very dynamic and
data-dependent tensors that can break model graph capturing.

All functions are standalone (no model weights) and compute tensors from
`grid_thw` + config scalars. They are used by vision encoders and can be
precomputed before `torch.compile` / `torch.export` tracing since they
use untraceable ops (`repeat_interleave`, `.tolist()`, `nonzero()`, loops).

Each `get_*` accepts an optional `kwargs` dict; if it contains the
precomputed tensor under the natural key (`"cu_seqlens"`, `"position_ids"`,
â€¦), the function pops and returns it instead of computing. Vision encoders
write `x = get_vision_x(..., kwargs=kwargs)` and the matching key is
removed from the caller's kwargs as a side-effect of the pop.
é    )ÚannotationsNé   )ÚPreTrainedConfig)Úlogging)Úget_max_seqlenFÚgrid_thwútorch.TensorÚmerge_temporalÚboolÚkwargsúdict | NoneÚreturnc                ó²  — |�|                      dd¦  «        x}�|S t          j                             ¦   «         r| j        nt          j        }|r'| dd…df         | dd…df         z  | dd…df         z  }n6t          j        | dd…df         | dd…df         z  | dd…df         ¦  «        }t          j        | 	                    d|¬¦  «        dd¬¦  «        S )	uÓ  Get cumulative sequence lengths from vision grid info, or pop from `kwargs` if precomputed.

    Args:
        grid_thw: `(num_images_or_videos, 3)` â€” temporal, height, width per entry.
        merge_temporal: when `False` (default), each frame is its own attention segment (`h * w`
            per frame, `t` segments per entry â€” the qwen2_vl / glm4v convention). When `True`,
            the whole clip is a single segment (`t * h * w`), i.e. attention spans all frames
            jointly (the kimi_k25 convention).
        kwargs: optional caller kwargs â€” if it contains `"cu_seqlens"` it is popped and returned.

    Returns:
        `cu_seqlens`: `(num_segments + 1,)` int32 cumulative sequence boundaries.
    NÚ
cu_seqlensr   r   é   )ÚdimÚdtype©r   r   )Úvalue)
ÚpopÚtorchÚjitÚ
is_tracingr   Úint32Úrepeat_interleaveÚFÚpadÚcumsum)r   r
   r   r   r   Úseqlenss         úi/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/transformers/vision_utils.pyÚget_vision_cu_seqlensr!   *   sí   € ð  Ð¨V¯ZªZ¸ÀdÑ-KÔ-KÐK˜zÐXØÐÝ#œi×2Ò2Ñ4Ô4ÐEˆHŒNˆN½%¼+€EØð [Ø˜1˜1˜1˜a˜4”. 8¨A¨A¨A¨q¨D¤>Ñ1°H¸Q¸Q¸QÀ¸T´NÑBˆˆåÔ)¨(°1°1°1°a°4¬.¸8ÀAÀAÀAÀqÀD¼>Ñ*IÈ8ÐTUÐTUÐTUÐWXÐTXÌ>ÑZÔZˆÝŒ5�—’ A¨U�Ñ3Ô3°VÀ1ÐEÑEÔEÐEó    Úconfigr   útuple[torch.Tensor, int | None]c                óR   — t          | ||¬¦  «        }t          |||¬¦  «        }||fS )z½Get cumulative and maximum sequence lengths for packed vision attention. ``merge_temporal`` is
    forwarded to [`get_vision_cu_seqlens`] (``True`` for clip-level attention, e.g. kimi_k25).)r
   r   )r   )r!   r   )r   r#   r
   r   r   Ú
max_seqlens         r    Úget_vision_attention_seqlensr'   D   s8   € õ ' xÀÐW]Ð^Ñ^Ô^€JÝ 
¨F¸6ÐBÑBÔB€JØ�zÐ!Ð!r"   Úspatial_merge_sizeúint | torch.TensorÚinclude_temporalc           
     óš  — |�|                      dd¦  «        x}�|S | j        }t          |t          ¦  «        r7t	          j        |g|¬¦  «                             t          | ¦  «        ¦  «        }g }t          |  	                    ¦   «         | 	                    ¦   «         ¦  «        D �]�\  \  }}}}	t	          j
        t	          j        ||¬¦  «        t	          j        ||¬¦  «        d¬¦  «        \  }
}||	z  |	||	z  |	f}|
                     |¦  «                             dd¦  «                             ¦   «         }
|                     |¦  «                             dd¦  «                             ¦   «         }|r€t	          j        ||¬¦  «                             ||z  ¦  «        }|                     t	          j        ||
                     |¦  «        |                     |¦  «        gd¬	¦  «        ¦  «         �ŒP|                     t	          j        |
|gd¬	¦  «                             |d¦  «        ¦  «         �Œ‘t	          j        |d
¬	¦  «        S )u  Get position IDs for vision rotary embeddings, or pop from `kwargs` if precomputed.

    Args:
        grid_thw: `(num_images_or_videos, 3)`
        spatial_merge_size: merge block size â€” either a single `int` (same for all images)
            or a `(num_images_or_videos,)` tensor (per-image).
        kwargs: optional caller kwargs â€” if it contains `"position_ids"` it is popped and returned.
        include_temporal: when ``True``, prepend a temporal-index column and return
            `(total_tokens, 3)` â€” for encoders whose rotary embedding rotates T/H/W axes
            (minimax_m3_vl). When ``False`` (default), return `(total_tokens, 2)` for the
            2-axis (h, w) case (qwen2_5_vl / qwen3_vl / glm4v / paddleocr_vl); the h/w
            indices are still repeated ``t`` times for video inputs.

    Returns:
        `position_ids`: `(total_tokens, 3)` long if ``include_temporal`` else `(total_tokens, 2)`,
        with the spatial indices laid out block-major over ``mÃ—m`` spatial-merge blocks.
    NÚposition_ids©ÚdeviceÚij)Úindexingr   r   éÿÿÿÿ©r   r   )r   r.   Ú
isinstanceÚintr   ÚtensorÚexpandÚlenÚzipÚtolistÚmeshgridÚarangeÚreshapeÚ	transposeÚflattenr   ÚappendÚstackÚrepeatÚcat)r   r(   r*   r   r,   r.   ÚtÚhÚwÚ
merge_sizeÚhpos_idsÚwpos_idsÚblock_shapeÚtpos_idss                 r    Úget_vision_position_idsrK   Q   s6  € ð. Ð¨v¯zªz¸.È$Ñ/OÔ/OÐO˜|Ð\ØÐàŒ_€FÝÐ$¥cÑ*Ô*ð eÝ"œ\Ð+=Ð*>ÀvÐNÑNÔN×UÒUÕVYÐZbÑVcÔVcÑdÔdÐà€LÝ!$ X§_¢_Ñ%6Ô%6Ð8J×8QÒ8QÑ8SÔ8SÑ!TÔ!Tð Xñ XÑ‰	ˆˆAˆq�:Ý"œ^ÝŒL˜ 6Ð*Ñ*Ô*ÝŒL˜ 6Ð*Ñ*Ô*Øð
ñ 
ô 
Ñˆ�(ð
 ˜J‘¨
°A¸±OÀZÐPˆØ×#Ò# KÑ0Ô0×:Ò:¸1¸aÑ@Ô@×HÒHÑJÔJˆØ×#Ò# KÑ0Ô0×:Ò:¸1¸aÑ@Ô@×HÒHÑJÔJˆØð 	XÝ”| A¨fÐ5Ñ5Ô5×GÒGÈÈAÉÑNÔNˆHØ×Ò¥¤¨X°x·²ÀqÑ7IÔ7IÈ8Ï?Ê?Ð[\ÑK]ÔK]Ð,^ÐdfÐ gÑ gÔ gÑhÔhÐhÑhà×Ò¥¤¨X°xÐ,@ÀbÐ IÑ IÔ I× PÒ PÐQRÐTUÑ VÔ VÑWÔWÐWÑWåŒ9�\ qÐ)Ñ)Ô)Ð)r"   r4   Úwindow_sizeÚ
patch_sizeú!tuple[torch.Tensor, torch.Tensor]c                óÄ  — |�4|                      dd¦  «        }|                      dd¦  «        }|�|�||fS g }dg}d}||z  |z  }|dz  }	|                      ¦   «         D �]­\  }
}}t          |
¦  «        t          |¦  «        t          |¦  «        }}}
||z  }||z  }t          j        |
|z  |z  ¦  «                             |
||¦  «        }|||z  z
  }|||z  z
  }||z   |z  }||z   |z  }t          j        |d|d|fdd¦  «        }|                     |
||||¦  «        }|                     ddd	dd
¦  «                             |
||z  ||¦  «        }|dk     	                    dd	g¦  «                             d¦  «        }|                     d¦  «        }||dk             }| 
                    ||z   ¦  «         |                     d¦  «        |	z  |d         z   }|                     |                     ¦   «         ¦  «         ||
|z  |z  z  }�Œ¯t          j        |d¬¦  «        }t          j        || j        t          j        ¬¦  «        }t          j        |¦  «        }||fS )u   Get window attention indices, or pop `"window_index"`/`"cu_window_seqlens"` from `kwargs` if both precomputed.

    Args:
        grid_thw: `(num_images_or_videos, 3)`
        spatial_merge_size: merge block size from vision config.
        window_size: window size from vision config.
        patch_size: patch size from vision config.
        kwargs: optional caller kwargs â€” if it contains both `"window_index"` and `"cu_window_seqlens"` they are popped and returned.

    Returns:
        `window_index`: `(total_tokens,)` long â€” reorder indices for windowed attention.
        `cu_window_seqlens`: `(num_windows + 1,)` int32 â€” cumulative window boundaries.
    NÚwindow_indexÚcu_window_seqlensr   r   Úconstantiœÿÿÿr   é   é   r1   r2   )r.   r   )r   r9   r4   r   r;   r<   r   r   ÚpermuteÚsumr?   r   ÚextendrB   r5   r.   r   Úunique_consecutive)r   r(   rL   rM   r   rP   rQ   Úwindow_index_idÚvit_merger_window_sizeÚspatial_merge_unitÚgrid_tÚgrid_hÚgrid_wÚ
llm_grid_hÚ
llm_grid_wÚindexÚpad_hÚpad_wÚnum_windows_hÚnum_windows_wÚindex_paddedr   Ú	index_newÚcu_seqlens_tmps                           r    Úget_vision_window_indexri   ‚   sÆ  € ð( ÐØ—z’z .°$Ñ7Ô7ˆØ"ŸJšJÐ':¸DÑAÔAÐØÐ#Ð(9Ð(EØÐ!2Ð2Ð2Ø€LØ ˜cÐØ€OØ(Ð,>Ñ>À*ÑLÐØ+¨QÑ.Ðà"*§/¢/Ñ"3Ô"3ð <ñ <Ñˆ�˜Ý!$ V¡¤­c°&©k¬k½3¸v¹;¼;˜�ˆØÐ1Ñ1ˆ
ØÐ1Ñ1ˆ
Ý”˜V jÑ0°:Ñ=Ñ>Ô>×FÒFÀvÈzÐ[eÑfÔfˆØ&¨Ð6LÑ)LÑLˆØ&¨Ð6LÑ)LÑLˆØ# eÑ+Ð0FÑFˆØ# eÑ+Ð0FÑFˆÝ”u˜U Q¨¨q°%Ð$8¸*ÀdÑKÔKˆØ#×+Ò+Ø�MÐ#9¸=ÐJ`ñ
ô 
ˆð $×+Ò+¨A¨q°!°Q¸Ñ:Ô:×BÒBØ�M MÑ1Ð3IÐKañ
ô 
ˆð   4Ò'×,Ò,¨a°¨VÑ4Ô4×<Ò<¸RÑ@Ô@ˆØ#×+Ò+¨BÑ/Ô/ˆØ  °Ò!5Ô6ˆ	Ø×Ò˜I¨Ñ7Ñ8Ô8Ð8Ø Ÿš¨Ñ*Ô*Ð-?Ñ?ÐBSÐTVÔBWÑWˆØ× Ò  ×!6Ò!6Ñ!8Ô!8Ñ9Ô9Ð9Ø˜6 JÑ.°Ñ;Ñ;ˆ‰å”9˜\¨qÐ1Ñ1Ô1€LÝœÐ%6¸x¼ÕV[ÔVaÐbÑbÔbÐÝÔ0Ð1BÑCÔCÐØÐ*Ð*Ð*r"   Úborderra   ÚsizeÚsideÚmodeÚstrÚalign_cornersÚpaddingc                ój  — |                       t          j        ¦  «        } |r#| |dz
  z  t          j        |dz
  d¬¦  «        z  }n| dz   |z  |z  dz
  }t          j        |¦  «        }|dk    rt          j        dd| j        ¬¦  «        }n6|dk    rt          j        d	d
| j        ¬¦  «        }nt          d|›d�¦  «        ‚|                     ¦   «         dd…df         |z   }	|	                     d|dz
  ¦  «        }
|dd…df         |dd…df         z
  |z
   	                    ¦   «         }|dk    rd|z
                       d¬¦  «        }nPd}|dz   |z  |d
z   z
  |z  |z  dz   }||z  d|z  z
  |z  d|z  z   |z  d|z  z
  }t          j
        |dk    ||¦  «        }|dk    r||	dk    |	|dz
  k    z  z  }|
|fS )u  Per-axis interpolation taps into a `side`-length source table and their weights, for `index`
    target positions on an axis of length `size`. `mode` selects the kernel width â€” 2 taps
    (`"bilinear"`) or 4 taps (`"bicubic"`, Keys convolution kernel with `a=-0.75`). `size` may be a
    scalar or a per-element tensor (ragged batches). `padding` controls out-of-range taps: `"border"`
    clamps to the edge value (like `F.interpolate`), `"zeros"` gives them zero weight (like
    `F.grid_sample(padding_mode="zeros")`).r   )Úming      à?Úbilinearr   r   r-   Úbicubicr1   rS   zUnsupported interpolation mode z$ (expected 'bilinear' or 'bicubic').Ng      è¿é   é   rT   Úzeros)Útor   Úfloat32ÚclampÚfloorr;   r.   Ú
ValueErrorÚlongÚabsÚwhere)ra   rk   rl   rm   ro   rp   Úsrcr{   ÚoffsetsÚraw_tapsÚtapsÚdistanceÚweightsÚaÚnearÚfars                   r    Ú _interpolation_axis_taps_weightsr‰   ¿   s  € ð �HŠH•U”]Ñ#Ô#€EØð 0ð �t˜a‘xÑ ¥5¤;¨t°a©x¸QÐ#?Ñ#?Ô#?Ñ?ˆˆà�s‰{˜dÑ" TÑ)¨CÑ/ˆÝŒK˜ÑÔ€EØˆzÒÐÝ”,˜q !¨E¬LÐ9Ñ9Ô9ˆˆØ	�Ò	Ð	Ý”,˜r 1¨U¬\Ð:Ñ:Ô:ˆˆåÐg¸4ÐgÐgÐgÑhÔhÐhØ�zŠz‰|Œ|˜A˜A˜A˜t˜GÔ$ wÑ.€HØ�>Š>˜!˜T A™XÑ&Ô&€DØ�A�A�A�t�G”˜u Q Q Q¨ Wœ~Ñ-°Ñ7×<Ò<Ñ>Ô>€HØˆzÒÐØ�x‘<×&Ò&¨1Ð&Ñ-Ô-ˆˆàˆØ�Q‘˜(Ñ" a¨!¡eÑ,°Ñ8¸8ÑCÀaÑGˆØ�H‘˜q 1™uÑ$¨Ñ0°1°q±5Ñ8¸HÑDÀqÈ1ÁuÑLˆÝ”+˜h¨!šm¨T°3Ñ7Ô7ˆØ�'ÒÐð ˜h¨!šm°¸DÀ1¹HÒ0DÑEÑFˆØ�ˆ=Ðr"   rs   Únum_grid_per_sidec                ó   — |�4|                      dd¦  «        }|                      dd¦  «        }|�|�||fS |}	|}
| j        }| dd…df         | dd…df         z  | dd…df         z  }t          j        | dd…df         |¦  «        }t          j        | dd…df         |¦  «        }t          j        t	          j        |                     d¦  «        dd…         d¦  «        |¦  «        }t          j        |                     ¦   «         |¬	¦  «        |z
  ||z  z  }||
z  }||
z  }||
z  |
z  }||
|
z  z  |z  }||
|
z  |z  z  }||
z  |z   }||
z  |z   }t          |||	|||¦  «        \  }}t          |||	|||¦  «        \  }}|j
        d         }|dd…dd…df         |	z  |dd…ddd…f         z                        d||z  ¦  «        }|dd…dd…df         |dd…ddd…f         z                       d||z  ¦  «        }||fS )
u-  Per-patch gather indices/weights that resample a square learned `(num_grid_per_side,
    num_grid_per_side)` position-embedding table to each image's `(h, w)` grid, or pop
    `"interp_indices"`/`"interp_weights"` from `kwargs` if both precomputed.

    Reproduces `F.interpolate(mode=mode, align_corners=align_corners)` as `(total_patches, n_taps)`
    indices + weights (`n_taps` = 4 for `"bilinear"`, 16 for `"bicubic"` â€” the Keys kernel with
    `a=-0.75`), consumed by a fused `F.embedding_bag` or a weighted `embedding` sum. Fully vectorised
    over packed patches (ragged `(h, w)` handled with `repeat_interleave`, no per-image loop), so it
    supports dynamic shapes like the other grid_thw precompute helpers. `spatial_merge_size > 1`
    emits patches in spatial-merge-block order (for encoders that consume merged tokens); `1` keeps
    raster order.

    Args:
        grid_thw: `(num_images_or_videos, 3)` â€” temporal, height, width per entry.
        num_grid_per_side: `int(num_position_embeddings ** 0.5)` from the vision config.
        mode: `"bilinear"` or `"bicubic"`.
        align_corners: matches the corresponding `F.interpolate` flag.
        spatial_merge_size: merge block size; `1` keeps raster patch order.
        kwargs: optional caller kwargs â€” if it contains both `"interp_indices"` and `"interp_weights"`
            they are popped and returned.

    Returns:
        `indices`: `(total_thw, n_taps)` long â€” gather indices into the flattened pos_embed table.
        `weights`: `(total_thw, n_taps)` float â€” interpolation weights.
    NÚinterp_indicesÚinterp_weightsr   r   r   r1   r   r-   )r   r.   r   r   r   r   r   r;   rV   r‰   Úshaper<   )r   rŠ   rm   ro   r(   rp   r   rŒ   r�   rl   Úmerger.   ÚcountsÚheightsÚwidthsÚstartsÚwithinÚblocks_wÚin_colÚin_rowÚ	block_colÚ	block_rowÚrowÚcolÚh_tapsÚ	h_weightsÚw_tapsÚ	w_weightsÚnÚindicesr…   s                                  r    Ú,get_vision_interpolation_indices_and_weightsr¢   ç   sl  € ðD ÐØŸšÐ$4°dÑ;Ô;ˆØŸšÐ$4°dÑ;Ô;ˆØÐ%¨.Ð*DØ! >Ð1Ð1à€DØ€EØŒ_€Fà�a�a�a˜�dŒ^˜h q q q¨! tœnÑ,¨x¸¸¸¸1¸¬~Ñ=€FÝÔ% h¨q¨q¨q°!¨t¤n°fÑ=Ô=€GÝÔ$ X¨a¨a¨a°¨d¤^°VÑ<Ô<€FÝÔ$¥Q¤U¨6¯=ª=¸Ñ+;Ô+;¸C¸R¸CÔ+@À&Ñ%IÔ%IÈ6ÑRÔR€FåŒl˜6Ÿ:š:™<œ<°Ð7Ñ7Ô7¸&Ñ@ÀWÈvÑEUÑV€Fð ˜‰€HØ�e‰^€FØ˜‰o Ñ&€FØ˜E E™MÑ*¨hÑ6€IØ˜5 5™=¨8Ñ3Ñ4€IØ
�eÑ
˜fÑ
$€CØ
�eÑ
˜fÑ
$€Cå8¸¸gÀtÈTÐS`ÐbiÑjÔjÑ€FˆIÝ8¸¸fÀdÈDÐR_ÐahÑiÔiÑ€FˆIØŒ�QŒ€Aà�a�a�a˜˜˜˜D�jÔ! DÑ(¨6°!°!°!°T¸1¸1¸1°*Ô+=Ñ=×FÒFÀrÈ1ÈqÉ5ÑQÔQ€GØ˜˜˜˜A˜A˜A˜t˜Ô$ y°°°°D¸!¸!¸!°Ô'<Ñ<×EÒEÀbÈ!ÈaÉ%ÑPÔP€GØ�GÐÐr"   Tc                ó(  — t                                d¦  «         |�4|                     dd¦  «        }|                     dd¦  «        }|�|�||fS t          | |dd|¬¦  «        \  }}|                     dd	¦  «        |                     dd	¦  «        fS )
uÚ   Deprecated â€” use [`get_vision_interpolation_indices_and_weights`] with `mode="bilinear"`,
    `align_corners=True`. Returns the legacy `(4, total_thw)` layout (transpose of the unified helper's
    `(total_thw, 4)`).a  `get_vision_bilinear_indices_and_weights` is deprecated and will be removed in v5.17. Use `get_vision_interpolation_indices_and_weights(..., mode='bilinear', align_corners=True)` instead (it returns `(total_thw, n_taps)`, the transpose of this function's output).NÚbilinear_indicesÚbilinear_weightsrs   T)rm   ro   r(   r   r   )ÚloggerÚwarning_oncer   r¢   r=   )	r   rŠ   r(   ro   r   r¤   r¥   r¡   r…   s	            r    Ú'get_vision_bilinear_indices_and_weightsr¨   ,  s¿   € õ ×Òð	_ñô ð ð
 ÐØ!Ÿ:š:Ð&8¸$Ñ?Ô?ÐØ!Ÿ:š:Ð&8¸$Ñ?Ô?ÐØÐ'Ð,<Ð,HØ#Ð%5Ð5Ð5ÝCØÐ#¨*ÀDÐ]oðñ ô Ñ€GˆWð ×Ò˜Q Ñ"Ô" G×$5Ò$5°a¸Ñ$;Ô$;Ð;Ð;r"   Útarget_sizesÚnum_patches_per_sidec                óN  — |�|                      dd¦  «        x}�|S | j        }t          j        d|z  dd|z  |¬¦  «        }g }|                      ¦   «         D ]º\  }}t          |¦  «        t          |¦  «        }}t          j        ||¬¦  «        |z  }	t          j        ||¬¦  «        |z  }
t          j        |	|d¬¦  «        }t          j        |
|d¬¦  «        }|                     |dd…df         |z  |z                        ¦   «         ¦  «         Œ»t          j	        |¦  «        S )u  Get nearest-neighbor position IDs into a `num_patches_per_side**2` 2-D table, or pop
    from `kwargs` if precomputed.

    For each image of size `(h, w)`, maps fractional grid coordinates `i/h` to the nearest
    bucket on a `num_patches_per_side` grid (via `bucketize`) and flattens to 1-D embedding
    indices, concatenated across all images. Used by NaViT-style packers (e.g. MiniCPM-V).

    Args:
        target_sizes: `(num_images, 2)` int â€” `(h, w)` per image.
        num_patches_per_side: side length of the learned 2-D position-embedding grid.
        kwargs: optional caller kwargs â€” if it contains `"position_ids"` it is popped and returned.

    Returns:
        `position_ids`: `(sum(h_i * w_i),)` long â€” flat indices into a `num_patches_per_side**2` table.
    Nr,   r   g      ð?r-   T)Úright)
r   r.   r   r;   r9   r4   Ú	bucketizer?   r>   rB   )r©   rª   r   Úpos_idsr.   Ú
boundariesÚpos_ids_listÚheightÚwidthÚh_coordsÚw_coordsÚbucket_hÚbucket_ws                r    Úget_vision_nearest_position_idsr·   F  s8  € ð$ Ð¨&¯*ª*°^ÀTÑ*JÔ*JÐJ˜wÐWØˆØÔ €FÝ”˜aÐ"6Ñ6¸¸QÐAUÑ=UÐ^dÐeÑeÔe€JØ€LØ%×,Ò,Ñ.Ô.ð ]ð ]‰ˆ�Ý˜F™œ¥S¨¡Z¤Z�ˆÝ”< ¨vÐ6Ñ6Ô6¸Ñ?ˆÝ”< ¨fÐ5Ñ5Ô5¸Ñ=ˆÝ”? 8¨Z¸tÐDÑDÔDˆÝ”? 8¨Z¸tÐDÑDÔDˆØ×Ò˜X a a a¨ gÔ.Ð1EÑEÈÑP×YÒYÑ[Ô[Ñ\Ô\Ð\Ð\ÝŒ9�\Ñ"Ô"Ð"r"   Úwindow_kernel_sizeútuple[int, int]c                óì   — |�|                      dd¦  «        x}�|S |\  }}t          | d                              ¦   «         ¦  «        |z  t          | d                              ¦   «         ¦  «        |z  fS )uÔ  Get post-window-merge `(merged_h, merged_w)` Python ints, or pop from `kwargs` if precomputed.

    `.view()` needs Python ints, but `target_sizes[0].item()` is non-traceable. Callers must pop
    the precomputed value from `kwargs` when running under `torch.export`. Assumes uniform
    `target_sizes` across the batch (standard NaViT preprocessing output).

    Args:
        target_sizes: `(num_images, 2)` int â€” `(h, w)` per image.
        window_kernel_size: `(window_h, window_w)` window-attention kernel.
        kwargs: optional caller kwargs â€” if it contains `"merged_shape"` it is popped and returned.

    Returns:
        `(merged_h, merged_w)`: per-image grid size after window merging, as Python ints.
    NÚmerged_shape)r   r   )r   r   )r   r4   Úitem)r©   r¸   r   ÚmergedÚwindow_hÚwindow_ws         r    Úget_vision_merged_shaperÀ   g  sy   € ð" Ð¨¯ª°NÀDÑ)IÔ)IÐI˜vÐVØˆØ+Ñ€HˆhÝˆ|˜DÔ!×&Ò&Ñ(Ô(Ñ)Ô)¨XÑ5µs¸<ÈÔ;M×;RÒ;RÑ;TÔ;TÑ7UÔ7UÐYaÑ7aÐaÐar"   )FN)r   r	   r
   r   r   r   r   r	   )
r   r	   r#   r   r
   r   r   r   r   r$   )
r   r	   r(   r)   r*   r   r   r   r   r	   )N)r   r	   r(   r4   rL   r4   rM   r4   r   r   r   rN   )rj   )ra   r	   rk   r	   rl   r4   rm   rn   ro   r   rp   rn   r   rN   )rs   Fr   rj   N)r   r	   rŠ   r4   rm   rn   ro   r   r(   r4   rp   rn   r   r   r   rN   )TN)r   r	   rŠ   r4   r(   r4   ro   r   r   r   r   rN   )r©   r	   rª   r4   r   r   r   r	   )r©   r	   r¸   r¹   r   r   r   r¹   )Ú__doc__Ú
__future__r   r   Útorch.nn.functionalÚnnÚ
functionalr   Úconfiguration_utilsr   Úutilsr   Úutils.genericr   Ú
get_loggerÚ__name__r¦   r!   r'   rK   ri   r‰   r¢   r¨   r·   rÀ   © r"   r    ú<module>rÌ      sÜ  ððð ð #Ð "Ð "Ð "Ð "Ð "à €€€Ø Ð Ð Ð Ð Ð Ð Ð Ð à 1Ð 1Ð 1Ð 1Ð 1Ð 1Ø Ð Ð Ð Ð Ð Ø )Ð )Ð )Ð )Ð )Ð )ð 
ˆÔ	˜HÑ	%Ô	%€ð QUðFð Fð Fð Fð Fð: !Øð	
"ð 
"ð 
"ð 
"ð 
"ð  #Øð	.*ð .*ð .*ð .*ð .*ðl ð:+ð :+ð :+ð :+ð :+ð| hpð%ð %ð %ð %ð %ðV ØØØØðBð Bð Bð Bð BðR Øð<ð <ð <ð <ð <ð6 RVð#ð #ð #ð #ð #ðD \`ðbð bð bð bð bð bð br"   