
    hc                        d Z ddlZddlm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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jL                  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      Z/ G d" d#e      Z0 G d$ d%ejb                        Z2 G d& d'ejf                        Z4 G d( d)ejf                        Z5 G d* d+ejf                        Z6e G d, d-e             Z7 ed.       G d/ d0e              Z8g d1Z9y)2zPyTorch EoMT model.    N)	dataclass)Optional)Tensornn   )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
| | `| `| `| `| `| `|| _        || _	        || _
        || _        || _        || _        || _        || _        || _        || _        || _        || _        || _        || _        || _        || _        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 )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&   r7   r(   r'   r)   r*   r+   r,   r-   r9   r:   r;   r8   r<   r=   r   r   r   r   r    r!   r"   r>   r?   kwargs	__class__s                               c/var/www/html/eduruby.in/venv/lib/python3.12/site-packages/transformers/models/eomt/modular_eomt.pyr0   zEomtConfig.__init__   s    < 	 	
#/ 3 3!/)!!%	
 	
 "MO#-"!2 0,"4,$ 0(&& 0 0'>$&#6     )i            gelu        g{Gz?ư>i  rF   r         ?rI   r   rI   FrG   g?g       @      @rL   i 1  g      @g      ?   rG   )	__name__
__module____qualname____doc__
model_typefloatintr0   __classcell__rB   s   @rC   r   r   3   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                   <   e Zd ZU dZdZeej                     ed<   dZ	eej                     ed<   dZ
eej                     ed<   dZeej                     ed<   dZeeej                        ed<   dZeeej                        ed<   dZeeej"                        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 segementation.
    Nlossclass_queries_logitsmasks_queries_logitslast_hidden_statehidden_states
attentionspatch_offsets)rN   rO   rP   rQ   rZ   r   torchFloatTensor__annotations__r[   r\   r]   r^   tupler_   r`   listr   r.   rD   rC   rY   rY      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   rY   c                       e Zd Zy)EomtLossNrN   rO   rP   r.   rD   rC   rg   rg          rD   rg   c                       e Zd Zy)EomtPatchEmbeddingsNrh   r.   rD   rC   rk   rk      ri   rD   rk   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)rq   F)
persistent)r   Moduler0   rn   r,   	Parameterra   randnr$   	cls_tokenzerosr?   register_tokensrk   patch_embeddingsnum_patchesDropoutr'   dropoutnum_prefix_tokens	Embeddingposition_embeddingsregister_bufferarangeexpand)r@   rn   r|   s      rC   r0   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   rq   dim)shaper{   
projectionweightr   torx   r   rz   r   rr   ra   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   )	rN   rO   rP   r   r0   r   ra   r   r   r.   rD   rC   rm   rm      s8    jz jd j :ELL U\\ rD   rm   c                       e Zd Zy)EomtAttentionNrh   r.   rD   rC   r   r      ri   rD   r   c                       e Zd Zy)EomtLayerScaleNrh   r.   rD   rC   r   r   $  ri   rD   r   c                   f    e Zd Z	 ddej                  deej                     dej                  fdZy)	EomtLayerNr^   	head_maskro   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#'>>2Di#P q $ 1 12G H '<=M zz-0xx-((6 ~~l3mCrD   r   )rN   rO   rP   ra   r   r   r   r.   rD   rC   r   r   (  s9     -1|| ELL) 
	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)r/   r0   )r@   r-   r   affinerB   s       rC   r0   zEomtLayerNorm2d.__init__A  s    36JrD   hidden_statero   c                     |j                  dddd      }t        j                  || j                  | j                  | j
                  | j                        }|j                  dddd      }|S )Nr   r   r   rq   )permuteF
layer_normnormalized_shaper   biasr   )r@   r   s     rC   r   zEomtLayerNorm2d.forwardD  sb    #++Aq!Q7||L$2G2GVZV_V_aeaiaij#++Aq!Q7rD   )rJ   T)rN   rO   rP   r0   ra   r   r   rU   rV   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 )EomtScaleLayerrn   c                    t         |           |j                  }t        j                  ||dd      | _        t        |j                     | _        t        j                  ||dd|d      | _
        t        |      | _        y )Nr   )kernel_sizestrider   rq   F)r   paddinggroupsr   )r/   r0   r$   r   ConvTranspose2dconv1r   r(   
activationConv2dconv2r   layernorm2dr@   rn   r$   rB   s      rC   r0   zEomtScaleLayer.__init__L  su    ((''[aXYZ
 !2!23YY

 +;7rD   r^   ro   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   	rN   rO   rP   r   r0   ra   r   r   rU   rV   s   @rC   r   r   K  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 )EomtScaleBlockrn   c                     t         |           |j                  | _        t	        j
                  t        | j                        D cg c]  }t        |       c}      | _        y c c}w r   )	r/   r0   r;   r=   r   
ModuleListranger   block)r@   rn   r   rB   s      rC   r0   zEomtScaleBlock.__init__e  sG     33]]E$//DZ#[qN6$:#[\
#[s   A&r^   ro   c                 8    | j                   D ]
  } ||      } |S r   )r   )r@   r^   r   s      rC   r   zEomtScaleBlock.forwardj  s%    ZZ 	1E!-0M	1rD   r   rV   s   @rC   r   r   d  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 )EomtMaskHeadrn   c                    t         |           |j                  }t        j                  ||      | _        t        j                  ||      | _        t        j                  ||      | _        t        |j                     | _
        y r   )r/   r0   r$   r   Linearfc1fc2fc3r   r(   r   r   s      rC   r0   zEomtMaskHead.__init__q  sa    ((99[+699[+699[+6 !2!23rD   r^   ro   c                     | j                  | j                  |            }| j                  | j                  |            }| j                  |      }|S r   )r   r   r   r   r   s     rC   r   zEomtMaskHead.forwardz  sD    (?@(?@/rD   r   rV   s   @rC   r   r   p  s*    4z 4U\\ ell rD   r   c                   d    e Zd ZU dZeed<   dZdZdZdgZ	dZ
dZeedZ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.
    rn   r   r   Fr   T)r^   r_   modulero   Nc                    | j                   j                  }t        |t        j                  t        j
                  t        j                  f      rt        j                  j                  |j                  t        j                  d             |j                  xt        j                  j                  |j                        \  }}|dkD  rdt        j                  |      z  nd}t        j                  j                  |j                  | |       y y t        |t        j                        rJ|j                  j                   j#                  d       |j                  j                   j%                          y t        |t        j&                        rf|j                  j                   j)                  dd       |j*                  2|j                  j                   |j*                     j%                          y y t        |t,              rGt/        |d      r:|j0                  j                   j#                  | j                   j2                         y y t        |t4              rt        j                  j7                  |j8                  j                   j;                  t<        j>                        d|      j;                  |j8                  j@                        |j8                  _        |jB                  j                   j%                          y y )	N   )ar   rq   rK   rI   )meanstdlambda1)"rn   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   r9   rm   trunc_normal_rx   r   ra   float32r   rz   )r@   r   r   fan_inr   bounds         rC   _init_weightsz!EomtPreTrainedModel._init_weights  s   kk++fryy"))R5G5GH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   )rN   rO   rP   rQ   r   rc   base_model_prefixmain_input_namesupports_gradient_checkpointing_no_split_modules_supports_sdpa_supports_flash_attnr   r   _can_record_outputsr   ru   r   r.   rD   rC   r   r     sX    
 $O&+#$N"#
0BII 0$ 0rD   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e      deee      deee      dee   defd              Zy)EomtForUniversalSegmentationrn   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   rq   )loss_cross_entropy	loss_mask	loss_dice)rn   weight_dictattn_mask_probs)'r
   r0   rn   r%   rm   r   r   r   r$   r*   	layernormr   r>   queryr   r   r   layersr   upscale_blockr   	mask_headr   
num_labelsclass_predictorr+   r,   	grid_sizer   r   r   r  rg   	criterionr   ra   onesr=   	post_init)r@   rn   r   s      rC   r0   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 )Nrq   r   r   rs   zbqc, bchw -> bqhw)rn   r>   r  r   r   	transposereshaper   r  r	  r  ra   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 )Nrq   r   )device)ra   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   ro   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 )ah  
        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.
        )r.   r.   Nz You have to specify pixel_valuesr   rs   rq   r   )r  r   bilinear)sizemode)r"  r#  r$  r  .g    erI   )r\   r[   r'  r(  auxiliary_predictions)rZ   r\   r[   r]   r`   )$
