Ë
    ÛÓ^j[W  ã                   ó  — 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
 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 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jV                  e,«      Z- ed¬«      e
 G d„ de*«      «       «       Z. ed¬«      e G d„ de«      «       «       Z/ G d„ de&«      Z0 G d„ de#«      Z1 G d „ d!e «      Z2 G d"„ d#e(«      Z3 G d$„ d%e"«      Z4 G d&„ d'e!«      Z5 G d(„ d)ejl                  «      Z7 G d*„ d+ejp                  «      Z9 G d,„ d-ejp                  «      Z: G d.„ d/ejp                  «      Z;e G d0„ d1e«      «       Z< ed2¬«       G d3„ d4e%«      «       Z=g d5¢Z>y)6zPyTorch EoMT model.é    N)Ú	dataclass)Ústrict)ÚTensorÚnné   )Úinitialization)ÚACT2FN)ÚModelOutput)ÚPreTrainedModel)ÚUnpack)ÚTransformersKwargsÚauto_docstringÚlogging)Úmerge_with_config_defaults)Úcapture_outputsé   )ÚDinov2EmbeddingsÚDinov2LayerÚDinov2LayerScaleÚDinov2PatchEmbeddings)Ú#Mask2FormerForUniversalSegmentationÚMask2FormerLoss)ÚSiglipAttention)Ú	ViTConfigz$tue-mps/coco_panoptic_eomt_large_640)Ú
checkpointc                   ó&  — e Zd ZU dZdZdZeed<   dZeed<   dZ	eed<   d	Z
eed
<   dZeed<   dZeez  ed<   dZeed<   dZeed<   dZeee   z  eeef   z  ed<   dZeee   z  eeef   z  ed<   dZeed<   dZeed<   dZeez  ed<   dZeed<   dZeez  ed<   dZeed<   d	Zeed <   d!Zeed"<   d#Zeed$<   d%Zeed&<   d%Z eed'<   d(Z!eed)<   d*Z"eed+<   d,Z#eed-<   d.Z$eed/<   d	Z%eed0<    e&«       Z' e&«       Z( e&«       Z) e&«       Z* e&«       Z+ e&«       Z,d1„ Z-y2)3Ú
EomtConfiga  
    layerscale_value (`float`, *optional*, defaults to 1.0):
        Initial value for the LayerScale parameter.
    num_upscale_blocks (`int`, *optional*, defaults to 2):
        Number of upsampling blocks used in the decoder or segmentation head.
    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.
    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
    ```Úeomti   Úhidden_sizeé   Únum_hidden_layersé   Únum_attention_headsé   Ú	mlp_ratioÚgeluÚ
hidden_actç        Úhidden_dropout_probg{®Gáz”?Úinitializer_rangeç�íµ ÷Æ°>Úlayer_norm_epsi€  Ú
image_sizeÚ
patch_sizer   Únum_channelsg      ð?Úlayerscale_valueÚdrop_path_rater   Únum_upscale_blocksÚattention_dropoutFÚuse_swiglu_ffnÚ
num_blocksgš™™™™™¹?Úno_object_weightg       @Úclass_weightg      @Úmask_weightÚdice_weighti 1  Útrain_num_pointsg      @Úoversample_ratiog      è?Úimportance_sample_ratioéÈ   Únum_queriesÚnum_register_tokensc                 ó   — t        d«      ‚)NzNot needed for Eomt©ÚAttributeError)ÚselfÚkwargss     úp/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/eomt/modular_eomt.pyÚ__post_init__zEomtConfig.__post_init__„   s   € ÜÐ2Ó3Ð3ó    N).Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú
model_typer   ÚintÚ__annotations__r!   r#   r%   r'   Ústrr)   Úfloatr*   r,   r-   ÚlistÚtupler.   r/   r0   r1   r2   r3   r4   Úboolr5   r6   r7   r8   r9   r:   r;   r<   r>   r?   rB   Úintermediate_sizeÚqkv_biasÚ
pooler_actÚpooler_output_sizeÚencoder_strideÚattention_probs_dropout_probrF   © rG   rE   r   r   4   s�  … ñ'ðR €Jà€K�ÓØÐ�sÓØ!Ð˜Ó!Ø€IˆsÓØ€J�ÓØ'*Ð˜ ™Ó*Ø#Ð�uÓ#Ø €N�EÓ Ø47€J��d˜3‘i‘ %¨¨S¨¡/Ñ1Ó7Ø46€J��d˜3‘i‘ %¨¨S¨¡/Ñ1Ó6Ø€L�#ÓØ!Ð�eÓ!Ø"%€N�E˜C‘KÓ%ØÐ˜ÓØ%(Ð�u˜s‘{Ó(Ø €N�DÓ Ø€J�ÓØ!Ð�eÓ!Ø€L�%ÓØ€K�ÓØ€K�ÓØ!Ð�cÓ!Ø!Ð�eÓ!Ø%)Ð˜UÓ)Ø€K�ÓØ Ð˜Ó á&Ó(ÐÙÓ€HÙÓ!€JÙ'Ó)ÐÙ#Ó%€NÙ#1Ó#3Ð ó4rG   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)rH   rI   rJ   rK   r^   ÚtorchÚFloatTensorrN   r_   r`   ra   rb   rR   rc   rd   rQ   r   rZ   rG   rE   r]   r]   ˆ   s¬   … ñð* &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø59Ð˜%×+Ñ+¨dÑ2Ó9Ø59Ð˜%×+Ñ+¨dÑ2Ó9Ø26Ð�u×(Ñ(¨4Ñ/Ó6Ø59€M�5˜×*Ñ*Ñ+¨dÑ2Ó9Ø26€J��e×'Ñ'Ñ(¨4Ñ/Ó6Ø/3€M�4˜Ÿ™Ñ%¨Ñ,Ô3rG   r]   c                   ó   — e Zd Zy)ÚEomtLossN©rH   rI   rJ   rZ   rG   rE   rh   rh   ²   ó   „ ØrG   rh   c                   ó   — e Zd Zy)ÚEomtPatchEmbeddingsNri   rZ   rG   rE   rl   rl   ¶   rj   rG   rl   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©rr   éÿÿÿÿF)Ú
persistent)r   ÚModuleÚ__init__ro   r.   Ú	Parameterre   Úrandnr   Ú	cls_tokenÚzerosr?   Úregister_tokensrl   Úpatch_embeddingsÚnum_patchesÚDropoutr)   ÚdropoutÚnum_prefix_tokensÚ	EmbeddingÚposition_embeddingsÚregister_bufferÚarangeÚexpand)rC   ro   r   s      rE   rx   zEomtEmbeddings.__init__»   s   € Ü
�	‰	×Ñ˜4Ô àˆŒØ ×+Ñ+ˆŒäŸ™¤e§k¡k°!°Q¸×8JÑ8JÓ&KÓLˆŒÜ!Ÿ|™|¬E¯K©K¸¸6×;UÑ;UÐW]×WiÑWiÓ,jÓkˆÔä 3°FÓ ;ˆÔØ×+Ñ+×7Ñ7ˆÜ—z‘z &×"<Ñ"<Ó=ˆŒØ!" V×%?Ñ%?Ñ!?ˆÔÜ#%§<¡<°¸V×=OÑ=OÓ#PˆÔ Ø×Ñ˜^¬U¯\©\¸+Ó-F×-MÑ-MÈgÓ-VÐchÐÕirG   c                 ó   — t        d«      ‚)NzNot needed for Eomt ModelrA   ©rC   s    rE   Úinterpolate_pos_encodingz'EomtEmbeddings.interpolate_pos_encodingË   s   € ÜÐ8Ó9Ð9rG   Ú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)Údtyperu   rr   ©Údim)Úshaper~   Ú
projectionÚweightr�   Útor{   r‡   r}   r„   rs   re   Úcatr�   )rC   r‹   Ú
batch_sizeÚ_Útarget_dtypeÚ
embeddingsÚ
cls_tokensr}   s           rE   ÚforwardzEomtEmbeddings.forwardÎ   sÆ   € Ø*×0Ñ0Ñˆ
�A�q˜!Ø×,Ñ,×7Ñ7×>Ñ>×DÑDˆØ×*Ñ*¨<¯?©?À¨?Ó+NÓOˆ
à—^‘^×*Ñ*¨:°r¸2Ó>ˆ
Ø×.Ñ.×5Ñ5°jÀ"ÀbÓIˆà $×":Ñ":¸4×;LÑ;LÓ"MÑMˆ
Ü—Y‘Y 
¨O¸ZÐHÈaÔPˆ
à—\‘\ *Ó-ˆ
àÐrG   )	rH   rI   rJ   r   rx   rŠ   re   r   rš   rZ   rG   rE   rn   rn   º   s8   „ ðj˜zð j¨dó jò :ð E§L¡Lð °U·\±\ô rG   rn   c                   ó   — e Zd Zy)ÚEomtAttentionNri   rZ   rG   rE   rœ   rœ   Þ   rj   rG   rœ   c                   ó   — e Zd Zy)ÚEomtLayerScaleNri   rZ   rG   rE   rž   rž   â   rj   rG   rž   c                   óf   — e Zd Z	 ddej                  dej                  dz  dej                  fd„Zy)Ú	EomtLayerNrb   Úattention_maskrp   c                 ó*  — | j                  |«      }| j                  ||«      \  }}| j                  |«      }| j                  |«      |z   }| j	                  |«      }| j                  |«      }| j                  |«      }| j                  |«      |z   }|S ©N)Únorm1Ú	attentionÚlayer_scale1Ú	drop_pathÚnorm2ÚmlpÚlayer_scale2)rC   rb   r¡   Úhidden_states_normÚself_attention_outputr–   Úlayer_outputs          rE   rš   zEomtLayer.forwardç   s›   € ð
 "ŸZ™Z¨Ó6ÐØ#'§>¡>Ð2DÀnÓ#UÑ Ð˜qØ $× 1Ñ 1Ð2GÓ HÐð Ÿ™Ð'<Ó=ÀÑMˆð —z‘z -Ó0ˆØ—x‘x Ó-ˆØ×(Ñ(¨Ó6ˆð —~‘~ lÓ3°mÑCˆàÐrG   r£   )rH   rI   rJ   re   r   rš   rZ   rG   rE   r    r    æ   s9   „ ð /3ñà—|‘|ðð Ÿ™ tÑ+ðð 
