
    <hwb                        S r SSKrSSKJr  SSKJr  SSKrSSKJs  J	r
  SSKJrJr  SSKJr  SSKJr  SS	KJr  SS
KJrJrJr  SSKJrJrJrJr  SSKJrJr  SSKJr  SSK J!r!  \RD                  " \#5      r$ " S S\!5      r%\\" SS9 " S S\5      5       5       r& " S S\5      r' " S S\5      r( " S S\\RR                  5      r* " S S\5      r+ " S S\5      r, " S  S!\5      r- " S" S#\R\                  5      r/ " S$ S%\RR                  5      r0 " S& S'\RR                  5      r1 " S( S)\RR                  5      r2\ " S* S+\5      5       r3\" S,S9 " S- S.\\RR                  5      5       r4/ S/Qr5g)0zPyTorch EoMT model.    N)	dataclass)Optional)Tensornn   )ACT2FN)ModelOutput)PreTrainedModel)auto_docstringcan_return_tuplelogging   )Dinov2EmbeddingsDinov2LayerDinov2LayerScaleDinov2PatchEmbeddings)#Mask2FormerForUniversalSegmentationMask2FormerLoss)SiglipAttention)	ViTConfigc                      ^  \ rS rSrSrSr                          SS\S\S\S\S\S	\S
\4U 4S jjjrSr	U =r
$ )
EomtConfig1   a  
This is the configuration class to store the configuration of a [`EomtForUniversalSegmentation`]. It is used to instantiate an EoMT model
according to the specified arguments, defining the model architecture. Instantiating a configuration with the
defaults will yield a similar configuration to that of the EoMT
[tue-mps/coco_panoptic_eomt_large_640](https://huggingface.co/tue-mps/coco_panoptic_eomt_large_640)
architecture.

Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
documentation from [`PretrainedConfig`] for more information.

Args:
    hidden_size (`int`, *optional*, defaults to 1024):
        Dimensionality of the hidden representations.
    num_hidden_layers (`int`, *optional*, defaults to 24):
        Number of hidden layers in the Transformer encoder.
    num_attention_heads (`int`, *optional*, defaults to 16):
        Number of attention heads in each attention layer.
    mlp_ratio (`int`, *optional*, defaults to 4):
        Ratio of the MLP hidden dimensionality to the hidden size.
    hidden_act (`str` or `function`, *optional*, defaults to `"gelu"`):
        The non-linear activation function (function or string) in the encoder.
    hidden_dropout_prob (`float`, *optional*, defaults to 0.0):
        The dropout probability for all fully connected layers in the embeddings and encoder.
    initializer_range (`float`, *optional*, defaults to 0.02):
        The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
    layer_norm_eps (`float`, *optional*, defaults to 1e-06):
        The epsilon used by the layer normalization layers.
    image_size (`int`, *optional*, defaults to 640):
        The size (resolution) of each input image.
    patch_size (`int`, *optional*, defaults to 16):
        The size (resolution) of each patch.
    num_channels (`int`, *optional*, defaults to 3):
        The number of input channels.
    layerscale_value (`float`, *optional*, defaults to 1.0):
        Initial value for the LayerScale parameter.
    drop_path_rate (`float`, *optional*, defaults to 0.0):
        The stochastic depth rate (drop path) used during training.
    num_upscale_blocks (`int`, *optional*, defaults to 2):
        Number of upsampling blocks used in the decoder or segmentation head.
    attention_dropout (`float`, *optional*, defaults to 0.0):
        Dropout probability applied after attention projection.
    use_swiglu_ffn (`bool`, *optional*, defaults to `False`):
        Whether to use the SwiGLU feedforward neural network.
    num_blocks (`int`, *optional*, defaults to 4):
        Number of feature blocks or stages in the architecture.
    no_object_weight (`float`, *optional*, defaults to 0.1):
        Loss weight for the 'no object' class in panoptic/instance segmentation.
    class_weight (`float`, *optional*, defaults to 2.0):
        Loss weight for classification targets.
    mask_weight (`float`, *optional*, defaults to 5.0):
        Loss weight for mask prediction.
    dice_weight (`float`, *optional*, defaults to 5.0):
        Loss weight for the dice loss component.
    train_num_points (`int`, *optional*, defaults to 12544):
        Number of points to sample for mask loss computation during training.
    oversample_ratio (`float`, *optional*, defaults to 3.0):
        Oversampling ratio used in point sampling for mask training.
    importance_sample_ratio (`float`, *optional*, defaults to 0.75):
        Ratio of points to sample based on importance during training.
    num_queries (`int`, *optional*, defaults to 200):
        Number of object queries in the Transformer.
    num_register_tokens (`int`, *optional*, defaults to 4):
        Number of learnable register tokens added to the transformer input.

Example:

```python
>>> from transformers import EomtConfig, EomtForUniversalSegmentation

>>> # Initialize configuration
>>> config = EomtConfig()

>>> # Initialize model
>>> model = EomtForUniversalSegmentation(config)

>>> # Access config
>>> config = model.config
```eomtno_object_weightclass_weightmask_weightdice_weighttrain_num_pointsoversample_ratioimportance_sample_ratioc                 *  > [         TU ]  " SUUUUUUUU	U
US.
UD6  U ?U ?U ?U ?U ?U ?X@l        Xl	        Xl
        Xl        Xl        UU l        UU l        UU l        UU l        UU l        UU l        UU l        UU l        UU l        UU l        UU l        g )N)
