
    id                        d Z ddlZddlmZ ddlZddlmc mZ ddlm	Z	mZ ddl
mZ ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZmZmZ ddlmZ ddlmZmZmZmZ ddl m!Z!m"Z" ddl#m$Z$ ddl%m&Z&  ejN                  e(      Z) G d de&      Z*e ed       G d de                    Z+ G d de"      Z, G d de      Z- G d de      Z. G d de$      Z/ G d  d!e      Z0 G d" d#e      Z1 G d$ d%ejd                        Z3 G d& d'ejh                        Z5 G d( d)ejh                        Z6 G d* d+ejh                        Z7e G d, d-e             Z8 ed.       G d/ d0e!             Z9g d1Z:y)2zPyTorch EoMT model.    N)	dataclass)Tensornn   )initialization)ACT2FN)ModelOutput)PreTrainedModel)Unpack)TransformersKwargsauto_docstringlogging)check_model_inputs   )Dinov2EmbeddingsDinov2LayerDinov2LayerScaleDinov2PatchEmbeddings)#Mask2FormerForUniversalSegmentationMask2FormerLoss)SiglipAttention)	ViTConfigc                   z     e Zd ZdZdZ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddedededededed	ef fd
Z xZS )
EomtConfiga  
    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                 2   || _         || _        || _        || _        || _        || _        || _        || _        || _        || _	        || _
        || _        || _        || _        || _        || _        t!        | D  d||||||||	|
|d
| | `| `| `| `| `| `y )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 )	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super__init__intermediate_sizeqkv_bias
pooler_actpooler_output_sizeencoder_strideattention_probs_dropout_prob)selfr$   r%   r&   r/   r(   r'   r)   r*   r+   r,   r-   r1   r2   r3   r0   r4   r5   r   r   r   r   r    r!   r"   r6   r7   kwargs	__class__s                               o/home/obispo/Crisostomo_bridge/mision_env/lib/python3.12/site-packages/transformers/models/eomt/modular_eomt.pyr9   zEomtConfig.__init__   s    < #!2 0,"4,$ 0(&& 0 0'>$&#6  	
#/ 3 3!/)!!%	
 	
 "MO#-    )i            gelu        g{Gz?ư>i  rF   r   g      ?rI   r   rI   FrG   g?g       @      @rK   i 1  g      @g      ?   rG   )	__name__
__module____qualname____doc__
model_typefloatintr9   __classcell__rB   s   @rC   r   r   2   s    M^ J "%!   %"%)-7B.&  'B.( )B.* +B., -B.. /B.0  1B.2 "'3B. B.rD   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                   <   e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	ej                  dz  ed<   dZ
ej                  dz  ed<   dZeej                     dz  ed<   dZeej                     dz  ed<   dZeej                      dz  ed	<   y)
"EomtForUniversalSegmentationOutputa*  
    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 segmentation.
    Nlossclass_queries_logitsmasks_queries_logitslast_hidden_statehidden_states
attentionspatch_offsets)rM   rN   rO   rP   rY   torchFloatTensor__annotations__rZ   r[   r\   r]   tupler^   r_   listr   r.   rD   rC   rX   rX      s    * &*D%

d
")59%++d2959%++d2926u((4/659M5**+d2926Je''(4/6/3M4%,3rD   rX   c                       e Zd Zy)EomtLossNrM   rN   rO   r.   rD   rC   rf   rf          rD   rf   c                       e Zd Zy)EomtPatchEmbeddingsNrg   r.   rD   rC   rj   rj      rh   rD   rj   c                   Z    e Zd ZdeddfdZd Zdej                  dej                  fdZy)EomtEmbeddingsconfigreturnNc                    t         j                  j                  |        || _        |j                  | _        t        j
                  t        j                  dd|j                              | _	        t        j
                  t        j                  d|j                  |j                              | _        t        |      | _        | j                  j                  }t        j                   |j"                        | _        d|j                  z   | _        t        j(                  ||j                        | _        | j-                  dt        j.                  |      j1                  d      d       y )N   position_idsrp   F)