�‰ô	rG   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)Úsuperrx   )rC   r/   r±   ÚaffineÚ	__class__s       €rE   rx   zEomtLayerNorm2d.__init__ÿ   s   ø€ Ü‰Ñ˜¨3À6ÐÕJrG   Úhidden_staterp   c                 óØ   — |j                  dddd«      }t        j                  || j                  | j                  | j
                  | j                  «      }|j                  dddd«      }|S )Nr   r   r   rr   )ÚpermuteÚFÚ
layer_normÚnormalized_shaper’   Úbiasr±   )rC   r¶   s     rE   rš   zEomtLayerNorm2d.forward  sb   € Ø#×+Ñ+¨A¨q°!°QÓ7ˆÜ—|‘| L°$×2GÑ2GÈÏÉÐVZ×V_ÑV_Ðae×aiÑaiÓjˆØ#×+Ñ+¨A¨q°!°QÓ7ˆØÐrG   )r+   T)rH   rI   rJ   rx   re   r   rš   Ú__classcell__©rµ   s   @rE   r¯   r¯   þ   s$   ø„ õKð E§L¡Lð °U·\±\÷ rG   r¯   c                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚEomtScaleLayerro   c                 ó  •— t         ‰| �  «        |j                  }t        j                  ||dd¬«      | _        t        |j                     | _        t        j                  ||dd|d¬«      | _
        t        |«      | _        y )Nr   )Úkernel_sizeÚstrider   rr   F)rÂ   ÚpaddingÚgroupsr¼   )r³   rx   r   r   ÚConvTranspose2dÚconv1r	   r'   Ú