hidden_sizenum_hidden_layersnum_attention_headshidden_dropout_prob
hidden_actinitializer_rangelayer_norm_eps
image_size
patch_sizenum_channels )super__init__intermediate_sizeqkv_bias
pooler_actpooler_output_sizeencoder_strideattention_probs_dropout_prob	mlp_ratioattention_dropoutlayerscale_valuedrop_path_ratenum_upscale_blocksuse_swiglu_ffn
num_blocksr   r   r   r   r   r    r!   num_queriesnum_register_tokens)selfr#   r$   r%   r6   r'   r&   r(   r)   r*   r+   r,   r8   r9   r:   r7   r;   r<   r   r   r   r   r   r    r!   r=   r>   kwargs	__class__s                               ]/var/www/html/shao/venv/lib/python3.13/site-packages/transformers/models/eomt/modular_eomt.pyr/   EomtConfig.__init__   s    < 	 	
#/ 3 3!/)!!%	
 	
 "MO#-"!2 0,"4,$ 0(&& 0 0'>$&#6     )r7   r   r   r9   r!   r8   r   r6   r   r<   r=   r>   r:   r    r   r;   )i            gelu        g{Gz?ư>i  rF   r         ?rI   r   rI   FrG   g?g       @      @rL   i 1  g      @g      ?   rG   )__name__
