ó
    ˆŽ¡jI— ã                   ó6  • S SK r S SKJrJr  S SKJr  S SKrS SKrS SK	J
r
  S SKJ
s  Jr  S SKJr  SSK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  SSKJ r   SSK!J"r"  SSK#J$r$J%r%J&r&J'r'  SSK(J)r)  SSK*J+r+J,r,J-r-J.r.  SSK/J0r0  SSK1J2r2  SSK3J4r4  SSK5J6r6  SSK7J8r8J9r9J:r:J;r;J<r<J=r=J>r>  \&" 5       (       a  S SK?r?\'R€                  " \A5      rB\$\ " S S\5      5       5       rC\$\ " S S\5      5       5       rD\$\ " S S\5      5       5       rE\$\ " S S\5      5       5       rF\$\ " S  S!\5      5       5       rG\$\ " S" S#\5      5       5       rHSuS$\R                  S%\IS&\R                  4S' jjrJSvS(\K4S) jjrLS* rM " S+ S,\
Rœ                  5      rO  SwS-\
Rœ                  S.\R                  S/\R                  S0\R                  S1\R                  S-  S2\IS-  S3\IS4\ \+   4S5 jjrP " S6 S7\
Rœ                  5      rQ " S8 S9\
Rœ                  5      rRS: rSS;\R                  S<\R                  S=\R                  S>\R                  S&\T\R                  \R                  4   4
S? jrU " S@ SA\
Rœ                  5      rV " SB SC\
Rœ                  5      rW " SD SE\
Rœ                  5      rXSF rYSG rZ " SH SI\
Rœ                  5      r[ " SJ SK\5      r\\$\0" SLSM9 " SN SO\5      5       5       r]\$ " SP SQ\]5      5       r^ " SR SS\
Rœ                  5      r_ " ST SU\
Rœ                  5      r` " SV SW\
Rœ                  5      ra\$" SXSY9 " SZ S[\]5      5       rb " S\ S]\
Rœ                  5      rc " S^ S_\
Rœ                  5      rd " S` Sa\
Rœ                  5      re " Sb Sc\]5      rf " Sd Se\
Rœ                  5      rg " Sf Sg\
Rœ                  5      rh " Sh Si\]5      ri " Sj Sk\
Rœ                  5      rj " Sl Sm\
Rœ                  5      rk " Sn So\
Rœ                  5      rl " Sp Sq\]5      rm " Sr Ss\]5      rn/ StQrog)xé    N)ÚCallableÚIterable)Ú	dataclass)ÚTensoré   )Úinitialization)ÚACT2FN)Úcreate_bidirectional_mask)ÚGradientCheckpointingLayer)ÚBaseModelOutputÚBaseModelOutputWithPoolingÚModelOutput)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)Ú#compile_compatible_method_lru_cache)Úauto_docstringÚcan_return_tupleÚis_torchvision_availableÚlogging)Údeprecate_kwarg)ÚTransformersKwargsÚis_flash_attention_requestedÚmaybe_autocastÚmerge_with_config_defaults)Úrequires)Úcapture_outputsé   )Ú	AutoModel)ÚCLIPTextModelWithProjectioné   )Ú
Sam3ConfigÚSam3DETRDecoderConfigÚSam3DETREncoderConfigÚSam3GeometryEncoderConfigÚSam3MaskDecoderConfigÚSam3VisionConfigÚSam3ViTConfigc                   ór   • \ rS rSr% SrSr\\R                  S4   \	S'   Sr
\\R                  S4   \	S'   Srg)ÚSam3VisionEncoderOutputéB   zÄ
fpn_hidden_states (`tuple[torch.FloatTensor]`):
    Tuple of multi-level FPN feature maps.
fpn_position_encoding (`tuple[torch.FloatTensor]`):
    Tuple of position encodings for each FPN level.
N.Úfpn_hidden_statesÚfpn_position_encoding© )Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r,   ÚtupleÚtorchÚFloatTensorÚ__annotations__r-   Ú__static_attributes__r.   ó    Ú´C:\Users\johnn\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\LocalCache\local-packages\Python313\site-packages\transformers/models/sam3/modeling_sam3.pyr*   r*   B   s?   ‡ ñð 8<Ð�u˜U×.Ñ.°Ð3Ñ4Ó;Ø;?Ð˜5 ×!2Ñ!2°CÐ!7Ñ8Ö?r9   r*   c                   ód   • \ rS rSr% SrSr\R                  \S'   Sr	\R                  S-  \S'   Srg)ÚSam3GeometryEncoderOutputéP   aJ  
last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_prompts, hidden_size)`):
    Encoded geometry prompt features (boxes).
attention_mask (`torch.BoolTensor` of shape `(batch_size, num_prompts)`, *optional*):
    Attention mask for geometry prompts where True indicates valid positions and False indicates padding.
NÚlast_hidden_stateÚattention_maskr.   )r/   r0   r1   r2   r3   r>   r5   r6   r7   r?   Ú
BoolTensorr8   r.   r9   r:   r<   r<   P   s/   ‡ ñð ,0Ð�u×(Ñ(Ó/Ø.2€N�E×$Ñ$ tÑ+Ö2r9   r<   c                   ó  • \ rS rSr% SrSr\R                  \S'   Sr	\R                  S-  \S'   Sr
\R                  S-  \S'   Sr\R                  S-  \S'   Sr\\R                     S-  \S'   Sr\\R                     S-  \S	'   S
rg)ÚSam3DETREncoderOutputé^   aT  
last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
    Encoded vision features (flattened from multi-level features).
pos_embeds_flattened (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
    Flattened position embeddings for the vision features.
text_features (`torch.FloatTensor` of shape `(batch_size, text_seq_len, hidden_size)`, *optional*):
    Text features (may be pooled after encoder processing).
spatial_shapes (`torch.LongTensor` of shape `(num_levels, 2)`, *optional*):
    Spatial shapes (height, width) for each feature pyramid level.
hidden_states (`tuple[torch.FloatTensor]`, *optional*):
    Tuple of hidden states from all encoder layers.
attentions (`tuple[torch.FloatTensor]`, *optional*):
    Tuple of attention weights from all encoder layers.
Nr>   Úpos_embeds_flattenedÚtext_featuresÚspatial_shapesÚhidden_statesÚ
attentionsr.   )r/   r0   r1   r2   r3   r>   r5   r6   r7   rD   rE   rF   Ú
LongTensorrG   r4   rH   r8   r.   r9   r:   rB   rB   ^   sŽ   ‡ ñð ,0Ð�u×(Ñ(Ó/Ø59Ð˜%×+Ñ+¨dÑ2Ó9Ø.2€M�5×$Ñ$ tÑ+Ó2Ø.2€N�E×$Ñ$ tÑ+Ó2Ø59€M�5˜×*Ñ*Ñ+¨dÑ2Ó9Ø26€J��e×'Ñ'Ñ(¨4Ñ/Ö6r9   rB   c                   óÜ   • \ rS rSr% SrSr\R                  \S'   Sr	\R                  \S'   Sr
\R                  \S'   Sr\\R                     S-  \S'   Sr\\R                     S-  \S'   S	rg)
ÚSam3DETRDecoderOutputéx   aæ  
intermediate_hidden_states (`torch.FloatTensor` of shape `(num_layers, batch_size, num_queries, hidden_size)`):
    Decoder hidden states from all layers.
reference_boxes (`torch.FloatTensor` of shape `(num_layers, batch_size, num_queries, 4)`):
    Predicted reference boxes from all decoder layers in (cx, cy, w, h) format.
presence_logits (`torch.FloatTensor` of shape `(num_layers, batch_size, 1)`):
    Presence logits from all decoder layers indicating object presence confidence.
hidden_states (`tuple[torch.FloatTensor]`, *optional*):
    Tuple of hidden states from all decoder layers.
attentions (`tuple[torch.FloatTensor]`, *optional*):
    Tuple of attention weights from all decoder layers (self-attention and cross-attention).
NÚintermediate_hidden_statesÚreference_boxesÚpresence_logitsrG   rH   r.   )r/   r0   r1   r2   r3   rM   r5   r6   r7   rN   rO   rG   r4   rH   r8   r.   r9   r:   rK   rK   x   sn   ‡ ñð 59Ð × 1Ñ 1Ó8Ø)-€O�U×&Ñ&Ó-Ø)-€O�U×&Ñ&Ó-Ø59€M�5˜×*Ñ*Ñ+¨dÑ2Ó9Ø26€J��e×'Ñ'Ñ(¨4Ñ/Ö6r9   rK   c                   ó’   • \ rS rSr% SrSr\R                  \S'   Sr	\R                  S-  \S'   Sr
\\R                     S-  \S'   Srg)ÚSam3MaskDecoderOutputé�   a‚  
pred_masks (`torch.FloatTensor` of shape `(batch_size, num_queries, height, width)`):
    Predicted segmentation masks for each query.
semantic_seg (`torch.FloatTensor` of shape `(batch_size, 1, height, width)`, *optional*):
    Semantic segmentation output.
attentions (`tuple[torch.FloatTensor]`, *optional*):
    Tuple of attention weights from mask decoder cross-attention layers.
NÚ
pred_masksÚsemantic_segrH   r.   )r/   r0   r1   r2   r3   rS   r5   r6   r7   rT   rH   r4   r8   r.   r9   r:   rQ   rQ   �   sH   ‡ ñð %)€J�×!Ñ!Ó(Ø-1€L�%×#Ñ# dÑ*Ó1Ø26€J��e×'Ñ'Ñ(¨4Ñ/Ö6r9   rQ   c                   ó@  • \ rS rSr% SrSr\R                  \S'   Sr	\R                  \S'   Sr
\R                  S-  \S'   Sr\R                  S-  \S'   Sr\R                  S-  \S'   Sr\\R                     S-  \S	'   Sr\R                  S-  \S
'   Sr\\R                     S-  \S'   Sr\\R                     S-  \S'   Sr\\R                     S-  \S'   Sr\\R                     S-  \S'   Sr\\R                     S-  \S'   Sr\\R                     S-  \S'   Srg)ÚSam3ImageSegmentationOutputé    a  
pred_masks (`torch.FloatTensor` of shape `(batch_size, num_queries, height, width)`):
    Predicted segmentation masks for each query.
pred_boxes (`torch.FloatTensor` of shape `(batch_size, num_queries, 4)`):
    Predicted bounding boxes in (x1, y1, x2, y2) format.
pred_logits (`torch.FloatTensor` of shape `(batch_size, num_queries)`, *optional*):
    Classification confidence scores for each query, computed via dot product between
    decoder query features and text features.
presence_logits (`torch.FloatTensor` of shape `(batch_size, 1)`, *optional*):
    Presence logits from the DETR decoder presence token (last layer only). These indicate whether objects
    are present in the scene. Can be used to compute final scores by multiplying with pred_logits:
    `final_scores = pred_logits.sigmoid() * presence_logits.sigmoid()`.
semantic_seg (`torch.FloatTensor` of shape `(batch_size, 1, height, width)`, *optional*):
    Semantic segmentation output.
decoder_hidden_states (`tuple[torch.FloatTensor]`, *optional*):
    Tuple of hidden states from all DETR decoder layers. Each tensor has shape `(batch_size, num_queries, hidden_size)`.
decoder_reference_boxes (`torch.FloatTensor` of shape `(num_layers, batch_size, num_queries, 4)`, *optional*):
    Reference boxes from all DETR decoder layers.
encoder_hidden_states (`tuple[torch.FloatTensor]`, *optional*):
    Tuple of hidden states from all DETR encoder layers.
vision_hidden_states (`tuple[torch.FloatTensor]`, *optional*):
    Tuple of hidden states from all vision encoder (ViT) layers.
vision_attentions (`tuple[torch.FloatTensor]`, *optional*):
    Attention weights from vision encoder (ViT) layers.
detr_encoder_attentions (`tuple[torch.FloatTensor]`, *optional*):
    Attention weights from DETR encoder layers.
detr_decoder_attentions (`tuple[torch.FloatTensor]`, *optional*):
    Attention weights from DETR decoder layers (self-attention and cross-attention).
mask_decoder_attentions (`tuple[torch.FloatTensor]`, *optional*):
    Attention weights from mask decoder layers.
NrS   Ú
pred_boxesÚpred_logitsrO   rT   Údecoder_hidden_statesÚdecoder_reference_boxesÚencoder_hidden_statesÚvision_hidden_statesÚvision_attentionsÚdetr_encoder_attentionsÚdetr_decoder_attentionsÚmask_decoder_attentionsr.   )r/   r0   r1   r2   r3   rS   r5   r6   r7   rX   rY   rO   rT   rZ   r4   r[   r\   r]   r^   r_   r`   ra   r8   r.   r9   r:   rV   rV       s<  ‡ ñð@ %)€J�×!Ñ!Ó(Ø$(€J�×!Ñ!Ó(Ø,0€K�×"Ñ" TÑ)Ó0Ø04€O�U×&Ñ&¨Ñ-Ó4Ø-1€L�%×#Ñ# dÑ*Ó1Ø=AÐ˜5 ×!2Ñ!2Ñ3°dÑ:ÓAØ8<Ð˜U×.Ñ.°Ñ5Ó<Ø=AÐ˜5 ×!2Ñ!2Ñ3°dÑ:ÓAØ<@Ð˜% × 1Ñ 1Ñ2°TÑ9Ó@Ø9=Ð�u˜U×.Ñ.Ñ/°$Ñ6Ó=Ø?CÐ˜U 5×#4Ñ#4Ñ5¸Ñ<ÓCØ?CÐ˜U 5×#4Ñ#4Ñ5¸Ñ<ÓCØ?CÐ˜U 5×#4Ñ#4Ñ5¸Ñ<ÖCr9   rV   ÚxÚepsÚreturnc                 ó”   • U R                  SSS9n U R                  US9nSU -
  R                  US9n[        R                  " X#-  5      $ )z5The inverse function for sigmoid activation function.r   r!   ©ÚminÚmax©rg   )Úclampr5   Úlog)rb   rc   Úx1Úx2s       r:   Úinverse_sigmoidrn   Ò   sI   € à	�‰�A˜1ˆÐ€AØ	
�‰�SˆÐ	€BØ
ˆa‰%�‰˜3ˆÐ	€BÜ�9Š9�R‘WÓÐr9   Úreturn_indexc                 ó<  • U R                   u  pVnUR                   u  p‰n
XXs=:X  a,  UR                  S5      s=:X  a  UR                  S5      :X  d   e   eXz:X  d   eXaR                  S5      :X  d   eX“R                  S5      :X  d   eUR                  SS9nUR                  SS9nX¼-   nXi-   n[        R                  " XâR
                  S9S   R                  US5      USS2S4   :  n[        R                  " X^U4UR
                  UR                  S9nU USS2SU2SS24'   [        R                  " X’R
                  S9S   R                  US5      nUUSS2S4   -   nUR                  SUSS2SS2S4   R                  SSU5      U5      nU(       a  UUU4$ UU4$ )a‹  
Concatenates two right-padded sequences, such that the resulting sequence
is contiguous and also right-padded.

Tensors are batch-first, masks are batch-first with True=valid, False=padding.

Args:
    seq1: A tensor of shape (batch_size, seq1_length, hidden_size).
    mask1: A tensor of shape (batch_size, seq1_length) with True=valid, False=padding.
    seq2: A tensor of shape (batch_size, seq2_length, hidden_size).
    mask2: A tensor of shape (batch_size, seq2_length) with True=valid, False=padding.
    return_index: If True, also returns the index of the ids of the element of seq2
        in the concatenated sequence. This can be used to retrieve the elements of seq2.

Returns:
    A tuple (concatenated_sequence, concatenated_mask) if return_index is False,
    otherwise (concatenated_sequence, concatenated_mask, index).
    The concatenated_mask uses True=valid, False=padding convention.
r   r!   éÿÿÿÿ©Údim)ÚdeviceN©rt   Údtype)ÚshapeÚsizeÚsumr5   Úarangert   ÚrepeatÚzerosrv   ÚscatterÚexpand)Úseq1Úmask1Úseq2Úmask2ro   Ú
batch_sizeÚseq1_lengthÚhidden_sizeÚbatch_size2Úseq2_lengthÚhidden_size2Úactual_seq1_lengthsÚactual_seq2_lengthsÚfinal_lengthsÚ
max_lengthÚconcatenated_maskÚconcatenated_sequenceÚindexs                     r:   Úconcat_padded_sequencesr�   Ú   s¸  € ð( ,0¯:©:Ñ(€J˜[Ø-1¯Z©ZÑ*€K˜làÕF¨¯
©
°1«ÕF¸¿¹ÀA»ÓFÐFÑFÐFÐFØÓ&Ð&Ð&ØŸ*™* Q›-Ó'Ð'Ð'ØŸ*™* Q›-Ó'Ð'Ð'àŸ)™)¨˜)Ð+ÐØŸ)™)¨˜)Ð+Ðà'Ñ=€MØÑ*€Jô 	�Š�Z¯©Ñ4°TÑ:×AÑAÀ*ÈaÓPÐS`ÒabÐdhÐahÑSiÑið ô "ŸKšK¨ÀÐ(MÐVZ×VaÑVaÐim×isÑisÑtÐØ04Ðš!˜\˜k˜\ª1Ð,Ñ-ô �LŠL˜¯[©[Ñ9¸$Ñ?×FÑFÀzÐSTÓU€EØÐ'ª¨4¨Ñ0Ñ0€Eð 2×9Ñ9¸!¸UÂ1ÂaÈÀ:Ñ=N×=UÑ=UÐVXÐZ\Ð^iÓ=jÐlpÓqÐæØ$Ð&7¸Ð>Ð>à Ð"3Ð3Ð3r9   c                 ó�   • U R                  S5      u  pp4USU-  -
  USU-  -
  USU-  -   USU-  -   /n[        R                  " USS9$ )zDConvert boxes from (cx, cy, w, h) format to (x1, y1, x2, y2) format.rq   ç      à?rr   )Úunbindr5   Ústack)rb   Úx_cÚy_cÚwÚhÚbs         r:   Úbox_cxcywh_to_xyxyrš     sR   € à—X‘X˜b“\�N€CˆaØ
��a‘‰-˜3  q¡™=¨C°#¸±'©M¸SÀ3ÈÁ7¹]ÐL€AÜ�;Š;�q˜bÑ!Ð!r9   c                   ób   ^ • \ rS rSrU 4S jrS\R                  S\R                  4S jrSrU =r	$ )ÚSam3MLPi  c                 óh  >• [         TU ]  5         Xl        [        UR                     U l        [        R                  " UR                  UR                  5      U l
        [        R                  " UR                  UR                  5      U l        [        R                  " UR                  5      U l        g ©N)ÚsuperÚ__init__Úconfigr	   Ú
hidden_actÚactivation_fnÚnnÚLinearr…   Úintermediate_sizeÚfc1Úfc2ÚDropoutÚhidden_dropoutÚdropout©Úselfr¡   Ú	__class__s     €r:   r    ÚSam3MLP.__init__  sx   ø€ Ü‰ÑÔØŒÜ# F×$5Ñ$5Ñ6ˆÔÜ—9’9˜V×/Ñ/°×1IÑ1IÓJˆŒÜ—9’9˜V×5Ñ5°v×7IÑ7IÓJˆŒÜ—z’z &×"7Ñ"7Ó8ˆ�r9   rG   rd   c                 óŽ   • U R                  U5      nU R                  U5      nU R                  U5      nU R                  U5      nU$ rž   )r§   r«   r£   r¨   )r­   rG   s     r:   ÚforwardÚSam3MLP.forward   sB   € ØŸ™ Ó/ˆØŸ™ ]Ó3ˆØ×*Ñ*¨=Ó9ˆØŸ™ Ó/ˆØÐr9   )r£   r¡   r«   r§   r¨   ©
r/   r0   r1   r2   r    r5   r   r±   r8   Ú__classcell__©r®   s   @r:   rœ   rœ     s(   ø† õ9ð U§\¡\ð °e·l±l÷ ò r9   rœ   ÚmoduleÚqueryÚkeyÚvaluer?   Úscalingr«   Úkwargsc                 óŽ  • Uc  UR                  S5      S-  n[        R                  " XR                  SS5      5      U-  nUb  X„-   n[        R
                  R                  USS9n[        R
                  R                  X†U R                  S9n[        R                  " Xƒ5      n	U	R                  SS5      R                  5       n	X˜4$ )Nrq   ç      à¿r   r   rr   )ÚpÚtrainingr!   )
rx   r5   ÚmatmulÚ	transposer¤   Ú
functionalÚsoftmaxr«   r¿   Ú
contiguous)
r¶   r·   r¸   r¹   r?   rº   r«   r»   Úattn_weightsÚattn_outputs
             r:   Úeager_attention_forwardrÇ   (  s±   € ð �Ø—*‘*˜R“. DÑ(ˆô —<’< §}¡}°Q¸Ó':Ó;¸gÑE€LàÑ!Ø#Ñ4ˆä—=‘=×(Ñ(¨¸2Ð(Ð>€LÜ—=‘=×(Ñ(¨È6Ï?É?Ð(Ð[€Lä—,’,˜|Ó3€KØ×'Ñ'¨¨1Ó-×8Ñ8Ó:€KàÐ$Ð$r9   c                   óâ   ^ • \ rS rSrSrU 4S jr SS\R                  S\R                  S\R                  S\R                  S-  S	\\	   S
\
\R                  \R                  4   4S jjrSrU =r$ )ÚSam3AttentioniD  zT
Multi-head attention.
Handles standard [batch_size, seq_len, hidden_size] tensors.
c                 ód  >• [         TU ]  5         Xl        UR                  U l        UR                  U l        U R                  UR                  -  U l        U R
                  S-  U l        SU l        [        R                  " U R                  U R                  5      U l
        [        R                  " U R                  U R                  5      U l        [        R                  " U R                  U R                  5      U l        [        R                  " U R                  U R                  5      U l        g ©Nr½   F)rŸ   r    r¡   r…   Únum_attention_headsÚhead_dimrº   Ú	is_causalr¤   r¥   Úq_projÚk_projÚv_projÚo_projr¬   s     €r:   r    ÚSam3Attention.__init__J  sÖ   ø€ Ü‰ÑÔØŒØ!×-Ñ-ˆÔØ#)×#=Ñ#=ˆÔ Ø×(Ñ(¨F×,FÑ,FÑFˆŒØ—}‘} dÑ*ˆŒØˆŒä—i’i × 0Ñ 0°$×2BÑ2BÓCˆŒÜ—i’i × 0Ñ 0°$×2BÑ2BÓCˆŒÜ—i’i × 0Ñ 0°$×2BÑ2BÓCˆŒÜ—i’i × 0Ñ 0°$×2BÑ2BÓCˆ�r9   Nr·   r¸   r¹   r?   r»   rd   c                 óô  • UR                   S   nUR                   S   nUR                   S   nU R                  U5      R                  XgU R                  U R                  5      R                  SS5      nU R                  U5      R                  XhU R                  U R                  5      R                  SS5      nU R                  U5      R                  XhU R                  U R                  5      R                  SS5      n[        R                  " U R                  R                  [        5      n	[        U R                  5      (       a?  Ub<  UR                  [        R                   :w  a  [        S   n	["        R%                  S5        U	" U UUU4USU R&                  U R(                  S.UD6u  p«U
R+                  XgU R                  U R                  -  5      R-                  5       n
U R/                  U
5      n
X«4$ )a“  
Args:
    query: [batch_size, query_len, hidden_size]
    key: [batch_size, key_len, hidden_size]
    value: [batch_size, value_len, hidden_size]
    attention_mask: [batch_size, num_heads, query_len, key_len] or broadcastable

Returns:
    Tuple of (output, attention_weights)
        output: [batch_size, query_len, hidden_size]
        attention_weights: [batch_size, num_heads, query_len, key_len]
r   r!   r   Úsdpaz‡Sam3Attention: falling back to SDPA for relative-position cross-attention because Flash Attention does not support additive bias masks.ç        ©r?   r«   rº   rÎ   )rw   rÏ   ÚviewrÌ   rÍ   rÁ   rÐ   rÑ   r   Úget_interfacer¡   Ú_attn_implementationrÇ   r   rv   r5   ÚboolÚloggerÚwarning_oncerº   rÎ   ÚreshaperÄ   rÒ   )r­   r·   r¸   r¹   r?   r»   rƒ   Ú	query_lenÚkey_lenÚattention_interfacerÆ   rÅ   s               r:   r±   ÚSam3Attention.forwardX  sÇ  € ð( —[‘[ ‘^ˆ
Ø—K‘K ‘Nˆ	Ø—)‘)˜A‘,ˆà—‘˜EÓ"×'Ñ'¨
¸t×?WÑ?WÐY]×YfÑYfÓg×qÑqÐrsÐuvÓwˆØ�k‰k˜#Ó×#Ñ# J¸×9QÑ9QÐSW×S`ÑS`Óa×kÑkÐlmÐopÓqˆØ—‘˜EÓ"×'Ñ'¨
¸T×=UÑ=UÐW[×WdÑWdÓe×oÑoÐpqÐstÓuˆä(?×(MÒ(MØ�K‰K×,Ñ,Ô.Eó)
Ðô
 )¨¯©×5Ñ5ØÑ*Ø×$Ñ$¬¯
©
Ó2ô #:¸&Ñ"AÐÜ×ÑðHôñ
 %8ØØØØð	
%
ð
 *ØØ—L‘LØ—n‘nñ
%
ð ñ
%
Ñ!ˆð "×)Ñ)¨*À×AYÑAYÐ\`×\iÑ\iÑAiÓj×uÑuÓwˆØ—k‘k +Ó.ˆàÐ(Ð(r9   )
r¡   rÍ   r…   rÎ   rÐ   rÌ   rÒ   rÏ   rº   rÑ   rž   )r/   r0   r1   r2   r3   r    r5   r   r   r   r4   r±   r8   r´   rµ   s   @r:   rÉ   rÉ   D  s„   ø† ñõ
Dð& /3ñ<)à�|‰|ð<)ð �\‰\ð<)ð �|‰|ð	<)ð
 Ÿ™ tÑ+ð<)ð Ð+Ñ,ð<)ð 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*÷<)ó <)r9   rÉ   c            	       óÒ   ^ • \ rS rSrSr\" SSS9SS\4U 4S jjj5       r\\" SSS9SS\S\	\
R                  \4   4S	 jj5       5       r\
R                  " 5       S
 5       rS rSrU =r$ )ÚSam3ViTRotaryEmbeddingi˜  zí
Simple axial 2D rope with same freqs used for H and W grids. The freqs are
pre-computed using `head-dim//4` which is later used to concat H and W positions.
The final angles rotate over the whole head dim, no partial rotation involved.
rt   z5.18)Úversionr¡   c                 ó¶  >• [         TU ]  5         Xl        U R                  R                  S   U l        U R
                  nU R                  S:w  a.  [        U R                  R                   SU R                   35      eU" U R                  U5      u  o@l	        [        R                  " USS9U l        [        R                  " UR                  5       SS9U l        g )NÚ	rope_typeÚaxialz) supports only axial rope, but requested F©Ú
persistent)rŸ   r    r¡   Úrope_parametersrç   Úcompute_axial_rope_parametersÚ
ValueErrorr®   r/   Úattention_scalingr¤   ÚBufferÚinv_freqÚcloneÚoriginal_inv_freq)r­   r¡   rt   Úrope_init_fnrð   r®   s        €r:   r    ÚSam3ViTRotaryEmbedding.__init__Ÿ  s¬   ø€ ä‰ÑÔØŒàŸ™×4Ñ4°[ÑAˆŒØ!%×!CÑ!CˆØ�>‰>˜WÓ$Ü §¡× 7Ñ 7Ð8Ð8aÐbf×bpÑbpÐaqÐrÓsÐsÙ+7¸¿¹ÀVÓ+LÑ(ˆÔ(äŸ	š	 (°uÑ=ˆŒÜ!#§¢¨8¯>©>Ó+;ÈÑ!NˆÕr9   rd   c           	      ó
  • U R                   S   n[        U SS5      =(       d    U R                  U R                  -  nUS-  nSnSU[        R
                  " SUS[        R                  S9U-  -  -  nUR                  U5      U4$ )a~  
Computes the inverse frequencies according to the original RoPE implementation
Args:
    config ([`~transformers.PreTrainedConfig`]):
        The model configuration.
Returns:
    Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the
    post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE).
Ú
rope_thetarÍ   Nr   ç      ð?r   ©rv   )rë   Úgetattrr…   rÌ   r5   rz   ÚfloatÚto)r¡   rt   r»   Úbasers   Úspatial_dimÚattention_factorrð   s           r:   rì   Ú4Sam3ViTRotaryEmbedding.compute_axial_rope_parameters­  s„   € ð ×%Ñ% lÑ3ˆÜ�f˜j¨$Ó/×c°6×3EÑ3EÈ×IcÑIcÑ3cˆØ˜Q‘hˆàÐØ˜$¤5§<¢<°°;ÀÌÏÉÑ#UÐXcÑ#cÑdÑeˆØ�{‰{˜6Ó"Ð$4Ð4Ð4r9   c                 ó  • US   R                  5       n[        UR                  R                  [        5      (       a0  UR                  R                  S:w  a  UR                  R                  OSn[        USS9   X0R                  R                  5       -  nUR                  5       U R                  -  nUR                  5       U R                  -  nS S S 5        U R                  W5      nU R                  W5      nXg4$ ! , (       d  f       N3= f)N).NÚmpsÚcpuF)Údevice_typeÚenabled)rú   Ú
isinstancert   ÚtypeÚstrr   rð   Úcosrî   ÚsinÚrecomposition_frequencies)r­   rb   Úposition_idsÚposition_ids_expandedr  Úfreqsr  r	  s           r:   r±   ÚSam3ViTRotaryEmbedding.forwardÁ  sÐ   € ð !-¨YÑ 7× =Ñ =Ó ?ÐÜ'1°!·(±(·-±-Ä×'EÑ'EÈ!Ï(É(Ï-É-Ð[`ÓJ`�a—h‘h—m’mÐfkˆÜ¨¸UÓCØ)¯M©M×,?Ñ,?Ó,AÑAˆEØ—)‘)“+ × 6Ñ 6Ñ6ˆCØ—)‘)“+ × 6Ñ 6Ñ6ˆC÷ Dð
 ×,Ñ,¨SÓ1ˆØ×,Ñ,¨SÓ1ˆØˆxˆ÷ DÕCús   Á9AC=Ã=
Dc                 óv   • USS2S4   USS2S4   p2[         R                  " X#/SS9S   nUR                  SSS9$ )zM
Recompose the frequencies into the final spatial layout used per each grid.
Nr   r!   rq   rr   )N.r   )r5   ÚcatÚrepeat_interleave)r­   ÚfreqÚfreq_hÚfreq_wÚfreq_hws        r:   r
  Ú0Sam3ViTRotaryEmbedding.recomposition_frequenciesÐ  sI   € ð
 ša ˜d™ Tª!¨Q¨$¡Z�Ü—)’)˜VÐ,°"Ñ5°iÑ@ˆØ×(Ñ(¨°Ð(Ð3Ð3r9   )rî   r¡   rð   rò   rç   rž   )r/   r0   r1   r2   r3   r   r(   r    Ústaticmethodr4   r5   r   rú   rì   Úno_gradr±   r
  r8   r´   rµ   s   @r:   rä   rä   ˜  s•   ø† ññ �X vÑ.ñO˜}÷ Oó /ðOð Ù�X vÑ.ñ5¨mð 5ÐW\Ð]b×]iÑ]iÐkpÐ]pÑWqô 5ó /ó ð5ð$ ‡]‚]ƒ_ñó ð÷4ð 4r9   rä   c                 ó¸   • U R                   " / U R                  SS QSPSP76 n U R                  SS9u  p[        R                  " U* U4SS9n U R                  SS9$ )aR  