activationÚConv2dÚconv2r¯   Úlayernorm2d©rC   ro   r   rµ   s      €rE   rx   zEomtScaleLayer.__init__
  su   ø€ Ü‰ÑÔØ×(Ñ(ˆÜ×'Ñ'¨°[ÈaÐXYÔZˆŒ
Ü  ×!2Ñ!2Ñ3ˆŒÜ—Y‘YØØØØØØô
ˆŒ
ô +¨;Ó7ˆÕrG   rb   rp   c                 óŽ   — | j                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }|S r£   )rÇ   rÈ   rÊ   rË   ©rC   rb   s     rE   rš   zEomtScaleLayer.forward  sB   € ØŸ
™
 =Ó1ˆØŸ™¨Ó6ˆØŸ
™
 =Ó1ˆØ×(Ñ(¨Ó7ˆØÐrG   ©	rH   rI   rJ   r   rx   re   r   rš   r½   r¾   s   @rE   rÀ   rÀ   	  s*   ø„ ð8˜zõ 8ð  U§\¡\ð °e·l±l÷ rG   rÀ   c                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚEomtScaleBlockro   c                 óÖ   •— t         ‰| �  «        |j                  | _        t	        j
                  t        | j                  «      D �cg c]  }t        |«      ‘Œ c}«      | _        y c c}w r£   )	r³   rx   r2   r5   r   Ú