ValueErrorr   	enumerater  r%   rn   r=   r  r   r   r   r   r  ra   r   trainingr  r  r  r  boolr   interpolater  viewr+  r>   r   r&  r&   rS   masked_fillzipget_loss_dictget_lossrY   )r@   r   r'  r(  r`   rA   masks_queries_logits_per_layerclass_queries_logits_per_layerattention_maskr^   idxlayer_moduler  norm_hidden_statesr\   r[   interpolated_logitsr#  r$  sequence_outputrZ   	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)rN   rO   rP   r   r0   r  r  ra   r   r  staticmethodr&  r   r   r   re   r   r   rY   r   r.   rD   rC   r   r     s    z 80<)ell )     /3/304e
e
 d6l+e
 tF|,	e

  V-e
 +,e
 
,e
  e
rD   r   )r   r   r   ):rQ   r   dataclassesr   typingr   ra   torch.nn.functionalr   
functionalr   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_loggerrN   loggerr   rY   rg   rk   rm   r   r   r   r   r   ru   r   r   r   r   r   __all__r.   rD   rC   <module>rS     s~     !      ! . & 
 0  d 4 - 
		H	%T7 T7n 	7 7	 7>	 		/ 	!% !H	O 		% 	 0bll RYY 2	RYY 	299 " (0/ (0 (0V 
e
#F e

e
P PrD   