pairwise rotation of the hidden dims of the input. Different from Llama Half-Tensor Rotation.

This is an optimized version of the following more explicit implementation:
```python
x_rotated = torch.zeros_like(x, dtype=x.dtype, device=x.device)
x_rotated[..., ::2] = -x[..., 1::2]
x_rotated[..., 1::2] = x[..., ::2]
return x_rotated
```
Nrq   r   rr   éþÿÿÿ)Ú	start_dim)rØ   rw   r“   r5   r”   Úflatten)rb   rl   rm   s      r:   Úrotate_pairwiser  Ú  sb   € ð 	
�ŠÐ$�—‘˜˜�Ð$˜bÐ$ !Ò$€AØ�X‰X˜"ˆXÐ�F€BÜ�Š�b�S˜"�I 2Ñ&€AØ�9‰9˜rˆ9Ð"Ð"r9   ÚqÚkr  r	  c                 óÒ   • U R                  5       nXB-  [        U5      U-  -   nUR                  5       nXR-  [        U5      U-  -   nUR                  U 5      UR                  U5      4$ )a   
Apply rotary position embedding to query and key tensors for self-attention.

Args:
    q: Query tensor of shape (batch_size, num_windows, seq_len, num_heads, head_dim)
    k: Key tensor of shape (batch_size, num_windows, seq_len, num_heads, head_dim)
    cos: Cosine position embedding of shape (seq_len, head_dim)
    sin: Sine position embedding of shape (seq_len, head_dim)

Returns:
    Rotated (q, k) tensors
)rú   r  Útype_as)r  r  r  r	  Úq_embedÚk_embeds         r:   Úapply_rotary_pos_emb_2dr$  ì  sc   € ð$ �g‰g‹i€GØ‰}¤°Ó!9¸CÑ!?Ñ@€Gà�g‰g‹i€GØ‰}¤°Ó!9¸CÑ!?Ñ@€Gà�?‰?˜1Ó˜wŸ™¨qÓ1Ð1Ð1r9   c                   óš   ^ • \ rS rSrSrS\4U 4S jjrS\R                  S\	\R                  \R                  4   S\
\   S\4S	 jrS
rU =r$ )ÚSam3ViTRoPEAttentioni  z-Self-attention with rotary position encoding.r¡   c                 ó†  >• [         TU ]  5         Xl        UR                  U l        UR                  U l        U R                  UR                  -  U l        U R
                  S-  U l        UR                  U l        SU l        [        R                  " U R                  U R                  5      U l        [        R                  " U R                  U R                  5      U l        [        R                  " U R                  U R                  5      U l        [        R                  " U R                  U R                  5      U l        g rË   )rŸ   r    r¡   r…   rÌ   rÍ   rº   Úattention_dropoutrÎ   r¤   r¥   rÏ   rÐ   rÑ   rÒ   r¬   s     €r:   r    ÚSam3ViTRoPEAttention.__init__
  sä   ø€ Ü‰ÑÔØŒØ!×-Ñ-ˆÔØ#)×#=Ñ#=ˆÔ Ø×(Ñ(¨F×,FÑ,FÑFˆŒØ—}‘} dÑ*ˆŒØ!'×!9Ñ!9ˆÔØˆŒä—i’i × 0Ñ 0°$×2BÑ2BÓCˆŒÜ—i’i × 0Ñ 0°$×2BÑ2BÓCˆŒÜ—i’i × 0Ñ 0°$×2BÑ2BÓCˆŒÜ—i’i × 0Ñ 0°$×2BÑ2BÓCˆ�r9   rG   Úposition_embeddingsr»   rd   c                 óâ  • UR                   u  pEpgXV-  nXHU R                  U R                  4n	U R                  U5      R                  " U	6 R                  SS5      n
U R                  U5      R                  " U	6 R                  SS5      nU R                  U5      R                  " U	6 R                  SS5      nUu  pÞ[        X«XÞS9u  p«[        R                  " U R                  R                  [        5      nU" U U
UU4S U R                  (       d  SOU R                  U R                   U R"                  S.UD6u  nnUR%                  XEUS5      R'                  5       nU R)                  U5      nUU4$ )Nr!   r   )r  r	  rÖ   r×   rq   )rw   rÌ   rÍ   rÏ   rØ   rÁ   rÐ   rÑ   r$  r   rÙ   r¡   rÚ   rÇ   r¿   r(  rº   rÎ   rÞ   rÄ   rÒ   )r­   rG   r*  r»   rƒ   ÚheightÚwidthÚ_Úseq_lenÚ	new_shaper·   r¸   r¹   r  r	  rá   rÆ   rÅ   s                     r:   r±   ÚSam3ViTRoPEAttention.forward  sa  € ð (5×':Ñ':Ñ$ˆ
˜EØ‘.ˆØ¨$×*BÑ*BÀDÇMÁMÐRˆ	Ø—‘˜MÓ*×/Ò/°Ð;×EÑEÀaÈÓKˆØ�k‰k˜-Ó(×-Ò-¨yÐ9×CÑCÀAÀqÓIˆØ—‘˜MÓ*×/Ò/°Ð;×EÑEÀaÈÓKˆØ&‰ˆÜ,¨U¸SÑJ‰
ˆä(?×(MÒ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØð	
%
ð
  Ø#Ÿ}Ÿ}‘C°$×2HÑ2HØ—L‘LØ—n‘nñ
%
ð ñ
%
Ñ!ˆ�\ð "×)Ñ)¨*¸eÀRÓH×SÑSÓUˆØ—k‘k +Ó.ˆØ˜LÐ(Ð(r9   )r(  r¡   rÍ   r…   rÎ   rÐ   rÌ   rÒ   rÏ   rº   rÑ   )r/   r0   r1   r2   r3   r(   r    r5   r   r4   r   r   r±   r8   r´   rµ   s   @r:   r&  r&    s`   ø† Ù7ðD˜}÷ Dð )à—|‘|ð )ð # 5§<¡<°·±Ð#=Ñ>ð )ð Ð+Ñ,ð	 )ð
 
÷ )ò  )r9   r&  c                   ón   ^ • \ rS 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$ )	ÚSam3ViTPatchEmbeddingsi<  zÜ
This class turns `pixel_values` of shape `(batch_size, num_channels, height, width)` into the initial
`hidden_states` (patch embeddings) of shape `(batch_size, seq_length, hidden_size)` to be consumed by a
Transformer.
r¡   c                 óz  >• [         TU ]  5         UR                  UR                  p2UR                  UR
                  pT[        U[        5      (       a  UOX"4n[        U[        5      (       a  UOX34nUS   US   -  US   US   -  -  nX l        X0l        X@l        X`l	        [        R                  " XEX3SS9U l        g )Nr!   r   F)Úkernel_sizeÚstrideÚbias)rŸ   r    Úpretrain_image_sizeÚ
patch_sizeÚnum_channelsr…   r  r   Ú
image_sizeÚnum_patchesr¤   ÚConv2dÚ
projection)r­   r¡   r;  r9  r:  r…   r<  r®   s          €r:   r    ÚSam3ViTPatchEmbeddings.__init__C  s°   ø€ Ü‰ÑÔØ!'×!;Ñ!;¸V×=NÑ=N�JØ$*×$7Ñ$7¸×9KÑ9K�kä#-¨j¼(×#CÑ#C‘ZÈ*ÐIaˆ
Ü#-¨j¼(×#CÑ#C‘ZÈ*ÐIaˆ
Ø! !‘}¨
°1©Ñ5¸*ÀQ¹-È:ÐVWÉ=Ñ:XÑYˆØ$ŒØ$ŒØ(ÔØ&ÔäŸ)š) LÈ:ÐotÑuˆ�r9   Úpixel_valuesrd   c                 óÀ   • U R                  UR                  U R                   R                  R                  5      5      R	                  S5      R                  SS5      nU$ )Nr   r!   )r>  rû   Úweightrv   r  rÁ   )r­   r@  Ú
embeddingss      r:   r±   ÚSam3ViTPatchEmbeddings.forwardR  sJ   € Ø—_‘_ \§_¡_°T·_±_×5KÑ5K×5QÑ5QÓ%RÓS×[Ñ[Ð\]Ó^×hÑhÐijÐlmÓnˆ
ØÐr9   )r;  r:  r<  r9  r>  )r/   r0   r1   r2   r3   r(   r    r5   r   r±   r8   r´   rµ   s   @r:   r3  r3  <  s6   ø† ñðv˜}÷ vð E§L¡Lð °U·\±\÷ ò r9   r3  c                   óº   ^ • \ rS rSrSrS\4U 4S jjrS\R                  S\	S\	S\R                  4S	 jr
 SS