ModuleListÚrangerÀ   Úblock)rC   ro   r–   rµ   s      €rE   rx   zEomtScaleBlock.__init__#  sG   ø€ Ü‰ÑÔØ ×3Ñ3ˆŒÜ—]‘]ÄEÈ$Ï/É/ÓDZÖ#[¸q¤N°6Õ$:Ò#[Ó\ˆ�
ùÒ#[s   ÁA&rb   rp   c                 ó8   — | j                   D ]
  } ||«      }Œ |S r£   )rÕ   )rC   rb   rÕ   s      rE   rš   zEomtScaleBlock.forward(  s%   € Ø—Z‘Zò 	1ˆEÙ! -Ó0‰Mð	1àÐrG   rÏ   r¾   s   @rE   rÑ   rÑ   "  s,   ø„ ð]˜zõ ]ð
 U§\¡\ð °e·l±l÷ rG   rÑ   c                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚEomtMaskHeadro   c                 ó  •— t         ‰| �  «        |j                  }t        j                  ||«      | _        t        j                  ||«      | _        t        j                  ||«      | _        t        |j                     | _
        y r£   )r³   rx   r   r   ÚLinearÚfc1Úfc2Úfc3r	   r'   rÈ   rÌ   s      €rE   rx   zEomtMaskHead.__init__/  sa   ø€ Ü‰ÑÔà×(Ñ(ˆÜ—9‘9˜[¨+Ó6ˆŒÜ—9‘9˜[¨+Ó6ˆŒÜ—9‘9˜[¨+Ó6ˆŒÜ  ×!2Ñ!2Ñ3ˆ�rG   rb   rp   c                 ó¨   — | j                  | j                  |«      «      }| j                  | j                  |«      «      }| j                  |«      }|S r£   )rÈ   rÛ   rÜ   rÝ   rÎ   s     rE   rš   zEomtMaskHead.forward8  sD   € ØŸ™¨¯©°Ó(?Ó@ˆØŸ™¨¯©°Ó(?Ó@ˆØŸ™ Ó/ˆØÐrG   rÏ   r¾   s   @rE   rØ   rØ   .  s*   ø„ ð4˜zõ 4ð U§\¡\ð °e·l±l÷ rG   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ˆ fd„«       Zˆ xZS )ÚEomtPreTrainedModelz†
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    ro   r   r‹   )ÚimageFr    T)rb   rc   Úmodulerp   Nc                 ón  •— t         ‰| �  |«       | j                  j                  }t	        |t
        j                  t
        j                  t
        j                  f«      r¹t        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$                  «      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        «      r›t        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        jV                  |jX                  «       y y )Né   )Úar   rr   r(   )ÚmeanÚstdÚ_is_hf_initializedFÚlambda1ru   rt   )-r³   Ú_init_weightsro   r*   Ú