persistent)r   Moduler9   rm   r,   	Parameterr`   randnr$   	cls_tokenzerosr7   register_tokensrj   patch_embeddingsnum_patchesDropoutr'   dropoutnum_prefix_tokens	Embeddingposition_embeddingsregister_bufferarangeexpand)r@   rm   r|   s      rC   r9   zEomtEmbeddings.__init__   s    
		4  ++ekk!Q8J8J&KL!||EKK6;U;UW]WiWi,jk 3F ;++77zz&"<"<=!"V%?%?!?#%<<V=O=O#P ^U\\+-F-M-Mg-VchirD   c                     t        d      )NzNot needed for Eomt ModelAttributeErrorr@   s    rC   interpolate_pos_encodingz'EomtEmbeddings.interpolate_pos_encoding  s    899rD   pixel_valuesc                    |j                   \  }}}}| j                  j                  j                  j                  }| j                  |j                  |            }| j                  j                  |dd      }| j                  j                  |dd      }|| j                  | j                        z   }t        j                  |||gd      }| j                  |      }|S )N)dtypers   rp   dim)shaper{   
projectionweightr   torx   r   rz   r   rq   r`   catr~   )r@   r   
batch_size_target_dtype
embeddings
cls_tokensrz   s           rC   forwardzEomtEmbeddings.forward  s    *00
Aq!,,77>>DD**<???+NO
^^**:r2>
..55j"bI$":":4;L;L"MM
YY
OZHaP
\\*-
rD   )	rM   rN   rO   r   r9   r   r`   r   r   r.   rD   rC   rl   rl      s8    jz jd j :ELL U\\ rD   rl   c                       e Zd Zy)EomtAttentionNrg   r.   rD   rC   r   r     rh   rD   r   c                       e Zd Zy)EomtLayerScaleNrg   r.   rD   rC   r   r   #  rh   rD   r   c                   f    e Zd Z	 ddej                  dej                  dz  dej                  fdZy)	EomtLayerNr]   attention_maskrn   c                 *   | j                  |      }| j                  ||      \  }}| j                  |      }| j                  |      |z   }| j	                  |      }| j                  |      }| j                  |      }| j                  |      |z   }|S N)norm1	attentionlayer_scale1	drop_pathnorm2mlplayer_scale2)r@   r]   r   hidden_states_normself_attention_outputr   layer_outputs          rC   r   zEomtLayer.forward(  s    
 "ZZ6#'>>2Dn#U q $ 1 12G H '<=M zz-0xx-((6 ~~l3mCrD   r   )rM   rN   rO   r`   r   r   r.   rD   rC   r   r   '  s9     /3|| t+ 
	rD   r   c                   X     e Zd Zd fd	Zdej
                  dej
                  fdZ xZS )EomtLayerNorm2dc                 *    t         |   |||       y )N)epselementwise_affine)r8   r9   )r@   r-   r   affinerB   s       rC   r9   zEomtLayerNorm2d.__init__@  s    36JrD   hidden_statern   c                     |j                  dddd      }t        j                  || j                  | j                  | j
                  | j                        }|j                  dddd      }|S )Nr   r   r   rp   )permuteF