\R                  S\S\R                  4S jjrSrU =r$ )ÚSam3ViTEmbeddingsiW  z¦
Construct the patch embeddings and position embeddings for SAM3 ViT.

Position embeddings are tiled (not interpolated) when resizing to match different input sizes.
r¡   c                 óN  >• [         TU ]  5         [        U5      U l        U R                  R                  n[
        R                  " [        R                  " SX!R                  5      5      U l
        [
        R                  " UR                  5      U l        UR                  U l        g )Nr!   )rŸ   r    r3  Úpatch_embeddingsr<  r¤   Ú	Parameterr5   Úrandnr…   r*  r©   rª   r«   r9  )r­   r¡   r<  r®   s      €r:   r    ÚSam3ViTEmbeddings.__init__^  sv   ø€ Ü‰ÑÔä 6°vÓ >ˆÔØ×+Ñ+×7Ñ7ˆÜ#%§<¢<Ü�KŠK˜˜;×(:Ñ(:Ó;ó$
ˆÔ ô —z’z &×"7Ñ"7Ó8ˆŒØ ×+Ñ+ˆ�r9   r*  r,  r-  rd   c                 óÔ  • [        UR                  S   S-  5      n[        R                  R	                  5       (       d  XB:X  a  XC:X  a  UR                  SX#-  S5      $ UR                  S   nUR                  SXDU5      R                  SSSS5      nX$-  S-   nX4-  S-   nUR                  SSXx/5      SS2SS2SU2SU24   nUR                  SSSS5      R                  SX#-  U5      $ )a  
Tile position embeddings to match target spatial dimensions.
Args:
    position_embeddings: Shape [1, num_pretrain_patches, hidden_size]
    height: Target height in patches
    width: Target width in patches

Returns:
    Shape [1, height * width, hidden_size]
r!   r’   rq   r   r   r   N)Úintrw   r5   ÚjitÚ
is_tracingrÞ   ÚpermuteÚtile)	r­   r*  r,  r-  Úpretrain_sizer…   Ú	pos_embedÚrepeat_hÚrepeat_ws	            r:   Ú_tile_position_embeddingsÚ+Sam3ViTEmbeddings._tile_position_embeddingsj  sþ   € ô  Ð/×5Ñ5°aÑ8¸CÑ?Ó@ˆô �y‰y×#Ñ#×%Ñ%¨-Ó*AÀmÓF\Ø&×.Ñ.¨q°&±.À"ÓEÐEð *×/Ñ/°Ñ3ˆØ'×/Ñ/°°=ÐQ\Ó]×eÑeÐfgÐijÐlmÐopÓqˆ	ØÑ*¨QÑ.ˆØÑ)¨AÑ-ˆØ—N‘N A q¨(Ð#=Ó>ºqÂ!ÀWÀfÀWÈfÈuÈfÐ?TÑUˆ	Ø× Ñ   A q¨!Ó,×4Ñ4°Q¸¹ÈÓTÐTr9   r@  Úinterpolate_pos_encodingc                 óæ   • UR                   SS  u  p4U R                  U5      nX0R                  -  nX@R                  -  nU R                  U R                  UU5      nXX-   nU R                  U5      nU$ )Nr  )rw   rH  r9  rV  r*  r«   )	r­   r@  rX  r,  r-  rC  Úheight_patchesÚwidth_patchesr*  s	            r:   r±   ÚSam3ViTEmbeddings.forwardˆ  s€   € ð
 %×*Ñ*¨2¨3Ð/‰ˆØ×*Ñ*¨<Ó8ˆ
ð  §?¡?Ñ2ˆØ§¡Ñ0ˆà"×<Ñ<Ø×$Ñ$ØØó
Ðð
  Ñ5ˆ
Ø—\‘\ *Ó-ˆ
àÐr9   )r«   rH  r9  r*  ©F)r/   r0   r1   r2   r3   r(   r    r5   r   rM  rV  rÛ   r±   r8   r´   rµ   s   @r:   rF  rF  W  s€   ø† ñð
,˜}÷ 
,ðUà"Ÿ\™\ðUð ðUð ð	Uð
 
�‰ôUðB */ñà—l‘lðð #'ðð 
�‰÷	ó r9   rF  c           	      óH  • U R                   u  p#pEXU-  -
  U-  nXU-  -
  U-  n[        R                  R                  U SSSUSU45      n X6-   XG-   p˜U R	                  X(U-  XU-  X5      n U R                  SSSSSS5      R                  5       R	                  SXU5      n
X¨U	44$ )aá  
Partition into non-overlapping windows with padding if needed.

Args:
    hidden_state (`torch.Tensor`):
        Input tokens with [batch_size, height, width, num_channels].
    window_size (`int`):
        Window size.

Returns:
    `tuple(torch.FloatTensor)` comprising various elements:
    - windows: windows after partition with [batch_size * num_windows, window_size, window_size, num_channels].
    - (padded_height, padded_width): padded height and width before partition
r   r!   r   r   é   é   rq   )rw   r¤   rÂ   ÚpadrØ   rP  rÄ   )Úhidden_stateÚwindow_sizerƒ   r,  r-  r:  Ú
pad_heightÚ	pad_widthÚpadded_heightÚpadded_widthÚwindowss              r:   Úwindow_partitionri  Ÿ  sÏ   € ð /;×.@Ñ.@Ñ+€J˜Ø¨Ñ 4Ñ4¸ÑC€JØ {Ñ2Ñ2°kÑA€Iô —=‘=×$Ñ$ \°A°q¸!¸YÈÈ:Ð3VÓW€Là"(Ñ"5°uÑ7H�<à×$Ñ$Ø [Ñ0°+È{Ñ?ZÐ\gó€Lð ×"Ñ" 1 a¨¨A¨q°!Ó4×?Ñ?ÓA×FÑFÀrÈ;ÐeqÓr€GØ LÐ1Ð1Ð1r9   c                 ó(  • Uu  pEUu  pgU R                   S   XE-  U-  U-  -  nU R                  X„U-  XQ-  XS5      n	U	R                  SSSSSS5      R                  5       n	U	R                  X„US5      n	U	SS2SU2SU2SS24   R                  5       n	U	$ )	a  
Window unpartition into original sequences and removing padding.

Args:
    windows (`torch.Tensor`):
        Input tokens with [batch_size * num_windows, window_size, window_size, num_channels].
    window_size (`int`):
        Window size.
    pad_height_width (`tuple[int]`):
        Padded height and width (padded_height, padded_width).
    height_width (`tuple[int]`):
        Original height and width before padding.

Returns:
    hidden_state: unpartitioned sequences with [batch_size, height, width, num_channels].
r   rq   r!   r   r   r_  r`  N)rw   rØ   rP  rÄ   )
rh  rc  Úpad_height_widthÚheight_widthrf  rg  r,  r-  rƒ   rb  s
             r:   Úwindow_unpartitionrm  ¾  s¹   € ð" #3Ñ€MØ �M€FØ—‘˜qÑ! mÑ&BÀkÑ&QÐU`Ñ&`Ña€JØ—<‘<Ø [Ñ0°,Ñ2MÈ{Ðikó€Lð  ×'Ñ'¨¨1¨a°°A°qÓ9×DÑDÓF€LØ×$Ñ$ ZÀÈbÓQ€Lð  ¢ 7 F 7¨F¨U¨F²AÐ 5Ñ6×AÑAÓC€LØÐr9   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	$ )ÚSam3ViTLayerScaleiÝ  rd   c                 ó®   >• [         TU ]  5         [        R                  " UR                  [
        R                  " UR                  5      -  5      U l        g rž   )	rŸ   r    r¤   rI  Úlayer_scale_init_valuer5   Úonesr…   Úlambda1r¬   s     €r:   r    ÚSam3ViTLayerScale.__init__Þ  s8   ø€ Ü‰ÑÔÜ—|’| F×$AÑ$AÄEÇJÂJÈv×OaÑOaÓDbÑ$bÓcˆ�r9   rb  c                 ó   • XR                   -  $ rž   ©rs  )r­   rb  s     r:   r±   ÚSam3ViTLayerScale.forwardâ  s   € ØŸl™lÑ*Ð*r9   rv  )rd   Nr³   rµ   s   @r:   ro  ro  Ý  s)   ø† ÷dð+ E§L¡Lð +°U·\±\÷ +ò +r9   ro  c                   ó    ^ • \ rS rSrSrSS\S\SS4U 4S jjjr\S\S\4S j5       r	S	\
R                  S
\\   S\
R                  4S jrSrU =r$ )ÚSam3ViTLayeriæ  zYVision Transformer layer with rotary position embeddings and optional windowed attention.r¡   rc  rd   Nc                 óÞ  >• [         TU ]  5         Xl        UR                  n[        R
                  " X1R                  S9U l        [        U5      U l	        [        U5      U l        [        R
                  " X1R                  S9U l        [        U5      U l        [        R                  " UR                   5      U l        X l        U R'                  X5      n[        R(                  " USS9U l        g )N©rc   Fré   )rŸ   r    r¡   r…   r¤   Ú	LayerNormÚlayer_norm_epsÚlayer_norm1rä   Ú
rotary_embr&  Ú	attentionÚlayer_norm2rœ   Úmlpr©   rª   r«   rc  Úprecompute_positionsrï   r  )r­   r¡   rc  r…   r  r®   s        €r:   r    ÚSam3ViTLayer.__init__é  s®   ø€ Ü‰ÑÔàŒØ×(Ñ(ˆÜŸ<š<¨×9NÑ9NÑOˆÔÜ0°Ó8ˆŒÜ-¨fÓ5ˆŒÜŸ<š<¨×9NÑ9NÑOˆÔÜ˜6“?ˆŒÜ—z’z &×"7Ñ"7Ó8ˆŒØ&Ôà×0Ñ0°ÓEˆÜŸIšI l¸uÑEˆÕr9   c                 ó  • US:”  a  X4nOnU R                   n[        U[        [        45      (       a  UOX34nU R                  n[        U[        [        45      (       a  UOXD4nUS   US   -  US   US   -  4n[
        R                  " [
        R                  " US   5      [
        R                  " US   5      SS9u  pV[
        R                  " UR                  5       UR                  5       /SS9nXpR                  US   -  -  nU$ )Nr   r!   Úij)Úindexingrq   rr   )r;  r  Úlistr4   r9  r5   Úmeshgridrz   r”   r  rc  )r¡   rc  Úhw_gridr;  r9  Úhpos_idsÚwpos_idsr  s           r:   rƒ  Ú!Sam3ViTLayer.precompute_positionsù  sý   € à˜‹?Ø"Ð0‰Gà×*Ñ*ˆJÜ'1°*¼tÄU¸m×'LÑ'L™ÐS]ÐRjˆJà×*Ñ*ˆJÜ'1°*¼tÄU¸m×'LÑ'L™ÐS]ÐRjˆJà! !‘}¨
°1©Ñ5°zÀ!±}È
ÐSTÉÑ7UÐVˆGä"Ÿ^š^Ü�LŠL˜ ™Ó$Ü�LŠL˜ ™Ó$Øñ
Ñˆô
 —{’{ H×$4Ñ$4Ó$6¸×8HÑ8HÓ8JÐ#KÐQSÑTˆØ#×'9Ñ'9¸GÀA¹JÑ'FÑGˆØÐr9   rG   r»   c                 óÜ  • UnU R                  U5      nU R                  S:”  a4  UR                  S   UR                  S   pT[        XR                  5      u  pU R	                  XR
                  5      nU R                  " X40 UD6u  pU R                  S:”  a  [        XR                  WWW45      nX1-   nUnU R                  U5      nU R                  U5      nX0R                  U5      -   nU$ )Nr   r!   r   )r~  rc  rw   ri  r  r  r€  rm  r�  r‚  r«   )	r­   rG   r»   Úresidualr,  r-  rk  r*  r.  s	            r:   r±   ÚSam3ViTLayer.forward  sï   € ð
 !ˆà×(Ñ(¨Ó7ˆà×Ñ˜aÓØ)×/Ñ/°Ñ2°M×4GÑ4GÈÑ4J�Eä.>¸}×N^ÑN^Ó._Ñ+ˆMà"Ÿo™o¨m×=NÑ=NÓOÐØŸ>š>¨-ÑWÐPVÑWÑˆà×Ñ˜aÓä.¨}×>NÑ>NÐP`ÐciÐkpÐbqÓrˆMà Ñ0ˆØ ˆØ×(Ñ(¨Ó7ˆØŸ™ Ó/ˆØ §<¡<°Ó#>Ñ>ˆàÐr9   )	r€  r¡   r«   r~  r�  r‚  r  r  rc  )r   )r/   r0   r1   r2   r3   r(   rM  r    r  rƒ  r5   r   r   r   r±   r8   r´   rµ   s   @r:   ry  ry  æ  s€   ø† ÙcñF˜}ð F¸3ð FÀt÷ Fð Fð  ð ]ð Àó ó ðð*à—|‘|ðð Ð+Ñ,ðð 
�‰÷	ò r9   ry  )r5   Útorchvision)Úbackendsc                   óL   ^ • \ rS rSr\rSrSrSS/rSr	Sr
SrSrU 4S jrSrU =r$ )	ÚSam3PreTrainedModeli-  Úsam3r@  ÚimageÚtextTc                 ór  >• [         TU ]  U5        [        U[        5      (       a5  [        R
                  " UR                  SU R                  R                  S9  g [        U[        5      (       aH  UR                  UR                  UR                  5      n[        R                  " UR                  U5        g g )NrÖ   )ÚmeanÚstd)rŸ   Ú_init_weightsr  rF  ÚinitÚnormal_r*  r¡   Úinitializer_rangery  rƒ  rc  Úcopy_r  )r­   r¶   r  r®   s      €r:   r›  Ú!Sam3PreTrainedModel._init_weights9  s€   ø€ Ü‰Ñ˜fÔ%Ü�fÔ/×0Ñ0Ü�LŠL˜×3Ñ3¸#À4Ç;Á;×C`ÑC`ÓaÜ˜¤×-Ñ-Ø!×6Ñ6°v·}±}Àf×FXÑFXÓYˆLÜ�JŠJ�v×*Ñ*¨LÕ9ð .r9   r.   )r/   r0   r1   r2   r"   Úconfig_classÚbase_model_prefixÚmain_input_nameÚinput_modalitiesÚ_supports_sdpaÚ_supports_flash_attnÚ_supports_flex_attnÚ_supports_attention_backendr›  r8   r´   rµ   s   @r:   r”  r”  -  sA   ø† ð €LØÐØ$€OØ Ð(ÐØ€NØÐØÐØ"&Ð÷:ó :r9   r”  c            	       óª   ^ • \ rS rSr% \\S'   \\S.rS\4U 4S jjr	S\
4S jr\\" SS9\S	\R                   S
\\   S\4S j5       5       5       rSrU =r$ )ÚSam3ViTModeliB  r¡   ©rG   rH   c           
      óš  >• [         TU ]  U5        Xl        [        U5      U l        [
        R                  " UR                  UR                  S9U l	        [
        R                  " [        UR                  5       Vs/ s H(  n[        XUR                  ;  a  UR                  OSS9PM*     sn5      U l        U R#                  5         g s  snf )Nr{  r   )rc  )rŸ   r    r¡   rF  rC  r¤   r|  r…   r}  Ú
layer_normÚ
ModuleListÚrangeÚnum_hidden_layersry  Úglobal_attn_indexesrc  ÚlayersÚ	post_init)r­   r¡   Úir®   s      €r:   r    ÚSam3ViTModel.__init__J  s¤   ø€ Ü‰Ñ˜Ô ØŒÜ+¨FÓ3ˆŒÜŸ,š, v×'9Ñ'9¸v×?TÑ?TÑUˆŒÜ—m’mô ˜v×7Ñ7Ô8óâ8�Aô ˜VÐPV×PjÑPjÓGj°×1CÒ1CÐpqÔrÙ8ñó
ˆŒð 	�‰Õùòs   Á</Crd   c                 ó.   • U R                   R                  $ rž   )rC  rH  ©r­   s    r:   Úget_input_embeddingsÚ!Sam3ViTModel.get_input_embeddingsW  s   € Ø�‰×/Ñ/Ð/r9   F)Útie_last_hidden_statesr@  r»   c                 ó²  • U R                  U5      nUR                  S   nUR                  S   U R                  R                  -  nUR                  S   U R                  R                  -  nUR                  S   nUR	                  XEXg5      nU R                  U5      nU R                   H  nU" U40 UD6nM     UR	                  XEU-  U5      n[        US9$ )Nr   r  rq   )r>   )rC  rw   r¡   r9  rØ   r­  r²  r   )	r­   r@  r»   rG   rƒ   r,  r-  r…   Úlayers	            r:   r±   ÚSam3ViTModel.forwardZ  sÒ   € ð Ÿ™¨Ó5ˆà"×(Ñ(¨Ñ+ˆ
Ø×#Ñ# BÑ'¨4¯;©;×+AÑ+AÑAˆØ×"Ñ" 2Ñ&¨$¯+©+×*@Ñ*@Ñ@ˆØ#×)Ñ)¨"Ñ-ˆð &×*Ñ*¨:¸uÓRˆàŸ™¨Ó6ˆØ—[”[ˆEÙ! -Ñ:°6Ñ:ŠMñ !ð &×*Ñ*¨:À±~À{ÓSˆä°Ñ?Ð?r9   )r¡   rC  r­  r²  )r/   r0   r1   r2   r(   r7   ry  r&  Ú_can_record_outputsr    r3  r¸  r   r   r   r5   r   r   r   r   r±   r8   r´   rµ   s   @r:   rª  rª  B  s„   ø‡ àÓà%Ø*ñÐð
˜}÷ ð0Ð&<ô 0ð  Ù¨EÑ2Øð@à—l‘lð@ð Ð+Ñ,ð@ð 
ó	@ó ó 3ó  ö@r9   rª  c                   ó\  ^ • \ rS rSrSr    SS\S\S\S\S-  4U 4S jjjrS	\	R                  S
\	R                  S\\	R                  \	R                  4   4S jrS\	R                  S\	R                  4S jr\\" SS9    SS\	R                   S\	R"                  \-  S\	R&                  S\S\S\S-  S\S\	R                  S-  S\	R                  4S jj5       5       r SS\	R                   S\	R"                  \-  S\	R&                  S\	R                  S-  S\	R                  4
S jjrSrU =r$ )ÚSam3SinePositionEmbeddingiv  z 
This is a more standard version of the position embedding, very similar to the one used by the Attention is all you
need paper, generalized to work on images.
NÚnum_position_featuresÚtemperatureÚ	normalizeÚscalec                 ó²   >• [         TU ]  5         Ub  USL a  [        S5      eXl        X l        X0l        Uc  S[        R                  -  U l        g UU l        g )NFz+normalize should be True if scale is passedr   )	rŸ   r    rí   rÁ  rÂ  rÃ  ÚmathÚpirÄ  )r­   rÁ  rÂ  rÃ  rÄ  r®   s        €r:   r    Ú"Sam3SinePositionEmbedding.__init__|  sS   ø€ ô 	‰ÑÔØÑ ¨eÒ!3ÜÐJÓKÐKØ%:Ô"Ø&ÔØ"ŒØ$)¡M�QœŸ™‘[ˆ�
°uˆ�
r9   rb   Úyrd   c                 ó®  • XR                   -  nX R                   -  n[        R                  " U R                  [        R                  UR
                  S9R                  UR                  5      nU R                  SUS-  -  U R                  -  -  nUSS2S4   U-  nUSS2S4   U-  n[        R                  " USS2SSS24   R                  5       USS2SSS24   R                  5       4SS9R                  S5      n[        R                  " USS2SSS24   R                  5       USS2SSS24   R                  5       4SS9R                  S5      nXg4$ )zä
Encode 1D coordinate pairs using sine/cosine positional embeddings.

Args:
    x: 1D tensor of x coordinates (flattened)
    y: 1D tensor of y coordinates (flattened)

Returns:
    Tuple of (pos_x, pos_y) positional embeddings
©rv   rt   r   Nr   r!   rr   )rÄ  r5   rz   rÁ  Úint64rt   rû   rv   rÂ  r”   r	  r  r  )r­   rb   rÉ  Úx_embedÚy_embedÚdim_tÚpos_xÚpos_ys           r:   Úencode_1d_positionsÚ-Sam3SinePositionEmbedding.encode_1d_positions‹  s?  € ð —j‘j‘.ˆØ—j‘j‘.ˆä—’˜T×7Ñ7¼u¿{¹{ÐST×S[ÑS[Ñ\×_Ñ_Ð`a×`gÑ`gÓhˆØ× Ñ  Q¨%°1©*Ñ%5¸×8RÑ8RÑ%RÑSˆàš˜4˜Ñ  5Ñ(ˆØš˜4˜Ñ  5Ñ(ˆÜ—’˜U¢1 a d¨ d 7™^×/Ñ/Ó1°5º¸A¸D¸q¸D¸±>×3EÑ3EÓ3GÐHÈaÑP×XÑXÐYZÓ[ˆÜ—’˜U¢1 a d¨ d 7™^×/Ñ/Ó1°5º¸A¸D¸q¸D¸±>×3EÑ3EÓ3GÐHÈaÑP×XÑXÐYZÓ[ˆØˆ|Ðr9   Úboxesc           	      ó®  • UR                  S5      S:X  d   SUR                   35       e[        R                  " U R                  [        R
                  UR                  S9R                  UR                  5      nU R                  S[        R                  " USSS9-  U R                  -  -  nUSS2SS2S	4   U R                  -  nUSS2SS2S
4   U R                  -  nUSS2SS2S4   U R                  -  nUSS2SS2S4   U R                  -  nUSS2SS2S4   U-  nUSS2SS2S4   U-  nUSS2SS2S4   U-  n	USS2SS2S4   U-  n
[        R                  " USS2SS2S	SS24   R                  5       USS2SS2S
SS24   R                  5       4SS9R                  S5      n[        R                  " USS2SS2S	SS24   R                  5       USS2SS2S
SS24   R                  5       4SS9R                  S5      n[        R                  " U	SS2SS2S	SS24   R                  5       U	SS2SS2S
SS24   R                  5       4SS9R                  S5      n	[        R                  " U
SS2SS2S	SS24   R                  5       U
SS2SS2S
SS24   R                  5       4SS9R                  S5      n
[        R                   " X‡Xš4SS9nU$ )a
  
Encode 4D box coordinates (x, y, w, h) for decoder conditioning using sine/cosine embeddings.

Args:
    boxes: Box coordinates [batch_size, num_queries, 4] in (x, y, w, h) format

Returns:
    Position embeddings [batch_size, num_queries, num_position_features*4]
rq   r_  z4Expected 4D box coordinates (x, y, w, h), got shape rË  r   Úfloor©Úrounding_modeNr   r!   r   rr   )rx   rw   r5   rz   rÁ  rÌ  rt   rû   rv   rÂ  ÚdivrÄ  r”   r	  r  r  r  )r­   rÔ  rÏ  rÍ  rÎ  Úw_embedÚh_embedrÐ  rÑ  Úpos_wÚpos_hÚposs               r:   Úencode_boxesÚ&Sam3SinePositionEmbedding.encode_boxes¢  s¸  € ð �z‰z˜"‹~ Ó"ÐhÐ&ZÐ[`×[fÑ[fÐZgÐ$hÓhÐ"Ü—’˜T×7Ñ7¼u¿{¹{ÐSX×S_ÑS_Ñ`×cÑcÐdi×doÑdoÓpˆØ× Ñ  Q¬¯ª°5¸!È7Ñ)SÑ%SÐVZ×VpÑVpÑ%pÑqˆàšš1˜a˜‘. 4§:¡:Ñ-ˆØšš1˜a˜‘. 4§:¡:Ñ-ˆØšš1˜a˜‘. 4§:¡:Ñ-ˆØšš1˜a˜‘. 4§:¡:Ñ-ˆàšš1˜d˜
Ñ# eÑ+ˆØšš1˜d˜
Ñ# eÑ+ˆØšš1˜d˜
Ñ# eÑ+ˆØšš1˜d˜
Ñ# eÑ+ˆä—’˜U¢1¢a¨¨¨A¨ :Ñ.×2Ñ2Ó4°eºAºqÀ!À$ÀQÀ$¸JÑ6G×6KÑ6KÓ6MÐNÐTUÑV×^Ñ^Ð_`ÓaˆÜ—’˜U¢1¢a¨¨¨A¨ :Ñ.×2Ñ2Ó4°eºAºqÀ!À$ÀQÀ$¸JÑ6G×6KÑ6KÓ6MÐNÐTUÑV×^Ñ^Ð_`ÓaˆÜ—’˜U¢1¢a¨¨¨A¨ :Ñ.×2Ñ2Ó4°eºAºqÀ!À$ÀQÀ$¸JÑ6G×6KÑ6KÓ6MÐNÐTUÑV×^Ñ^Ð_`ÓaˆÜ—’˜U¢1¢a¨¨¨A¨ :Ñ.×2Ñ2Ó4°eºAºqÀ!À$ÀQÀ$¸JÑ6G×6KÑ6KÓ6MÐNÐTUÑV×^Ñ^Ð_`Óaˆä�iŠi˜ uÐ4¸!Ñ<ˆàˆ
r9   r_  ©Úmaxsizerw   rt   rv   Úmaskc           
      ór  • U u  p‰p«Ucc  [         R                  " SU
S-   X!S9S S S 2S 4   R                  XŠU5      n[         R                  " SUS-   X!S9S S S S 24   R                  XŠU5      nO3UR                  U5      nUR	                  S5      nUR	                  S5      nU(       a.  SnXÌS S 2SS 2S S 24   U-   -  U-  nXÝS S 2S S 2SS 24   U-   -  U-  n[         R                  " U[         R
                  US9R                  U5      nUS[         R                  " USSS9-  U-  -  nUS S 2S S 2S S 2S 4   U-  nUS S 2S S 2S S 2S 4   U-  n[         R                  " US S 2S S 2S S 2SS S24   R                  5       US S 2S S 2S S 2SS S24   R                  5       4S	S
9R                  S5      n[         R                  " US S 2S S 2S S 2SS S24   R                  5       US S 2S S 2S S 2SS S24   R                  5       4S	S
9R                  S5      n[         R                  " UU4SS
9R                  SSSS5      nU$ )Nr!   rË  r   g�íµ ÷Æ°>rq   rÖ  r×  r   r_  rr   r   )r5   rz   r~   rû   ÚcumsumrÌ  rÙ  r”   r	  r  r  r  rP  )rw   rt   rv   rÁ  rÃ  rÄ  rÂ  rã  rƒ   r.  r,  r-  rÎ  rÍ  Ú
embed_maskrc   rÏ  rÐ  rÑ  rÞ  s                       r:   Úbuild_sine_position_embeddingÚ7Sam3SinePositionEmbedding.build_sine_position_embeddingÃ  sC  € ð (-Ñ$ˆ
�vØ‰<ô —l’l 1 f¨q¡j¸ÑMÈdÒTUÐW[ÈmÑ\×cÑcØ EóˆGô —l’l 1 e¨a¡i°uÑLÈTÐSWÒYZÈ]Ñ[×bÑbØ Eó‰Gð Ÿ™ ›ˆJØ ×'Ñ'¨Ó*ˆGØ ×'Ñ'¨Ó*ˆGÞØˆCØª¨B©C²¨Ñ!3°cÑ!9Ñ:¸UÑBˆGØªªA¨r©s¨Ñ!3°cÑ!9Ñ:¸UÑBˆGä—’Ð2¼%¿+¹+ÈfÑU×XÑXÐY^Ó_ˆØ ¤E§I¢I¨e°QÀgÑ$NÑ NÐQfÑ fÑgˆàšš1ša ˜Ñ&¨Ñ.ˆØšš1ša ˜Ñ&¨Ñ.ˆÜ—’˜U¢1¢aª¨A¨D¨q¨D =Ñ1×5Ñ5Ó7¸ºqÂ!ÂQÈÈÈ1È¸}Ñ9M×9QÑ9QÓ9SÐTÐZ[Ñ\×dÑdÐefÓgˆÜ—’˜U¢1¢aª¨A¨D¨q¨D =Ñ1×5Ñ5Ó7¸ºqÂ!ÂQÈÈÈ1È¸}Ñ9M×9QÑ9QÓ9SÐTÐZ[Ñ\×dÑdÐefÓgˆÜ�iŠi˜ ˜¨AÑ.×6Ñ6°q¸!¸QÀÓBˆØˆ
r9   c           
      ó~   • U R                  XX0R                  U R                  U R                  U R                  U5      $ rž   )rç  rÁ  rÃ  rÄ  rÂ  )r­   rw   rt   rv   rã  s        r:   r±   Ú!Sam3SinePositionEmbedding.forwardï  s:   € ð ×1Ñ1Ø˜5×"<Ñ"<¸d¿n¹nÈdÏjÉjÐZ^×ZjÑZjÐlpó
ð 	
r9   )rÃ  rÁ  rÄ  rÂ  )é@   é'  FN)FNrì  Nrž   )r/   r0   r1   r2   r3   rM  rÛ   rú   r    r5   r   r4   rÒ  rß  r  r   ÚSizert   r  rv   rç  r±   r8   r´   rµ   s   @r:   rÀ  rÀ  v  s¢  ø† ñð &(Ø ØØ"ñ=à"ð=ð ð=ð ð	=ð
 �t‰|÷=ð =ð U§\¡\ð °e·l±lð ÀuÈUÏ\É\Ð[`×[gÑ[gÐMgÑGhô ð. %§,¡,ð °5·<±<ô ðB Ù(°Ñ3ð  Ø"Ø Ø$(ñ(Ø�z‰zð(à—‘˜sÑ"ð(ð �{‰{ð(ð  #ð	(ð
 ð(ð �t‰|ð(ð ð(ð �l‰l˜TÑ!ð(ð 
�‰ô(ó 4ó ð(ð^ %)ñ	
à�z‰zð	
ð —‘˜sÑ"ð	
ð �{‰{ð		
ð
 �l‰l˜TÑ!ð	
ð 
�‰÷	
ó 	
r9   rÀ  c                   ór   ^ • \ rS rSrS\S\S\4U 4S jjrS\R                  S\R                  4S jr	S	r
U =r$ )
ÚSam3FPNLayeriû  Úin_channelsÚfpn_dimÚscale_factorc           	      ó*  >• [         TU ]  5         X0l        [        R                  " 5       U l        US:X  aœ  U R
                  R                  [        R                  " XS-  SSS95        U R
                  R                  [        R                  " 5       5        U R
                  R                  [        R                  " US-  US-  SSS95        US-  nO�US:X  a8  U R
                  R                  [        R                  " XS-  SSS95        US-  nOOUS:X  a  UnOFUS:X  a1  U R
                  R                  [        R                  " SSS95        UnO[        SU S	35      e[        R                  " XBS
S9U l        [        R                  " X"SS
S9U l        g )Ng      @r   )r5  r6  r_  g       @r÷   r’   zscale_factor=z is not supported yet.r!   )rð  Úout_channelsr5  r   )rð  rô  r5  Úpadding)rŸ   r    rò  r¤   r®  Úscale_layersÚappendÚConvTranspose2dÚGELUÚ	MaxPool2dÚNotImplementedErrorr=  Úproj1Úproj2)r­   rð  rñ  rò  Úintermediate_channelsr®   s        €r:   r    ÚSam3FPNLayer.__init__ü  sf  ø€ Ü‰ÑÔØ(Ôô ŸMšM›OˆÔà˜3ÓØ×Ñ×$Ñ$¤R×%7Ò%7¸ÐTUÑEUÐcdÐmnÑ%oÔpØ×Ñ×$Ñ$¤R§W¢W£YÔ/Ø×Ñ×$Ñ$¤R×%7Ò%7¸ÀqÑ8HÈ+ÐYZÑJZÐhiÐrsÑ%tÔuØ$/°1Ñ$4Ñ!Ø˜SÓ Ø×Ñ×$Ñ$¤R×%7Ò%7¸ÐTUÑEUÐcdÐmnÑ%oÔpØ$/°1Ñ$4Ñ!Ø˜SÓ Ø$/Ñ!Ø˜SÓ Ø×Ñ×$Ñ$¤R§\¢\¸aÈÑ%JÔKØ$/Ñ!ä%¨°l°^ÐCYÐ&ZÓ[Ð[ä—Y’YÐ+@ÐdeÑfˆŒ
Ü—Y’Y¨7ÐVWÐabÑcˆ�
r9   rG   rd   c                 óÞ   • UR                  U R                  R                  R                  5      nU R                   H  nU" U5      nM     U R                  U5      nU R                  U5      nU$ rž   )rû   rü  rB  rv   rö  rý  )r­   rG   r¼  s      r:   r±   ÚSam3FPNLayer.forward  s`   € Ø%×(Ñ(¨¯©×):Ñ):×)@Ñ)@ÓAˆØ×&Ô&ˆEÙ! -Ó0ŠMñ 'ð Ÿ
™
 =Ó1ˆØŸ
™
 =Ó1ˆàÐr9   )rü  rý  rò  rö  )r/   r0   r1   r2   rM  rú   r    r5   r   r±   r8   r´   rµ   s   @r:   rï  rï  û  sA   ø† ðd Cð d°#ð dÀU÷ dð4 U§\¡\ð °e·l±l÷ ò r9   rï  c                   óœ   ^ • \ rS rSrS\4U 4S jjrS\R                  S\\\R                  S4   \\R                  S4   4   4S jr	Sr
U =r$ )	ÚSam3VisionNecki!  r¡   c                 ó*  >• [         TU ]  5         Xl        [        UR                  S-  SS9U l        [        R                  " UR                   Vs/ s H,  n[        UR                  R                  UR                  US9PM.     sn5      U l        g s  snf )Nr   T©rÁ  rÃ  )rð  rñ  rò  )rŸ   r    r¡   rÀ  Úfpn_hidden_sizeÚposition_encodingr¤   r®  Úscale_factorsrï  Úbackbone_configr…   Ú
fpn_layers)r­   r¡   rÄ  r®   s      €r:   r    ÚSam3VisionNeck.__init__"  s�   ø€ Ü‰ÑÔØŒä!:Ø"(×"8Ñ"8¸AÑ"=Èñ"
ˆÔô
 Ÿ-š-ð
 $×1Ò1ó	ò 2�Eô Ø &× 6Ñ 6× BÑ BÈF×LbÑLbÐqvôñ 2ñ	ó
ˆ�ùòs   Á3BrG   rd   .c                 ó¼   • SnSnU R                    HF  nU" U5      nX%4-  nU R                  UR                  UR                  UR                  5      nX64-  nMH     X#4$ )Nr.   )r
  r  rw   rt   rv   )r­   rG   r,   r-   Ú	fpn_layerÚ
fpn_outputÚpos_encs          r:   r±   ÚSam3VisionNeck.forward4  sn   € ØÐØ "ÐàŸœˆIÙ" =Ó1ˆJØ Ñ.Ðà×,Ñ,¨Z×-=Ñ-=¸z×?PÑ?PÐR\×RbÑRbÓcˆGØ! ZÑ/Ò!ñ )ð !Ð7Ð7r9   )r¡   r
  r  )r/   r0   r1   r2   r'   r    r5   r   r4   r±   r8   r´   rµ   s   @r:   r  r  !  sX   ø† ð
Ð/÷ 
ð$8 U§\¡\ð 8°e¸EÀ%Ç,Á,ÐPSÐBSÑ<TÐV[Ð\a×\hÑ\hÐjmÐ\mÑVnÐ<nÑ6o÷ 8ò 8r9   r  zJ
    The vision model from Sam without any head or projection on top.
    )Úcustom_introc            	       óŠ   ^ • \ rS rSr\rSrS\4U 4S jjrS r\	 SS\
R                  S-  S\\   S\\-  4S	 jj5       rS
rU =r$ )ÚSam3VisionModeliB  r@  r¡   c                 óº   >• [         TU ]  U5        Xl        [        R                  " UR
                  5      U l        [        U5      U l        U R                  5         g rž   )
rŸ   r    r¡   r   Úfrom_configr	  Úbackboner  Úneckr³  r¬   s     €r:   r    ÚSam3VisionModel.__init__K  sC   ø€ Ü‰Ñ˜Ô ØŒÜ!×-Ò-¨f×.DÑ.DÓEˆŒÜ" 6Ó*ˆŒ	à�‰Õr9   c                 ó6   • U R                   R                  5       $ rž   )r  r¸  r·  s    r:   r¸  Ú$Sam3VisionModel.get_input_embeddingsS  s   € Ø�}‰}×1Ñ1Ó3Ð3r9   Nr»   rd   c                 óì  • Uc  [        S5      eU R                  " U40 UD6nUR                  nUR                  S   nUR                  S   U R                  R
                  R                  -  nUR                  S   U R                  R
                  R                  -  nUR                  XVUS5      R                  SSSS5      nU R                  U5      u  pš[        UU	U
UR                  UR                  S9$ )	Nz You have to specify pixel_valuesr   r  rq   r   r!   r   )r>   r,   r-   rG   rH   )rí   r  r>   rw   r¡   r	  r9  rØ   rP  r  r*   rG   rH   )r­   r@  r»   Úbackbone_outputrG   rƒ   r,  r-  Úhidden_states_spatialr,   r-   s              r:   r±   ÚSam3VisionModel.forwardV  sõ   € ð ÑÜÐ?Ó@Ð@àŸ-š-¨Ñ?¸Ñ?ˆØ'×9Ñ9ˆð #×(Ñ(¨Ñ+ˆ
Ø×#Ñ# BÑ'¨4¯;©;×+FÑ+F×+QÑ+QÑQˆØ×"Ñ" 2Ñ&¨$¯+©+×*EÑ*E×*PÑ*PÑPˆØ -× 2Ñ 2°:ÀuÈbÓ Q× YÑ YÐZ[Ð]^Ð`aÐcdÓ eÐØ37·9±9Ð=RÓ3SÑ0Ðä&Ø+Ø/Ø"7Ø)×7Ñ7Ø&×1Ñ1ñ
ð 	
r9   )r  r¡   r  rž   )r/   r0   r1   r2   r'   r¡  r£  r    r¸  r   r5   r6   r   r   r4   r*   r±   r8   r´   rµ   s   @r:   r  r  B  sm   ø† ð $€LØ$€OðÐ/÷ ò4ð ð 26ñ
à×'Ñ'¨$Ñ.ð
ð Ð+Ñ,ð
ð 
Ð(Ñ	(ô	
ó ö
r9   r  c                   óT   ^ • \ rS rSrS\4U 4S jjrS\S\S\S\S\\   4
S	 jr	S
r
U =r$ )ÚSam3GeometryEncoderLayerir  r¡   c                 óª  >• [         TU ]  5         [        R                  " UR                  5      U l        [        U5      U l        [        R                  " UR                  5      U l	        [        U5      U l
        [        R                  " UR                  5      U l        [        U5      U l        [        R                  " UR                  5      U l        g rž   )rŸ   r    r¤   r|  r…   r~  rÉ   Ú	self_attnr©   r«   Ú
cross_attnr�  rœ   r‚  Úlayer_norm3r¬   s     €r:   r    Ú!Sam3GeometryEncoderLayer.__init__s  sŠ   ø€ Ü‰ÑÔÜŸ<š<¨×(:Ñ(:Ó;ˆÔÜ& vÓ.ˆŒÜ—z’z &§.¡.Ó1ˆŒä'¨Ó/ˆŒÜŸ<š<¨×(:Ñ(:Ó;ˆÔä˜6“?ˆŒÜŸ<š<¨×(:Ñ(:Ó;ˆÕr9   Úprompt_featsÚvision_featsÚvision_pos_encodingÚprompt_maskr»   c                 óv  • UnU R                  U5      nU R                  " SXwXtS.UD6u  pxU R                  U5      U-   nUnU R                  U5      nX#-   n	U R                  " SXyUS.UD6u  pxU R                  U5      U-   nUnU R                  U5      nU R                  U5      nU R                  U5      U-   nU$ )N©r·   r¸   r¹   r?   ©r·   r¸   r¹   r.   ©r~  r"  r«   r�  r#  r$  r‚  )
r­   r&  r'  r(  r)  r»   r�  rG   r.  r¸   s
             r:   r±   Ú Sam3GeometryEncoderLayer.forward  sÙ   € ð  ˆØ×(Ñ(¨Ó6ˆØŸ>š>ð 
Ø¸-ñ
Øgmñ
Ñˆð Ÿ™ ]Ó3°hÑ>ˆØ ˆØ×(Ñ(¨Ó7ˆØÑ0ˆØŸ?š?Ðf°È|ÑfÐ_eÑfÑˆØŸ™ ]Ó3°hÑ>ˆØ ˆØ×(Ñ(¨Ó7ˆØŸ™ Ó/ˆØŸ™ ]Ó3°hÑ>ˆàÐr9   )r#  r«   r~  r�  r$  r‚  r"  )r/   r0   r1   r2   r%   r    r   r   r   r±   r8   r´   rµ   s   @r:   r   r   r  sP   ø† ð
<Ð8÷ 
<ðàðð ðð $ð	ð
 ðð Ð+Ñ,÷ò r9   r   c                   ó^  ^ • \ rS rSrSrS\4U 4S jjrS\R                  S\R                  S\R                  S\R                  S	\R                  4
S
 jr	S r
 SS\R                  S\R                  S\R                  S\\R                  S4   S\\R                  S4   S-  4
S jjrSrU =r$ )ÚSam3GeometryEncoderiš  a’  
Encoder for geometric prompts (boxes).

Boxes are encoded using three approaches:
 - Direct projection: linear projection from coordinate space to hidden_size
 - Pooling: pool features from the backbone at the specified location (ROI align for boxes)
 - Position encoding: use position encoding of the box center

These encodings are combined additively and further processed with transformer layers.
r¡   c                 óB  >• [         TU ]  5         Xl        UR                  U l        UR                  U l        [        UR                  S-  SS9U l        [        R                  " SU R                  5      U l	        [        R                  " SU R                  5      U l
        [        R                  " SU R                  5      U l        [        R                  " U R                  U R                  U R                  5      U l        [        R                  " U R                  S-   U R                  5      U l        [        R                   " U R                  5      U l        [        R                  " U R                  U R                  5      U l        [        R                   " U R                  5      U l        [        R(                  " [+        UR,                  5       Vs/ s H  n[/        U5      PM     sn5      U l        [        R                   " U R                  5      U l        g s  snf )Nr   Tr  r!   r_  )rŸ   r    r¡   r…   Úroi_sizerÀ  r  r¤   Ú	EmbeddingÚlabel_embedÚ	cls_embedr¥   Úboxes_direct_projectr=  Úboxes_pool_projectÚboxes_pos_enc_projectr|  Úvision_layer_normÚ
final_projÚprompt_layer_normr®  r¯  Ú
num_layersr   r²  Úoutput_layer_norm©r­   r¡   r.  r®   s      €r:   r    ÚSam3GeometryEncoder.__init__¦  s…  ø€ Ü‰ÑÔØŒØ!×-Ñ-ˆÔØŸ™ˆŒä!:Ø"(×"4Ñ"4¸Ñ"9ÀTñ"
ˆÔô Ÿ<š<¨¨4×+;Ñ+;Ó<ˆÔÜŸš a¨×)9Ñ)9Ó:ˆŒô %'§I¢I¨a°×1AÑ1AÓ$BˆÔ!Ü"$§)¢)¨D×,<Ñ,<¸d×>NÑ>NÐPT×P]ÑP]Ó"^ˆÔÜ%'§Y¢Y¨t×/?Ñ/?À!Ñ/CÀT×EUÑEUÓ%VˆÔ"ô "$§¢¨d×.>Ñ.>Ó!?ˆÔô Ÿ)š) D×$4Ñ$4°d×6FÑ6FÓGˆŒÜ!#§¢¨d×.>Ñ.>Ó!?ˆÔô —m’mÌuÐU[×UfÑUfÔOgÓ$hÒOgÈ!Ô%=¸fÖ%EÑOgÑ$hÓiˆŒÜ!#§¢¨d×.>Ñ.>Ó!?ˆÕùò %is   ÇHÚcenter_xÚcenter_yr-  r,  rd   c                 óŒ   • U R                   R                  X5      u  pV[        R                  " XeUSS2S4   USS2S4   4SS9nU$ )aE  
Encode box coordinates by combining position-encoded centers with raw width/height.

Args:
    center_x: 1D tensor of box center x coordinates
    center_y: 1D tensor of box center y coordinates
    width: 1D tensor of box widths
    height: 1D tensor of box heights

Returns:
    Encoded box coordinates [N, embedding_dim]
Nr!   rr   )r  rÒ  r5   r  )r­   r@  rA  r-  r,  rÐ  rÑ  rÞ  s           r:   Ú_encode_box_coordinatesÚ+Sam3GeometryEncoder._encode_box_coordinatesÂ  sH   € ð ×-Ñ-×AÑAÀ(ÓU‰ˆÜ�iŠi˜ vªa°¨g¡¸ºaÀ¸g¹ÐGÈQÑOˆØˆ
r9   c                 ó6  • UR                   SS u  pVUR                   SS u  pxU R                  U5      n	[        U5      n
[        R                  " X‡X‡/U
R
                  U
R                  S9nUR                  SSS5      nX«-  n
UR
                  [        R                  :X  a  [        R                  OUR
                  n[        R                  R                  UR                  U5      U
R                  U5      R                  S5      U R                  5      R                  UR
                  5      nU R!                  U5      nUR                  XVU R"                  5      nXž-   n	UR                  S5      u  nnnnU R%                  UR'                  5       UR'                  5       UR'                  5       UR'                  5       5      nUR                  XVUR                   S   5      nU R)                  U5      nU	U-   n	U R+                  UR-                  5       5      nUU	-   U4$ )	z?Encode box prompts. Mask convention: True=valid, False=padding.Nr   r  rË  r!   r_  r   rq   )rw   r6  rš   r5   Útensorrv   rt   rØ   Úbfloat16Úfloat16r‘  ÚopsÚ	roi_alignrû   r“   r2  r7  r…   rC  r  r8  r4  Úlong)r­   rÔ  Ú
boxes_maskÚboxes_labelsÚvision_featuresrƒ   Ú	num_boxesr,  r-  Úboxes_embedÚ
boxes_xyxyrÄ  rv   Úsampled_featuresÚpooled_projectionr@  rA  Ú	box_widthÚ
box_heightr  Úpos_projectionr4  s                         r:   Ú_encode_boxesÚ!Sam3GeometryEncoder._encode_boxesÕ  sâ  € à %§¡¨B¨Q Ñˆ
Ø'×-Ñ-¨b¨cÐ2‰ˆØ×/Ñ/°Ó6ˆô (¨Ó.ˆ
Ü—’˜e¨UÐ;À:×CSÑCSÐ\f×\mÑ\mÑnˆØ—
‘
˜1˜a Ó#ˆØÑ'ˆ
ð "1×!6Ñ!6¼%¿.¹.Ó!H”—’Èo×NcÑNcˆÜ&Ÿ?™?×4Ñ4Ø×Ñ˜uÓ% z§}¡}°UÓ';×'BÑ'BÀ1Ó'EÀtÇ}Á}ó
ç
‰"ˆ_×"Ñ"Ó
#ð 	ð !×3Ñ3Ð4DÓEÐØ-×2Ñ2°:È$×JZÑJZÓ[ÐØ!Ñ5ˆð 5:·L±LÀÓ4DÑ1ˆ�(˜I zØ×.Ñ.Ø×ÑÓ × 0Ñ 0Ó 2°I×4EÑ4EÓ4GÈ×I[ÑI[ÓI]ó
ˆð —,‘,˜z°g·m±mÀBÑ6GÓHˆØ×3Ñ3°GÓ<ˆØ! NÑ2ˆð ×&Ñ& |×'8Ñ'8Ó':Ó;ˆØ˜[Ñ(¨*Ð4Ð4r9   NÚbox_embeddingsÚbox_maskÚ
box_labelsÚ	img_feats.Úimg_pos_embedsc                 ó„  • UR                   S   nUS   nUb  US   O[        R                  " U5      nUR                  S5      R	                  SS5      n	UR                  S5      R	                  SS5      n
US   nUR                  SSSS5      nU R                  U5      nUR                  SSSS5      nU R                  XX<5      u  pÞU R                  R                  R                  SU R                  5      R                  S5      R                  USS5      n[        R                  " USUR                  UR                   S9n[#        XÞUU5      u  pÞU R%                  U R'                  U5      5      nSnUb  [)        U R*                  UUS9nU R,                   H  nU" UU	U
US	9nM     U R/                  U5      n[1        UUS
9$ )aè  
Forward pass for encoding geometric prompts.

Args:
    box_embeddings: Box coordinates in CxCyWH format [batch_size, num_boxes, 4]
    box_mask: Attention mask for boxes [batch_size, num_boxes]
    box_labels: Labels for boxes (positive/negative) [batch_size, num_boxes]
    img_feats: Image features from vision encoder
    img_pos_embeds: Optional position embeddings for image features

Returns:
    Sam3GeometryEncoderOutput containing encoded geometry features and attention mask.
r   rq   Nr   r!   r   rË  )r¡   Úinputs_embedsr?   )r&  r'  r(  r)  )r>   r?   )rw   r5   Ú
zeros_liker  rÁ   rP  r9  rW  r5  rB  rØ   r…   Ú	unsqueezer~   rr  rv   rt   r�   r;  r:  r
   r¡   r²  r=  r<   )r­   rY  rZ  r[  r\  r]  rƒ   r'  Úvision_pos_embedsÚvision_feats_flatÚvision_pos_embeds_flatÚimg_feats_lastÚnormalized_img_featsÚprompt_embedsr)  r5  Úcls_maskÚprompt_attention_maskr¼  s                      r:   r±   ÚSam3GeometryEncoder.forwardù  s×  € ð* $×)Ñ)¨!Ñ,ˆ
ð ! ‘}ˆØ2@Ñ2L˜N¨2Ò.ÔRW×RbÒRbÐcoÓRpÐØ(×0Ñ0°Ó3×=Ñ=¸aÀÓCÐØ!2×!:Ñ!:¸1Ó!=×!GÑ!GÈÈ1Ó!MÐð # 2™ˆØ'×/Ñ/°°1°a¸Ó;ˆØ#×5Ñ5°nÓEÐØ3×;Ñ;¸A¸qÀ!ÀQÓGÐà%)×%7Ñ%7¸ÐR\Ó%sÑ"ˆð —N‘N×)Ñ)×.Ñ.¨q°$×2BÑ2BÓC×MÑMÈaÓP×WÑWÐXbÐdfÐhjÓkˆ	Ü—:’:˜j¨!°;×3DÑ3DÈ[×M_ÑM_Ñ`ˆÜ%<¸]ÐYbÐdlÓ%mÑ"ˆà×.Ñ.¨t¯©¸}Ó/MÓNˆð !%ÐØÑ"Ü$=Ø—{‘{Ø+Ø*ñ%Ð!ð —[”[ˆEÙ!Ø*Ø.Ø$:Ø1ñ	ŠMñ !ð ×.Ñ.¨}Ó=ˆä(Ø+Ø&ñ
ð 	
r9   )r6  r7  r8  r5  r¡   r:  r…   r4  r²  r=  r  r;  r2  r9  rž   )r/   r0   r1   r2   r3   r%   r    r5   r   rC  rW  r4   r±   r8   r´   rµ   s   @r:   r0  r0  š  sÓ   ø† ñ	ð@Ð8÷ @ð8ØŸ™ðØ05·±ðØEJÇ\Á\ðØ[`×[gÑ[gðà	�‰ôò&"5ðT ;?ñD
àŸ™ðD
ð —,‘,ðD
ð —L‘Lð	D
ð
 ˜Ÿ™ sÐ*Ñ+ðD
ð ˜eŸl™l¨CÐ/Ñ0°4Ñ7÷D
ó D
r9   r0  c                   ód   ^ • \ rS rSrSrS\4U 4S jjr SS\S\S\S	\S-  S
\\	   4
S jjr
SrU =r$ )ÚSam3DetrEncoderLayeri@  z;DETR encoder layer with self-attention and cross-attention.r¡   c                 ó¶  >• [         TU ]  5         Xl        [        R                  " UR
                  5      U l        [        U5      U l        [        R                  " UR                  5      U l
        [        U5      U l        [        R                  " UR
                  5      U l        [        U5      U l        [        R                  " UR
                  5      U l        g rž   )rŸ   r    r¡   r¤   r|  r…   r~  rÉ   r"  r©   r«   r#  r�  rœ   r‚  r$  r¬   s     €r:   r    ÚSam3DetrEncoderLayer.__init__C  s�   ø€ Ü‰ÑÔØŒÜŸ<š<¨×(:Ñ(:Ó;ˆÔÜ& vÓ.ˆŒÜ—z’z &§.¡.Ó1ˆŒä'¨Ó/ˆŒÜŸ<š<¨×(:Ñ(:Ó;ˆÔä˜6“?ˆŒÜŸ<š<¨×(:Ñ(:Ó;ˆÕr9   Nr'  r&  r(  Úprompt_cross_attn_maskr»   c                 ó|  • UnU R                  U5      nXs-   nU R                  " SUUUS.UD6u  pyU R                  U5      U-   nUnU R                  U5      nU R                  " SUUUUS.UD6u  pyU R                  U5      U-   nUnU R                  U5      nU R                  U5      nU R                  U5      U-   nU$ )aÂ  
Forward pass for DETR encoder layer.

Args:
    vision_feats: Vision features [batch_size, vision_len, hidden_size] (main hidden states)
    prompt_feats: Text prompt features [batch_size, text_len, hidden_size]
    vision_pos_encoding: Position encoding for vision [batch_size, vision_len, hidden_size]
    prompt_cross_attn_mask: Cross-attention mask for prompt features

Returns:
    Updated vision features [batch_size, vision_len, hidden_size]
r,  r+  r.   r-  )
r­   r'  r&  r(  ro  r»   r�  rG   Úhidden_states_with_posr.  s
             r:   r±   ÚSam3DetrEncoderLayer.forwardP  sö   € ð*  ˆØ×(Ñ(¨Ó6ˆØ!.Ñ!DÐØŸ>š>ð 
Ø(Ø&Øñ
ð ñ	
Ñˆð Ÿ™ ]Ó3°hÑ>ˆð !ˆØ×(Ñ(¨Ó7ˆàŸ?š?ð 
ØØØØ1ñ	
ð
 ñ
Ñˆð Ÿ™ ]Ó3°hÑ>ˆð !ˆØ×(Ñ(¨Ó7ˆØŸ™ Ó/ˆØŸ™ ]Ó3°hÑ>ˆàÐr9   )r¡   r#  r«   r~  r�  r$  r‚  r"  rž   )r/   r0   r1   r2   r3   r$   r    r   r   r   r±   r8   r´   rµ   s   @r:   rl  rl  @  s\   ø† ÙEð<Ð4÷ <ð$ 15ñ3àð3ð ð3ð $ð	3ð
 !'¨¡ð3ð Ð+Ñ,÷3ó 3r9   rl  c                   óR  ^ • \ rS rSrSr\\S.rS\4U 4S jjr	S\
\R                     S\
\R                     4S jr\\   SS\
\R                     S
\R                  S\
\R                     S	-  S\R                  S	-  S\
\\\4      S	-  S\\   S\\-  4S jj5       5       rSrU =r$ )ÚSam3DetrEncoderi†  a  
DETR-style encoder that processes multi-level vision features with text fusion.

This encoder processes vision features from multiple levels (e.g., FPN features at different
resolutions) and fuses them with text prompts through a stack of transformer encoder layers.
r«  r¡   c                 ó  >• [         TU ]  U5        Xl        UR                  U l        [        R
                  " [        UR                  5       Vs/ s H  n[        U5      PM     sn5      U l	        U R                  5         g s  snf rž   )rŸ   r    r¡   r…   r¤   r®  r¯  r<  rl  r²  r³  r>  s      €r:   r    ÚSam3DetrEncoder.__init__“  sf   ø€ Ü‰Ñ˜Ô ØŒØ!×-Ñ-ˆÔä—m’mÌ5ÐQW×QbÑQbÔKcÓ$dÒKcÀaÔ%9¸&Ö%AÑKcÑ$dÓeˆŒà�‰Õùò %es   ÁBrN  rb  c                 óþ  • / n/ n/ n[        X5       HŒ  u  pgUR                  SS u  p‰UR                  X‰45        UR                  S5      R	                  SS5      nUR                  S5      R	                  SS5      nUR                  U5        UR                  U5        MŽ     [
        R                  " USS9n[
        R                  " USS9n[
        R                  " U[
        R                  UR                  S9nUUU4$ )a–  
Prepare multi-level vision features by flattening spatial dimensions and adding level embeddings.

Args:
    vision_features: List of vision features at different levels [batch_size, channels, height, width]
    vision_pos_embeds: List of position embeddings for each level [batch_size, channels, height, width]

Returns:
    Tuple containing flattened features, position embeddings, and spatial metadata
r  Nr   r!   rr   rË  )
Úziprw   r÷  r  rÁ   r5   r  rF  rK  rt   )
r­   rN  rb  Úfeatures_flattenedrD   rF   ÚfeaturesrS  r,  r-  s
             r:   Ú_prepare_multilevel_featuresÚ,Sam3DetrEncoder._prepare_multilevel_featuresœ  sú   € ð  ÐØ!ÐØˆä#& Ö#JÑˆHØ$ŸN™N¨2¨3Ð/‰MˆFØ×!Ñ! 6 /Ô2ð  ×'Ñ'¨Ó*×4Ñ4°Q¸Ó:ˆHØ!×)Ñ)¨!Ó,×6Ñ6°q¸!Ó<ˆIà×%Ñ% hÔ/Ø ×'Ñ'¨	Ö2ñ $Kô #ŸYšYÐ'9¸qÑAÐÜ$ŸyšyÐ)=À1ÑEÐäŸš n¼E¿J¹JÐOa×OhÑOhÑiˆð Ø Øð
ð 	
r9   NrE   Ú	text_maskÚspatial_sizesr»   rd   c                 ó  • US   R                  5       S:X  a  US   R                  S   OUS   R                  S   nUbi  [        U5       HZ  u  nu  pšX   R                  XšUS5      R	                  SSSS5      X'   X8   R                  XšUS5      R	                  SSSS5      X8'   M\     U R                  X5      u  nnnSnUb  [        U R                  UUUS9nUnU R                   H  nU" U4UUUS	.UD6nM     [        UUUUS
9$ )aÙ  
Forward pass for the DETR encoder.

Args:
    vision_features: List of vision features at different levels
    text_features: Text prompt features [batch_size, seq_len, hidden_size]
    vision_pos_embeds: Optional list of position embeddings for each level
    text_mask: Optional text padding mask [batch_size, seq_len]
    spatial_sizes: Optional list of (height, width) tuples for reshaping

Returns:
    Sam3DETREncoderOutput containing encoded features and metadata.
r   r_  r!   Nrq   r   r   ©r¡   r_  r?   r\   )r&  r(  ro  )r>   rD   rE   rF   )
rs   rw   Ú	enumeraterÞ   rP  r{  r
   r¡   r²  rB   )r­   rN  rE   rb  r}  r~  r»   rƒ   r´  r,  r-  ry  rD   rF   ro  rG   r¼  s                    r:   r±   ÚSam3DetrEncoder.forwardÆ  sa  € ð0 5DÀAÑ4F×4JÑ4JÓ4LÐPQÓ4Q�_ QÑ'×-Ñ-¨aÒ0ÐWfÐghÑWi×WoÑWoÐpqÑWrˆ
ð Ñ$Ü&/°Ö&>Ñ"�‘?�Fà%4Ñ%7×%?Ñ%?ÀÈzÐ[]Ó%^×%fÑ%fÐghÐjkÐmnÐpqÓ%r�Ñ"Ø'8Ñ';×'CÑ'CÀFÐS]Ð_aÓ'b×'jÑ'jÐklÐnoÐqrÐtuÓ'vÐ!Ó$ñ '?ð ×-Ñ-¨oÓQñ		
ØØ Øð "&ÐØÑ Ü%>Ø—{‘{Ø0Ø(Ø&3ñ	&Ð"ð +ˆØ—[”[ˆEÙ!Øðà*Ø$8Ø'=ñ	ð
 ñŠMñ !ô %Ø+Ø!5Ø'Ø)ñ	
ð 	
r9   )r¡   r…   r²  )NNN)r/   r0   r1   r2   r3   rl  rÉ   r¾  r$   r    rˆ  r5   r   r{  r   r   r4   rM  r   r   rB   r±   r8   r´   rµ   s   @r:   rt  rt  †  sü   ø† ñð .Ø#ñÐð
Ð4÷ ð(
à˜eŸl™lÑ+ð(
ð   §¡Ñ-ô(
ðT  Øð
 8<Ø)-Ø6:ñ=
à˜eŸl™lÑ+ð=
ð —|‘|ð=
ð   §¡Ñ-°Ñ4ð	=
ð
 —<‘< $Ñ&ð=
ð ˜E # s (™OÑ,¨tÑ3ð=
ð Ð+Ñ,ð=
ð 
Ð&Ñ	&ô=
ó ó  ö=
r9   rt  c            	       ó~   ^ • \ rS rSrSrSS\S\S\S\4U 4S jjjrS\R                  S	\R                  4S
 jr	Sr
U =r$ )ÚSam3DecoderMLPi  z/Simple 2 or 3-layer MLP for decoder components.Ú	input_dimÚ
hidden_dimÚ
output_dimr<  c                 ót  >• [         TU ]  5         US:X  a>  [        R                  " X5      U l        [        R                  " X#5      U l        S U l        g US:X  aR  [        R                  " X5      U l        [        R                  " X"5      U l        [        R                  " X#5      U l        g [        SU 35      e)Nr   r   z"Only 2 or 3 layers supported, got )rŸ   r    r¤   r¥   Úlayer1Úlayer2Úlayer3rí   )r­   r…  r†  r‡  r<  r®   s        €r:   r    ÚSam3DecoderMLP.__init__  s†   ø€ Ü‰ÑÔØ˜‹?ÜŸ)š) IÓ:ˆDŒKÜŸ)š) JÓ;ˆDŒKØˆD�KØ˜1‹_ÜŸ)š) IÓ:ˆDŒKÜŸ)š) JÓ;ˆDŒKÜŸ)š) JÓ;ˆD�KäÐAÀ*ÀÐNÓOÐOr9   rb   rd   c                 óü   • [         R                  " U R                  U5      5      nU R                  b8  [         R                  " U R	                  U5      5      nU R                  U5      nU$ U R	                  U5      nU$ rž   )ÚFÚrelur‰  r‹  rŠ  )r­   rb   s     r:   r±   ÚSam3DecoderMLP.forward  s`   € Ü�FŠF�4—;‘;˜q“>Ó"ˆØ�;‰;Ñ"Ü—’�t—{‘{ 1“~Ó&ˆAØ—‘˜A“ˆAð ˆð —‘˜A“ˆAØˆr9   )r‰  rŠ  r‹  )r   )r/   r0   r1   r2   r3   rM  r    r5   r   r±   r8   r´   rµ   s   @r:   r„  r„    sS   ø† Ù9ñP #ð P°3ð PÀCð PÐUX÷ Pð Pð˜Ÿ™ð ¨%¯,©,÷ ò r9   r„  c                   ó  ^ • \ rS rSrSrS\4U 4S jjr  SS\R                  S\R                  S\R                  S	\R                  S
\R                  S\R                  S-  S\R                  S-  S\	\
   S\R                  4S jjrSrU =r$ )ÚSam3DetrDecoderLayeri"  zYDETR decoder layer with self-attention, text cross-attention, and vision cross-attention.r¡   c                 óþ  >• [         TU ]  5         Xl        [        U5      U l        [
        R                  " UR                  5      U l        [
        R                  " UR                  5      U l        [        U5      U l        [
        R                  " UR                  5      U l        [
        R                  " UR                  5      U l        [        U5      U l        [
        R                  " UR                  5      U l        [
        R                  " UR                  5      U l        [%        U5      U l        [
        R                  " UR                  5      U l        [
        R                  " UR                  5      U l        g rž   )rŸ   r    r¡   rÉ   r"  r¤   r©   r«   Úself_attn_dropoutr|  r…   Úself_attn_layer_normÚtext_cross_attnÚtext_cross_attn_dropoutÚtext_cross_attn_layer_normÚvision_cross_attnÚvision_cross_attn_dropoutÚvision_cross_attn_layer_normrœ   r‚  Úmlp_layer_normÚmlp_dropoutr¬   s     €r:   r    ÚSam3DetrDecoderLayer.__init__%  sô   ø€ Ü‰ÑÔØŒÜ& vÓ.ˆŒÜ!#§¢¨F¯N©NÓ!;ˆÔÜ$&§L¢L°×1CÑ1CÓ$DˆÔ!ä,¨VÓ4ˆÔÜ')§z¢z°&·.±.Ó'AˆÔ$Ü*,¯,ª,°v×7IÑ7IÓ*JˆÔ'ä!.¨vÓ!6ˆÔÜ)+¯ª°F·N±NÓ)CˆÔ&Ü,.¯LªL¸×9KÑ9KÓ,LˆÔ)ä˜6“?ˆŒÜ Ÿlšl¨6×+=Ñ+=Ó>ˆÔÜŸ:š: f§n¡nÓ5ˆÕr9   NrG   Ú	query_posrE   rN  r(  Útext_cross_attn_maskÚvision_cross_attn_maskr»   rd   c                 ó<  • [         R                  " USSSS9nUn	X-   n
U R                  " SU
U
USS.UD6u  p¼X�R                  U5      -   nU R	                  U5      nUn	X-   n
U R
                  " SU
UUUS.UD6u  p¼X�R                  U5      -   nU R                  U5      nUn	X-   n
XE-   nU R                  " SU
UUUS.UD6u  p¼X�R                  U5      -   nU R                  U5      nUn	U R                  U5      nX�R                  U5      -   nU R                  U5      nU$ )a¶  
Forward pass for decoder layer.

Args:
    hidden_states: Query features [batch_size, num_queries + 1, hidden_size] (includes presence token at position 0)
    query_pos: Query position embeddings [batch_size, num_queries, hidden_size]
    text_features: Text features [batch_size, seq_len, hidden_size]
    vision_features: Vision features [batch_size, height*width, hidden_size]
    vision_pos_encoding: Vision position encoding [batch_size, height*width, hidden_size]
    text_cross_attn_mask: Text cross-attention mask
    vision_cross_attn_mask: Vision cross-attention mask, already expanded for presence token

Returns:
    Updated hidden states (including presence token at position 0)
©r   r   r!   r   Úconstantr   ©Úmoder¹   Nr+  r.   )rŽ  ra  r"  r”  r•  r–  r—  r˜  r™  rš  r›  r‚  r�  rœ  )r­   rG   rŸ  rE   rN  r(  r   r¡  r»   r�  Úquery_with_posrÆ   r.  Úkey_with_poss                 r:   r±   ÚSam3DetrDecoderLayer.forward8  s  € ô6 —E’E˜) \¸
È!ÑLˆ	ð !ˆØ&Ñ2ˆØŸšð 
Ø ØØØñ	
ð
 ñ
‰ˆð !×#9Ñ#9¸+Ó#FÑFˆØ×1Ñ1°-Ó@ˆð !ˆØ&Ñ2ˆà×-Ò-ð 
Ø ØØØ/ñ	
ð
 ñ
‰ˆð !×#?Ñ#?ÀÓ#LÑLˆØ×7Ñ7¸ÓFˆð !ˆØ&Ñ2ˆØ&Ñ<ˆØ×/Ò/ð 
Ø ØØ!Ø1ñ	
ð
 ñ
‰ˆð !×#AÑ#AÀ+Ó#NÑNˆØ×9Ñ9¸-ÓHˆð !ˆØŸ™ Ó/ˆØ ×#3Ñ#3°MÓ#BÑBˆØ×+Ñ+¨MÓ:ˆàÐr9   )r¡   r‚  r�  rœ  r"  r”  r•  r–  r—  r˜  r™  rš  r›  ©NN)r/   r0   r1   r2   r3   r#   r    r5   r   r   r   r±   r8   r´   rµ   s   @r:   r’  r’  "  s¸   ø† Ùcð6Ð4÷ 6ð4 59Ø6:ñLà—|‘|ðLð —<‘<ðLð —|‘|ð	Lð
 Ÿ™ðLð #Ÿ\™\ðLð $Ÿl™l¨TÑ1ðLð !&§¡¨tÑ 3ðLð Ð+Ñ,ðLð 
�‰÷Ló Lr9   r’  c                   ó  ^ • \ rS rSrSr\\S.rS\4U 4S jjr	\
" SS9S\R                  S	\R                  S
\R                  S\R                  S\\R                  \R                  4   4
S j5       rS\R                  S\\R                  \R                  4   S\R                  4S jr\\  SS\R                  S\R                  S\R                  S\R                  S-  S\R                  S-  S\\   S\\-  4S jj5       5       rSrU =r$ )ÚSam3DetrDecoderi‡  zÿ
DETR-style decoder with box refinement and presence token.

Simplified version that assumes:
- Box refinement is always enabled
- Intermediate outputs are always returned
- BoxRPB (relative position bias) with log-scale encoding
- Presence token is used
r«  r¡   c                 ó~  >• [         TU ]  U5        Xl        UR                  U l        [        R
                  " [        UR                  5       Vs/ s H  n[        U5      PM     sn5      U l	        [        R                  " UR                  5      U l        [        UR                  UR                  SS5      U l        [        R                  " UR                  UR                  5      U l        [        R                  " UR                  S5      U l        [        R                  " SUR                  5      U l        [        UR                  UR                  SS5      U l        [        R                  " UR                  5      U l        SU l        [        SUR                  -  UR                  UR                  S5      U l        [        SUR                  UR.                  S5      U l        [        SUR                  UR.                  S5      U l        [5        UR                  S-  SS9U l        U R9                  5         g s  snf )Nr_  r   r!   g      $@r   Fr  )rŸ   r    r¡   r…   r¤   r®  r¯  r<  r’  r²  r|  r=  r„  Úbox_headr3  Únum_queriesÚquery_embedÚreference_pointsÚpresence_tokenÚpresence_headÚpresence_layer_normÚclamp_presence_logit_max_valÚref_point_headrÌ   Úbox_rpb_embed_xÚbox_rpb_embed_yrÀ  r  r³  r>  s      €r:   r    ÚSam3DetrDecoder.__init__—  sº  ø€ ô 	‰Ñ˜Ô ØŒØ!×-Ñ-ˆÔä—m’mÌ5ÐQW×QbÑQbÔKcÓ$dÒKcÀaÔ%9¸&Ö%AÑKcÑ$dÓeˆŒä!#§¢¨f×.@Ñ.@Ó!AˆÔä& v×'9Ñ'9¸6×;MÑ;MÈqÐRSÓTˆŒäŸ<š<¨×(:Ñ(:¸F×<NÑ<NÓOˆÔÜ "§¢¨V×-?Ñ-?ÀÓ CˆÔä Ÿlšl¨1¨f×.@Ñ.@ÓAˆÔÜ+¨F×,>Ñ,>À×@RÑ@RÐTUÐWXÓYˆÔÜ#%§<¢<°×0BÑ0BÓ#CˆÔ Ø,0ˆÔ)ä,¨Q°×1CÑ1CÑ-CÀV×EWÑEWÐY_×YkÑYkÐmnÓoˆÔä-¨a°×1CÑ1CÀV×E_ÑE_ÐabÓcˆÔÜ-¨a°×1CÑ1CÀV×E_ÑE_ÐabÓcˆÔä!:Ø"(×"4Ñ"4¸Ñ"9ÀUñ"
ˆÔð 	�‰Õùò/ %es   ÁH:r!   rá  r,  r-  rv   rt   rd   c                 ól   • [         R                  " SXUS9U-  n[         R                  " SX$US9U-  nXV4$ )z%Generate normalized coordinate grids.r   ru   )r5   rz   )r­   r,  r-  rv   rt   Úcoords_hÚcoords_ws          r:   Ú_get_coordsÚSam3DetrDecoder._get_coords¸  s;   € ô
 —<’<  6ÀÑFÈÑOˆÜ—<’<  5¸uÑEÈÑMˆØÐ!Ð!r9   rN   Úspatial_shapec                 ó  • Uu  p4[        U5      nUR                  u  pgnU R                  X4UR                  UR                  S9u  pšU	R                  SSS5      UR                  SSS5      SS2SS2SSS24   -
  nUR                  XgSS5      nU
R                  SSS5      UR                  SSS5      SS2SS2SSS24   -
  nUR                  XgSS5      nUS	-  n[        R                  " U5      [        R                  " [        R                  " U5      S
-   5      -  [        R                  " S	5      -  nUS	-  n[        R                  " U5      [        R                  " [        R                  " U5      S
-   5      -  [        R                  " S	5      -  nU R                  U5      nU R                  U5      nUR                  S5      UR                  S5      -   nUR                  SS5      nUR!                  SSSS5      R#                  5       nU$ )a“  
Compute box relative position bias (RPB) matrix using log-scale encoding.
RPB helps the decoder attend to relevant spatial locations based on predicted box positions.

Args:
    reference_boxes: Reference boxes [batch_size, num_queries, 4] in sigmoid space
    spatial_shape: (height, width) of the vision features as tensors

Returns:
    RPB matrix [batch_size, num_heads, num_queries, height*width]
rË  r!   rq   r_  Nr   r   r   é   r÷   )rš   rw   r½  rv   rt   rØ   rÞ   r5   ÚsignÚlog2ÚabsrÆ  r·  r¸  ra  r  rP  rÄ   )r­   rN   r¿  r,  r-  rQ  rƒ   r¯  r.  r»  r¼  Údeltas_yÚdeltas_xÚdeltas_x_logÚdeltas_y_logÚ
rpb_matrixs                   r:   Ú_get_rpb_matrixÚSam3DetrDecoder._get_rpb_matrixÁ  sþ  € ð &‰ˆÜ'¨Ó8ˆ
Ø%/×%5Ñ%5Ñ"ˆ
 ð "×-Ñ-Ø ×!6Ñ!6¸×?UÑ?Uð .ð 
Ñˆð
 —=‘=  B¨Ó*¨Z×-?Ñ-?ÀÀAÀqÓ-IÊ!ÊQÐPQÐRSÐTUÐPUÈ+Ñ-VÑVˆØ—=‘= ¸"¸aÓ@ˆØ—=‘=  B¨Ó*¨Z×-?Ñ-?ÀÀAÀqÓ-IÊ!ÊQÐPQÐRSÐTUÐPUÈ+Ñ-VÑVˆØ—=‘= ¸"¸aÓ@ˆð   !‘|ˆÜ—z’z ,Ó/´%·*²*¼U¿YºYÀ|Ó=TÐWZÑ=ZÓ2[Ñ[Ô^b×^gÒ^gÐhiÓ^jÑjˆØ !‘|ˆÜ—z’z ,Ó/´%·*²*¼U¿YºYÀ|Ó=TÐWZÑ=ZÓ2[Ñ[Ô^b×^gÒ^gÐhiÓ^jÑjˆð ×'Ñ'¨Ó5ˆØ×'Ñ'¨Ó5ˆð ×'Ñ'¨Ó*¨X×-?Ñ-?Øó.
ñ 
ˆ
ð  ×'Ñ'¨¨1Ó-ˆ
Ø×'Ñ'¨¨1¨a°Ó3×>Ñ>Ó@ˆ
ØÐr9   NrN  rE   r(  r}  rF   r»   c                 óü  • UR                   S   nU R                  R                  R                  S5      R	                  USS5      nU R
                  R                  R                  S5      R	                  USS5      n	U	R                  5       n	U R                  R                  R                  S5      R	                  USS5      n
[        R                  " X¨/SS9nSnUb  [        U R                  UUUS9n/ nU	/n/ nU R                   GH£  nU	R                  S5      nU R                  R                  USS2SS2SSS24   5      nU R                  U5      nSnUbF  UR                   S   S:X  a3  US   US	   4nU R!                  U	U5      n["        R$                  " US
SSS9nU" U4UUUUUUS.UD6nUSS2SS24   n['        U	5      nU R)                  U R+                  U5      5      nUU-   R                  5       nUR-                  5       n	UR/                  U R+                  U5      5        UR/                  U5        USS2SS24   nU R1                  U R3                  U5      5      R5                  S5      nUR7                  U R8                  * U R8                  S9nUR/                  U5        GM¦     [        R:                  " U5      n[        R:                  " USS 5      n[        R:                  " U5      n[=        UUUS9$ )að  
Forward pass for the DETR decoder.

Args:
    vision_features: Vision features [batch_size, height*width, hidden_size]
    text_features: Text features [batch_size, seq_len, hidden_size]
    vision_pos_encoding: Vision position encoding [batch_size, height*width, hidden_size]
    text_mask: Text padding mask [batch_size, seq_len] where True=valid, False=padding
    spatial_shapes: Spatial shapes [num_levels, 2]

Returns:
    Sam3DETRDecoderOutput containing decoder outputs from all layers.
r   rq   r!   rr   Nr€  r   )r   r   )r   r!   r£  r¤  r¥  )rŸ  rE   rN  r(  r   r¡  rf   )rM   rN   rO   )rw   r°  rB  ra  r~   r±  Úsigmoidr²  r5   r  r
   r¡   r²  r  rß  r¶  rÊ  rŽ  ra  rn   r®  r=  Údetachr÷  r³  r´  Úsqueezerj   rµ  r”   rK   )r­   rN  rE   r(  r}  rF   r»   rƒ   Úquery_embedsrN   r²  rG   r   Úintermediate_outputsÚintermediate_boxesÚintermediate_presence_logitsr¼  Úreference_points_inputÚquery_sine_embedrŸ  r¡  r¿  rÉ  Úquery_hidden_statesÚreference_boxes_before_sigmoidÚdelta_boxesÚnew_reference_boxesÚpresence_hiddenrO   s                                r:   r±   ÚSam3DetrDecoder.forwardð  s*  € ð0 %×*Ñ*¨1Ñ-ˆ
à×'Ñ'×.Ñ.×8Ñ8¸Ó;×BÑBÀ:ÈrÐSUÓVˆØ×/Ñ/×6Ñ6×@Ñ@ÀÓC×JÑJÈ:ÐWYÐ[]Ó^ˆØ)×1Ñ1Ó3ˆØ×,Ñ,×3Ñ3×=Ñ=¸aÓ@×GÑGÈ
ÐTVÐXZÓ[ˆô Ÿ	š	 >Ð"@ÀaÑHˆà#ÐØÑ Ü#<Ø—{‘{Ø+Ø(Ø&3ñ	$Ð ð  "ÐØ-Ð.ÐØ')Ð$à—[•[ˆEà%4×%>Ñ%>¸qÓ%AÐ"Ø#×5Ñ5×BÑBÐCYÒZ[Ò]^Ð`aÒcdÐZdÑCeÓfÐØ×+Ñ+Ð,<Ó=ˆIð &*Ð"ØÑ)¨n×.BÑ.BÀ1Ñ.EÈÓ.JØ!/°Ñ!5°~ÀdÑ7KÐ L�Ø!×1Ñ1°/À=ÓQ�
ä)*¯ª¨z¸<ÈjÐ`aÑ)bÐ&á!Øð	à#Ø+Ø /Ø$7Ø%9Ø'=ñ	ð ñ	ˆMð #0²°1±2°Ñ"6Ðô .=¸_Ó-MÐ*ØŸ-™-¨×(>Ñ(>Ð?RÓ(SÓTˆKØ#.Ð1OÑ#O×"XÑ"XÓ"ZÐØ1×8Ñ8Ó:ˆOà ×'Ñ'¨×(>Ñ(>Ð?RÓ(SÔTØ×%Ñ%Ð&9Ô:ð ,ªA¨r°¨r¨EÑ2ˆOØ"×0Ñ0°×1IÑ1IÈ/Ó1ZÓ[×cÑcÐdfÓgˆOØ-×3Ñ3Ø×6Ñ6Ð6¸D×<]Ñ<]ð 4ð ˆOð )×/Ñ/°×@ñW !ô\  %Ÿ{š{Ð+?Ó@ÐÜ"Ÿ[š[Ð);¸C¸RÐ)@ÓAÐÜ',§{¢{Ð3OÓ'PÐ$ä$Ø';Ø.Ø8ñ
ð 	
r9   )r®  r·  r¸  rµ  r¡   r…   r²  r=  r  r³  r´  r²  r°  r¶  r±  rª  )r/   r0   r1   r2   r3   r’  rÉ   r¾  r#   r    r   r5   r   rv   rt   r4   r½  rÊ  r   r   r   r   rK   r±   r8   r´   rµ   s   @r:   r¬  r¬  ‡  sa  ø† ñð .Ø#ñÐð
à%÷ñB )°Ñ3ð"Ø—l‘lð"Ø+0¯<©<ð"Ø@EÇÁð"ØUZ×UaÑUað"à	ˆu�|‰|˜UŸ\™\Ð)Ñ	*ó"ó 4ð"ð-Ø$Ÿ|™|ð-Ø<AÀ%Ç,Á,ÐPU×P\ÑP\ÐB\Ñ<]ð-à	�‰ô-ð^  Øð *.Ø.2ñc
àŸ™ðc
ð —|‘|ðc
ð #Ÿ\™\ð	c
ð
 —<‘< $Ñ&ðc
ð Ÿ™ tÑ+ðc
ð Ð+Ñ,ðc
ð 
Ð&Ñ	&ôc
ó ó  öc
r9   r¬  c            	       ó  ^ • \ rS rSrSrS\4U 4S jjrS\R                  S\R                  S-  S\R                  4S	 jr	 SS
\R                  S\R                  S\R                  S-  S\R                  4S jjr
SrU =r$ )ÚSam3DotProductScoringiX  zº
Computes classification scores by computing dot product between projected decoder queries and pooled text features.
This is used to determine confidence/presence scores for each query.
r¡   c                 ó:  >• [         TU ]  5         Xl        UR                  R                  nUR                  R                  n[        UUR                  R                  USS9U l        [        R                  " UR                  R                  5      U l        [        R                  " U5      U l        [        R                  " X#5      U l        [        R                  " X#5      U l        [#        S[$        R&                  " U5      -  5      U l        SU l        SU l        g )Nr   )r…  r†  r‡  r<  r÷   Tg      (@)rŸ   r    r¡   Údetr_decoder_configr…   r„  r¦   Útext_mlpr¤   r©   r«   Útext_mlp_dropoutr|  Útext_mlp_out_normr¥   Ú	text_projÚ
query_projrú   ÚnpÚsqrtrÄ  Úclamp_logitsÚclamp_max_val)r­   r¡   r…   Úprojection_dimr®   s       €r:   r    ÚSam3DotProductScoring.__init__^  sÙ   ø€ Ü‰ÑÔØŒØ×0Ñ0×<Ñ<ˆØ×3Ñ3×?Ñ?ˆä&Ø!Ø×1Ñ1×CÑCØ"Øñ	
ˆŒô !#§
¢
¨6×+EÑ+E×+MÑ+MÓ NˆÔÜ!#§¢¨kÓ!:ˆÔô Ÿš ;Ó?ˆŒÜŸ)š) KÓ@ˆŒô ˜3¤§¢¨Ó!8Ñ8Ó9ˆŒ
ð !ˆÔØ!ˆÕr9   rE   r}  Nrd   c                 óÞ   • Uc  UR                  SS9$ UR                  UR                  5      R                  S5      nUR	                  SS9R                  SS9nX-  R	                  SS9U-  nU$ )a  
Mean pool text features, accounting for padding.

Args:
    text_features: [batch_size, seq_len, hidden_size]
    text_mask: [batch_size, seq_len] where True indicates valid tokens, False indicates padding

Returns:
    pooled_text: [batch_size, hidden_size]
r!   rr   rq   r÷   ri   )r™  rû   rv   ra  ry   rj   )r­   rE   r}  Úis_validÚ	num_validÚpooled_texts         r:   Ú_pool_text_featuresÚ)Sam3DotProductScoring._pool_text_featuresx  s€   € ð Ñà ×%Ñ%¨!Ð%Ð,Ð,à—<‘< × 3Ñ 3Ó4×>Ñ>¸rÓBˆð —L‘L Q�LÐ'×-Ñ-°#Ð-Ð6ˆ	ð %Ñ/×4Ñ4¸Ð4Ð;¸iÑGˆàÐr9   rZ   c                 óÒ  • UnU R                  U5      nU R                  U5      nX$-   nU R                  U5      nU R                  X#5      nU R	                  U5      nU R                  U5      nUR                  S5      n[        R                  " XvR                  S5      5      nX€R                  -  nU R                  (       a%  UR                  U R                  * U R                  S9nU$ )a?  
Compute classification scores via dot product.

Args:
    decoder_hidden_states: [num_layers, batch_size, num_queries, hidden_size]
    text_features: [batch_size, seq_len, hidden_size]
    text_mask: [batch_size, seq_len] where True=valid, False=padding

Returns:
    scores: [num_layers, batch_size, num_queries, 1]
rq   r   rf   )rà  rá  râ  rï  rã  rä  ra  r5   rÀ   rÄ  rç  rj   rè  )	r­   rZ   rE   r}  Úorig_text_featuresrî  Ú	proj_textÚproj_queriesÚscoress	            r:   r±   ÚSam3DotProductScoring.forward‘  sÑ   € ð" +ÐØŸ™ mÓ4ˆØ×-Ñ-¨mÓ<ˆØ%Ñ:ˆØ×.Ñ.¨}Ó=ˆà×.Ñ.¨}ÓHˆà—N‘N ;Ó/ˆ	Ø—‘Ð'<Ó=ˆà×'Ñ'¨Ó+ˆ	Ü—’˜l×,?Ñ,?ÀÓ,BÓCˆØŸ*™*Ñ$ˆØ××Ø—\‘\ t×'9Ñ'9Ð&9¸t×?QÑ?Q�\ÐRˆFàˆr9   )	rç  rè  r¡   rä  rÄ  rà  rá  râ  rã  rž   )r/   r0   r1   r2   r3   r"   r    r5   r   rï  r±   r8   r´   rµ   s   @r:   rÝ  rÝ  X  s�   ø† ñð
"˜z÷ "ð4°·±ð È%Ï,É,ÐY]ÑJ]ð Ðbg×bnÑbnô ð: *.ñ	"à$Ÿ|™|ð"ð —|‘|ð"ð —<‘< $Ñ&ð	"ð
 
�‰÷"ó "r9   rÝ  c                   ón   ^ • \ rS 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$ )	ÚSam3MaskEmbedderi¶  z\
MLP that embeds object queries for mask prediction.
Similar to MaskFormer's mask embedder.
r¡   c                 ó.  >• [         TU ]  5         Xl        UR                  n[        R
                  " [        R                  " X"5      [        R                  " X"5      [        R                  " X"5      /5      U l        [        R                  " 5       U l	        g rž   )
rŸ   r    r¡   r…   r¤   r®  r¥   r²  ÚReLUÚ
activation©r­   r¡   r…   r®   s      €r:   r    ÚSam3MaskEmbedder.__init__¼  sf   ø€ Ü‰ÑÔØŒØ×(Ñ(ˆä—m’mä—	’	˜+Ó3Ü—	’	˜+Ó3Ü—	’	˜+Ó3ðó
ˆŒô Ÿ'š'›)ˆ�r9   Úqueriesrd   c                 ó´   • Un[        U R                  5       H<  u  p4U" U5      nU[        U R                  5      S-
  :  d  M+  U R                  U5      nM>     U$ )z‘
Args:
    queries: Query embeddings [batch_size, num_queries, hidden_size]

Returns:
    Mask embeddings [batch_size, num_queries, hidden_size]
r!   )r�  r²  Úlenrû  )r­   rþ  rG   r´  r¼  s        r:   r±   ÚSam3MaskEmbedder.forwardÊ  sT   € ð  ˆÜ! $§+¡+Ö.‰HˆAÙ! -Ó0ˆMØ”3�t—{‘{Ó# aÑ'Õ'Ø $§¡°Ó >’ñ /ð Ðr9   )rû  r¡   r²  )r/   r0   r1   r2   r3   r&   r    r5   r   r±   r8   r´   rµ   s   @r:   rø  rø  ¶  s5   ø† ñð
$Ð4÷ $ð˜uŸ|™|ð °·±÷ ò r9   rø  c                   ót   ^ • \ rS 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$ )	ÚSam3PixelDecoderiÚ  zt
Feature Pyramid Network (FPN) decoder that generates pixel-level features.
Inspired by MaskFormer's pixel decoder.
r¡   c                 ó¦  >• [         TU ]  5         Xl        UR                  nUR                  n[
        R                  " [        U5       Vs/ s H  n[
        R                  " X"SSSS9PM     sn5      U l	        [
        R                  " [        U5       Vs/ s H  n[
        R                  " SU5      PM     sn5      U l        X l        g s  snf s  snf )Nr   r!   )r5  r6  rõ  rÁ  )rŸ   r    r¡   r…   Únum_upsampling_stagesr¤   r®  r¯  r=  Úconv_layersÚ	GroupNormÚnormsrô  )r­   r¡   r…   r  r.  r®   s        €r:   r    ÚSam3PixelDecoder.__init__à  sµ   ø€ Ü‰ÑÔØŒØ×(Ñ(ˆØ &× <Ñ <Ðô Ÿ=š=ô Ð4Ô5óâ5�Aô —	’	˜+ÀÈ!ÐUVÔWÙ5ñó
ˆÔô —]’]Ì%ÐPeÔJfÓ#gÒJfÀQ¤B§L¢L°°KÖ$@ÑJfÑ#gÓhˆŒ
à'Õùòùò
 $hs   Á!C	Â!CÚbackbone_featuresrd   c                 ó  • US   n[        [        USS 5      5       Hk  u  p4[        R                  " X$R                  SS SS9nX$-   nU R
                  U   " U5      nU R                  U   " U5      n[        R                  " U5      nMm     U$ )a  
Args:
    backbone_features: List of backbone features [batch_size, hidden_size, H_i, W_i]
                      from low to high resolution (assumes already projected to hidden_size)

Returns:
    Pixel embeddings [batch_size, hidden_size, H, W] at the finest resolution
rq   Nr  Únearest)rx   r¦  )r�  ÚreversedrŽ  Úinterpolaterw   r  r  r�  )r­   r
  Úprev_fpnÚ	layer_idxÚbackbone_feats        r:   r±   ÚSam3PixelDecoder.forwardñ  s•   € ð % RÑ(ˆä(1´(Ð;LÈSÈbÐ;QÓ2RÖ(SÑ$ˆIä—}’} X×4GÑ4GÈÈÐ4LÐS\Ñ]ˆHð  Ñ/ˆHð ×'Ñ'¨	Ò2°8Ó<ˆHØ—z‘z )Ò,¨XÓ6ˆHÜ—v’v˜hÓ'ŠHñ )Tð ˆr9   )r¡   r  r  rô  )r/   r0   r1   r2   r3   r&   r    rˆ  r5   r   r±   r8   r´   rµ   s   @r:   r  r  Ú  s:   ø† ñð
(Ð4÷ (ð"¨¨e¯l©lÑ);ð ÀÇÁ÷ ò r9   r  c                   óX  ^ • \ rS rSrSrS\0rS\4U 4S jjr\	\
  SS\R                  S\\R                     S	\R                  S
\R                  S-  S\R                  S-  S\\   S\\-  4S jj5       5       rS\\R                     S	\R                  S\R                  4S jrSrU =r$ )ÚSam3MaskDecoderi  z¶
Mask decoder that combines object queries with pixel-level features to predict instance masks.
Also produces a semantic segmentation output and supports cross-attention to prompts.
rH   r¡   c                 ó  >• [         TU ]  U5        Xl        UR                  n[	        U5      U l        [        U5      U l        [        R                  " U R
                  R                  USS9U l        [        R                  " U R
                  R                  SSS9U l        [        U5      U l        [        R                  " U5      U l        [        R"                  " UR$                  5      U l        U R)                  5         g )Nr!   )r5  )rŸ   r    r¡   r…   r  Úpixel_decoderrø  Úmask_embedderr¤   r=  rô  Úinstance_projectionÚsemantic_projectionrÉ   Úprompt_cross_attnr|  Úprompt_cross_attn_normr©   r«   Úprompt_cross_attn_dropoutr³  rü  s      €r:   r    ÚSam3MaskDecoder.__init__  sÃ   ø€ Ü‰Ñ˜Ô ØŒØ×(Ñ(ˆô .¨fÓ5ˆÔô .¨fÓ5ˆÔô $&§9¢9¨T×-?Ñ-?×-LÑ-LÈkÐghÑ#iˆÔ ô $&§9¢9¨T×-?Ñ-?×-LÑ-LÈaÐ]^Ñ#_ˆÔ ä!.¨vÓ!6ˆÔÜ&(§l¢l°;Ó&?ˆÔ#Ü)+¯ª°F·N±NÓ)CˆÔ&à�‰Õr9   NÚdecoder_queriesr
  r\   Úprompt_featuresr)  r»   rd   c                 ó„  • UbZ  UnU R                  U5      nSn	Ub  [        U R                  UUUS9n	U R                  " SUUUU	S.UD6u  p«XpR	                  U
5      -   nU R                  UUS9nU R                  U5      nU R                  U5      n[        R                  " SXí5      nU R                  U5      n[        UUS9$ )a  
Args:
    decoder_queries: Decoder output queries [batch_size, num_queries, hidden_size]
    backbone_features: List of backbone features to process through FPN
    encoder_hidden_states: Encoder outputs [batch_size, seq_len, hidden_size]
    prompt_features: Prompt features (text + geometry) for cross-attention [batch_size, prompt_len, hidden_size]
    prompt_mask: Padding mask [batch_size, prompt_len] where True=valid, False=padding

Returns:
    Sam3MaskDecoderOutput containing predicted masks and semantic segmentation.
N)r¡   r_  r\   r?   r+  )r
  r\   zbqc,bchw->bqhw)rS   rT   r.   )r  r
   r¡   r  r  Ú_embed_pixelsr  r  r5   Úeinsumr  rQ   )r­   r  r
  r\   r  r)  r»   r�  Únormed_hidden_statesÚcross_attn_maskrÆ   r.  Úpixel_embedÚinstance_embedsÚmask_embeddingsrS   rT   s                    r:   r±   ÚSam3MaskDecoder.forward-  s   € ð, Ñ&à,ˆHØ#'×#>Ñ#>Ð?TÓ#UÐ à"ˆOØÑ&Ü";ØŸ;™;Ø"6Ø*9Ø#.ñ	#�ð "×3Ò3ð Ø*Ø#Ø%Ø.ñ	ð
 ñ‰NˆKð %-×/MÑ/MÈkÓ/ZÑ$ZÐ!ð ×(Ñ(Ø/Ø"7ð )ð 
ˆð ×2Ñ2°;Ó?ˆØ×,Ñ,¨_Ó=ˆÜ—\’\Ð"2°OÓUˆ
ð ×/Ñ/°Ó<ˆä$Ø!Ø%ñ
ð 	
r9   c                 óh  • U Vs/ s H  o3R                  5       PM     nnUS   R                  S   US   R                  S   -  nUSS2SU2SS24   nUR                  u  pxn	US   R                  SS u  p«UR                  SS5      R                  XyX«5      nXdS'   U R	                  U5      nU$ s  snf )az  
Embed pixels by combining backbone FPN features with encoder vision features.
The encoder vision features replace the finest-resolution backbone feature.

Args:
    backbone_features: List of backbone features [batch_size, C, H_i, W_i]
    encoder_hidden_states: Encoder outputs [batch_size, seq_len, hidden_size]

Returns:
    Pixel embeddings [batch_size, hidden_size, H, W]
rq   r  Nr!   r   )rñ   rw   rÁ   rÞ   r  )r­   r
  r\   ÚfeatÚbackbone_visual_featsrý   Úencoder_visual_embedrƒ   r.  r…   r,  r-  r%  s                r:   r!  ÚSam3MaskDecoder._embed_pixelsm  s×   € ñ  ;LÓ LÒ:K°$§¡¦Ñ:KÐÐ Lð (¨Ñ+×1Ñ1°"Ñ5Ð8IÈ"Ñ8M×8SÑ8SÐTVÑ8WÑWˆØ4²Q¸¸¸ÂaÐ5GÑHÐØ%9×%?Ñ%?Ñ"ˆ
�{Ø)¨"Ñ-×3Ñ3°B°CÐ8‰ˆØ3×=Ñ=¸aÀÓC×KÑKÈJÐekÓsÐð %9˜bÑ!ð ×(Ñ(Ð)>Ó?ˆàÐùò !Ms   …B/)r¡   r  r  r  r  r  r  r  rª  )r/   r0   r1   r2   r3   rÉ   r¾  r&   r    r   r   r5   r   rˆ  r   r   r4   rQ   r±   r!  r8   r´   rµ   s   @r:   r  r    só   ø† ñð 	�mðÐðÐ4÷ ð.  Øð 04Ø+/ñ<
àŸ™ð<
ð   §¡Ñ-ð<
ð  %Ÿ|™|ð	<
ð
 Ÿ™¨Ñ,ð<
ð —\‘\ DÑ(ð<
ð Ð+Ñ,ð<
ð 
Ð&Ñ	&ô<
ó ó  ð<
ð|à §¡Ñ-ðð  %Ÿ|™|ðð 
�‰÷	ò r9   r  c                   óè  ^ • \ rS rSrSS/rSrSS/rS\4U 4S jjr\	\
 SS
\R                  S\R                  S	-  S\\   S\\-  4S jj5       5       r\
S\R&                  S\\   S\4S j5       r\	\
       SS\R&                  S	-  S\S	-  S
\R                  S	-  S\R                  S	-  S\R&                  S	-  S\R&                  S	-  S\R                  S	-  S\\   S\4S jj5       5       rSrU =r$ )Ú	Sam3Modeli�  r–  r—  Údetector_modelz^tracker_model.z^tracker_neck.r¡   c                 óÊ  >• [        US5      (       a;  UR                  b.  UR                  n[        U[        5      (       a  [	        S0 UD6nUn[
        TU ]  U5        [        UR                  5      U l	        [        UR                  5      U l        UR                  R                  U l        [        R                  " UR                  R                   UR"                  R                   5      U l        UR&                  UR(                  l        UR&                  UR"                  l        UR&                  UR*                  l        UR&                  UR,                  l        [/        UR(                  5      U l        [3        UR"                  5      U l        [7        UR*                  5      U l        [;        UR,                  5      U l        [?        U5      U l         U RC                  5         g )NÚdetector_configr.   )"Úhasattrr2  r  Údictr"   rŸ   r    r  Úvision_configÚvision_encoderr    Útext_configÚtext_encoderÚ
vocab_sizer¤   r¥   r…   Údetr_encoder_configÚtext_projectionrÚ   Úgeometry_encoder_configrß  Úmask_decoder_configr0  Úgeometry_encoderrt  Údetr_encoderr¬  Údetr_decoderr  Úmask_decoderrÝ  Údot_product_scoringr³  )r­   r¡   r2  r®   s      €r:   r    ÚSam3Model.__init__—  sq  ø€ ä�6Ð,×-Ñ-°&×2HÑ2HÑ2TØ$×4Ñ4ˆOÜ˜/¬4×0Ñ0Ü",Ñ"?¨Ñ"?�Ø$ˆFÜ‰Ñ˜Ô Ü-¨f×.BÑ.BÓCˆÔÜ7¸×8JÑ8JÓKˆÔØ ×,Ñ,×7Ñ7ˆŒô  "Ÿyšy¨×);Ñ);×)GÑ)GÈ×IcÑIc×IoÑIoÓpˆÔð ?E×>YÑ>Yˆ×&Ñ&Ô;Ø:@×:UÑ:Uˆ×"Ñ"Ô7Ø:@×:UÑ:Uˆ×"Ñ"Ô7Ø:@×:UÑ:Uˆ×"Ñ"Ô7ä 3°F×4RÑ4RÓ SˆÔÜ+¨F×,FÑ,FÓGˆÔÜ+¨F×,FÑ,FÓGˆÔÜ+¨F×,FÑ,FÓGˆÔô $9¸Ó#@ˆÔ à�‰Õr9   NÚ	input_idsr?   r»   rd   c                 ót   • U R                   " SXSS.UD6nUR                  nU R                  U5      Ul        U$ )a  
Example:

```python
>>> from transformers import Sam3Model, Sam3Processor
>>> from PIL import Image
>>> import httpx
>>> from io import BytesIO

>>> model = Sam3Model.from_pretrained("facebook/sam3")
>>> processor = Sam3Processor.from_pretrained("facebook/sam3")

>>> # Pre-compute text embeddings
>>> text_inputs = processor(text="cat", return_tensors="pt")
>>> text_embeds = model.get_text_features(**text_inputs).pooler_output

>>> # Reuse text embeddings for multiple images
>>> url = "http://images.cocodataset.org/val2017/000000077595.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))
>>> img_inputs = processor(images=image, return_tensors="pt")
>>> outputs = model(pixel_values=img_inputs.pixel_values, text_embeds=text_embeds)
```
T©rD  r?   Úreturn_dictr.   )r8  r>   r;  Úpooler_output)r­   rD  r?   r»   Útext_outputsr>   s         r:   Úget_text_featuresÚSam3Model.get_text_features·  sO   € ð@ ×(Ò(ð 
ØÈDñ
ØTZñ
ˆð )×:Ñ:ÐØ%)×%9Ñ%9Ð:KÓ%LˆÔ"àÐr9   r@  c                 ó,   • U R                   " U40 UD6nU$ )a2  
Example:

```python
>>> from transformers import Sam3Model, Sam3Processor
>>> from PIL import Image
>>> import httpx
>>> from io import BytesIO

>>> model = Sam3Model.from_pretrained("facebook/sam3")
>>> processor = Sam3Processor.from_pretrained("facebook/sam3")

>>> # Pre-compute vision embeddings
>>> url = "http://images.cocodataset.org/val2017/000000077595.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))
>>> img_inputs = processor(images=image, return_tensors="pt")
>>> vision_embeds = model.get_vision_features(pixel_values=img_inputs.pixel_values)

>>> # Reuse vision embeddings for multiple text prompts
>>> text_inputs = processor(text="cat", return_tensors="pt")
>>> outputs = model(vision_embeds=vision_embeds, input_ids=text_inputs.input_ids)
```
)r6  )r­   r@  r»   Úvision_outputss       r:   Úget_vision_featuresÚSam3Model.get_vision_featuresß  s   € ð< ×,Ò,¨\ÑD¸VÑDˆØÐr9   Úvision_embedsÚtext_embedsÚinput_boxesÚinput_boxes_labelsc                 óÄ
  • USL USL :X  a  [        S5      eUSL USL :X  a  [        S5      eUb  UR                  S   n	UR                  n
O5UR                  S   R                  S   n	UR                  S   R                  n
Uc  U R                  " U40 UD6nOUnUR                  SS nUR
                  SS nUc  U R                  X4SS9nUR                  nUb  UR                  5       OSnUSL=(       a    UR                  5       S:„  nSnSnU(       Ga0  Ub–  UR                  5       S:”  a‚  UnUb  UO%[        R                  " US   [        R                  S	9nUb  US
:g  O0[        R                  " X–R                  S   [        R                  U
S9n[        R                  " US
:H  SU5      nOl[        R                  " U	SSUR                   U
S9n[        R                  " U	S[        R                  U
S9n[        R                  " U	S[        R                  U
S9nU R#                  UUUUUS9nUR$                  nUR&                  nUGb_  UR                  S   S:X  a3  UR                  S   S:”  a   UR)                  UR                  S   SS5      n[        R*                  " UU/SS9nUbE  UR                  S   S:X  a2  UR                  S   S:”  a  UR)                  UR                  S   S5      nUb  Ub  [        R*                  " UU/SS9nO UbJ  [        R                  " U	UR                  S   [        R                  U
S9n[        R*                  " UU/SS9nOSUbI  [        R                  " XžR                  S   [        R                  U
S9n[        R*                  " UU/SS9nOSnOUnUnU R,                  " SUS   /UUS   /US.UD6nU R.                  " SUR$                  UR0                  UR2                  UUR4                  S.UD6nU R.                  R7                  UR8                  5      n[;        UR<                  5      nUU-   R?                  5       n[A        U5      n U RC                  UR8                  UR0                  US9RE                  S5      n!U!S   n"U S   n#UR8                  S   n$URF                  S   n%U RH                  " SU$[K        U5      UR$                  UUS.UD6n&[M        U&RN                  U#U"U%U&RP                  URR                  UR<                  URR                  URR                  URT                  URT                  URT                  U&RT                  S9$ )aö  
vision_embeds (`Sam3VisionEncoderOutput`, *optional*):
    Pre-computed vision embeddings. Can be used to easily reuse vision embeddings. If provided, `pixel_values`
    should not be passed. Mutually exclusive with `pixel_values`.
text_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
    Pre-computed text embeddings. Can be used to easily reuse text embeddings. If provided, `input_ids`
    should not be passed. Mutually exclusive with `input_ids`.
input_boxes (`torch.FloatTensor` of shape `(batch_size, num_boxes, 4)`, *optional*):
    Normalized box coordinates in [0, 1] range, in (cx, cy, w, h) format.
input_boxes_labels (`torch.LongTensor` of shape `(batch_size, num_boxes)`, *optional*):
    Labels for boxes: 1 (positive), 0 (negative).

Example:

```python
>>> from PIL import Image
>>> import httpx
>>> from io import BytesIO
>>> from transformers import AutoModel, AutoProcessor

>>> model = AutoModel.from_pretrained("facebook/sam3")
>>> processor = AutoProcessor.from_pretrained("facebook/sam3")

>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam-car.png"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read())).convert("RGB")
>>> text = "car"
>>> inputs = processor(images=image, text=text, return_tensors="pt")

>>> # Get segmentation output
>>> outputs = model(**inputs)
>>> pred_masks = outputs.pred_masks
>>> pred_boxes = outputs.pred_boxes
```
Nz=You must specify exactly one of pixel_values or vision_embedsz8You must specify exactly one of input_ids or text_embedsr   rq   TrF  ).r   rø   iöÿÿÿr!   rË  r_  )rY  rZ  r[  r\  r]  rr   )rN  rE   rb  r}  )rN  rE   r(  r}  rF   )rZ   rE   r}  )r  r
  r\   r  r)  )rS   rX   rY   rO   rT   rZ   r[   r\   r]   r^   r_   r`   ra   r.   )+rí   rw   rt   r,   r6  r-   rJ  rH  rÛ   Únumelr5   Ú	ones_likerK  rr  Úwherer|   rv   r>  r>   r?   r{   r  r?  r@  rE   rD   rF   r®  rM   rn   rN   rÍ  rš   rB  rÏ  rO   rA  rˆ  rV   rS   rT   rG   rH   )'r­   r@  rP  rD  r?   rQ  rR  rS  r»   rƒ   rt   rM  r,   r-   rE   r}  Úhas_geometry_promptsÚgeometry_prompt_featuresÚgeometry_prompt_maskrY  r[  rZ  Úgeometry_outputsÚcombined_prompt_featuresÚcombined_prompt_maskÚgeo_valid_maskÚtext_valid_maskÚencoder_outputsÚdecoder_outputsÚall_box_offsetsÚreference_boxes_inv_sigÚall_pred_boxes_cxcywhÚall_pred_boxesÚall_pred_logitsrY   rX   rZ   rO   Úmask_outputss'                                          r:   r±   ÚSam3Model.forward 	  sÁ  € ð` ˜DÐ  m°tÐ&;Ó<ÜÐ\Ó]Ð]à˜Ð ;°$Ð#6Ó7ÜÐWÓXÐXàÑ#Ø%×+Ñ+¨AÑ.ˆJØ!×(Ñ(‰Fà&×8Ñ8¸Ñ;×AÑAÀ!ÑDˆJØ"×4Ñ4°QÑ7×>Ñ>ˆFàÑ Ø!×0Ò0°ÑHÀÑH‰Nà*ˆNà*×<Ñ<¸S¸bÐAÐØ .× DÑ DÀSÀbÐ IÐàÑØ×0Ñ0¸9ÐquÐ0ÐvˆKà#×1Ñ1ˆØ-;Ñ-G�N×'Ñ'Ô)ÈTˆ	Ø*°$Ð6×R¸;×;LÑ;LÓ;NÐQRÑ;RÐà#'Ð Ø#ÐçØÑ&¨;×+<Ñ+<Ó+>ÀÓ+BØ!,�ð *Ñ5ñ 'äŸš¨¸Ñ)?ÄuÇzÁzÑRð ð *Ñ5ð (¨3Ò.äŸš J×0AÑ0AÀ!Ñ0DÌEÏJÉJÐ_eÑfð ô
 #Ÿ[š[¨°sÑ):¸A¸zÓJ‘
ä!&§¢¨Z¸¸AÀ]×EXÑEXÐagÑ!h�Ü"Ÿ[š[¨°Q¼e¿j¹jÐQWÑX�
Ü Ÿ;š; z°1¼E¿J¹JÈvÑV�à#×4Ñ4Ø-Ø!Ø%Ø+Ø4ð  5ð  Ðð (8×'IÑ'IÐ$Ø#3×#BÑ#BÐ à#Ò/à×"Ñ" 1Ñ%¨Ó*Ð/G×/MÑ/MÈaÑ/PÐSTÓ/TØ -× 4Ñ 4Ð5M×5SÑ5SÐTUÑ5VÐXYÐ[\Ó ]�Ü',§y¢y°-ÐAYÐ1ZÐ`aÑ'bÐ$ØÑ$¨¯©¸Ñ);¸qÓ)@ÐEY×E_ÑE_Ð`aÑEbÐefÓEfØ%×,Ñ,Ð-A×-GÑ-GÈÑ-JÈAÓN�	àÑ$Ð)=Ñ)IÜ',§y¢y°)Ð=QÐ1RÐXYÑ'ZÑ$ØÑ&Ü!&§¢ØÐ 8× >Ñ >¸qÑ AÌÏÉÐ\bñ"�ô (-§y¢y°)¸^Ð1LÐRSÑ'TÑ$Ø%Ñ1Ü"'§*¢*¨Z×9LÑ9LÈQÑ9OÔW\×WaÑWaÐjpÑ"q�Ü',§y¢y°/ÐCWÐ1XÐ^_Ñ'`Ñ$à'+Ñ$à'4Ð$Ø#,Ð à×+Ò+ð 
Ø.¨rÑ2Ð3Ø2Ø4°RÑ8Ð9Ø*ñ	
ð
 ñ
ˆð ×+Ò+ð 
Ø+×=Ñ=Ø)×7Ñ7Ø /× DÑ DØ*Ø*×9Ñ9ñ
ð ñ
ˆð ×+Ñ+×4Ñ4°_×5_Ñ5_Ó`ˆÜ"1°/×2QÑ2QÓ"RÐØ!8¸?Ñ!J× SÑ SÓ UÐÜ+Ð,AÓBˆà×2Ñ2Ø"1×"LÑ"LØ)×7Ñ7Ø*ð 3ð 
÷ ‰'�"‹+ð	 	ð & bÑ)ˆØ# BÑ'ˆ
Ø /× JÑ JÈ2Ñ NÐØ)×9Ñ9¸"Ñ=ˆà×(Ò(ð 
Ø1Ü"Ð#4Ó5Ø"1×"CÑ"CØ4Ø,ñ
ð ñ
ˆô +Ø#×.Ñ.Ø!Ø#Ø+Ø%×2Ñ2Ø"1×"?Ñ"?Ø$3×$CÑ$CØ"1×"?Ñ"?Ø!/×!=Ñ!=Ø,×7Ñ7Ø$3×$>Ñ$>Ø$3×$>Ñ$>Ø$0×$;Ñ$;ñ
ð 	
r9   )	r@  r?  rB  r>  rA  r8  r;  r6  r9  rž   )NNNNNNN)r/   r0   r1   r2   r¤  r¢  Ú"_keys_to_ignore_on_load_unexpectedr"   r    r   r   r5   rI   r   r   r   r4   r   rJ  r6   r*   rN  rV   r±   r8   r´   rµ   s   @r:   r/  r/  �  s°  ø† Ø Ð(ÐØ(ÐàØð*Ð&ð
˜z÷ ð@ Øð /3ñ$à×#Ñ#ð$ð Ÿ™ tÑ+ð$ð Ð+Ñ,ð	$ð
 
Ð+Ñ	+ô$ó ó ð$ðL ðà×'Ñ'ðð Ð+Ñ,ðð 
!ó	ó ðð@ Øð 26Ø8<Ø-1Ø.2Ø04Ø04Ø6:ñ|
à×'Ñ'¨$Ñ.ð|
ð /°Ñ5ð|
ð ×#Ñ# dÑ*ð	|
ð
 Ÿ™ tÑ+ð|
ð ×&Ñ&¨Ñ-ð|
ð ×&Ñ&¨Ñ-ð|
ð "×,Ñ,¨tÑ3ð|
ð Ð+Ñ,ð|
ð 
%ô|
ó ó ö|
r9   r/  )r/  r  rª  r”  )gü©ñÒMbP?r]  )NrÖ   )prÆ  Úcollections.abcr   r   Údataclassesr   Únumpyrå  r5   Útorch.nnr¤   Útorch.nn.functionalrÂ   rŽ  r   Ú r   rœ  Úactivationsr	   Úmasking_utilsr
   Úmodeling_layersr   Úmodeling_outputsr   r   r   Úmodeling_utilsr   r   Úprocessing_utilsr   Úpytorch_utilsr   Úutilsr   r   r   r   Úutils.deprecationr   Úutils.genericr   r   r   r   Úutils.import_utilsr   Úutils.output_capturingr   Úautor   Úclipr    Úconfiguration_sam3r"   r#   r$   r%   r&   r'   r(   r‘  Ú
get_loggerr/   rÜ   r*   r<   rB   rK   rQ   rV   rú   rn   rÛ   r�   rš   ÚModulerœ   rÇ   rÉ   rä   r  r4   r$  r&  r3  rF  ri  rm  ro  ry  r”  rª  rÀ  rï  r  r  r   r0  rl  rt  r„  r’  r¬  rÝ  rø  r  r  r/  Ú__all__r.   r9   r:   Ú<module>r‚     s„  ðó ß .Ý !ã Û Ý ß Ð Ý å &Ý !Ý 6Ý 9÷ñ ÷
 GÝ &Ý @ß XÓ XÝ 0÷ó õ +Ý 5Ý Ý .÷÷ ñ ñ ×ÑÛà	×	Ò	˜HÓ	%€ð Ø
ô	@Ð8ó 	@ó ó ð	@ð Ø
ô	3 ó 	3ó ó ð	3ð Ø
ô7˜Kó 7ó ó ð7ð0 Ø
ô7˜Kó 7ó ó ð7ð* Ø
ô7˜Kó 7ó ó ð7ð Ø
ô-D +ó -Dó ó ð-Dñ`�u—|‘|ð ¨%ð ¸5¿<¹<õ ñ34ÀDõ 34òl"ôˆb�i‰iô ð. !Øñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 —L‘L 4Ñ'ð%ð �T‰\ð%ð ð%ð Ð'Ñ(õ%ô8P)�B—I‘Iô P)ôh?4˜RŸY™Yô ?4òD#ð$2Ø‡|�|ð2à‡|�|ð2ð 
�‰ð2ð 
�‰ð	2ð
 ˆ5�<‰<˜Ÿ™Ð%Ñ&ô2ô62)˜2Ÿ9™9ô 2)ôj˜RŸY™Yô ô6E˜Ÿ	™	ô EòP2ò>ô>+˜Ÿ	™	ô +ôDÐ-ô DðN Ù	Ð+Ñ,ô:˜/ó :ó -ó ð:ð& ô0@Ð&ó 0@ó ð0@ôfB
 §	¡	ô B
ôJ#�2—9‘9ô #ôL8�R—Y‘Yô 8ñB ðñô
(
Ð)ó (
óð
(
ôV%˜rŸy™yô %ôPc
˜"Ÿ)™)ô c
ôLC˜2Ÿ9™9ô CôL
Ð)ô 
ôD�R—Y‘Yô ô4b˜2Ÿ9™9ô bôJN
Ð)ô N
ôb[˜BŸI™Iô [ô|!�r—y‘yô !ôH/�r—y‘yô /ôd@Ð)ô @ôFo
Ð#ô o
òd	 R�r9   