isinstancer   rÚ   rÉ   rÆ   ÚinitÚkaiming_uniform_r’   ÚmathÚsqrtr¼   re   Ú_calculate_fan_in_and_fan_outÚuniform_rƒ   Únormal_Úpadding_idxÚgetattrÚzeros_rž   ÚhasattrÚ	constant_ré   r0   rn   Útrunc_normal_r{   r}   Úcopy_rs   r†   r�   r‡   rh   ÚonesÚ
num_labelsÚeos_coefÚempty_weightÚEomtForUniversalSegmentationÚones_Úattn_mask_probs)rC   râ   rç   Úfan_inr–   Úboundrý   rµ   s          €rE   rê   z!EomtPreTrainedModel._init_weightsR  s*  ø€ ä‰Ñ˜fÔ%Ø�k‰k×+Ñ+ˆÜ�fœrŸy™y¬"¯)©)´R×5GÑ5GÐHÔIÜ×!Ñ! &§-¡-´4·9±9¸Q³<Õ@Ø�{‰{Ð&Ü!ŸH™HŸM™M×GÑGÈÏÉÓV‘	�˜Ø17¸!²˜œDŸI™I fÓ-Ò-À�Ü—‘˜fŸk™k¨E¨6°5Õ9ð 'ô ˜¤§¡Ô-Ü�L‰L˜Ÿ™¨S°aÕ8à×!Ñ!Ð-´g¸f¿m¹mÐMaÐchÔ6iÜ—‘˜FŸM™M¨&×*<Ñ*<Ñ=Õ>ð 7jÐ-ä˜¤Ô/Ü�v˜yÔ)Ü—‘˜vŸ~™~¨t¯{©{×/KÑ/KÕLð *ä˜¤Ô/Ü×Ñ˜v×/Ñ/°c¸sÕCÜ�K‰K˜×.Ñ.Ô/Ü�J‰J�v×*Ñ*¬E¯L©L¸×9LÑ9L×9RÑ9RÐSUÑ9VÓ,W×,^Ñ,^Ð_fÓ,gÕhÜ˜¤Ô)Ü Ÿ:™: f×&7Ñ&7¸!Ñ&;Ó<ˆLØ%Ÿ™ˆL˜ÑÜ�J‰J�v×*Ñ*¨LÕ9Ü˜Ô <Ô=Ü�J‰J�v×-Ñ-Õ.ð >rG   )rH   rI   rJ   rK   r   rN   Úbase_model_prefixÚmain_input_nameÚinput_modalitiesÚsupports_gradient_checkpointingÚ_no_split_modulesÚ_supports_sdpar    rœ   Ú_can_record_outputsre   Úno_gradr   rw   rê   r½   r¾   s   @rE   rà   rà   ?  sp   ø… ñð
 ÓØÐØ$€OØ!ÐØ&+Ð#Ø$˜ÐØ€Nà"Ø#ñÐð
 €U‡]�]ƒ_ð/ B§I¡Ið /°$ô /ó ô/rG   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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þ   ro   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±   rr   )Úloss_cross_entropyÚ	loss_maskÚ	loss_dice)ro   Úweight_dictr   )'r   rx   ro   r!   rn   r˜   r   Ú	LayerNormr   r,   Ú	layernormrƒ   r>   ÚqueryrÓ   rÔ   r    ÚlayersrÑ   Úupscale_blockrØ   Ú	mask_headrÚ   rû   Úclass_predictorr-   r.   Ú	grid_sizer7   r8   r9   r  rh   Ú	criterionr…   re   rú   r5   Ú	post_init)rC   ro   r–   s      rE   rx   z%EomtForUniversalSegmentation.__init__v  sr  € Ü× Ñ   vÔ.ØˆŒØ!'×!9Ñ!9ˆÔÜ(¨Ó0ˆŒÜŸ™ f×&8Ñ&8¸f×>SÑ>SÔTˆŒä—\‘\ &×"4Ñ"4°f×6HÑ6HÓIˆŒ
Ü—m‘mÄÀf×F^ÑF^Ó@_Ö$`¸1¤Y¨vÕ%6Ò$`ÓaˆŒä+¨FÓ3ˆÔÜ% fÓ-ˆŒä!Ÿy™y¨×);Ñ);¸V×=NÑ=NÐQRÑ=RÓSˆÔà ×+Ñ+¨v×/@Ñ/@Ñ@À&×BSÑBSÐW]×WhÑWhÑBhÐiˆŒà"(×"5Ñ"5Ø×+Ñ+Ø×+Ñ+ñ.
ˆÔô "¨¸T×=MÑ=MÔNˆŒà×ÑÐ.´·
±
¸6×;LÑ;LÓ0MÔNà�‰Õùò% %as   ÃG0c                 ó.   — | j                   j                  S r£   )r˜   r~   r‰   s    rE   Úget_input_embeddingsz1EomtForUniversalSegmentation.get_input_embeddings’  s   € Ø�‰×/Ñ/Ð/rG   c                 ó   — t        d«      ‚)NzNote needed for Eomt Model.rA   r‰   s    rE   Úget_auxiliary_logitsz1EomtForUniversalSegmentation.get_auxiliary_logits•  s   € ÜÐ:Ó;Ð;rG   Ú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 )Nrr   r   r   ru   zbqc, bchw -> bqhw)ro   r>   r  r˜   r‚   Ú	transposeÚreshaper�   r  r  r  re   Úeinsum)rC   r  Úquery_tokensÚclass_logitsÚprefix_tokensÚmask_logitss         rE   Úpredictz$EomtForUniversalSegmentation.predict˜  s×   € ØšaÐ!: 4§;¡;×#:Ñ#:Ð!:ºAÐ=Ñ>ˆØ×+Ñ+¨LÓ9ˆàšq $§+¡+×"9Ñ"9¸D¿O¹O×<]Ñ<]Ñ"]Ñ"_ÒabÐbÑcˆØ%×/Ñ/°°1Ó5ˆà-˜×-Ñ-¨m×.AÑ.AÀ!Ñ.DÀbÐZÈ4Ï>É>ÒZˆà—~‘~ lÓ3ˆØ×*Ñ*¨=Ó9ˆä—l‘lÐ#6¸ÀmÓTˆà˜LÐ(Ð(rG   c                 ó‚   — |dk  r9t        j                  | j                  d   ||¬«      |kD  }d| d d …d |…|d …f   |<   | S )Nrr   r   )Údevice)re   Úrandr�   )Ú	attn_maskÚprobÚnum_query_tokensÚencoder_start_tokensr*  Úrandom_queriess         rE   Ú_disable_attention_maskz4EomtForUniversalSegmentation._disable_attention_mask¨  sW   € à�!Š8ä"ŸZ™Z¨	¯©¸Ñ(:Ð<LÐU[Ô\Ð_cÑcˆNð VWˆI’aÐ*Ð*Ð*Ð,@Ñ,AÐAÑBÀ>ÑRàÐrG   Nr‹   Úmask_labelsÚclass_labelsrd   rD   rp   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.
        )rZ   rZ   Nz You have to specify pixel_valuesr   ru   rr   rŽ   )r*  r�   Úbilinear)ÚsizeÚmode)r-  r.  r/  r*  .g    eÍÍÁr(   )r`   r_   r2  r3  Úauxiliary_predictions)r^   r`   r_   ra   rd   )$Ú