layer_normnormalized_shaper   biasr   )r@   r   s     rC   r   zEomtLayerNorm2d.forwardC  sb    #++Aq!Q7||L$2G2GVZV_V_aeaiaij#++Aq!Q7rD   )rJ   T)rM   rN   rO   r9   r`   r   r   rT   rU   s   @rC   r   r   ?  s$    KELL U\\ rD   r   c                   \     e Zd Zdef fdZdej                  dej                  fdZ xZS )EomtScaleLayerrm   c                    t         |           |j                  }t        j                  ||dd      | _        t        |j                     | _        t        j                  ||dd|d      | _
        t        |      | _        y )Nr   )kernel_sizestrider   rp   F)r   paddinggroupsr   )r8   r9   r$   r   ConvTranspose2dconv1r   r(   
activationConv2dconv2r   layernorm2dr@   rm   r$   rB   s      rC   r9   zEomtScaleLayer.__init__K  su    ((''[aXYZ
 !2!23YY

 +;7rD   r]   rn   c                     | j                  |      }| j                  |      }| j                  |      }| j                  |      }|S r   )r   r   r   r   r@   r]   s     rC   r   zEomtScaleLayer.forward[  sB    

=16

=1((7rD   	rM   rN   rO   r   r9   r`   r   r   rT   rU   s   @rC   r   r   J  s*    8z 8 U\\ ell rD   r   c                   \     e Zd Zdef fdZdej                  dej                  fdZ xZS )EomtScaleBlockrm   c                     t         |           |j                  | _        t	        j
                  t        | j                        D cg c]  }t        |       c}      | _        y c c}w r   )	r8   r9   r3   r5   r   
ModuleListranger   block)r@   rm   r   rB   s      rC   r9   zEomtScaleBlock.__init__d  sG     33]]E$//DZ#[qN6$:#[\
#[s   A&r]   rn   c                 8    | j                   D ]
  } ||      } |S r   )r   )r@   r]   r   s      rC   r   zEomtScaleBlock.forwardi  s%    ZZ 	1E!-0M	1rD   r   rU   s   @rC   r   r   c  s,    ]z ]
U\\ ell rD   r   c                   \     e Zd Zdef fdZdej                  dej                  fdZ xZS )EomtMaskHeadrm   c                    t         |           |j                  }t        j                  ||      | _        t        j                  ||      | _        t        j                  ||      | _        t        |j                     | _
        y r   )r8   r9   r$   r   Linearfc1fc2fc3r   r(   r   r   s      rC   r9   zEomtMaskHead.__init__p  sa    ((99[+699[+699[+6 !2!23rD   r]   rn   c                     | j                  | j                  |            }| j                  | j                  |            }| j                  |      }|S r   )r   r   r   r   r   s     rC   r   zEomtMaskHead.forwardy  sD    (?@(?@/rD   r   rU   s   @rC   r   r   o  s*    4z 4U\\ ell rD   r   c                       e Zd ZU dZeed<   dZdZdZdZ	dgZ
dZeed	Z ej                          d
ej$                  ddfd       Zy)EomtPreTrainedModelz
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    rm   r   r   )imageFr   T)r]   r^   modulern   Nc                     | j                   j                  }t        |t        j                  t        j
                  t        j                  f      rt        j                  |j                  t        j                  d             |j                  xt        j                  j                  j                  |j                        \  }}|dkD  rdt        j                  |      z  nd}t        j                  |j                  | |       y y t        |t        j                         r?t        j"                  |j                         t        j$                  |j                         y t        |t        j&                        rtt        j(                  |j                  dd       |j*                  Et-        |j                  dd      s-t        j$                  |j                  |j*                            y y y t        |t.              rBt1        |d	      r5t        j2                  |j4                  | j                   j6                         y y t        |t8              rt        j:                  |j<                  d|       t        j$                  |j>                         t        j@                  |jB                  t        jD                  |jB                  jF                  d
         jI                  d             y t        |tJ              rRt        jL                  |jN                  dz         }|jP                  |d
<   t        j@                  |jR                  |       y t        |tT              r t        j"                  |jV                         y y )N   )ar   rp   rI   )meanstd_is_hf_initializedFlambda1rs   rr   ),rm   r)   
isinstancer   r   r   r   initkaiming_uniform_r   mathsqrtr   r`   _calculate_fan_in_and_fan_outuniform_	LayerNormones_zeros_r   normal_padding_idxgetattrr   hasattr	constant_r   r1   rl   trunc_normal_rx   rz   copy_rq   r   r   r   rf   ones
num_labelseos_coefempty_weightEomtForUniversalSegmentationattn_mask_probs)r@   r   r   fan_inr   boundr   s          rC   _init_weightsz!EomtPreTrainedModel._init_weights  sJ   kk++fryy"))R5G5GHI!!&--499Q<@{{&!HHMMGGV	17!DIIf--fkkE659 ' -JJv}}%KK$-LLSa8!!-gfmmMach6iFMM&*<*<=> 7j-/vy)v~~t{{/K/KL */v//csCKK../JJv**ELL9L9L9R9RSU9V,W,^,^_f,gh) ::f&7&7!&;<L%LJJv**L9 <=JJv--. >rD   )rM   rN   rO   rP   r   rb   base_model_prefixmain_input_nameinput_modalitiessupports_gradient_checkpointing_no_split_modules_supports_sdpar   r   _can_record_outputsr`   no_gradr   ru   r   r.   rD   rC   r   r     so    
 $O!&+#$N"#
 U]]_/BII /$ / /rD   r   zV
    The EoMT Model with head on top for instance/semantic/panoptic segmentation.
    c                       e Zd ZdefdZd Zd Zdej                  fdZ	e