__module____qualname____firstlineno____doc__
model_typefloatintr/   __static_attributes____classcell__rA   s   @rB   r   r   1   s    M^ J "%!   %"%)-7B7&  'B7( )B7* +B7, -B7. /B70  1B72 "'3B7 B7rD   r   a  
    Class for outputs of [`EomtForUniversalSegmentationOutput`].

    This output can be directly passed to [`~EomtImageProcessor.post_process_semantic_segmentation`] or
    [`~EomtImageProcessor.post_process_instance_segmentation`] or
    [`~EomtImageProcessor.post_process_panoptic_segmentation`] to compute final segmentation maps. Please, see
    [`~EomtImageProcessor] for details regarding usage.
    )custom_introc                   D   \ rS rSr% SrSr\\R                     \	S'   Sr
\\R                     \	S'   Sr\\R                     \	S'   Sr\\R                     \	S'   Sr\\\R                        \	S'   Sr\\\R                        \	S	'   Sr\\\R$                        \	S
'   Srg)"EomtForUniversalSegmentationOutputrM   a  
loss (`torch.Tensor`, *optional*):
    The computed loss, returned when labels are present.
class_queries_logits (`torch.FloatTensor`):
    A tensor of shape `(batch_size, num_queries, num_labels + 1)` representing the proposed classes for each
    query. Note the `+ 1` is needed because we incorporate the null class.
masks_queries_logits (`torch.FloatTensor`):
    A tensor of shape `(batch_size, num_queries, height, width)` representing the proposed masks for each
    query.
last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
    Last hidden states (final feature map) of the last layer.
hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
    Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
    shape `(batch_size, sequence_length, hidden_size)`. Hidden-states all layers of the model.
attentions (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
    Tuple of `tuple(torch.FloatTensor)` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
    sequence_length)`. Self and Cross Attentions weights from transformer decoder.
patch_offsets (`list[torch.Tensor]`, *optional*):
    list of tuples indicating the image index and start and end positions of patches for semantic segementation.
Nlossclass_queries_logitsmasks_queries_logitslast_hidden_statehidden_states
attentionspatch_offsetsr-   )rN   rO   rP   rQ   rR   r\   r   torchFloatTensor__annotations__r]   r^   r_   r`   tuplera   rb   listr   rV   r-   rD   rB   r[   r[      s    * )-D(5$$
%,8<(5#4#45<8<(5#4#45<59x 1 1298<M8E%"3"345<59Ju0012926M8D./6rD   r[   c                       \ rS rSrSrg)EomtLoss   r-   NrN   rO   rP   rQ   rV   r-   rD   rB   ri   ri          rD   ri   c                       \ rS rSrSrg)EomtPatchEmbeddings   r-   Nrk   r-   rD   rB   rn   rn      rl   rD   rn   c                   f    \ rS rSrS\SS4S jrS rS\R                  S\R                  4S jr	S	r
g)
EomtEmbeddings   configreturnNc                    [        5       R                  5         Xl        UR                  U l        [        R
                  " [        R                  " SSUR                  5      5      U l	        [        R
                  " [        R                  " SUR                  UR                  5      5      U l        [        U5      U l        U R                  R                  n[        R                   " UR"                  5      U l        SUR                  -   U l        [        R(                  " X!R                  5      U l        U R-                  S[        R.                  " U5      R1                  S5      SS9  g )N   position_ids)rv   F)
persistent)r   r/   rs   r+   r   	Parameterrc   randnr#   	cls_tokenzerosr>   register_tokensrn   patch_embeddingsnum_patchesDropoutr&   dropoutnum_prefix_tokens	Embeddingposition_embeddingsregister_bufferarangeexpand)r?   rs   r   s      rB   r/   EomtEmbeddings.__init__   s    ##% ++ekk!Q8J8J&KL!||EKK6;U;UW]WiWi,jk 3F ;++77zz&"<"<=!"V%?%?!?#%<<=O=O#P ^U\\+-F-M-Mg-VchirD   c                     [        S5      e)NzNot needed for Eomt ModelAttributeErrorr?   s    rB   interpolate_pos_encoding'EomtEmbeddings.interpolate_pos_encoding  s    899rD   pixel_valuesc                    UR                   u  n    nU R                  R                  R                  R                  nU R                  UR                  US95      nU R                  R                  USS5      nU R                  R                  USS5      nXPR                  U R                  5      -   n[        R                  " XgU/SS9nU R                  U5      nU$ )N)dtyperx   rv   dim)shaper   
projectionweightr   tor|   r   r~   r   rw   rc   catr   )r?   r   
batch_size_target_dtype
embeddings
cls_tokensr~   s           rB   forwardEomtEmbeddings.forward  s    *00
Aq!,,77>>DD**<???+NO
^^**:r2>
..55j"bI":":4;L;L"MM
YY
ZHaP
\\*-
rD   )r|   rs   r   r   r   r+   r   r~   )rN   rO   rP   rQ   r   r/   r   rc   r   r   rV   r-   rD   rB   rq   rq      s8    jz jd j :ELL U\\ rD   rq   c                       \ rS rSrSrg)EomtAttentioni  r-   Nrk   r-   rD   rB   r   r     rl   rD   r   c                       \ rS rSrSrg)EomtLayerScalei"  r-   Nrk   r-   rD   rB   r   r   "  rl   rD   r   c                       \ rS rSrSrg)	EomtLayeri&  r-   Nrk   r-   rD   rB   r   r   &  rl   rD   r   c                   f   ^  \ rS rSrSU 4S jjrS\R                  S\R                  4S jrSrU =r	$ )EomtLayerNorm2di*  c                 "   > [         TU ]  XUS9  g )N)epselementwise_affine)r.   r/   )r?   r,   r   affinerA   s       rB   r/   EomtLayerNorm2d.__init__+  s    6JrD   hidden_statert   c                     UR                  SSSS5      n[        R                  " XR                  U R                  U R
                  U R                  5      nUR                  SSSS5      nU$ )Nr   r   r   rv   )permuteF
layer_normnormalized_shaper   biasr   )r?   r   s     rB   r   EomtLayerNorm2d.forward.  s`    #++Aq!Q7||L2G2GVZV_V_aeaiaij#++Aq!Q7rD   r-   )rJ   T)
rN   rO   rP   rQ   r/   rc   r   r   rV   rW   rX   s   @rB   r   r   *  s)    KELL U\\  rD   r   c                   j   ^  \ rS rSrS\4U 4S jjrS\R                  S\R                  4S jr	Sr
U =r$ )EomtScaleLayeri5  rs   c           	         > [         TU ]  5         UR                  n[        R                  " X"SSS9U l        [        UR                     U l        [        R                  " UUSSUSS9U l
        [        U5      U l        g )Nr   )kernel_sizestrider   rv   F)r   paddinggroupsr   )r.   r/   r#   r   ConvTranspose2dconv1r   r'   