ValueErrorr˜   Ú	enumerater  r!   ro   r5   r  r’   r‡   r�   r“   r*  re   r”   Útrainingr   r  r(  rú   rS   r¹   Úinterpolater  Úviewr6  r>   r‚   r1  r#   rP   Úmasked_fillÚzipÚget_loss_dictÚget_lossr]   )rC   r‹   r2  r3  rd   rD   Úmasks_queries_logits_per_layerÚclass_queries_logits_per_layerr¡   rb   ÚidxÚlayer_moduler  Únorm_hidden_statesr`   r_   Úinterpolated_logitsr.  r/  Úsequence_outputr^   Ú	loss_dicts                         rE   rš   z$EomtForUniversalSegmentation.forward³  sÅ  € ð* JPÑFÐ&Ð(FØˆàÐÜÐ?Ó@Ð@àŸ™¨Ó5ˆä!*¨4¯;©;Ó!7ó .	HÑˆC�Ø�d×,Ñ,¨t¯{©{×/EÑ/EÑEÒEØŸ
™
×)Ñ)¨$²²1¨*Ñ5×<Ñ<¸]×=PÑ=PÐQRÑ=SÐUWÐY[Ó\×_Ñ_Ð`m×`tÑ`tÓu�Ü %§	¡	¨5°-Ð*@ÀaÔ H�à�d×,Ñ,¨t¯{©{×/EÑ/EÑEÓEØ—’ ×!5Ñ!5°c¸D×<RÑ<RÑ6RÐUY×U`ÑU`×UkÑUkÑ6kÑ!lÐopÓ!pà%)§^¡^°MÓ%BÐ"Ø=A¿\¹\ÐJ\Ó=]Ñ:Ð$Ð&:à.Ð3GÐ2IÑIÐ.Ø.Ð3GÐ2IÑIÐ.ä!&§¡Ø!×'Ñ'¨Ñ*Ø!×'Ñ'¨Ñ*Ø!×'Ñ'¨Ñ*Ø(×/Ñ/ÜŸ*™*ô"�ô '(§m¡mÐ4HÈtÏ~É~ÐdnÔ&oÐ#Ø&9×&>Ñ&>Ø'×,Ñ,¨QÓ/Ð1D×1IÑ1IÈ!Ó1LÈbó'Ð#ð $(§;¡;×#:Ñ#:Ð Ø'7¸$¿/¹/×:[Ñ:[Ñ'[Ð$ð ObÐdeÑNe�šqÐ"3Ð#3Ð"3Ð5IÑ5JÐJÑKð "&×!=Ñ!=Ø"Ø×-Ñ-¨c°D×4JÑ4JÑ.JÈTÏ[É[×McÑMcÑ.cÑdØ%5Ø)=Ø)×0Ñ0ð ">ó "�ð "0²°4¸°Ñ!=×!DÑ!DÀRÈÏÉ×IhÑIhÐjlÐnpÓ!q�Ø!/×!5Ñ!5Ó!7×!CÑ!CÀ^ÀOÐUYÓ!Z�á(¨¸ÓGŠMð].	Hð` Ÿ.™.¨Ó7ˆà59·\±\À/Ó5RÑ2ÐÐ2Ø&Ð+?Ð*AÑAÐ&Ø&Ð+?Ð*AÑAÐ&àˆØÐ" |Ð'?ØˆDÜ>AØ.Ð0Nó?ò 
1Ñ:Ð$Ð&:ð !×.Ñ.Ø)=Ø)=Ø +Ø!-Ø*.ð /ó �	ð ˜Ÿ™ iÓ0Ñ0‘ð
1ô 2ØØ!5Ø!5Ø-Ø'ô
ð 	
rG   )NNN)rH   rI   rJ   r   rx   r  r  re   r   r(  Ústaticmethodr1  r   r   r   rQ   r   r   r]   rš   rZ   rG   rE   rþ   rþ   p  sÎ   „ ð˜zó ò80ò<ð)˜eŸl™ló )ð  ñó ðð  ØØð ,0Ø,0Ø-1ñe
àðe
ð ˜&‘\ DÑ(ðe
ð ˜6‘l TÑ)ð	e
ð
 ˜F‘| dÑ*ðe