d        Zee	 	 	 dd	ed
ee   dz  dee   dz  dee   dz  dee   defd              Zy)r   rm   c                    t        j                  | |       || _        |j                  | _        t	        |      | _        t        j                  |j                  |j                        | _
        t        j                  |j                  |j                        | _        t        j                  t        |j                        D cg c]  }t!        |       c}      | _        t%        |      | _        t)        |      | _        t        j,                  |j                  |j.                  dz         | _        |j2                  |j4                  z  |j2                  |j4                  z  f| _        |j8                  |j:                  |j<                  d| _        tA        || j>                        | _!        | jE                  dtG        jH                  |jJ                               | jM                          y c c}w )N)r   rp   )loss_cross_entropy	loss_mask	loss_dice)rm   weight_dictr   )'r
   r9   rm   r%   rl   r   r   r   r$   r*   	layernormr   r6   queryr   r   r   layersr   upscale_blockr   	mask_headr   r   class_predictorr+   r,   	grid_sizer   r   r   r  rf   	criterionr   r`   r   r5   	post_init)r@   rm   r   s      rC   r9   z%EomtForUniversalSegmentation.__init__  sr     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++++.
 "T=M=MN.

6;L;L0MN% %as   G0c                 .    | j                   j                  S r   )r   r{   r   s    rC   get_input_embeddingsz1EomtForUniversalSegmentation.get_input_embeddings  s    ///rD   c                     t        d      )NzNote needed for Eomt Model.r   r   s    rC   get_auxiliary_logitsz1EomtForUniversalSegmentation.get_auxiliary_logits  s    :;;rD   logitsc                    |d d d | j                   j                  d d f   }| j                  |      }|d d | j                   j                  | j                  j                  z   d d d f   }|j                  dd      } |j                  |j                  d   dg| j                   }| j                  |      }| j                  |      }t        j                  d||      }||fS )Nrp   r   r   rs   zbqc, bchw -> bqhw)rm   r6   r  r   r   	transposereshaper   r  r  r  r`   einsum)r@   r  query_tokensclass_logitsprefix_tokensmask_logitss         rC   predictz$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mTL((rD   c                     |dk  r9t        j                  | j                  d   ||      |kD  }d| d d d ||d f   |<   | S )Nrp   r   )device)r`   randr   )	attn_maskprobnum_query_tokensencoder_start_tokensr%  random_queriess         rC   _disable_attention_maskz4EomtForUniversalSegmentation._disable_attention_mask  sW    !8"ZZ	(:<LU[\_ccN VWIa***,@,AAB>RrD   Nr   mask_labelsclass_labelsr_   rA   rn   c                 (   d\  }}d}|t        d      | j                  |      }	t        | j                        D ]  \  }
}|
| j                  | j
                  j                  z
  k(  rp| j                  j                  dddddf   j                  |	j                  d   dd      j                  |	j                        }t        j                  ||	fd      }	|
| j                  | j
                  j                  z
  k\  r| j                  s7| j                   |
| j                  z
  | j
                  j                  z      dkD  r| j#                  |	      }| j%                  |      \  }}||fz  }||fz  }t        j&                  |	j                  d   |	j                  d   |	j                  d   |	j                  t        j(                        }t+        j,                  || j.                  d	
      }|j1                  |j3                  d      |j3                  d      d      }| j
                  j4                  }|| j                  j6                  z   }|dkD  |ddd||df<   | j9                  || j                   |
| j                  z
  | j
                  j                  z      |||j                        }|ddddf   j                  d| j
                  j:                  dd      }|j=                         j?                  | d      } ||	|      }	 | j#                  |	      }| j%                  |      \  }}||fz  }||fz  }d}|B|@d}tA        ||      D ]/  \  }}| jC                  ||||d      }|| jE                  |      z  }1 tG        |||||      S )ag  
        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 segmentation.
        )r.   r.   Nz You have to specify pixel_valuesr   rs   rp   r   )r%  r   bilinear)sizemode)r(  r)  r*  r%  .g    erI   )r[   rZ   r-  r.  auxiliary_predictions)rY   r[   rZ   r\   r_   )$
ValueErrorr   	enumerater  r%   rm   r5   r  r   r   r   r   r%  r`   r   trainingr   r  r#  r   boolr   interpolater  viewr1  r6   r   r,  r&   rR   masked_fillzipget_loss_dictget_lossrX   )r@   r   r-  r.  r_   rA   masks_queries_logits_per_layerclass_queries_logits_per_layerr   r]   idxlayer_moduler  norm_hidden_statesr[   rZ   interpolated_logitsr)  r*  sequence_outputrY   	loss_dicts                         rC   r   z$EomtForUniversalSegmentation.forward  s   ( JPF&(F?@@5!*4;;!7 .	HCd,,t{{/E/EEE

))$1*5<<]=P=PQR=SUWY[\__`m`t`tu %		5-*@a Hd,,t{{/E/EEE!5!5cD<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 "&!=!="--cD4J4J.JT[[McMc.cd%5)=)00 "> " "04!=!D!DRIhIhjlnp!q!/!5!5!7!C!C^OUY!Z(GM].	H` ..759\\/5R22&+?*AA&&+?*AA&"|'?D>A.0N? 
1:$&: !..)=)= +!-*. / 	 i00
1 2!5!5-'
 	
rD   )NNN)rM   rN   rO   r   r9   r  r  r`   r   r#  staticmethodr,  r   r   rd   r   r   rX   r   r.   rD   rC   r   r     s    z 80<)ell )     ,0,0-1e
e
 &\D(e
 6lT)	e

 F|d*e
 +,e
 
,e
  e
rD   r   )r   r   r   );rP   r   dataclassesr   r`   torch.nn.functionalr   
functionalr   r    r   r   activationsr   
file_utilsr	   modeling_utilsr
   processing_utilsr   utilsr   r   r   utils.genericr   dinov2.modeling_dinov2r   r   r   r    mask2former.modeling_mask2formerr   r   siglip.modeling_siglipr   vit.configuration_vitr   
get_loggerrM   loggerr   rX   rf   rj   rl   r   r   r   r   r   ru   r   r   r   r   r   __all__r.   rD   rC   <module>rX     s~     !     & ! . & 
 0  d 4 - 
		H	%T. T.n 	4 4	 4>	 		/ 	!% !H	O 		% 	 0bll RYY 2	RYY 	299 " /// // //d 
e
#F e

e
P PrD   