activationConv2dconv2r   layernorm2dr?   rs   r#   rA   s      rB   r/   EomtScaleLayer.__init__6  ss    ((''aXYZ
 !2!23YY

 +;7rD   r`   rt   c                     U R                  U5      nU R                  U5      nU R                  U5      nU R                  U5      nU$ N)r   r   r   r   r?   r`   s     rB   r   EomtScaleLayer.forwardF  sB    

=16

=1((7rD   )r   r   r   r   )rN   rO   rP   rQ   r   r/   rc   tensorr   r   rV   rW   rX   s   @rB   r   r   5  s/    8z 8 U\\ ell  rD   r   c                   j   ^  \ rS rSrS\4U 4S jjrS\R                  S\R                  4S jrSr	U =r
$ )EomtScaleBlockiN  rs   c                    > [         TU ]  5         UR                  U l        [        R
                  " [        U R                  5       Vs/ sH  n[        U5      PM     sn5      U l        g s  snf r   )	r.   r/   r:   r<   r   
ModuleListranger   block)r?   rs   r   rA   s      rB   r/   EomtScaleBlock.__init__O  sM     33]]E$//DZ#[DZqN6$:DZ#[\
#[s   A)r`   rt   c                 <    U R                    H  nU" U5      nM     U$ r   )r   )r?   r`   r   s      rB   r   EomtScaleBlock.forwardT  s     ZZE!-0M  rD   )r   r<   rN   rO   rP   rQ   r   r/   rc   r   r   rV   rW   rX   s   @rB   r   r   N  s1    ]z ]
U\\ ell  rD   r   c                   j   ^  \ rS rSrS\4U 4S jjrS\R                  S\R                  4S jrSr	U =r
$ )EomtMaskHeadiZ  rs   c                   > [         TU ]  5         UR                  n[        R                  " X"5      U l        [        R                  " X"5      U l        [        R                  " X"5      U l        [        UR                     U l
        g r   )r.   r/   r#   r   Linearfc1fc2fc3r   r'   r   r   s      rB   r/   EomtMaskHead.__init__[  s[    ((99[699[699[6 !2!23rD   r`   rt   c                     U R                  U R                  U5      5      nU R                  U R                  U5      5      nU R                  U5      nU$ r   r   r   r   r   r   s     rB   r   EomtMaskHead.forwardd  sD    (?@(?@/rD   r   r   rX   s   @rB   r   r   Z  s/    4z 4U\\ ell  rD   r   c                   d    \ rS rSr% Sr\\S'   SrSrSr	S/r
SrSrS	\R                  S
S4S jrSrg)EomtPreTrainedModelik  zz
An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
models.
rs   r   r   Fr   Tmodulert   Nc                 D   U R                   R                  n[        U[        R                  [        R
                  [        R                  45      (       a  [        R                  R                  UR                  [        R                  " S5      S9  UR                  by  [        R                  R                  UR                  5      u  p4US:  a  S[        R                  " U5      -  OSn[        R                  R                  UR                  U* U5        g g [        U[        R                  5      (       aJ  UR                  R                   R#                  S5        UR                  R                   R%                  5         g [        U[        R&                  5      (       ad  UR                  R                   R)                  SSS9  UR*                  b2  UR                  R                   UR*                     R%                  5         g g [        U[,        5      (       aL  [/        US5      (       a:  UR0                  R                   R#                  U R                   R2                  5        g g [        U[4        5      (       a  [        R                  R7                  UR8                  R                   R;                  [<        R>                  5      SUS9R;                  UR8                  R@                  5      UR8                  l        URB                  R                   R%                  5         g g )	N   )ar   rv   rK   rI   )meanstdlambda1)"rs   r(   
isinstancer   r   r   r   initkaiming_uniform_r   mathsqrtr   _calculate_fan_in_and_fan_outuniform_	LayerNormdatafill_zero_r   normal_padding_idxr   hasattrr   r8   rq   trunc_normal_r|   r   rc   float32r   r~   )r?   r   r   fan_inr   bounds         rB   _init_weights!EomtPreTrainedModel._init_weightsz  s!   kk++fryy"))R5G5GHIIGG$$V]]diil$C{{&GGAA&--P	17!DIIf--  ufe< ' --MM$$S)KK""$--MM&&CQ&7!!-""6#5#56<<> .//vy))##))$++*F*FG *//$&GG$9$9  %%((7cs %: %b!!''( ! ""''--/	 0rD   r-   )rN   rO   rP   rQ   rR   r   re   base_model_prefixmain_input_namesupports_gradient_checkpointing_no_split_modules_supports_sdpa_supports_flash_attnr   Moduler   rV   r-   rD   rB   r   r   k  sJ    
 $O&+#$N0BII 0$ 0rD   r   zV
    The EoMT Model with head on top for instance/semantic/panoptic segmentation.
    c                       \ rS rSrS\SS4S jrS rS rS\R                  4S	 jr
\S
 5       r\\     SS\	S\\\	      S\\\	      S\\   S\\   S\\\	      4S jj5       5       rSrg)EomtForUniversalSegmentationi  rs   rt   Nc                    [         R                  " 5       R                  U5        Xl        UR                  U l        [        U5      U l        [         R                  " UR                  UR                  S9U l
        [         R                  " UR                  UR                  5      U l        [         R                  " [        UR                  5       Vs/ sH  n[!        U5      PM     sn5      U l        [%        U5      U l        [)        U5      U l        [         R,                  " UR                  UR.                  S-   5      U l        UR2                  UR4                  -  UR2                  UR4                  -  4U l        UR8                  UR:                  UR<                  S.U l        [A        XR>                  S9U l!        U RE                  S[F        RH                  " URJ                  5      5        U RM                  5         g s  snf )N)r   rv   )loss_cross_entropy	loss_mask	loss_dice)rs   weight_dictattn_mask_probs)'r   r  r/   rs   r$   rq   r   r   r#   r)   	layernormr   r=   queryr   r   r   layersr   upscale_blockr   	mask_headr   
num_labelsclass_predictorr*   r+   	grid_sizer   r   r   r	  ri   	criterionr   rc   onesr<   	post_init)r?   rs   r   s      rB   r/   %EomtForUniversalSegmentation.__init__  sx   
		V$!'!9!9(0f&8&8f>S>ST\\&"4"4f6H6HI
mmfF^F^@_$`@_1Yv%6@_$`a+F3%f-!yy););V=N=NQR=RS ++v/@/@@&BSBSW]WhWhBhi"("5"5++++.
 "=M=MN.

6;L;L0MN% %as   G=c                 .    U R                   R                  $ r   )r   r   r   s    rB   get_input_embeddings1EomtForUniversalSegmentation.get_input_embeddings  s    ///rD   c                     [        S5      e)NzNote needed for Eomt Model.r   r   s    rB   get_auxiliary_logits1EomtForUniversalSegmentation.get_auxiliary_logits  s    :;;rD   logitsc                    US S 2S U R                   R                  2S S 24   nU R                  U5      nUS S 2U R                   R                  U R                  R                  -   S 2S S 24   nUR                  SS5      nUR                  " UR                  S   S/U R                  Q76 nU R                  U5      nU R                  U5      n[        R                  " SX$5      nXS4$ )Nrv   r   r   rx   zbqc, bchw -> bqhw)rs   r=   r  r   r   	transposereshaper   r  r  r  rc   einsum)r?   r  query_tokensclass_logitsprefix_tokensmask_logitss         rB   predict$EomtForUniversalSegmentation.predict  s    a!:4;;#:#:!:A=>++L9q$++"9"9DOO<]<]"]"_abbc%//15%--m.A.A!.DbZ4>>Z~~l3**=9ll#6T((rD   c                 ~    US:  a6  [         R                  " U R                  S   X$S9U:  nSU S S 2S U2US 24   U'   U $ )Nrv   r   )device)rc   randr   )	attn_maskprobnum_query_tokensencoder_start_tokensr)  random_queriess         rB   _disable_attention_mask4EomtForUniversalSegmentation._disable_attention_mask  sT    !8"ZZ	(:<L\_ccN VWIa***,@,AAB>RrD   r   mask_labelsclass_labelsoutput_hidden_statesoutput_attentionsrb   c           
         Ub  UOU R                   R                  nUb  UOU R                   R                  nU(       a  SOSnU(       a  SOSnSu  pSnUc  [        S5      eU R	                  U5      n[        U R                  5       GH  u  pU(       a  X|4-  nXR                  U R                   R                  -
  :X  am  U R                  R                  SSS2SS24   R                  UR                  S   SS5      R                  UR                  5      n[        R                   " X4SS9nXR                  U R                   R                  -
  :  Ga  U R"                  (       d7  U R$                  XR                  -
  U R                   R                  -      S:  Ga  U R'                  U5      nU R)                  U5      u  nnU	U4-  n	U
U4-  n
[        R*                  " UR                  S   UR                  S   UR                  S   UR                  [        R,                  S	9n[.        R0                  " UU R2                  S
S9nUR5                  UR7                  S5      UR7                  S5      S5      nU R                   R8                  nUU R                  R:                  -   nUS:  USS2SU2US24'   U R=                  UU R$                  XR                  -
  U R                   R                  -      UUUR                  S9nUSS2SS4   R                  SU R                   R>                  SS5      nURA                  5       RC                  U) S5      nU" XU5      nUS   nU(       d  GM  UUS   4-  nGM     U R'                  U5      nU(       a  UU4-  nU R)                  U5      u  nnU	U4-  n	U
U4-  n
SnUbA  Ub>  Sn[E        X5       H-  u  nnU RG                  UUUUSS9nUU RI                  U5      -  nM/     [K        UUUUUUUS9$ )a(  
mask_labels (`list[torch.Tensor]`, *optional*):
    list of mask labels of shape `(num_labels, height, width)` to be fed to a model
class_labels (`list[torch.LongTensor]`, *optional*):
    list of target class labels of shape `(num_labels, height, width)` to be fed to a model. They identify the
    labels of `mask_labels`, e.g. the label of `mask_labels[i][j]` if `class_labels[i][j]`.
patch_offsets (`list[torch.Tensor]`, *optional*):
    list of tuples indicating the image index and start and end positions of patches for semantic segementation.
Nr-   )r-   r-   z You have to specify pixel_valuesr   rx   rv   r   )r)  r   bilinear)sizemode)r,  r-  r.  r)  .g    erI   )r^   r]   r2  r3  auxiliary_predictions)r\   r^   r]   r_   r`   ra   rb   )&rs   r4  r5  
ValueErrorr   	enumerater  r$   r<   r  r   r   r   r   r)  rc   r   trainingr
  r  r&  r  boolr   interpolater  viewr8  r=   r   r0  r%   rT   masked_fillzipget_loss_dictget_lossr[   )r?   r   r2  r3  r4  r5  rb   all_hidden_statesall_attentionsmasks_queries_logits_per_layerclass_queries_logits_per_layerattention_maskr`   idxlayer_moduler  norm_hidden_statesr^   r]   interpolated_logitsr-  r.  layer_outputssequence_outputr\   	loss_dicts                             rB   r   $EomtForUniversalSegmentation.forward  s9   * %9$D $++JjJj 	 2C1N-TXT_T_TqTq"6BD0dIOF&?@@5!*4;;!7C#!%55!,,t{{/E/EEE

))$1*5<<]=P=PQR=SUWY[\__`m`t`tu %		5*@a H,,t{{/E/EEE!5!5c<R<R6RUYU`U`UkUk6k!lop!p%)^^M%B"=A\\J\=]:$&:.3G2II..3G2II.!&!''*!''*!''*(//**" '(mm4Ht~~dn&o#&9&>&>',,Q/1D1I1I!1Lb'# $(;;#:#: '7$//:[:['[$ ObdeNeq"3#3"35I5JJK "&!=!="--c4J4J.JT[[McMc.cd%5)=)00 "> " "04!=!D!DRIhIhjlnp!q!/!5!5!7!C!C^OUY!Z(HYZM)!,M  =#3"55k "8n ..7/!3359\\/5R22&+?*AA&&+?*AA&"|'?D>A.?:$&: !..)=)= +!-*. / 	 i00? 2!5!5-+%'
 	
rD   )r  rs   r  r   r  r  r  r  r$   r  r  r	  )NNNNN)rN   rO   rP   rQ   r   r/   r  r  rc   r   r&  staticmethodr0  r   r   r   rg   r>  r   rV   r-   rD   rB   r  r    s    z d 80<)ell )     /3/3/3,004x
x
 d6l+x
 tF|,	x

 'tnx
 $D>x
  V-x
  x
rD   r  )r   r   r  )6rR   r   dataclassesr   typingr   rc   torch.nn.functionalr   
functionalr   r   activationsr   
file_utilsr	   modeling_utilsr
   utilsr   r   r   dinov2.modeling_dinov2r   r   r   r    mask2former.modeling_mask2formerr   r   siglip.modeling_siglipr   vit.configuration_vitr   
get_loggerrN   loggerr   r[   ri   rn   r  rq   r   r   r   r   r   r   r   r   r   r  __all__r-   rD   rB   <module>rb     s     !      ! . 
  d 4 - 
		H	%T7 T7n 	7 7	 7>	 		/ 	!%ryy !H	O 		% 		 	bll RYY 2	RYY 	299 " $0/ $0 $0N 
x
#F		 x

x
v PrD   