ð Ð+Ñ,ðe
ð 
,òe
ó ó ó  ñe
rG   rþ   )r   rà   rþ   )?rK   rî   Údataclassesr   re   Útorch.nn.functionalr   Ú
functionalr¹   Úhuggingface_hub.dataclassesr   r   Ú r   rì   Úactivationsr	   Ú
file_utilsr
   Úmodeling_utilsr   Úprocessing_utilsr   Úutilsr   r   r   Úutils.genericr   Úutils.output_capturingr   Údinov2.modeling_dinov2r   r   r   r   Ú mask2former.modeling_mask2formerr   r   Úsiglip.modeling_siglipr   Úvit.configuration_vitr   Ú
get_loggerrH   Úloggerr   r]   rh   rl   rn   rœ   rž   r    r  r¯   rw   rÀ   rÑ   rØ   rà   rþ   Ú__all__rZ   rG   rE   ú<module>r^     s¥  ðñ ã Ý !ã ß Ð Ý .ß å &Ý !õõ .Ý &÷ñ õ
 8Ý 5÷ó ÷ dÝ 4Ý -ð 
ˆ×	Ñ	˜HÓ	%€ñ ÐAÔBØôO4�ó O4ó ó CðO4ñd ðô	ð ô4¨ó 4ó ó	ð4ô>	ˆô 	ô	Ð/ô 	ô!Ð%ô !ôH	�Oô 	ô	Ð%ô 	ô�ô ô0�b—l‘lô ô�R—Y‘Yô ô2	�R—Y‘Yô 	ô�2—9‘9ô ð" ô-/˜/ó -/ó ð-/ñ` ðôô
f
Ð#Fó f
óð
f
òR P�rG   