+
    œ°³jI— ã                   óæ  € ^ RI t ^ RIHtHt ^ RIHt ^ RIt^ RIt^ RI	H
t
 ^ RIH
u Ht ^ RIHt ^RIHt ^RIHt ^RIHt ^RIHt ^R	IHtHtHt ^R
IHtHt ^RIH t  ^RI!H"t" ^RI#H$t$H%t%H&t&H't' ^RI(H)t) ^RI*H+t+H,t,H-t-H.t. ^RI/H0t0 ^RI1H2t2 ^RI3H4t4 ^RI5H6t6 ^RI7H8t8H9t9H:t:H;t;H<t<H=t=H>t> ]&! 4       '       d   ^ RI?t?]'P€                  ! ]A4      tB]$] ! R R]4      4       4       tC]$] ! R R]4      4       4       tD]$] ! R R]4      4       4       tE]$] ! R R]4      4       4       tF]$] ! R R]4      4       4       tG]$] ! R R ]4      4       4       tHRdR! R" lltIReR# R$ lltJR% tK ! R& R']
P˜                  4      tMRfR( R) lltN ! R* R+]
P˜                  4      tO ! R, R-]
P˜                  4      tPR. tQR/ R0 ltR ! R1 R2]
P˜                  4      tS ! R3 R4]
P˜                  4      tT ! R5 R6]
P˜                  4      tUR7 tVR8 tW ! R9 R:]
P˜                  4      tX ! R; R<]4      tY]$]0! RgR=7       ! R> R?]4      4       4       tZ]$ ! R@ RA]Z4      4       t[ ! RB RC]
P˜                  4      t\ ! RD RE]
P˜                  4      t] ! RF RG]
P˜                  4      t^]$! RHRI7       ! RJ RK]Z4      4       t_ ! RL RM]
P˜                  4      t` ! RN RO]
P˜                  4      ta ! RP RQ]
P˜                  4      tb ! RR RS]Z4      tc ! RT RU]
P˜                  4      td ! RV RW]
P˜                  4      te ! RX RY]Z4      tf ! RZ R[]
P˜                  4      tg ! R\ R]]
P˜                  4      th ! R^ R_]
P˜                  4      ti ! R` Ra]Z4      tj ! Rb Rc]Z4      tk. RhOtlR# )ié    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                   ó8   a € ] tR t^Bt o RtRtRtV 3R ltRtV t	R# )ÚSam3VisionEncoderOutputzÄ
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.
Nc                ó‚   <€ V ^8„  d   Qh/ S[ S[P                  R3,          ;R&   S[ S[P                  R3,          ;R&   # )é   .Úfpn_hidden_statesÚfpn_position_encoding)ÚtupleÚtorchÚFloatTensor)ÚformatÚ__classdict__s   "€Úg/home/luca/screen-checking/.venv/lib/python3.14/site-packages/transformers/models/sam3/modeling_sam3.pyÚ__annotate__Ú$Sam3VisionEncoderOutput.__annotate__B   s?   ø‡ ‚ ñ ™U×.Ñ.°Ð3Õ4Ñ;ñ ñ !¡×!2Ñ!2°CÐ!7Õ8Ñ?ò ó    © )
Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r*   r+   Ú__annotate_func__Ú__static_attributes__Ú__classdictcell__©r0   s   @r1   r'   r'   B   s   ø‡ € ñð 8<ÐØ;?Ð÷ ƒ r4   r'   c                   ó8   a € ] tR t^Pt o RtRtRtV 3R ltRtV t	R# )ÚSam3GeometryEncoderOutputaJ  
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.
Nc                óh   <€ V ^8„  d   Qh/ S[ P                  ;R&   S[ P                  R,          ;R&   # )r)   Úlast_hidden_stateNÚattention_mask)r-   r.   Ú
BoolTensor)r/   r0   s   "€r1   r2   Ú&Sam3GeometryEncoderOutput.__annotate__P   s0   ø‡ ‚ ñ ×(Ñ(Ñ/ñ ñ ×$Ñ$ tÕ+Ñ2ò r4   r5   )
r6   r7   r8   r9   r:   rB   rC   r;   r<   r=   r>   s   @r1   r@   r@   P   s   ø‡ € ñð ,0ÐØ.2€N÷ ƒ r4   r@   c                   óH   a € ] tR t^^t o RtRtRtRtRtRt	Rt
V 3R ltRtV tR# )ÚSam3DETREncoderOutputaT  
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.
Nc                ó@  <€ V ^8„  d   Qh/ S[ P                  ;R&   S[ P                  R,          ;R&   S[ P                  R,          ;R&   S[ P                  R,          ;R&   S[S[ P                  ,          R,          ;R&   S[S[ P                  ,          R,          ;R&   # )r)   rB   NÚpos_embeds_flattenedÚtext_featuresÚspatial_shapesÚhidden_statesÚ
attentions)r-   r.   Ú
LongTensorr,   )r/   r0   s   "€r1   r2   Ú"Sam3DETREncoderOutput.__annotate__^   sš   ø‡ ‚ ñ$ ×(Ñ(Ñ/ñ% ñ&  ×+Ñ+¨dÕ2Ñ9ñ' ñ( ×$Ñ$ tÕ+Ñ2ñ) ñ* ×$Ñ$ tÕ+Ñ2ñ+ ñ, ™×*Ñ*Õ+¨dÕ2Ñ9ñ- ñ. ‘e×'Ñ'Õ(¨4Õ/Ñ6ò/ r4   r5   )r6   r7   r8   r9   r:   rB   rI   rJ   rK   rL   rM   r;   r<   r=   r>   s   @r1   rG   rG   ^   s3   ø‡ € ñð ,0ÐØ59ÐØ.2€MØ.2€NØ59€MØ26€J÷/ ƒ r4   rG   c                   óD   a € ] tR t^xt o RtRtRtRtRtRt	V 3R lt
RtV tR# )ÚSam3DETRDecoderOutputaæ  
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).
Nc                óö   <€ V ^8„  d   Qh/ S[ P                  ;R&   S[ P                  ;R&   S[ P                  ;R&   S[S[ P                  ,          R,          ;R&   S[S[ P                  ,          R,          ;R&   # )r)   Úintermediate_hidden_statesÚreference_boxesÚpresence_logitsNrL   rM   ©r-   r.   r,   )r/   r0   s   "€r1   r2   Ú"Sam3DETRDecoderOutput.__annotate__x   sx   ø‡ ‚ ñ  !&× 1Ñ 1Ñ8ñ! ñ" ×&Ñ&Ñ-ñ# ñ$ ×&Ñ&Ñ-ñ% ñ& ™×*Ñ*Õ+¨dÕ2Ñ9ñ' ñ( ‘e×'Ñ'Õ(¨4Õ/Ñ6ò) r4   r5   )r6   r7   r8   r9   r:   rS   rT   rU   rL   rM   r;   r<   r=   r>   s   @r1   rQ   rQ   x   s-   ø‡ € ñð 59ÐØ)-€OØ)-€OØ59€MØ26€J÷) ƒ r4   rQ   c                   ó<   a € ] tR t^�t o RtRtRtRtV 3R ltRt	V t
R# )ÚSam3MaskDecoderOutputa‚  
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.
Nc                ó¦   <€ V ^8„  d   Qh/ S[ P                  ;R&   S[ P                  R,          ;R&   S[S[ P                  ,          R,          ;R&   # )r)   Ú
pred_masksNÚsemantic_segrM   rV   )r/   r0   s   "€r1   r2   Ú"Sam3MaskDecoderOutput.__annotate__�   sM   ø‡ ‚ ñ ×!Ñ!Ñ(ñ ñ ×#Ñ# dÕ*Ñ1ñ ñ ‘e×'Ñ'Õ(¨4Õ/Ñ6ò r4   r5   )r6   r7   r8   r9   r:   r[   r\   rM   r;   r<   r=   r>   s   @r1   rY   rY   �   s"   ø‡ € ñð %)€JØ-1€LØ26€J÷ ƒ r4   rY   c                   ód   a € ] tR t^ t o RtRtRtRtRtRt	Rt
RtRtRtRtRtRtRtV 3R ltRtV tR# )ÚSam3ImageSegmentationOutputa  
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.
Nc                óÄ  <€ V ^8„  d   Qh/ S[ P                  ;R&   S[ P                  ;R&   S[ P                  R,          ;R&   S[ P                  R,          ;R&   S[ P                  R,          ;R&   S[S[ P                  ,          R,          ;R&   S[ P                  R,          ;R&   S[S[ P                  ,          R,          ;R	&   S[S[ P                  ,          R,          ;R
&   S[S[ P                  ,          R,          ;R&   S[S[ P                  ,          R,          ;R&   S[S[ P                  ,          R,          ;R&   S[S[ P                  ,          R,          ;R&   # )r)   r[   Ú
pred_boxesNÚpred_logitsrU   r\   Údecoder_hidden_statesÚdecoder_reference_boxesÚencoder_hidden_statesÚvision_hidden_statesÚvision_attentionsÚdetr_encoder_attentionsÚdetr_decoder_attentionsÚmask_decoder_attentionsrV   )r/   r0   s   "€r1   r2   Ú(Sam3ImageSegmentationOutput.__annotate__    sp  ø‡ ‚ ñF ×!Ñ!Ñ(ñG ñH ×!Ñ!Ñ(ñI ñJ ×"Ñ" TÕ)Ñ0ñK ñL ×&Ñ&¨Õ-Ñ4ñM ñN ×#Ñ# dÕ*Ñ1ñO ñP !¡×!2Ñ!2Õ3°dÕ:ÑAñQ ñR #×.Ñ.°Õ5Ñ<ñS ñT !¡×!2Ñ!2Õ3°dÕ:ÑAñU ñV  ¡× 1Ñ 1Õ2°TÕ9Ñ@ñW ñX ™U×.Ñ.Õ/°$Õ6Ñ=ñY ñZ #¡5×#4Ñ#4Õ5¸Õ<ÑCñ[ ñ\ #¡5×#4Ñ#4Õ5¸Õ<ÑCñ] ñ^ #¡5×#4Ñ#4Õ5¸Õ<ÑCò_ r4   r5   )r6   r7   r8   r9   r:   r[   ra   rb   rU   r\   rc   rd   re   rf   rg   rh   ri   rj   r;   r<   r=   r>   s   @r1   r_   r_       s^   ø‡ € ñð@ %)€JØ$(€JØ,0€KØ04€OØ-1€LØ=AÐØ8<ÐØ=AÐØ<@ÐØ9=ÐØ?CÐØ?CÐØ?CÐ÷_ ƒ r4   r_   c                ód   € V ^8„  d   QhR\         P                  R\        R\         P                  /# )r)   ÚxÚepsÚreturn)r-   r   Úfloat)r/   s   "r1   r2   r2   Ò   s)   € ÷ ñ ”u—|‘|ð ¬%ð ¼5¿<¹<ñ r4   c                ó¶   € V P                  ^ ^R7      p V P                  VR7      p^V ,
          P                  VR7      p\        P                  ! W#,          4      # )z5The inverse function for sigmoid activation function.©ÚminÚmax©rs   )Úclampr-   Úlog)rm   rn   Úx1Úx2s   &&  r1   Úinverse_sigmoidrz   Ò   sI   € à	�‰�A˜1ˆÓ€AØ	
�‰�SˆÓ	€BØ
ˆa�%�‰˜3ˆÓ	€BÜ�9Š9�R•WÓÐr4   c                ó$   € V ^8„  d   QhR\         /# )r)   Úreturn_index)Úbool)r/   s   "r1   r2   r2   Ú   s   € ÷ 34ñ 34ÄDñ 34r4   c                ó‚  € V P                   w  rVpVP                   w  r‰p
YXu;8X  d/   VP                  ^ 4      u;8X  d   VP                  ^ 4      8X  g   Q h Q hWz8X  g   Q hWaP                  ^4      8X  g   Q hW“P                  ^4      8X  g   Q hVP                  RR7      pVP                  RR7      pW¼,           pWi,           p\        P                  ! WâP
                  R7      R,          P                  V^4      VR,          8  p\        P                  ! W^V3VP
                  VP                  R7      pV VRRV1R3&   \        P                  ! W’P
                  R7      R,          P                  V^4      pVVR,          ,           pVP                  ^VR,          P                  RRV4      V4      pV'       d   VVV3# VV3# )	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.
©Údim)ÚdeviceNºNNN©r�   Údtypeéÿÿÿÿ©r‚   N©r‚   r‚   N)ÚshapeÚsizeÚsumr-   Úaranger�   ÚrepeatÚzerosr„   ÚscatterÚexpand)Úseq1Úmask1Úseq2Úmask2r|   Ú
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   &&&&&             r1   Ú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`Ð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ØÐ'¨Õ0Õ0€Eð 2×9Ñ9¸!¸UÀ:Õ=N×=UÑ=UÐVXÐZ\Ð^iÓ=jÐlpÓqÐçØ$Ð&7¸Ð>Ð>à Ð"3Ð3Ð3r4   c                óÖ   € V P                  R4      w  rr4VRV,          ,
          VRV,          ,
          VRV,          ,           VRV,          ,           .p\        P                  ! VRR7      # )zDConvert boxes from (cx, cy, w, h) format to (x1, y1, x2, y2) format.ç      à?r   r…   )Úunbindr-   Ústack)rm   Úx_cÚy_cÚwÚhÚbs   &     r1   Úbox_cxcywh_to_xyxyr«     sR   € à—X‘X˜b“\�N€CˆaØ
��a•�-˜3  q¥�=¨C°#¸µ'­M¸SÀ3ÈÅ7½]ÐL€AÜ�;Š;�q˜bÔ!Ð!r4   c                   óD   a a€ ] tR tRt oV 3R ltV3R lR ltRtVtV ;t# )ÚSam3MLPi  c                ór  <€ \         SV `  4        Wn        \        VP                  ,          V n        \        P                  ! VP                  VP                  4      V n
        \        P                  ! VP                  VP                  4      V n        \        P                  ! VP                  4      V n        R # ©N)ÚsuperÚ__init__Úconfigr   Ú
hidden_actÚactivation_fnÚnnÚLinearr–   Úintermediate_sizeÚfc1Úfc2ÚDropoutÚhidden_dropoutÚdropout©Úselfr²   Ú	__class__s   &&€r1   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ˆŽr4   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# ©r)   rL   ro   ©r-   r   )r/   r0   s   "€r1   r2   ÚSam3MLP.__annotate__   s#   ø€ ÷ ñ ¡U§\¡\ð ±e·l±lñ r4   c                óŽ   € V P                  V4      pV P                  V4      pV P                  V4      pV P                  V4      pV# r¯   )r¸   r¼   r´   r¹   )r¾   rL   s   &&r1   ÚforwardÚSam3MLP.forward   sB   € ØŸ™ Ó/ˆØŸ™ ]Ó3ˆØ×*Ñ*¨=Ó9ˆØŸ™ Ó/ˆØÐr4   )r´   r²   r¼   r¸   r¹   ©	r6   r7   r8   r9   r±   rÆ   r<   r=   Ú__classcell__©r¿   r0   s   @@r1   r­   r­     s   ù‡ € õ9÷÷ ð r4   r­   c                ó  € V ^8„  d   QhR\         P                  R\        P                  R\        P                  R\        P                  R\        P                  R,          R\        R,          R\        R	\
        \        ,          /# )
r)   ÚmoduleÚqueryÚkeyÚvaluerC   NÚscalingr¼   Úkwargs)rµ   ÚModuler-   r   rp   r   r   )r/   s   "r1   r2   r2   (  s{   € ÷ %ñ %Ü�I‰Ið%ä�<‰<ð%ô 
�‰ð%ô �<‰<ð	%ô
 —L‘L 4Õ'ð%ô �T�\ð%ô ð%ô Ô'Õ(ñ%r4   c                 ó¶  € Vf   VP                  R4      R,          p\        P                  ! WP                  ^^4      4      V,          pVe	   W„,           p\        P
                  P                  VRR7      p\        P
                  P                  W†V P                  R7      p\        P                  ! Wƒ4      p	V	P                  ^^4      P                  4       p	W˜3# )Nr   )ÚpÚtrainingr…   ç      à¿)
r‰   r-   ÚmatmulÚ	transposerµ   Ú
functionalÚsoftmaxr¼   rÕ   Ú
contiguous)
rÌ   rÍ   rÎ   rÏ   rC   rÐ   r¼   rÑ   Úattn_weightsÚattn_outputs
   &&&&&&&,  r1   Úeager_attention_forwardrÞ   (  s±   € ð ‚Ø—*‘*˜R“. DÕ(ˆô —<’< §}¡}°Q¸Ó':Ó;¸gÕE€LàÒ!Ø#Õ4ˆä—=‘=×(Ñ(¨¸2Ð(Ó>€LÜ—=‘=×(Ñ(¨È6Ï?É?Ð(Ó[€Lä—,’,˜|Ó3€KØ×'Ñ'¨¨1Ó-×8Ñ8Ó:€KàÐ$Ð$r4   c                   óL   a a€ ] tR tRt oRtV 3R ltRV3R lR lltRtVtV ;t	# )ÚSam3AttentioniD  zT
Multi-head attention.
Handles standard [batch_size, seq_len, hidden_size] tensors.
c                óv  <€ \         SV `  4        Wn        VP                  V n        VP                  V n        V P                  VP                  ,          V n        V P
                  R,          V n        RV n        \        P                  ! V P                  V P                  4      V n
        \        P                  ! V P                  V P                  4      V n        \        P                  ! V P                  V P                  4      V n        \        P                  ! V P                  V P                  4      V n        R# ©r£   FNrÖ   )r°   r±   r²   r–   Únum_attention_headsÚhead_dimrÐ   Ú	is_causalrµ   r¶   Úq_projÚk_projÚv_projÚo_projr½   s   &&€r1   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ˆŽr4   c                óê   <€ V ^8„  d   QhRS[ P                  RS[ P                  RS[ P                  RS[ P                  R,          RS[S[,          RS[S[ P                  S[ P                  3,          /# )r)   rÍ   rÎ   rÏ   rC   NrÑ   ro   )r-   r   r   r   r,   )r/   r0   s   "€r1   r2   ÚSam3Attention.__annotate__X  st   ø€ ÷ <)ñ <)á�|‰|ð<)ñ �\‰\ð<)ñ �|‰|ð	<)ñ
 Ÿ™ tÕ+ð<)ñ Ñ+Õ,ð<)ñ 
‰u�|‰|™UŸ\™\Ð)Õ	*ñ<)r4   c                ó(  € VP                   ^ ,          pVP                   ^,          pVP                   ^,          pV P                  V4      P                  WgV P                  V P                  4      P                  ^^4      pV P                  V4      P                  WhV P                  V P                  4      P                  ^^4      pV P                  V4      P                  WhV P                  V P                  4      P                  ^^4      p\        P                  ! V P                  P                  \        4      p	\        V P                  4      '       dF   VeB   VP                  \        P                   8w  d#   \        R,          p	\"        P%                  R4       V	! V VVV3RVRRRV P&                  RV P(                  /VB w  r«V
P+                  WgV P                  V P                  ,          4      P-                  4       p
V P/                  V
4      p
W«3# )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]
Úsdpaz‡Sam3Attention: falling back to SDPA for relative-position cross-attention because Flash Attention does not support additive bias masks.rC   r¼   ç        rÐ   rå   )rˆ   ræ   Úviewrã   rä   rØ   rç   rè   r   Úget_interfacer²   Ú_attn_implementationrÞ   r   r„   r-   r}   ÚloggerÚwarning_oncerÐ   rå   ÚreshaperÛ   ré   )r¾   rÍ   rÎ   rÏ   rC   rÑ   r”   Ú	query_lenÚkey_lenÚattention_interfacerÝ   rÜ   s   &&&&&,      r1   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 +Ó.ˆàÐ(Ð(r4   )
r²   rä   r–   rå   rç   rã   ré   ræ   rÐ   rè   r¯   ©
r6   r7   r8   r9   r:   r±   rÆ   r<   r=   rÉ   rÊ   s   @@r1   rà   rà   D  s   ù‡ € ñõ
D÷<)÷ <)ò <)r4   rà   c                   óÎ   a a€ ] tR tRt oRt]! RRR7      RV3R lV 3R lll4       t]]! RRR7      RV3R lR	 ll4       4       t]	P                  ! 4       R
 4       tR tRtVtV ;t# )Ú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.
r�   z5.18)Úversionc                ó    <€ V ^8„  d   QhRS[ /# ©r)   r²   ©r%   )r/   r0   s   "€r1   r2   Ú#Sam3ViTRotaryEmbedding.__annotate__   s   ø€ ÷ Oñ O™}ñ Or4   c                óÎ  <€ \         SV `  4        Wn        V P                  P                  R ,          V n        V P
                  pV P                  R8w  d/   \        V P                  P                   RV P                   24      hV! V P                  V4      w  q@n	        \        P                  ! VRR7      V n        \        P                  ! VP                  4       RR7      V n        R# )Ú	rope_typeÚaxialz) supports only axial rope, but requested F©Ú
persistentN)r°   r±   r²   Úrope_parametersr  Úcompute_axial_rope_parametersÚ
ValueErrorr¿   r6   Úattention_scalingrµ   ÚBufferÚinv_freqÚcloneÚoriginal_inv_freq)r¾   r²   r�   Úrope_init_fnr  r¿   s   &&&  €r1   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ˆÖr4   c                óP   <€ V ^8„  d   QhRS[ RS[S[P                  S[3,          /# )r)   r²   ro   )r%   r,   r-   r   rp   )r/   r0   s   "€r1   r2   r  ¯  s.   ø€ ÷ 5ñ 5©mð 5ÑW\Ñ]b×]iÑ]iÑkpÐ]pÕWqñ 5r4   c           	     óB  € V P                   R,          p\        V RR4      ;'       g    V P                  V P                  ,          pV^,          pRpRV\        P
                  ! ^ V^\        P                  R7      V,          ,          ,          pVP                  V4      V3# )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ä   Nç      ð?©r„   )r  Úgetattrr–   rã   r-   r‹   rp   Úto)r²   r�   rÑ   Úbaser€   Úspatial_dimÚattention_factorr  s   &&,     r1   r  Ú4Sam3ViTRotaryEmbedding.compute_axial_rope_parameters­  s‡   € ð ×%Ñ% lÕ3ˆÜ�f˜j¨$Ó/×cÐc°6×3EÑ3EÈ×IcÑIcÕ3cˆØ˜Q•hˆàÐØ˜$¤5§<¢<°°;ÀÌÏÉÔ#UÐXcÕ#cÕdÕeˆØ�{‰{˜6Ó"Ð$4Ð4Ð4r4   c                óZ  € VR,          P                  4       p\        VP                  P                  \        4      '       d2   VP                  P                  R8w  d   VP                  P                  MRp\        VRR7      ;_uu_ 4        W0P                  P                  4       ,          pVP                  4       V P                  ,          pVP                  4       V P                  ,          pRRR4       V P                  X4      pV P                  X4      pWg3#   + '       g   i     L5; i).NÚmpsÚcpuF)Údevice_typeÚenabled).N)rp   Ú
isinstancer�   ÚtypeÚstrr   r  Úcosr
  ÚsinÚrecomposition_frequencies)r¾   rm   Úposition_idsÚposition_ids_expandedr  Úfreqsr$  r%  s   &&&     r1   rÆ   ÚSam3ViTRotaryEmbedding.forwardÁ  sÓ   € ð !-¨YÕ 7× =Ñ =Ó ?ÐÜ'1°!·(±(·-±-Ä×'EÒ'EÈ!Ï(É(Ï-É-Ð[`ÔJ`�a—h‘h—m’mÐfkˆÜ¨¸U×CÖCØ)¯M©M×,?Ñ,?Ó,AÕAˆEØ—)‘)“+ × 6Ñ 6Õ6ˆCØ—)‘)“+ × 6Ñ 6Õ6ˆC÷ Dð
 ×,Ñ,¨SÓ1ˆØ×,Ñ,¨SÓ1ˆØˆxˆ÷ D×Cús   Â
A#DÄD*	c                óŠ   € VR,          VR,          r2\         P                  ! W#.RR7      R,          pVP                  ^RR7      # )zM
Recompose the frequencies into the final spatial layout used per each grid.
r   )r‚   r   )r‚   é   r…   )N.)r-   ÚcatÚrepeat_interleave)r¾   ÚfreqÚfreq_hÚfreq_wÚfreq_hws   &&   r1   r&  Ú0Sam3ViTRotaryEmbedding.recomposition_frequenciesÐ  sA   € ð
 ˜d� T¨$¥Z�Ü—)’)˜VÐ,°"Ô5°iÕ@ˆØ×(Ñ(¨°Ð(Ó3Ð3r4   )r
  r²   r  r  r  r¯   )r6   r7   r8   r9   r:   r   r±   Ústaticmethodr  r-   Úno_gradrÆ   r&  r<   r=   rÉ   rÊ   s   @@r1   rü   rü   ˜  sy   ù‡ € ññ �X vÔ.÷Oô Oó /ðOð Ù�X vÔ.÷5ñ 5ó /ó ð5ð$ ‡]‚]ƒ_ñó ð÷4ò 4r4   rü   c                óÌ   € V P                   ! . V P                  RR ORN^N5!  p V P                  RR7      w  r\        P                  ! V) V3RR7      p V P                  RR7      # )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
```
Nr   )Ú	start_dimr…   éþÿÿÿ)rð   rˆ   r¤   r-   r¥   Úflatten)rm   rx   ry   s   &  r1   Úrotate_pairwiser:  Ú  sb   € ð 	
�ŠÐ$�—‘˜˜�Ð$˜bÐ$ !Ó$€AØ�X‰X˜"ˆXÓ�F€BÜ�Š�b�S˜"�I 2Ô&€AØ�9‰9˜rˆ9Ó"Ð"r4   c                óî   € V ^8„  d   QhR\         P                  R\         P                  R\         P                  R\         P                  R\        \         P                  \         P                  3,          /# )r)   ÚqÚkr$  r%  ro   ©r-   r   r,   )r/   s   "r1   r2   r2   ì  s\   € ÷ 2ñ 2Ü‡|�|ð2ä‡|�|ð2ô 
�‰ð2ô 
�‰ð	2ô
 Œ5�<‰<œŸ™Ð%Õ&ñ2r4   c                ó  € V P                  4       pWB,          \        V4      V,          ,           pVP                  4       pWR,          \        V4      V,          ,           pVP                  V 4      VP                  V4      3# )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
)rp   r:  Útype_as)r<  r=  r$  r%  Úq_embedÚk_embeds   &&&&  r1   Úapply_rotary_pos_emb_2drC  ì  sc   € ð$ �g‰g‹i€GØ�}¤°Ó!9¸CÕ!?Õ@€Gà�g‰g‹i€GØ�}¤°Ó!9¸CÕ!?Õ@€Gà�?‰?˜1Ó˜wŸ™¨qÓ1Ð1Ð1r4   c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚSam3ViTRoPEAttentioni  z-Self-attention with rotary position encoding.c                ó    <€ V ^8„  d   QhRS[ /# rÿ   r   )r/   r0   s   "€r1   r2   Ú!Sam3ViTRoPEAttention.__annotate__
  s   ø€ ÷ Dñ D™}ñ Dr4   c                ó˜  <€ \         SV `  4        Wn        VP                  V n        VP                  V n        V P                  VP                  ,          V n        V P
                  R,          V n        VP                  V n        RV n        \        P                  ! V P                  V P                  4      V n        \        P                  ! V P                  V P                  4      V n        \        P                  ! V P                  V P                  4      V n        \        P                  ! V P                  V P                  4      V n        R# râ   )r°   r±   r²   r–   rã   rä   rÐ   Úattention_dropoutrå   rµ   r¶   ræ   rç   rè   ré   r½   s   &&€r1   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ˆŽr4   c                ó”   <€ V ^8„  d   QhRS[ P                  RS[S[ P                  S[ P                  3,          RS[S[,          RS[/# )r)   rL   Úposition_embeddingsrÑ   ro   )r-   r   r,   r   r   )r/   r0   s   "€r1   r2   rG    sO   ø€ ÷  )ñ  )á—|‘|ð )ñ #¡5§<¡<±·±Ð#=Õ>ð )ñ Ñ+Õ,ð	 )ñ
 
ñ )r4   c                óþ  € VP                   w  rErgWV,          pWHV P                  V P                  3p	V P                  V4      P                  ! V	!  P                  ^^4      p
V P                  V4      P                  ! V	!  P                  ^^4      pV P                  V4      P                  ! V	!  P                  ^^4      pVw  rÞ\        W«WÞR7      w  r«\        P                  ! V P                  P                  \        4      pT! V V
VV3RRRV P                  '       g   RMV P                  RV P                   RV P"                  /VB w  ppVP%                  WEVR4      P'                  4       pV P)                  V4      pVV3# )	r,  )r$  r%  rC   Nr¼   rï   rÐ   rå   r…   )rˆ   rã   rä   ræ   rð   rØ   rç   rè   rC  r   rñ   r²   rò   rÞ   rÕ   rI  rÐ   rå   rõ   rÛ   ré   )r¾   rL   rL  rÑ   r”   ÚheightÚwidthÚ_Úseq_lenÚ	new_shaperÍ   rÎ   rÏ   r$  r%  rø   rÝ   rÜ   s   &&&,              r1   rÆ   ÚSam3ViTRoPEAttention.forward  sx  € ð (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Ð(Ð(r4   )rI  r²   rä   r–   rå   rç   rã   ré   ræ   rÐ   rè   rú   rÊ   s   @@r1   rE  rE    s#   ù‡ € Ù7÷Dó D÷ )÷  )ð  )r4   rE  c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )Ú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.
c                ó    <€ V ^8„  d   QhRS[ /# rÿ   r   )r/   r0   s   "€r1   r2   Ú#Sam3ViTPatchEmbeddings.__annotate__C  s   ø€ ÷ vñ v™}ñ vr4   c                ó¾  <€ \         SV `  4        VP                  VP                  r2VP                  VP
                  rT\        V\        4      '       d   TMW"3p\        V\        4      '       d   TMW33pV^,          V^,          ,          V^ ,          V^ ,          ,          ,          pW n        W0n        W@n        W`n	        \        P                  ! WEW3RR7      V n        R# )r,  F)Úkernel_sizeÚstrideÚbiasN)r°   r±   Úpretrain_image_sizeÚ
patch_sizeÚnum_channelsr–   r!  r   Ú
image_sizeÚnum_patchesrµ   ÚConv2dÚ
projection)r¾   r²   r_  r]  r^  r–   r`  r¿   s   &&     €r1   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ˆŽr4   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# )r)   Úpixel_valuesro   rÃ   )r/   r0   s   "€r1   r2   rW  R  s#   ø€ ÷ ñ ¡E§L¡Lð ±U·\±\ñ r4   c                óÀ   € V P                  VP                  V P                   P                  P                  4      4      P	                  ^4      P                  ^^4      pV# ©r)   )rb  r  Úweightr„   r9  rØ   )r¾   re  Ú
embeddingss   && r1   rÆ   ÚSam3ViTPatchEmbeddings.forwardR  sJ   € Ø—_‘_ \§_¡_°T·_±_×5KÑ5K×5QÑ5QÓ%RÓS×[Ñ[Ð\]Ó^×hÑhÐijÐlmÓnˆ
ØÐr4   )r_  r^  r`  r]  rb  rú   rÊ   s   @@r1   rU  rU  <  s%   ù‡ € ñ÷vó v÷÷ ð r4   rU  c                   ój   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltR
V3R lR lltR	tVt	V ;t
# )Ú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.
c                ó    <€ V ^8„  d   QhRS[ /# rÿ   r   )r/   r0   s   "€r1   r2   ÚSam3ViTEmbeddings.__annotate__^  s   ø€ ÷ 
,ñ 
,™}ñ 
,r4   c                óP  <€ \         SV `  4        \        V4      V n        V P                  P                  p\
        P                  ! \        P                  ! ^W!P                  4      4      V n
        \
        P                  ! VP                  4      V n        VP                  V n        R# )r,  N)r°   r±   rU  Úpatch_embeddingsr`  rµ   Ú	Parameterr-   Úrandnr–   rL  rº   r»   r¼   r]  )r¾   r²   r`  r¿   s   && €r1   r±   ÚSam3ViTEmbeddings.__init__^  sv   ø€ Ü‰ÑÔä 6°vÓ >ˆÔØ×+Ñ+×7Ñ7ˆÜ#%§<¢<Ü�KŠK˜˜;×(:Ñ(:Ó;ó$
ˆÔ ô —z’z &×"7Ñ"7Ó8ˆŒØ ×+Ñ+ˆŽr4   c                óZ   <€ V ^8„  d   QhRS[ P                  RS[RS[RS[ P                  /# )r)   rL  rN  rO  ro   )r-   r   Úint)r/   r0   s   "€r1   r2   rn  j  sA   ø€ ÷ Uñ Uá"Ÿ\™\ðUñ ðUñ ð	Uñ
 
�‰ñUr4   c                ó"  € \        VP                  ^,          R,          4      p\        P                  P	                  4       '       g&   WB8X  d    WC8X  d   VP                  ^W#,          R4      # VP                  R,          pVP                  ^WDV4      P                  ^ ^^^4      pW$,          ^,           pW4,          ^,           pVP                  ^^Wx.4      RRRV1RV13,          pVP                  ^ ^^^4      P                  ^W#,          V4      # )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‚   Nr…   )ru  rˆ   r-   ÚjitÚ
is_tracingrõ   ÚpermuteÚtile)	r¾   rL  rN  rO  Úpretrain_sizer–   Ú	pos_embedÚrepeat_hÚrepeat_ws	   &&&&     r1   Ú_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ÐTr4   c                óT   <€ V ^8„  d   QhRS[ P                  RS[RS[ P                  /# )r)   re  Úinterpolate_pos_encodingro   )r-   r   r}   )r/   r0   s   "€r1   r2   rn  ˆ  s1   ø€ ÷ ñ á—l‘lðñ #'ðñ 
�‰ñ	r4   c                óþ   € VP                   RR w  r4V P                  V4      pW0P                  ,          pW@P                  ,          pV P                  V P                  VV4      pWX,           pV P                  V4      pV# )r)   Nr8  )rˆ   rp  r]  r  rL  r¼   )	r¾   re  r‚  rN  rO  ri  Úheight_patchesÚwidth_patchesrL  s	   &&&      r1   rÆ   ÚSam3ViTEmbeddings.forwardˆ  s€   € ð
 %×*Ñ*¨2¨3Ð/‰ˆØ×*Ñ*¨<Ó8ˆ
ð  §?¡?Õ2ˆØ§¡Õ0ˆà"×<Ñ<Ø×$Ñ$ØØó
Ðð
  Õ5ˆ
Ø—\‘\ *Ó-ˆ
àÐr4   )r¼   rp  r]  rL  ©F)r6   r7   r8   r9   r:   r±   r  rÆ   r<   r=   rÉ   rÊ   s   @@r1   rl  rl  W  s/   ù‡ € ñ÷
,ó 
,÷Uð U÷<÷ ò r4   rl  c           	     ó˜  € V P                   w  r#rEWV,          ,
          V,          pWV,          ,
          V,          p\        P                  P                  V ^ ^ ^ V^ V34      p W6,           WG,           r˜V P	                  W(V,          WV,          W4      p V P                  ^ ^^^^^4      P                  4       P	                  RWV4      p
W¨V	33# )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Ù   Úpadrð   ry  rÛ   )Úhidden_stateÚwindow_sizer”   rN  rO  r^  Ú
pad_heightÚ	pad_widthÚpadded_heightÚpadded_widthÚwindowss   &&         r1   Úwindow_partitionr‘  Ÿ  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Ð1r4   c                ó`  € Vw  rEVw  rgV P                   ^ ,          WE,          V,          V,          ,          pV P                  W„V,          WQ,          WR4      p	V	P                  ^ ^^^^^4      P                  4       p	V	P                  W„VR4      p	V	RRV1RV1R3,          P                  4       p	V	# )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‚   Nr…   )rˆ   rð   ry  rÛ   )
r�  r‹  Úpad_height_widthÚheight_widthrŽ  r�  rN  rO  r”   rŠ  s
   &&&&      r1   Úwindow_unpartitionr•  ¾  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ØÐr4   c                   óP   a a€ ] tR tRt oV3R lV 3R lltV3R lR ltRtVtV ;t# )ÚSam3ViTLayerScaleiÝ  c                ó   <€ V ^8„  d   QhRR/# )r)   ro   Nr5   )r/   r0   s   "€r1   r2   ÚSam3ViTLayerScale.__annotate__Þ  s   ø€ ÷ dñ d $ñ dr4   c                ó¸   <€ \         SV `  4        \        P                  ! VP                  \
        P                  ! VP                  4      ,          4      V n        R # r¯   )	r°   r±   rµ   rq  Úlayer_scale_init_valuer-   Úonesr–   Úlambda1r½   s   &&€r1   r±   ÚSam3ViTLayerScale.__init__Þ  s8   ø€ Ü‰ÑÔÜ—|’| F×$AÑ$AÄEÇJÂJÈv×OaÑOaÓDbÕ$bÓcˆŽr4   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# )r)   rŠ  ro   rÃ   )r/   r0   s   "€r1   r2   r™  â  s#   ø€ ÷ +ñ +¡E§L¡Lð +±U·\±\ñ +r4   c                ó&   € WP                   ,          # r¯   ©r�  )r¾   rŠ  s   &&r1   rÆ   ÚSam3ViTLayerScale.forwardâ  s   € ØŸl™lÕ*Ð*r4   r¡  rÈ   rÊ   s   @@r1   r—  r—  Ý  s    ù‡ € ÷dó d÷+÷ +ð +r4   r—  c                   ót   a a€ ] tR tRt oRtR
V3R lV 3R lllt]V3R lR l4       tV3R lR ltR	t	Vt
V ;t# )ÚSam3ViTLayeriæ  zYVision Transformer layer with rotary position embeddings and optional windowed attention.c                ó*   <€ V ^8„  d   QhRS[ RS[RR/# )r)   r²   r‹  ro   N©r%   ru  )r/   r0   s   "€r1   r2   ÚSam3ViTLayer.__annotate__é  s'   ø€ ÷ Fñ F™}ð F¹3ð FÀtñ Fr4   c                óò  <€ \         SV `  4        Wn        VP                  p\        P
                  ! W1P                  R 7      V n        \        V4      V n	        \        V4      V n        \        P
                  ! W1P                  R 7      V n        \        V4      V n        \        P                  ! VP                   4      V n        W n        V P'                  W4      p\        P(                  ! VRR7      V n        R# )©rn   Fr  N)r°   r±   r²   r–   rµ   Ú	LayerNormÚlayer_norm_epsÚlayer_norm1rü   Ú
rotary_embrE  Ú	attentionÚlayer_norm2r­   Úmlprº   r»   r¼   r‹  Úprecompute_positionsr  r'  )r¾   r²   r‹  r–   r'  r¿   s   &&&  €r1   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ˆÖr4   c                ó&   <€ V ^8„  d   QhRS[ RS[/# )r)   r²   r‹  r¦  )r/   r0   s   "€r1   r2   r§  ú  s   ø€ ÷ ñ ¡]ð Áñ r4   c                óz  € V^ 8”  d   W3pMˆV P                   p\        V\        \        34      '       d   TMW33pV P                  p\        V\        \        34      '       d   TMWD3pV^,          V^,          ,          V^ ,          V^ ,          ,          3p\
        P                  ! \
        P                  ! V^ ,          4      \
        P                  ! V^,          4      RR7      w  rV\
        P                  ! VP                  4       VP                  4       .RR7      pWpP                  V^,          ,          ,          pV# )r   Úij)Úindexingr   r…   )r_  r!  Úlistr,   r]  r-   Úmeshgridr‹   r¥   r9  r‹  )r²   r‹  Úhw_gridr_  r]  Úhpos_idsÚwpos_idsr'  s   &&      r1   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ˆØÐr4   c                ód   <€ V ^8„  d   QhRS[ P                  RS[S[,          RS[ P                  /# )r)   rL   rÑ   ro   ©r-   r   r   r   )r/   r0   s   "€r1   r2   r§    s7   ø€ ÷ ñ á—|‘|ðñ Ñ+Õ,ðñ 
�‰ñ	r4   c                ó   € TpV P                  V4      pV P                  ^ 8”  d=   VP                  ^,          VP                  ^,          rT\        WP                  4      w  rV P	                  WP
                  4      pV P                  ! W3/ VB w  rV P                  ^ 8”  d   \        WP                  XXX34      pW1,           pTpV P                  V4      pV P                  V4      pW0P                  V4      ,           pV# ©r   )r¬  r‹  rˆ   r‘  r­  r'  r®  r•  r¯  r°  r¼   )	r¾   rL   rÑ   ÚresidualrN  rO  r“  rL  rP  s	   &&,      r1   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ˆØŸ™ Ó/ˆØ §<¡<°Ó#>Õ>ˆàÐr4   )	r®  r²   r¼   r¬  r¯  r°  r'  r­  r‹  rÀ  )r6   r7   r8   r9   r:   r±   r4  r±  rÆ   r<   r=   rÉ   rÊ   s   @@r1   r¤  r¤  æ  s7   ù‡ € Ùc÷Fõ Fð  ÷ó ð÷*÷ ð r4   r¤  )Úbackendsc                   óV   a a€ ] tR tRt o]tRtRtRR.tRt	Rt
RtRtV 3R ltRtVtV ;t# )	ÚSam3PreTrainedModeli-  Úsam3re  ÚimageÚtextTc                ó‚  <€ \         SV `  V4       \        V\        4      '       d:   \        P
                  ! VP                  R V P                  P                  R7       R# \        V\        4      '       dJ   VP                  VP                  VP                  4      p\        P                  ! VP                  V4       R# R# )rï   )ÚmeanÚstdN)r°   Ú_init_weightsr!  rl  ÚinitÚnormal_rL  r²   Úinitializer_ranger¤  r±  r‹  Úcopy_r'  )r¾   rÌ   r'  r¿   s   && €r1   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ñ .r4   r5   )r6   r7   r8   r9   r   Úconfig_classÚbase_model_prefixÚmain_input_nameÚinput_modalitiesÚ_supports_sdpaÚ_supports_flash_attnÚ_supports_flex_attnÚ_supports_attention_backendrÌ  r<   r=   rÉ   rÊ   s   @@r1   rÅ  rÅ  -  sC   ù‡ € ð €LØÐØ$€OØ Ð(ÐØ€NØÐØÐØ"&Ð÷:õ :r4   rÅ  c                   ó¦   a a€ ] tR tRt oR]R]/tV3R lV 3R lltV3R lR lt]	]
! RR	7      ]V3R
 lR l4       4       4       tV3R ltRtVtV ;t# )ÚSam3ViTModeliB  rL   rM   c                ó    <€ V ^8„  d   QhRS[ /# rÿ   r   )r/   r0   s   "€r1   r2   ÚSam3ViTModel.__annotate__J  s   ø€ ÷ ñ ™}ñ r4   c           
     ó¨  <€ \         SV `  V4       Wn        \        V4      V n        \
        P                  ! VP                  VP                  R 7      V n	        \
        P                  ! \        VP                  4       Uu. uF,  p\        YVP                  9  d   VP                  M^ R7      NK.  	  up4      V n        V P#                  4        R# u upi )r©  )r‹  N)r°   r±   r²   rl  ri  rµ   rª  r–   r«  Ú
layer_normÚ
ModuleListÚrangeÚnum_hidden_layersr¤  Úglobal_attn_indexesr‹  ÚlayersÚ	post_init)r¾   r²   Úir¿   s   && €r1   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   Á?2Cc                ó    <€ V ^8„  d   QhRS[ /# )r)   ro   )rU  )r/   r0   s   "€r1   r2   rÝ  W  s   ø€ ÷ 0ñ 0Ñ&<ñ 0r4   c                ó.   € V P                   P                  # r¯   )ri  rp  ©r¾   s   &r1   Úget_input_embeddingsÚ!Sam3ViTModel.get_input_embeddingsW  s   € Ø�‰×/Ñ/Ð/r4   F)Útie_last_hidden_statesc                óP   <€ V ^8„  d   QhRS[ P                  RS[S[,          RS[/# ©r)   re  rÑ   ro   )r-   r   r   r   r   )r/   r0   s   "€r1   r2   rÝ  ]  s8   ø€ ÷ @ñ @á—l‘lð@ñ Ñ+Õ,ð@ñ 
ñ	@r4   c                óð  € V P                  V4      pVP                  ^ ,          pVP                  R,          V P                  P                  ,          pVP                  R,          V P                  P                  ,          pVP                  R,          pVP	                  WEWg4      pV P                  V4      pV P                   F  pV! V3/ VB pK  	  VP	                  WEV,          V4      p\        VR7      # )r   )rB   r8  r…   )ri  rˆ   r²   r]  rð   rß  rä  r   )	r¾   re  rÑ   rL   r”   rN  rO  r–   Úlayers	   &&,      r1   rÆ   ÚSam3ViTModel.forwardZ  sÒ   € ð Ÿ™¨Ó5ˆà"×(Ñ(¨Õ+ˆ
Ø×#Ñ# BÕ'¨4¯;©;×+AÑ+AÕAˆØ×"Ñ" 2Õ&¨$¯+©+×*@Ñ*@Õ@ˆØ#×)Ñ)¨"Õ-ˆð &×*Ñ*¨:¸uÓRˆàŸ™¨Ó6ˆØ—[”[ˆEÙ! -Ñ:°6Ñ:ŠMñ !ð &×*Ñ*¨:Àµ~À{ÓSˆä°Ô?Ð?r4   c                ó&   <€ V ^8„  d   Qh/ S[ ;R&   # rÿ   r   )r/   r0   s   "€r1   r2   rÝ  B  s   ø‡ ‚ áÑò r4   )r²   ri  rß  rä  )r6   r7   r8   r9   r¤  rE  Ú_can_record_outputsr±   rë  r   r   r   rÆ   r;   r<   r=   rÉ   rÊ   s   @@r1   rÛ  rÛ  B  s`   ù‡ € ð 	˜ØÐ*ðÐ÷
ó ÷0ð 0ð  Ù¨EÔ2Ø÷@ó ó 3ó  ð@÷7 … r4   rÛ  c                   ó¸   a a€ ] tR tRt oRtRV3R lV 3R llltV3R lR ltV3R lR lt]]	! ^R	7      RV3R
 lR ll4       4       t
RV3R lR lltRtVtV ;t# )Ú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.
c          	      ó@   <€ V ^8„  d   QhRS[ RS[ RS[RS[R,          /# )r)   Únum_position_featuresÚtemperatureÚ	normalizeÚscaleN)ru  r}   rp   )r/   r0   s   "€r1   r2   Ú&Sam3SinePositionEmbedding.__annotate__|  s7   ø€ ÷ =ñ =á"ð=ñ ð=ñ ð	=ñ
 �t�|ñ=r4   c                óÄ   <€ \         SV `  4        Ve   VRJ d   \        R4      hWn        W n        W0n        Vf   ^\        P                  ,          V n        R # TV n        R # )NFz+normalize should be True if scale is passed)	r°   r±   r	  rø  rù  rú  ÚmathÚpirû  )r¾   rø  rù  rú  rû  r¿   s   &&&&&€r1   r±   Ú"Sam3SinePositionEmbedding.__init__|  sS   ø€ ô 	‰ÑÔØÒ ¨eÓ!3ÜÐJÓKÐKØ%:Ô"Ø&ÔØ"ŒØ$)¢M�QœŸ™•[ˆŽ
°uˆŽ
r4   c                ó’   <€ V ^8„  d   QhRS[ P                  RS[ P                  RS[S[ P                  S[ P                  3,          /# )r)   rm   Úyro   r>  )r/   r0   s   "€r1   r2   rü  ‹  s?   ø€ ÷ ñ ¡U§\¡\ð ±e·l±lð ÁuÉUÏ\É\Ñ[`×[gÑ[gÐMgÕGhñ r4   c                óè  € WP                   ,          pW P                   ,          p\        P                  ! V P                  \        P                  VP
                  R7      P                  VP                  4      pV P                  ^V^,          ,          V P                  ,          ,          pVR,          V,          pVR,          V,          p\        P                  ! VR,          P                  4       VR,          P                  4       3^R7      P                  ^4      p\        P                  ! VR,          P                  4       VR,          P                  4       3^R7      P                  ^4      pWg3# )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
©r„   r�   r   r†   )r‚   ºr   Nr)   )r‚   ºr,  Nr)   )rû  r-   r‹   rø  Úint64r�   r  r„   rù  r¥   r%  r$  r9  )r¾   rm   r  Úx_embedÚy_embedÚdim_tÚpos_xÚpos_ys   &&&     r1   Ú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ˆà˜Õ  5Õ(ˆØ˜Õ  5Õ(ˆÜ—’˜U 7�^×/Ñ/Ó1°5¸µ>×3EÑ3EÓ3GÐHÈaÔP×XÑXÐYZÓ[ˆÜ—’˜U 7�^×/Ñ/Ó1°5¸µ>×3EÑ3EÓ3GÐHÈaÔP×XÑXÐYZÓ[ˆØˆ|Ðr4   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# )r)   Úboxesro   rÃ   )r/   r0   s   "€r1   r2   rü  ¢  s#   ø€ ÷ ñ ¡%§,¡,ð ±5·<±<ñ r4   c                ó¢  € VP                  R4      ^8X  g   Q RVP                   24       h\        P                  ! V P                  \        P
                  VP                  R7      P                  VP                  4      pV P                  ^\        P                  ! V^RR7      ,          V P                  ,          ,          pVR,          V P                  ,          pVR,          V P                  ,          pVR	,          V P                  ,          pVR
,          V P                  ,          pVR,          V,          pVR,          V,          pVR,          V,          p	VR,          V,          p
\        P                  ! VR,          P                  4       VR,          P                  4       3^R7      P                  ^4      p\        P                  ! VR,          P                  4       VR,          P                  4       3^R7      P                  ^4      p\        P                  ! V	R,          P                  4       V	R,          P                  4       3^R7      P                  ^4      p	\        P                  ! V
R,          P                  4       V
R,          P                  4       3^R7      P                  ^4      p
\        P                   ! W‡Wš3^R7      pV# )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]
z4Expected 4D box coordinates (x, y, w, h), got shape r  Úfloor©Úrounding_moder   r…   )r‚   r‚   r   )r‚   r‚   r,  )r‚   r‚   r)   )r‚   r‚   é   r‡   )r‚   r‚   r  )r‚   r‚   r  )r‰   rˆ   r-   r‹   rø  r  r�   r  r„   rù  Údivrû  r¥   r%  r$  r9  r-  )r¾   r  r
  r  r	  Úw_embedÚh_embedr  r  Úpos_wÚpos_hÚposs   &&          r1   Ú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ˆà˜•. 4§:¡:Õ-ˆØ˜•. 4§:¡:Õ-ˆØ˜•. 4§:¡:Õ-ˆØ˜•. 4§:¡:Õ-ˆà˜
Õ# eÕ+ˆØ˜
Õ# eÕ+ˆØ˜
Õ# eÕ+ˆØ˜
Õ# eÕ+ˆä—’˜U :Õ.×2Ñ2Ó4°e¸JÕ6G×6KÑ6KÓ6MÐNÐTUÔV×^Ñ^Ð_`ÓaˆÜ—’˜U :Õ.×2Ñ2Ó4°e¸JÕ6G×6KÑ6KÓ6MÐNÐTUÔV×^Ñ^Ð_`ÓaˆÜ—’˜U :Õ.×2Ñ2Ó4°e¸JÕ6G×6KÑ6KÓ6MÐNÐTUÔV×^Ñ^Ð_`ÓaˆÜ—’˜U :Õ.×2Ñ2Ó4°e¸JÕ6G×6KÑ6KÓ6MÐNÐTUÔV×^Ñ^Ð_`Óaˆä�iŠi˜ uÐ4¸!Ô<ˆàˆ
r4   ©Úmaxsizec                óà   <€ V ^8„  d   QhRS[ P                  RS[ P                  S[,          RS[ P                  RS[RS[RS[R,          RS[R	S[ P                  R,          R
S[ P                  /	# )r)   rˆ   r�   r„   rø  rú  rû  Nrù  Úmaskro   )	r-   ÚSizer�   r#  r„   ru  r}   rp   r   )r/   r0   s   "€r1   r2   rü  Å  s…   ø€ ÷ (ñ (Ù�z‰zð(á—‘™sÕ"ð(ñ �{‰{ð(ñ  #ð	(ñ
 ð(ñ �t�|ð(ñ ð(ñ �l‰l˜TÕ!ð(ñ 
�‰ñ(r4   c                ó¤  € V w  r‰r«Vfp   \         P                  ! ^V
^,           W!R7      R,          P                  WŠV4      p\         P                  ! ^V^,           W!R7      R,          P                  WŠV4      pM3VP                  V4      pVP	                  ^4      pVP	                  ^4      pV'       dG   RpWÌRR	R 1R3,          V,           ,          V,          pWÝRRR	R 13,          V,           ,          V,          p\         P                  ! V\         P
                  VR7      P                  V4      pV^\         P                  ! V^RR7      ,          V,          ,          pVR
,          V,          pVR
,          V,          p\         P                  ! VR,          P                  4       VR,          P                  4       3^R7      P                  ^4      p\         P                  ! VR,          P                  4       VR,          P                  4       3^R7      P                  ^4      p\         P                  ! VV3^R7      P                  ^ ^^^4      pV# )Nr  r‚   g�íµ ÷Æ°>r  r  r   )Nr‚   N)NNr‚   r…   )r‚   r‚   r‚   N)r‚   r‚   r‚   r  )r‚   r‚   r‚   r  )r-   r‹   r�   r  Úcumsumr  r  r¥   r%  r$  r9  r-  ry  )rˆ   r�   r„   rø  rú  rû  rù  r!  r”   rP  rN  rO  r	  r  Ú
embed_maskrn   r
  r  r  r  s   &&&&&&&&            r1   Úbuild_sine_position_embeddingÚ7Sam3SinePositionEmbedding.build_sine_position_embeddingÃ  së  € ð (-Ñ$ˆ
�vØŠ<ô —l’l 1 f¨q¥j¸ÔMÈmÕ\×cÑcØ EóˆGô —l’l 1 e¨a¥i°uÔLÈ]Õ[×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ˆà˜Õ&¨Õ.ˆØ˜Õ&¨Õ.ˆÜ—’˜U =Õ1×5Ñ5Ó7¸¸}Õ9M×9QÑ9QÓ9SÐTÐZ[Ô\×dÑdÐefÓgˆÜ—’˜U =Õ1×5Ñ5Ó7¸¸}Õ9M×9QÑ9QÓ9SÐTÐZ[Ô\×dÑdÐefÓgˆÜ�iŠi˜ ˜¨AÔ.×6Ñ6°q¸!¸QÀÓBˆØˆ
r4   c          
      óº   <€ V ^8„  d   QhRS[ P                  RS[ P                  S[,          RS[ P                  RS[ P
                  R,          RS[ P
                  /# )r)   rˆ   r�   r„   r!  Nro   )r-   r"  r�   r#  r„   r   )r/   r0   s   "€r1   r2   rü  ï  s[   ø€ ÷ 	
ñ 	
á�z‰zð	
ñ —‘™sÕ"ð	
ñ �{‰{ð		
ñ
 �l‰l˜TÕ!ð	
ñ 
�‰ñ	
r4   c           
     ó~   € V P                  WW0P                  V P                  V P                  V P                  V4      # r¯   )r&  rø  rú  rû  rù  )r¾   rˆ   r�   r„   r!  s   &&&&&r1   rÆ   Ú!Sam3SinePositionEmbedding.forwardï  s:   € ð ×1Ñ1Ø˜5×"<Ñ"<¸d¿n¹nÈdÏjÉjÐZ^×ZjÑZjÐlpó
ð 	
r4   )rú  rø  rû  rù  )é@   é'  FN)FNr,  Nr¯   )r6   r7   r8   r9   r:   r±   r  r  r4  r   r&  rÆ   r<   r=   rÉ   rÊ   s   @@r1   rö  rö  v  s_   ù‡ € ñ÷
=õ =÷ð ÷.ð ðB Ù(°Ô3÷(ñ (ó 4ó ð(÷T	
÷ 	
ò 	
r4   rö  c                   óP   a a€ ] tR tRt oV3R lV 3R lltV3R lR ltRtVtV ;t# )ÚSam3FPNLayeriû  c                ó,   <€ V ^8„  d   QhRS[ RS[ RS[/# )r)   Úin_channelsÚfpn_dimÚscale_factor)ru  rp   )r/   r0   s   "€r1   r2   ÚSam3FPNLayer.__annotate__ü  s'   ø€ ÷ dñ d¡Cð d±#ð dÁUñ dr4   c           	     óˆ  <€ \         SV `  4        W0n        \        P                  ! 4       V n        VR 8X  d³   V P
                  P                  \        P                  ! W^,          ^^R7      4       V P
                  P                  \        P                  ! 4       4       V P
                  P                  \        P                  ! V^,          V^,          ^^R7      4       V^,          pMžVR8X  dD   V P
                  P                  \        P                  ! W^,          ^^R7      4       V^,          pMTVR8X  d   TpMJVR8X  d5   V P
                  P                  \        P                  ! ^^R7      4       TpM\        RV R24      h\        P                  ! WB^R7      V n        \        P                  ! W"^^R7      V n        R	# )
g      @)rY  rZ  g       @r  r£   zscale_factor=z is not supported yet.)r0  Úout_channelsrY  )r0  r5  rY  ÚpaddingN)r°   r±   r2  rµ   rà  Úscale_layersÚappendÚConvTranspose2dÚGELUÚ	MaxPool2dÚNotImplementedErrorra  Úproj1Úproj2)r¾   r0  r1  r2  Úintermediate_channelsr¿   s   &&&& €r1   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ˆŽ
r4   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# rÂ   rÃ   )r/   r0   s   "€r1   r2   r3    s#   ø€ ÷ ñ ¡U§\¡\ð ±e·l±lñ r4   c                óÞ   € VP                  V P                  P                  P                  4      pV P                   F  pV! V4      pK  	  V P                  V4      pV P                  V4      pV# r¯   )r  r=  rh  r„   r7  r>  )r¾   rL   rñ  s   && r1   rÆ   ÚSam3FPNLayer.forward  s`   € Ø%×(Ñ(¨¯©×):Ñ):×)@Ñ)@ÓAˆØ×&Ô&ˆEÙ! -Ó0ŠMñ 'ð Ÿ
™
 =Ó1ˆØŸ
™
 =Ó1ˆàÐr4   )r=  r>  r2  r7  rÈ   rÊ   s   @@r1   r.  r.  û  s    ù‡ € ÷dó d÷4÷ ð r4   r.  c                   óP   a a€ ] tR tRt oV3R lV 3R lltV3R lR ltRtVtV ;t# )ÚSam3VisionNecki!  c                ó    <€ V ^8„  d   QhRS[ /# rÿ   ©r$   )r/   r0   s   "€r1   r2   ÚSam3VisionNeck.__annotate__"  s   ø€ ÷ 
ñ 
Ñ/ñ 
r4   c                ó>  <€ \         SV `  4        Wn        \        VP                  ^,          RR7      V n        \        P                  ! VP                   Uu. uF/  p\        VP                  P                  VP                  VR7      NK1  	  up4      V n        R# u upi )r)   T©rø  rú  )r0  r1  r2  N)r°   r±   r²   rö  Úfpn_hidden_sizeÚposition_encodingrµ   rà  Úscale_factorsr.  Úbackbone_configr–   Ú
fpn_layers)r¾   r²   rû  r¿   s   && €r1   r±   ÚSam3VisionNeck.__init__"  s�   ø€ Ü‰ÑÔØŒä!:Ø"(×"8Ñ"8¸AÕ"=Èô"
ˆÔô
 Ÿ-š-ð
 $×1Ò1ó	ñ 2�Eô Ø &× 6Ñ 6× BÑ BÈF×LbÑLbÐqv÷ñ 2ñ	ó
ˆŽùòs   Á5Bc                ó    <€ V ^8„  d   QhRS[ P                  RS[S[S[ P                  R3,          S[S[ P                  R3,          3,          /# )r)   rL   ro   .r>  )r/   r0   s   "€r1   r2   rH  4  sK   ø€ ÷ 8ñ 8¡U§\¡\ð 8±e¹EÁ%Ç,Á,ÐPSÐBSÕ<TÑV[Ñ\a×\hÑ\hÐjmÐ\mÕVnÐ<nÕ6oñ 8r4   c                óÌ   € RpRpV P                    FN  pV! V4      pW%3,          pV P                  VP                  VP                  VP                  4      pW63,          pKP  	  W#3# )Nr5   )rO  rL  rˆ   r�   r„   )r¾   rL   r*   r+   Ú	fpn_layerÚ
fpn_outputÚpos_encs   &&     r1   rÆ   ÚSam3VisionNeck.forward4  sn   € ØÐØ "ÐàŸœˆIÙ" =Ó1ˆJØ Õ.Ðà×,Ñ,¨Z×-=Ñ-=¸z×?PÑ?PÐR\×RbÑRbÓcˆGØ! ZÕ/Ò!ñ )ð !Ð7Ð7r4   )r²   rO  rL  rÈ   rÊ   s   @@r1   rE  rE  !  s   ù‡ € ÷
ó 
÷$8÷ 8ð 8r4   rE  zJ
    The vision model from Sam without any head or projection on top.
    )Úcustom_introc                   ól   a a€ ] tR tRt o]tRtV3R lV 3R lltR t]	R	V3R lR ll4       t
RtVtV ;t# )
ÚSam3VisionModeliB  re  c                ó    <€ V ^8„  d   QhRS[ /# rÿ   rG  )r/   r0   s   "€r1   r2   ÚSam3VisionModel.__annotate__K  s   ø€ ÷ ñ Ñ/ñ r4   c                ó¼   <€ \         SV `  V4       Wn        \        P                  ! VP
                  4      V n        \        V4      V n        V P                  4        R # r¯   )
r°   r±   r²   r   Úfrom_configrN  ÚbackbonerE  Úneckrå  r½   s   &&€r1   r±   ÚSam3VisionModel.__init__K  sC   ø€ Ü‰Ñ˜Ô ØŒÜ!×-Ò-¨f×.DÑ.DÓEˆŒÜ" 6Ó*ˆŒ	à�‰Ör4   c                ó6   € V P                   P                  4       # r¯   )r^  rë  rê  s   &r1   rë  Ú$Sam3VisionModel.get_input_embeddingsS  s   € Ø�}‰}×1Ñ1Ó3Ð3r4   c                ón   <€ V ^8„  d   QhRS[ P                  R,          RS[S[,          RS[S[,          /# )r)   re  NrÑ   ro   )r-   r.   r   r   r,   r'   )r/   r0   s   "€r1   r2   r[  W  s@   ø€ ÷ 
ñ 
á×'Ñ'¨$Õ.ð
ñ Ñ+Õ,ð
ñ 
Ñ(Õ	(ñ	
r4   c                ó  € Vf   \        R4      hV P                  ! V3/ VB pVP                  pVP                  ^ ,          pVP                  R,          V P                  P
                  P                  ,          pVP                  R,          V P                  P
                  P                  ,          pVP                  WVVR4      P                  ^ ^^^4      pV P                  V4      w  rš\        VV	V
VP                  VP                  R7      # )Nz You have to specify pixel_values)rB   r*   r+   rL   rM   r8  r…   )r	  r^  rB   rˆ   r²   rN  r]  rð   ry  r_  r'   rL   rM   )r¾   re  rÑ   Úbackbone_outputrL   r”   rN  rO  Úhidden_states_spatialr*   r+   s   &&,        r1   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ô
ð 	
r4   )r^  r²   r_  r¯   )r6   r7   r8   r9   r$   rÒ  rÔ  r±   rë  r   rÆ   r<   r=   rÉ   rÊ   s   @@r1   rY  rY  B  s>   ù‡ € ð $€LØ$€O÷ó ò4ð ÷
ñ 
ó ÷
ð 
r4   rY  c                   óP   a a€ ] tR tRt oV3R lV 3R lltV3R lR ltRtVtV ;t# )ÚSam3GeometryEncoderLayerir  c                ó    <€ V ^8„  d   QhRS[ /# rÿ   ©r"   )r/   r0   s   "€r1   r2   Ú%Sam3GeometryEncoderLayer.__annotate__s  s   ø€ ÷ 
<ñ 
<Ñ8ñ 
<r4   c                ó¬  <€ \         SV `  4        \        P                  ! VP                  4      V n        \        V4      V n        \        P                  ! VP                  4      V n	        \        V4      V n
        \        P                  ! VP                  4      V n        \        V4      V n        \        P                  ! VP                  4      V n        R # r¯   )r°   r±   rµ   rª  r–   r¬  rà   Ú	self_attnrº   r¼   Ú
cross_attnr¯  r­   r°  Úlayer_norm3r½   s   &&€r1   r±   Ú!Sam3GeometryEncoderLayer.__init__s  sŠ   ø€ Ü‰ÑÔÜŸ<š<¨×(:Ñ(:Ó;ˆÔÜ& vÓ.ˆŒÜ—z’z &§.¡.Ó1ˆŒä'¨Ó/ˆŒÜŸ<š<¨×(:Ñ(:Ó;ˆÔä˜6“?ˆŒÜŸ<š<¨×(:Ñ(:Ó;ˆÖr4   c                óH   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ RS[S[,          /# )r)   Úprompt_featsÚvision_featsÚvision_pos_encodingÚprompt_maskrÑ   ©r   r   r   )r/   r0   s   "€r1   r2   rl    sC   ø€ ÷ ñ áðñ ðñ $ð	ñ
 ðñ Ñ+Õ,ñr4   c                ó¦  € TpV P                  V4      pV P                  ! RR VRVRVRV/VB w  rxV P                  V4      V,           pTpV P                  V4      pW#,           p	V P                  ! RR VRV	RV/VB w  rxV P                  V4      V,           pTpV P                  V4      pV P                  V4      pV P                  V4      V,           pV# )rÍ   rÎ   rÏ   rC   r5   ©r¬  rn  r¼   r¯  ro  rp  r°  )
r¾   rs  rt  ru  rv  rÑ   rÁ  rL   rP  rÎ   s
   &&&&&,    r1   rÆ   Ú Sam3GeometryEncoderLayer.forward  s÷   € ð  ˆØ×(Ñ(¨Ó6ˆØŸ>š>ñ 
Øð
Ø%2ð
Ø:Gð
ØXcð
Øgmñ
Ñˆð Ÿ™ ]Ó3°hÕ>ˆØ ˆØ×(Ñ(¨Ó7ˆØÕ0ˆØŸ?š?Ñf°ÐfÀCÐfÈ|ÐfÐ_eÑfÑˆØŸ™ ]Ó3°hÕ>ˆØ ˆØ×(Ñ(¨Ó7ˆØŸ™ Ó/ˆØŸ™ ]Ó3°hÕ>ˆàÐr4   )ro  r¼   r¬  r¯  rp  r°  rn  rÈ   rÊ   s   @@r1   ri  ri  r  s   ù‡ € ÷
<ó 
<÷÷ ð r4   ri  c                   óp   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltR tRV3R lR	 lltR
t	Vt
V ;t# )Ú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.
c                ó    <€ V ^8„  d   QhRS[ /# rÿ   rk  )r/   r0   s   "€r1   r2   Ú Sam3GeometryEncoder.__annotate__¦  s   ø€ ÷ @ñ @Ñ8ñ @r4   c                óX  <€ \         SV `  4        Wn        VP                  V n        VP                  V n        \        VP                  ^,          RR7      V n        \        P                  ! ^V P                  4      V n	        \        P                  ! ^V P                  4      V n
        \        P                  ! ^V P                  4      V n        \        P                  ! V P                  V P                  V P                  4      V n        \        P                  ! V P                  ^,           V P                  4      V n        \        P                   ! V P                  4      V n        \        P                  ! V P                  V P                  4      V n        \        P                   ! V P                  4      V n        \        P(                  ! \+        VP,                  4       Uu. uF  p\/        V4      NK  	  up4      V n        \        P                   ! V P                  4      V n        R# u upi )r)   TrJ  N)r°   r±   r²   r–   Úroi_sizerö  rL  rµ   Ú	EmbeddingÚlabel_embedÚ	cls_embedr¶   Úboxes_direct_projectra  Úboxes_pool_projectÚboxes_pos_enc_projectrª  Úvision_layer_normÚ
final_projÚprompt_layer_normrà  rá  Ú
num_layersri  rä  Úoutput_layer_norm©r¾   r²   rP  r¿   s   && €r1   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'c          
      óœ   <€ V ^8„  d   QhRS[ P                  RS[ P                  RS[ P                  RS[ P                  RS[ P                  /# )r)   Úcenter_xÚcenter_yrO  rN  ro   rÃ   )r/   r0   s   "€r1   r2   r~  Â  sK   ø€ ÷ ñ ÙŸ™ðÙ05·±ðÙEJÇ\Á\ðÙ[`×[gÑ[gðá	�‰ñr4   c                ó’   € V P                   P                  W4      w  rV\        P                  ! WeVR,          VR,          3^R7      pV# )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]
r   r†   )rL  r  r-   r-  )r¾   r�  r�  rO  rN  r  r  r  s   &&&&&   r1   Ú_encode_box_coordinatesÚ+Sam3GeometryEncoder._encode_box_coordinatesÂ  s@   € ð ×-Ñ-×AÑAÀ(ÓU‰ˆÜ�iŠi˜ v¨g¥¸¸g½ÐGÈQÔOˆØˆ
r4   c                ón  € VP                   R,          w  rVVP                   RR w  rxV P                  V4      p	\        V4      p
\        P                  ! W‡W‡.V
P
                  V
P                  R7      pVP                  ^^^4      pW«,          p
VP
                  \        P                  8X  d   \        P                  MVP
                  p\        P                  P                  VP                  V4      V
P                  V4      P                  ^ 4      V P                  4      P                  VP
                  4      pV P!                  V4      pVP                  WVV P"                  4      pWž,           p	VP                  R4      w  ppppV P%                  VP'                  4       VP'                  4       VP'                  4       VP'                  4       4      pVP                  WVVP                   R,          4      pV P)                  V4      pV	V,           p	V P+                  VP-                  4       4      pVV	,           V3# )z?Encode box prompts. Mask convention: True=valid, False=padding.:Nr)   NNr  r8  r…   )rˆ   r„  r«   r-   Útensorr„   r�   rð   Úbfloat16Úfloat16ÚtorchvisionÚopsÚ	roi_alignr  r¤   r€  r…  r–   r’  r9  r†  r‚  Úlong)r¾   r  Ú
boxes_maskÚboxes_labelsÚvision_featuresr”   Ú	num_boxesrN  rO  Úboxes_embedÚ
boxes_xyxyrû  r„   Úsampled_featuresÚpooled_projectionr�  r�  Ú	box_widthÚ
box_heightrU  Úpos_projectionr‚  s   &&&&&                 r1   Ú_encode_boxesÚ!Sam3GeometryEncoder._encode_boxesÕ  sà  € à %§¡¨B¥Ñˆ
Ø'×-Ñ-¨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Ð4r4   c                óÒ   <€ V ^8„  d   QhRS[ P                  RS[ P                  RS[ P                  RS[S[ P                  R3,          RS[S[ P                  R3,          R,          /# )r)   Úbox_embeddingsÚbox_maskÚ
box_labelsÚ	img_feats.Úimg_pos_embedsNr>  )r/   r0   s   "€r1   r2   r~  ù  sq   ø€ ÷ D
ñ D
áŸ™ðD
ñ —,‘,ðD
ñ —L‘Lð	D
ñ
 ™Ÿ™ sÐ*Õ+ðD
ñ ™eŸl™l¨CÐ/Õ0°4Õ7ñD
r4   c                óÀ  € VP                   ^ ,          pVR,          pVe
   VR,          M\        P                  ! V4      pVP                  ^4      P	                  ^^4      p	VP                  ^4      P	                  ^^4      p
VR,          pVP                  ^ ^^^4      pV P                  V4      pVP                  ^ ^^^4      pV P                  WW<4      w  rÞV P                  P                  P                  ^V P                  4      P                  ^ 4      P                  VRR4      p\        P                  ! V^VP                  VP                   R7      p\#        WÞVV4      w  rÞV P%                  V P'                  V4      4      pRpVe   \)        V P*                  VVR7      pV P,                   F  pV! VV	V
VR7      pK  	  V P/                  V4      p\1        VVR7      # )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.
Nr  )r²   Úinputs_embedsrC   )rs  rt  ru  rv  )rB   rC   r…   )rˆ   r-   Ú
zeros_liker9  rØ   ry  r‡  r§  rƒ  rh  rð   r–   Ú	unsqueezer�   rœ  r„   r�   r¡   r‰  rˆ  r	   r²   rä  r‹  r@   )r¾   rª  r«  r¬  r­  r®  r”   rt  Úvision_pos_embedsÚvision_feats_flatÚvision_pos_embeds_flatÚimg_feats_lastÚnormalized_img_featsÚprompt_embedsrv  rƒ  Úcls_maskÚprompt_attention_maskrñ  s   &&&&&&             r1   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ñ !ð ×.Ñ.¨}Ó=ˆä(Ø+Ø&ô
ð 	
r4   )r„  r…  r†  rƒ  r²   rˆ  r–   r‚  rä  r‹  rL  r‰  r€  r‡  r¯   )r6   r7   r8   r9   r:   r±   r’  r§  rÆ   r<   r=   rÉ   rÊ   s   @@r1   r|  r|  š  s8   ù‡ € ñ	÷@ó @÷8ð ò&"5÷HD
÷ D
ò D
r4   r|  c                   óX   a a€ ] tR tRt oRtV3R lV 3R lltRV3R lR lltRtVtV ;t	# )	ÚSam3DetrEncoderLayeri@  z;DETR encoder layer with self-attention and cross-attention.c                ó    <€ V ^8„  d   QhRS[ /# rÿ   ©r!   )r/   r0   s   "€r1   r2   Ú!Sam3DetrEncoderLayer.__annotate__C  s   ø€ ÷ <ñ <Ñ4ñ <r4   c                ó¸  <€ \         SV `  4        Wn        \        P                  ! VP
                  4      V n        \        V4      V n        \        P                  ! VP                  4      V n
        \        V4      V n        \        P                  ! VP
                  4      V n        \        V4      V n        \        P                  ! VP
                  4      V n        R # r¯   )r°   r±   r²   rµ   rª  r–   r¬  rà   rn  rº   r¼   ro  r¯  r­   r°  rp  r½   s   &&€r1   r±   ÚSam3DetrEncoderLayer.__init__C  s�   ø€ Ü‰ÑÔØŒÜŸ<š<¨×(:Ñ(:Ó;ˆÔÜ& vÓ.ˆŒÜ—z’z &§.¡.Ó1ˆŒä'¨Ó/ˆŒÜŸ<š<¨×(:Ñ(:Ó;ˆÔä˜6“?ˆŒÜŸ<š<¨×(:Ñ(:Ó;ˆÖr4   c                óV   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ R,          RS[S[,          /# )r)   rt  rs  ru  Úprompt_cross_attn_maskNrÑ   rw  )r/   r0   s   "€r1   r2   rÀ  P  sG   ø€ ÷ 3ñ 3áð3ñ ð3ñ $ð	3ñ
 !'¨¥ð3ñ Ñ+Õ,ñ3r4   c                ó¦  € TpV P                  V4      pWs,           pV P                  ! RRVRVRV/VB w  ryV P                  V4      V,           pTpV P                  V4      pV P                  ! RRVRVRVRV/VB w  ryV P                  V4      V,           pTpV P                  V4      pV P                  V4      pV P                  V4      V,           pV# )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Ï   rC   r5   ry  )
r¾   rt  rs  ru  rÄ  rÑ   rÁ  rL   Úhidden_states_with_posrP  s
   &&&&&,    r1   rÆ   ÚSam3DetrEncoderLayer.forwardP  s  € ð*  ˆØ×(Ñ(¨Ó6ˆØ!.Õ!DÐØŸ>š>ñ 
Ø(ð
à&ð
ð  ð
ð ñ	
Ñˆð Ÿ™ ]Ó3°hÕ>ˆð !ˆØ×(Ñ(¨Ó7ˆàŸ?š?ñ 
Øð
àð
ð ð
ð 2ð	
ð
 ñ
Ñˆð Ÿ™ ]Ó3°hÕ>ˆð !ˆØ×(Ñ(¨Ó7ˆØŸ™ Ó/ˆØŸ™ ]Ó3°hÕ>ˆàÐr4   )r²   ro  r¼   r¬  r¯  rp  r°  rn  r¯   rú   rÊ   s   @@r1   r½  r½  @  s!   ù‡ € ÙE÷<ó <÷3÷ 3ò 3r4   r½  c                   óŠ   a a€ ] tR tRt oRtR]R]/tV3R lV 3R lltV3R lR lt	]
]RV3R	 lR
 ll4       4       tRtVtV ;t# )Ú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.
rL   rM   c                ó    <€ V ^8„  d   QhRS[ /# rÿ   r¿  )r/   r0   s   "€r1   r2   ÚSam3DetrEncoder.__annotate__“  s   ø€ ÷ ñ Ñ4ñ r4   c                ó  <€ \         SV `  V4       Wn        VP                  V n        \        P
                  ! \        VP                  4       Uu. uF  p\        V4      NK  	  up4      V n	        V P                  4        R # u upi r¯   )r°   r±   r²   r–   rµ   rà  rá  rŠ  r½  rä  rå  rŒ  s   && €r1   r±   ÚSam3DetrEncoder.__init__“  sf   ø€ Ü‰Ñ˜Ô ØŒØ!×-Ñ-ˆÔä—m’mÌ5ÐQW×QbÑQbÔKcÓ$dÑKcÀaÔ%9¸&Ö%AÑKcÑ$dÓeˆŒà�‰Öùò %es   ÁBc                ón   <€ V ^8„  d   QhRS[ S[P                  ,          RS[ S[P                  ,          /# )r)   rž  r³  ©r·  r-   r   )r/   r0   s   "€r1   r2   rË  œ  s1   ø€ ÷ (
ñ (
á™eŸl™lÕ+ð(
ñ  ¡§¡Õ-ñ(
r4   c                ó  € . p. p. p\        W4       FŒ  w  rgVP                  RR w  r‰VP                  W‰34       VP                  ^4      P	                  ^^4      pVP                  ^4      P	                  ^^4      pVP                  V4       VP                  V4       KŽ  	  \
        P                  ! V^R7      p\
        P                  ! V^R7      p\
        P                  ! V\
        P                  VP                  R7      pVVV3# )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
Nr   r  r8  )
Úziprˆ   r8  r9  rØ   r-   r-  r•  r›  r�   )
r¾   rž  r³  Úfeatures_flattenedrI   rK   Úfeaturesr|  rN  rO  s
   &&&       r1   Ú_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ˆð Ø Øð
ð 	
r4   c                ó$  <€ V ^8„  d   QhRS[ S[P                  ,          RS[P                  RS[ S[P                  ,          R,          RS[P                  R,          RS[ S[S[S[3,          ,          R,          RS[S[,          RS[S[,          /# )	r)   rž  rJ   r³  NÚ	text_maskÚspatial_sizesrÑ   ro   )r·  r-   r   r,   ru  r   r   rG   )r/   r0   s   "€r1   r2   rË  È  s“   ø€ ÷ =
ñ =
á™eŸl™lÕ+ð=
ñ —|‘|ð=
ñ  ¡§¡Õ-°Õ4ð	=
ñ
 —<‘< $Õ&ð=
ñ ™E¡#¡s (�OÕ,¨tÕ3ð=
ñ Ñ+Õ,ð=
ñ 
Ñ&Õ	&ñ=
r4   c           
     óZ  € V^ ,          P                  4       ^8X  d   V^ ,          P                  ^ ,          MV^ ,          P                  ^,          pVer   \        V4       Fb  w  pw  ršW,          P                  WšVR4      P	                  ^^^ ^4      W&   W8,          P                  WšVR4      P	                  ^^^ ^4      W8&   Kd  	  V P                  W4      w  pppRpVe   \        V P                  VVVR7      pTpV P                   F  pV! V3RVRVRV/VB pK  	  \        VVVVR7      # )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.
N©r²   r°  rC   re   rs  ru  rÄ  )rB   rI   rJ   rK   r…   )
r€   rˆ   Ú	enumeraterõ   ry  rÔ  r	   r²   rä  rG   )r¾   rž  rJ   r³  r×  rØ  rÑ   r”   ræ  rN  rO  rÒ  rI   rK   rÄ  rL   rñ  s   &&&&&&,          r1   rÆ   ÚSam3DetrEncoder.forwardÆ  so  € ð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Ù!Øñà*ðð %9ðð (>ð	ð
 ñŠMñ !ô %Ø+Ø!5Ø'Ø)ô	
ð 	
r4   )r²   r–   rä  )NNN)r6   r7   r8   r9   r:   r½  rà   rô  r±   rÔ  r   r   rÆ   r<   r=   rÉ   rÊ   s   @@r1   rÉ  rÉ  †  sZ   ù‡ € ñð 	Ð-Ø�mðÐ÷
ó ÷(
ð (
ðT  Ø÷=
ñ =
ó ó  ÷=
ð =
r4   rÉ  c                   óX   a a€ ] tR tRt oRtRV3R lV 3R llltV3R lR ltRtVtV ;t	# )	ÚSam3DecoderMLPi  z/Simple 2 or 3-layer MLP for decoder components.c                ó2   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ /# )r)   Ú	input_dimÚ
hidden_dimÚ
output_dimrŠ  )ru  )r/   r0   s   "€r1   r2   ÚSam3DecoderMLP.__annotate__  s0   ø€ ÷ Pñ P¡#ð P±3ð PÁCð PÑUXñ Pr4   c                ó|  <€ \         SV `  4        V^8X  d@   \        P                  ! W4      V n        \        P                  ! W#4      V n        RV n        R# V^8X  dT   \        P                  ! W4      V n        \        P                  ! W"4      V n        \        P                  ! W#4      V n        R# \        RV 24      h)r)   Nz"Only 2 or 3 layers supported, got )r°   r±   rµ   r¶   Úlayer1Úlayer2Úlayer3r	  )r¾   rà  rá  râ  rŠ  r¿   s   &&&&&€r1   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ÐOr4   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# )r)   rm   ro   rÃ   )r/   r0   s   "€r1   r2   rã    s#   ø€ ÷ ñ ™Ÿ™ð ©%¯,©,ñ r4   c                óþ   € \         P                  ! V P                  V4      4      pV P                  e9   \         P                  ! V P	                  V4      4      pV P                  V4      pV# V P	                  V4      pV# r¯   )ÚFÚrelurå  rç  ræ  )r¾   rm   s   &&r1   rÆ   ÚSam3DecoderMLP.forward  s`   € Ü�FŠF�4—;‘;˜q“>Ó"ˆØ�;‰;Ò"Ü—’�t—{‘{ 1“~Ó&ˆAØ—‘˜A“ˆAð ˆð —‘˜A“ˆAØˆr4   )rå  ræ  rç  rg  rú   rÊ   s   @@r1   rÞ  rÞ    s#   ù‡ € Ù9÷Põ P÷÷ ð r4   rÞ  c                   óX   a a€ ] tR tRt oRtV3R lV 3R lltRV3R lR lltRtVtV ;t	# )	ÚSam3DetrDecoderLayeri"  zYDETR decoder layer with self-attention, text cross-attention, and vision cross-attention.c                ó    <€ V ^8„  d   QhRS[ /# rÿ   ©r    )r/   r0   s   "€r1   r2   Ú!Sam3DetrDecoderLayer.__annotate__%  s   ø€ ÷ 6ñ 6Ñ4ñ 6r4   c                ó   <€ \         SV `  4        Wn        \        V4      V n        \
        P                  ! VP                  4      V n        \
        P                  ! VP                  4      V n        \        V4      V n        \
        P                  ! VP                  4      V n        \
        P                  ! VP                  4      V n        \        V4      V n        \
        P                  ! VP                  4      V n        \
        P                  ! VP                  4      V n        \%        V4      V n        \
        P                  ! VP                  4      V n        \
        P                  ! VP                  4      V n        R # r¯   )r°   r±   r²   rà   rn  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   &&€r1   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ˆÖr4   c                ó  <€ V ^8„  d   QhRS[ P                  RS[ P                  RS[ P                  RS[ P                  RS[ P                  RS[ P                  R,          RS[ P                  R,          R	S[S[,          R
S[ P                  /	# )r)   rL   Ú	query_posrJ   rž  ru  Útext_cross_attn_maskNÚvision_cross_attn_maskrÑ   ro   r¾  )r/   r0   s   "€r1   r2   rò  8  s    ø€ ÷ Lñ Lá—|‘|ðLñ —<‘<ðLñ —|‘|ð	Lñ
 Ÿ™ðLñ #Ÿ\™\ðLñ $Ÿl™l¨TÕ1ðLñ !&§¡¨tÕ 3ðLñ Ñ+Õ,ðLñ 
�‰ñLr4   c                ó”  € \         P                  ! VRR^ R7      pTp	W,           p
V P                  ! R	RV
RV
RVRR/VB w  r¼W�P                  V4      ,           pV P	                  V4      pTp	W,           p
V P
                  ! R	RV
RVRVRV/VB w  r¼W�P                  V4      ,           pV P                  V4      pTp	W,           p
WE,           pV P                  ! R	RV
RVRVRV/VB w  r¼W�P                  V4      ,           pV P                  V4      pTp	V P                  V4      pW�P                  V4      ,           pV P                  V4      pV# )
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)
Úconstant©ÚmoderÏ   rÍ   rÎ   rÏ   rC   N©r   r   r,  r   r5   )rë  r‰  rn  rô  rõ  rö  r÷  rø  rù  rú  rû  r°  rý  rü  )r¾   rL   r   rJ   rž  ru  r  r  rÑ   rÁ  Úquery_with_posrÝ   rP  Úkey_with_poss   &&&&&&&&,     r1   rÆ   ÚSam3DetrDecoderLayer.forward8  s¸  € ô6 —E’E˜) \¸
È!ÔLˆ	ð !ˆØ&Õ2ˆØŸšñ 
Ø ð
àð
ð  ð
ð  ð	
ð
 ñ
‰ˆð !×#9Ñ#9¸+Ó#FÕFˆØ×1Ñ1°-Ó@ˆð !ˆØ&Õ2ˆà×-Ò-ñ 
Ø ð
àð
ð  ð
ð 0ð	
ð
 ñ
‰ˆð !×#?Ñ#?ÀÓ#LÕLˆØ×7Ñ7¸ÓFˆð !ˆØ&Õ2ˆØ&Õ<ˆØ×/Ò/ñ 
Ø ð
àð
ð "ð
ð 2ð	
ð
 ñ
‰ˆð !×#AÑ#AÀ+Ó#NÕNˆØ×9Ñ9¸-ÓHˆð !ˆØŸ™ Ó/ˆØ ×#3Ñ#3°MÓ#BÕBˆØ×+Ñ+¨MÓ:ˆàÐr4   )r²   r°  rý  rü  rn  rô  rõ  rö  r÷  rø  rù  rú  rû  ©NNrú   rÊ   s   @@r1   rï  rï  "  s$   ù‡ € Ùc÷6ó 6÷&L÷ Lò Lr4   rï  c                   ó´   a a€ ] tR tRt oRtR]R]/tV3R lV 3R llt]	! ^R7      V3R lR	 l4       t
V3R
 lR lt]]RV3R lR ll4       4       tRtVtV ;t# )Ú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
rL   rM   c                ó    <€ V ^8„  d   QhRS[ /# rÿ   rñ  )r/   r0   s   "€r1   r2   ÚSam3DetrDecoder.__annotate__—  s   ø€ ÷ ñ á%ñr4   c                ó”  <€ \         SV `  V4       Wn        VP                  V n        \        P
                  ! \        VP                  4       Uu. uF  p\        V4      NK  	  up4      V n	        \        P                  ! VP                  4      V n        \        VP                  VP                  ^^4      V n        \        P                  ! VP                  VP                  4      V n        \        P                  ! VP                  ^4      V n        \        P                  ! ^VP                  4      V n        \        VP                  VP                  ^^4      V n        \        P                  ! VP                  4      V n        RV n        \        ^VP                  ,          VP                  VP                  ^4      V n        \        ^VP                  VP.                  ^4      V n        \        ^VP                  VP.                  ^4      V n        \5        VP                  ^,          RR7      V n        V P9                  4        R# u upi )é   g      $@FrJ  N)r°   r±   r²   r–   rµ   rà  rá  rŠ  rï  rä  rª  r‹  rÞ  Úbox_headr�  Ú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ö  rL  rå  rŒ  s   && €r1   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   ÁIr  c                óÆ   <€ V ^8„  d   QhRS[ P                  RS[ P                  RS[ P                  RS[ P                  RS[S[ P                  S[ P                  3,          /# )r)   rN  rO  r„   r�   ro   )r-   r   r„   r�   r,   )r/   r0   s   "€r1   r2   r  ¹  sY   ø€ ÷ "ñ "Ù—l‘lð"Ù+0¯<©<ð"Ù@EÇÁð"ÙUZ×UaÑUað"á	‰u�|‰|™UŸ\™\Ð)Õ	*ñ"r4   c                óˆ   € \         P                  ! ^ WVR7      V,          p\         P                  ! ^ W$VR7      V,          pWV3# )z%Generate normalized coordinate grids.rƒ   )r-   r‹   )r¾   rN  rO  r„   r�   Úcoords_hÚcoords_ws   &&&&&  r1   Ú_get_coordsÚSam3DetrDecoder._get_coords¸  s;   € ô
 —<’<  6ÀÔFÈÕOˆÜ—<’<  5¸uÔEÈÕMˆØÐ!Ð!r4   c                ó’   <€ V ^8„  d   QhRS[ P                  RS[S[ P                  S[ P                  3,          RS[ P                  /# )r)   rT   Úspatial_shapero   r>  )r/   r0   s   "€r1   r2   r  Á  sB   ø€ ÷ -ñ -Ù$Ÿ|™|ð-Ù<AÁ%Ç,Á,ÑPU×P\ÑP\ÐB\Õ<]ð-á	�‰ñ-r4   c                ód  € Vw  r4\        V4      pVP                  w  rgpV P                  W4VP                  VP                  R7      w  ršV	P                  ^R^4      VP                  R^^4      R,          ,
          pVP                  WgR^4      pV
P                  ^R^4      VP                  R^^4      R,          ,
          pVP                  WgR^4      pV^,          p\        P                  ! V4      \        P                  ! \        P                  ! V4      R,           4      ,          \        P                  ! ^4      ,          pV^,          p\        P                  ! V4      \        P                  ! \        P                  ! V4      R,           4      ,          \        P                  ! ^4      ,          pV P                  V4      pV P                  V4      pVP                  ^4      VP                  ^4      ,           pVP                  ^^4      pVP!                  ^ ^^^4      P#                  4       pV# )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  r…   )r‚   r‚   :r,  r  r)   )r‚   r‚   :r   r  r)   )r«   rˆ   r"  r„   r�   rð   rõ   r-   ÚsignÚlog2Úabsrþ  r  r  r²  r9  ry  rÛ   )r¾   rT   r%  rN  rO  r¡  r”   r  rP  r   r!  Údeltas_yÚdeltas_xÚdeltas_x_logÚdeltas_y_logÚ
rpb_matrixs   &&&             r1   Ú_get_rpb_matrixÚSam3DetrDecoder._get_rpb_matrixÁ  sÞ  € ð &‰ˆÜ'¨Ó8ˆ
Ø%/×%5Ñ%5Ñ"ˆ
 ð "×-Ñ-Ø ×!6Ñ!6¸×?UÑ?Uð .ó 
Ñˆð
 —=‘=  B¨Ó*¨Z×-?Ñ-?ÀÀAÀqÓ-IÈ+Õ-VÕVˆØ—=‘= ¸"¸aÓ@ˆØ—=‘=  B¨Ó*¨Z×-?Ñ-?ÀÀAÀqÓ-IÈ+Õ-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×>Ñ>Ó@ˆ
ØÐr4   c                óä   <€ V ^8„  d   QhRS[ P                  RS[ P                  RS[ P                  RS[ P                  R,          RS[ P                  R,          RS[S[,          RS[S[,          /# )	r)   rž  rJ   ru  r×  NrK   rÑ   ro   )r-   r   r   r   r,   rQ   )r/   r0   s   "€r1   r2   r  ò  s„   ø€ ÷ c
ñ c
áŸ™ðc
ñ —|‘|ðc
ñ #Ÿ\™\ð	c
ñ
 —<‘< $Õ&ðc
ñ Ÿ™ tÕ+ðc
ñ Ñ+Õ,ðc
ñ 
Ñ&Õ	&ñc
r4   c                ó>  € VP                   ^ ,          pV P                  P                  P                  ^ 4      P	                  VRR4      pV P
                  P                  P                  ^ 4      P	                  VRR4      p	V	P                  4       p	V P                  P                  P                  ^ 4      P	                  VRR4      p
\        P                  ! W¨.^R7      pRpVe   \        V P                  VVVR7      p. pV	.p. pV P                   EF¶  pV	P                  ^4      pV P                  P                  VR,          4      pV P                  V4      pRpVeW   VP                   ^ ,          ^8X  d?   VR,          VR,          3pV P!                  V	V4      p\"        P$                  ! VRR^ R7      pV! V3RVRVRVR	VR
VRV/VB pVR,          p\'        V	4      pV P)                  V P+                  V4      4      pVV,           P                  4       pVP-                  4       p	VP/                  V P+                  V4      4       VP/                  V4       VR,          pV P1                  V P3                  V4      4      P5                  R4      pVP7                  V P8                  ) V P8                  R7      pVP/                  V4       EK¹  	  \        P:                  ! V4      p\        P:                  ! VRR 4      p\        P:                  ! V4      p\=        VVVR7      # )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   NrÚ  r  r  r   rJ   rž  ru  r  r  rr   )rS   rT   rU   r…   )r‚   r‚   r   r‚   )r   r   )r   r,  r  )r‚   :r,  NN)r‚   :Nr,  N)rˆ   r  rh  r²  r�   r  Úsigmoidr  r-   r-  r	   r²   rä  rL  r  r  r/  rë  r‰  rz   r  r‹  Údetachr8  r  r  Úsqueezerv   r  r¥   rQ   )r¾   rž  rJ   ru  r×  rK   rÑ   r”   Úquery_embedsrT   r  rL   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_hiddenrU   s   &&&&&&,                      r1   rÆ   ÚSam3DetrDecoder.forwardð  s3  € ð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ÐZdÕCeÓfÐØ×+Ñ+Ð,<Ó=ˆIð &*Ð"ØÒ)¨n×.BÑ.BÀ1Õ.EÈÔ.JØ!/°Õ!5°~ÀdÕ7KÐ L�Ø!×1Ñ1°/À=ÓQ�
ä)*¯ª¨z¸<ÈjÐ`aÔ)bÐ&á!Øñ	à#ð	ð ,ð	ð !0ð		ð
 %8ð	ð &:ð	ð (>ð	ð ñ	ˆMð #0°Õ"6Ðô .=¸_Ó-MÐ*ØŸ-™-¨×(>Ñ(>Ð?RÓ(SÓTˆKØ#.Ð1OÕ#O×"XÑ"XÓ"ZÐØ1×8Ñ8Ó:ˆOà ×'Ñ'¨×(>Ñ(>Ð?RÓ(SÔTØ×%Ñ%Ð&9Ô:ð ,¨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ô
ð 	
r4   )r  r  r  r  r²   r–   rä  r‹  rL  r  r  r  r  r  r  r  )r6   r7   r8   r9   r:   rï  rà   rô  r±   r   r"  r/  r   r   rÆ   r<   r=   rÉ   rÊ   s   @@r1   r  r  ‡  sx   ù‡ € ñð 	Ð-Ø�mðÐ÷
ó ñB )°Ô3÷"ó 4ð"÷-ð -ð^  Ø÷c
ñ c
ó ó  ÷c
ð c
r4   r  c                   ój   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltR
V3R lR lltR	tVt	V ;t
# )Ú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.
c                ó    <€ V ^8„  d   QhRS[ /# rÿ   ©r   )r/   r0   s   "€r1   r2   Ú"Sam3DotProductScoring.__annotate__^  s   ø€ ÷ "ñ "™zñ "r4   c                óJ  <€ \         SV `  4        Wn        VP                  P                  pVP                  P                  p\        VVP                  P                  V^R7      V n        \        P                  ! VP                  P                  4      V n        \        P                  ! V4      V n        \        P                  ! W#4      V n        \        P                  ! W#4      V n        \#        R\$        P&                  ! V4      ,          4      V n        RV n        RV n        R# )r)   )rà  rá  râ  rŠ  r  Tg      (@N)r°   r±   r²   Údetr_decoder_configr–   rÞ  r·   Útext_mlprµ   rº   r¼   Útext_mlp_dropoutrª  Útext_mlp_out_normr¶   Ú	text_projÚ
query_projrp   ÚnpÚsqrtrû  Úclamp_logitsÚclamp_max_val)r¾   r²   r–   Úprojection_dimr¿   s   &&  €r1   r±   ÚSam3DotProductScoring.__init__^  sÙ   ø€ Ü‰ÑÔØŒØ×0Ñ0×<Ñ<ˆØ×3Ñ3×?Ñ?ˆä&Ø!Ø×1Ñ1×CÑCØ"Øô	
ˆŒô !#§
¢
¨6×+EÑ+E×+MÑ+MÓ NˆÔÜ!#§¢¨kÓ!:ˆÔô Ÿš ;Ó?ˆŒÜŸ)š) KÓ@ˆŒô ˜3¤§¢¨Ó!8Õ8Ó9ˆŒ
ð !ˆÔØ!ˆÖr4   c                óv   <€ V ^8„  d   QhRS[ P                  RS[ P                  R,          RS[ P                  /# )r)   rJ   r×  Nro   rÃ   )r/   r0   s   "€r1   r2   rF  x  s7   ø€ ÷ ñ ±·±ð É%Ï,É,ÐY]ÕJ]ð Ñbg×bnÑbnñ r4   c                ó  € Vf   VP                  ^R7      # VP                  VP                  4      P                  R4      pVP	                  ^R7      P                  RR7      pW,          P	                  ^R7      V,          pV# )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   r  ru   r…   )rÊ  r  r„   r²  rŠ   rv   )r¾   rJ   r×  Úis_validÚ	num_validÚpooled_texts   &&&   r1   Ú_pool_text_featuresÚ)Sam3DotProductScoring._pool_text_featuresx  s€   € ð Òà ×%Ñ%¨!Ð%Ó,Ð,à—<‘< × 3Ñ 3Ó4×>Ñ>¸rÓBˆð —L‘L Q�LÓ'×-Ñ-°#Ð-Ó6ˆ	ð %Õ/×4Ñ4¸Ð4Ó;¸iÕGˆàÐr4   c                ó�   <€ V ^8„  d   QhRS[ P                  RS[ P                  RS[ P                  R,          RS[ P                  /# )r)   rc   rJ   r×  Nro   rÃ   )r/   r0   s   "€r1   r2   rF  ‘  sH   ø€ ÷ "ñ "á$Ÿ|™|ð"ñ —|‘|ð"ñ —<‘< $Õ&ð	"ñ
 
�‰ñ"r4   c                óê  € TpV P                  V4      pV P                  V4      pW$,           pV P                  V4      pV P                  W#4      pV P	                  V4      pV P                  V4      pVP                  R4      p\        P                  ! WvP                  ^ 4      4      pW€P                  ,          pV P                  '       d)   VP                  V P                  ) V P                  R7      pV# )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]
rr   r…   )rI  rJ  rK  rY  rL  rM  r²  r-   r×   rû  rP  rv   rQ  )	r¾   rc   rJ   r×  Úorig_text_featuresrX  Ú	proj_textÚproj_queriesÚscoress	   &&&&     r1   rÆ   ÚSam3DotProductScoring.forward‘  sÔ   € ð" +ÐØŸ™ mÓ4ˆØ×-Ñ-¨mÓ<ˆØ%Õ:ˆØ×.Ñ.¨}Ó=ˆà×.Ñ.¨}ÓHˆà—N‘N ;Ó/ˆ	Ø—‘Ð'<Ó=ˆà×'Ñ'¨Ó+ˆ	Ü—’˜l×,?Ñ,?ÀÓ,BÓCˆØŸ*™*Õ$ˆØ××ÐØ—\‘\ t×'9Ñ'9Ð&9¸t×?QÑ?Q�\ÓRˆFàˆr4   )	rP  rQ  r²   rM  rû  rI  rJ  rK  rL  r¯   )r6   r7   r8   r9   r:   r±   rY  rÆ   r<   r=   rÉ   rÊ   s   @@r1   rC  rC  X  s-   ù‡ € ñ÷
"ó "÷4ð ÷2"÷ "ò "r4   rC  c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚSam3MaskEmbedderi¶  z\
MLP that embeds object queries for mask prediction.
Similar to MaskFormer's mask embedder.
c                ó    <€ V ^8„  d   QhRS[ /# rÿ   ©r#   )r/   r0   s   "€r1   r2   ÚSam3MaskEmbedder.__annotate__¼  s   ø€ ÷ $ñ $Ñ4ñ $r4   c                ó0  <€ \         SV `  4        Wn        VP                  p\        P
                  ! \        P                  ! W"4      \        P                  ! W"4      \        P                  ! W"4      .4      V n        \        P                  ! 4       V n	        R # r¯   )
r°   r±   r²   r–   rµ   rà  r¶   rä  ÚReLUÚ
activation©r¾   r²   r–   r¿   s   && €r1   r±   ÚSam3MaskEmbedder.__init__¼  sf   ø€ Ü‰ÑÔØŒØ×(Ñ(ˆä—m’mä—	’	˜+Ó3Ü—	’	˜+Ó3Ü—	’	˜+Ó3ðó
ˆŒô Ÿ'š'›)ˆŽr4   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# )r)   Úqueriesro   rÃ   )r/   r0   s   "€r1   r2   rf  Ê  s#   ø€ ÷ ñ ™uŸ|™|ð ±·±ñ r4   c                ó¾   € Tp\        V P                  4       FA  w  r4V! V4      pV\        V P                  4      ^,
          8  g   K0  V P                  V4      pKC  	  V# )z‘
Args:
    queries: Query embeddings [batch_size, num_queries, hidden_size]

Returns:
    Mask embeddings [batch_size, num_queries, hidden_size]
)rÛ  rä  Úlenri  )r¾   rm  rL   ræ  rñ  s   &&   r1   rÆ   ÚSam3MaskEmbedder.forwardÊ  sT   € ð  ˆÜ! $§+¡+Ö.‰HˆAÙ! -Ó0ˆMØ”3�t—{‘{Ó# aÕ'Ö'Ø $§¡°Ó >’ñ /ð Ðr4   )ri  r²   rä  rú   rÊ   s   @@r1   rc  rc  ¶  s#   ù‡ € ñ÷
$ó $÷÷ ð r4   rc  c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚSam3PixelDecoderiÚ  zt
Feature Pyramid Network (FPN) decoder that generates pixel-level features.
Inspired by MaskFormer's pixel decoder.
c                ó    <€ V ^8„  d   QhRS[ /# rÿ   re  )r/   r0   s   "€r1   r2   ÚSam3PixelDecoder.__annotate__à  s   ø€ ÷ (ñ (Ñ4ñ (r4   c                óª  <€ \         SV `  4        Wn        VP                  pVP                  p\
        P                  ! \        V4       Uu. uF  p\
        P                  ! W"^^^R7      NK  	  up4      V n	        \
        P                  ! \        V4       Uu. uF  p\
        P                  ! ^V4      NK  	  up4      V n        W n        R# u upi u upi )r  )rY  rZ  r6  N)r°   r±   r²   r–   Únum_upsampling_stagesrµ   rà  rá  ra  Úconv_layersÚ	GroupNormÚnormsr5  )r¾   r²   r–   rv  rP  r¿   s   &&   €r1   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c                ó^   <€ V ^8„  d   QhRS[ S[P                  ,          RS[P                  /# )r)   Úbackbone_featuresro   rÏ  )r/   r0   s   "€r1   r2   rt  ñ  s(   ø€ ÷ ñ ©©e¯l©lÕ);ð ÁÇÁñ r4   c                óB  € VR,          p\        \        VRR 4      4       Fz  w  r4\        P                  ! W$P                  RR RR7      pW$,           pV P
                  V,          ! V4      pV P                  V,          ! V4      p\        P                  ! V4      pK|  	  V# )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
NÚnearest)r‰   r  r…   r8  )rÛ  Úreversedrë  Úinterpolaterˆ   rw  ry  rì  )r¾   r|  Úprev_fpnÚ	layer_idxÚbackbone_feats   &&   r1   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ð ˆr4   )r²   rw  ry  r5  rú   rÊ   s   @@r1   rr  rr  Ú  s#   ù‡ € ñ÷
(ó (÷"÷ ð r4   rr  c                   ó†   a a€ ] tR tRt oRtR]/tV3R lV 3R llt]]	RV3R lR ll4       4       t
V3R lR	 ltR
tVtV ;t# )Ú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.
rM   c                ó    <€ V ^8„  d   QhRS[ /# rÿ   re  )r/   r0   s   "€r1   r2   ÚSam3MaskDecoder.__annotate__  s   ø€ ÷ ñ Ñ4ñ r4   c                ó  <€ \         SV `  V4       Wn        VP                  p\	        V4      V n        \        V4      V n        \        P                  ! V P
                  P                  V^R7      V n        \        P                  ! V P
                  P                  ^^R7      V n        \        V4      V n        \        P                  ! V4      V n        \        P"                  ! VP$                  4      V n        V P)                  4        R# )r,  )rY  N)r°   r±   r²   r–   rr  Úpixel_decoderrc  Úmask_embedderrµ   ra  r5  Úinstance_projectionÚsemantic_projectionrà   Úprompt_cross_attnrª  Úprompt_cross_attn_normrº   r¼   Úprompt_cross_attn_dropoutrå  rj  s   && €r1   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ˆÔ&à�‰Ör4   c                óô   <€ V ^8„  d   QhRS[ P                  RS[S[ P                  ,          RS[ P                  RS[ P                  R,          RS[ P                  R,          RS[S[,          RS[S[,          /# )	r)   Údecoder_queriesr|  re   Úprompt_featuresNrv  rÑ   ro   )r-   r   r·  r   r   r,   rY   )r/   r0   s   "€r1   r2   rˆ  /  s€   ø€ ÷ <
ñ <
áŸ™ð<
ñ  ¡§¡Õ-ð<
ñ  %Ÿ|™|ð	<
ñ
 Ÿ™¨Õ,ð<
ñ —\‘\ DÕ(ð<
ñ Ñ+Õ,ð<
ñ 
Ñ&Õ	&ñ<
r4   c                ó¨  € Vef   TpV P                  V4      pRp	Ve   \        V P                  VVVR7      p	V P                  ! R
RVRVRVRV	/VB w  r«WpP	                  V
4      ,           pV P                  VVR7      pV P                  V4      pV P                  V4      p\        P                  ! RWí4      pV P                  V4      p\        VVR	7      # )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°  re   rC   rÍ   rÎ   rÏ   rC   )r|  re   zbqc,bchw->bqhw)r[   r\   r5   )r�  r	   r²   rŽ  r�  Ú_embed_pixelsrŒ  r‹  r-   Úeinsumr�  rY   )r¾   r“  r|  re   r”  rv  rÑ   rÁ  Únormed_hidden_statesÚcross_attn_maskrÝ   rP  Úpixel_embedÚinstance_embedsÚmask_embeddingsr[   r\   s   &&&&&&,          r1   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ˆ
ð ×/Ñ/°Ó<ˆä$Ø!Ø%ô
ð 	
r4   c                óx   <€ V ^8„  d   QhRS[ S[P                  ,          RS[P                  RS[P                  /# )r)   r|  re   ro   rÏ  )r/   r0   s   "€r1   r2   rˆ  m  s:   ø€ ÷ ñ á¡§¡Õ-ðñ  %Ÿ|™|ðñ 
�‰ñ	r4   c                ó–  € V Uu. uF  q3P                  4       NK  	  ppVR,          P                  R,          VR,          P                  R,          ,          pVRRV1R3,          pVP                  w  rxp	VR,          P                  RR w  r«VP                  ^^4      P                  WyW«4      pWdR&   V P	                  V4      pV# u upi )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]
r‚   Nr…   r8  )r  rˆ   rØ   rõ   rŠ  )r¾   r|  re   ÚfeatÚbackbone_visual_featsr  Úencoder_visual_embedr”   rP  r–   rN  rO  rš  s   &&&          r1   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   …C)r²   rŒ  r‹  rŠ  rŽ  r�  r�  r�  r  )r6   r7   r8   r9   r:   rà   rô  r±   r   r   rÆ   r–  r<   r=   rÉ   rÊ   s   @@r1   r†  r†    sT   ù‡ € ñð 	�mðÐ÷ó ð.  Ø÷<
ñ <
ó ó  ð<
÷|÷ ð r4   r†  c                   óÂ   a a€ ] tR tRt oRR.tRtRR.tV3R lV 3R llt]]	RV3R	 lR
 ll4       4       t
]	V3R lR l4       t]]	RV3R lR ll4       4       tRtVtV ;t# )Ú	Sam3Modeli�  rÇ  rÈ  Údetector_modelz^tracker_model.z^tracker_neck.c                ó    <€ V ^8„  d   QhRS[ /# rÿ   rE  )r/   r0   s   "€r1   r2   ÚSam3Model.__annotate__—  s   ø€ ÷ ñ ™zñ r4   c                óÒ  <€ \        VR 4      '       d>   VP                  e0   VP                  p\        V\        4      '       d   \	        R/ VB pTp\
        SV `  V4       \        VP                  4      V n	        \        VP                  4      V n        VP                  P                  V n        \        P                  ! VP                  P                   VP"                  P                   4      V n        VP&                  VP(                  n        VP&                  VP"                  n        VP&                  VP*                  n        VP&                  VP,                  n        \/        VP(                  4      V n        \3        VP"                  4      V n        \7        VP*                  4      V n        \;        VP,                  4      V n        \?        V4      V n         V PC                  4        R# )Údetector_configNr5   )"Úhasattrrª  r!  Údictr   r°   r±   rY  Úvision_configÚvision_encoderr   Útext_configÚtext_encoderÚ
vocab_sizerµ   r¶   r–   Údetr_encoder_configÚtext_projectionrò   Úgeometry_encoder_configrH  Úmask_decoder_configr|  Úgeometry_encoderrÉ  Údetr_encoderr  Údetr_decoderr†  Úmask_decoderrC  Údot_product_scoringrå  )r¾   r²   rª  r¿   s   && €r1   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¸Ó#@ˆÔ à�‰Ör4   c          	      óˆ   <€ V ^8„  d   QhRS[ P                  RS[ P                  R,          RS[S[,          RS[S[,          /# )r)   Ú	input_idsrC   NrÑ   ro   )r-   rN   r   r   r   r,   r   )r/   r0   s   "€r1   r2   r¨  ¹  sN   ø€ ÷ $ñ $á×#Ñ#ð$ñ Ÿ™ tÕ+ð$ñ Ñ+Õ,ð	$ñ
 
Ñ+Õ	+ñ$r4   c           	     óz   € V P                   ! RRVRVRR/VB pVP                  pV P                  V4      Vn        V# )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)
```
r½  rC   Úreturn_dictTr5   )r°  rB   r³  Úpooler_output)r¾   r½  rC   rÑ   Útext_outputsrB   s   &&&,  r1   Úget_text_featuresÚSam3Model.get_text_features·  s]   € ð@ ×(Ò(ñ 
Øð
Ø0>ð
ØLPð
ØTZñ
ˆð )×:Ñ:ÐØ%)×%9Ñ%9Ð:KÓ%LˆÔ"àÐr4   c                óP   <€ V ^8„  d   QhRS[ P                  RS[S[,          RS[/# rï  )r-   r.   r   r   r'   )r/   r0   s   "€r1   r2   r¨  à  s5   ø€ ÷ ñ á×'Ñ'ðñ Ñ+Õ,ðñ 
!ñ	r4   c                ó,   € V P                   ! V3/ VB pV# )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)
```
)r®  )r¾   re  rÑ   Úvision_outputss   &&, r1   Úget_vision_featuresÚSam3Model.get_vision_featuresß  s   € ð< ×,Ò,¨\ÑD¸VÑDˆØÐr4   c                ó:  <€ V ^8„  d   QhRS[ P                  R,          RS[R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          R	S[S[,          R
S[/	# )r)   re  NÚvision_embedsr½  rC   Útext_embedsÚinput_boxesÚinput_boxes_labelsrÑ   ro   )r-   r.   r'   rN   r   r   r   r_   )r/   r0   s   "€r1   r2   r¨  	  s»   ø€ ÷ |
ñ |
á×'Ñ'¨$Õ.ð|
ñ /°Õ5ð|
ñ ×#Ñ# dÕ*ð	|
ñ
 Ÿ™ tÕ+ð|
ñ ×&Ñ&¨Õ-ð|
ñ ×&Ñ&¨Õ-ð|
ñ "×,Ñ,¨tÕ3ð|
ñ Ñ+Õ,ð|
ñ 
%ñ|
r4   c                ó  € VRJ VRJ 8X  d   \        R4      hVRJ VRJ 8X  d   \        R4      hVe!   VP                  ^ ,          p	VP                  p
MAVP                  ^ ,          P                  ^ ,          p	VP                  ^ ,          P                  p
Vf   V P                  ! V3/ VB pMTpVP                  RR pVP
                  RR pVf   V P                  W4RR7      pVP                  pVe   VP                  4       MRpVRJ;'       d    VP                  4       ^ 8„  pRpRpV'       EdO   Ve¨   VP                  4       ^ 8”  d“   TpVe   TM,\        P                  ! VR,          \        P                  R7      pVe   VR8g  M7\        P                  ! W–P                  ^,          \        P                  V
R7      p\        P                  ! VR8H  ^ V4      pMu\        P                  ! V	^ ^VP                   V
R7      p\        P                  ! V	^ \        P                  V
R7      p\        P                  ! V	^ \        P                  V
R7      pV P#                  VVVVVR7      pVP$                  pVP&                  pVEe›   VP                  ^ ,          ^8X  d=   VP                  ^ ,          ^8”  d%   VP)                  VP                  ^ ,          ^^4      p\        P*                  ! VV.^R	7      pVeT   VP                  ^ ,          ^8X  d<   VP                  ^ ,          ^8”  d$   VP)                  VP                  ^ ,          ^4      pVe    Ve   \        P*                  ! VV.^R	7      pM¶VeU   \        P                  ! V	VP                  ^,          \        P                  V
R7      p\        P*                  ! VV.^R	7      pM^VeT   \        P                  ! WžP                  ^,          \        P                  V
R7      p\        P*                  ! VV.^R	7      pMRpMTpTpV P,                  ! RR
VR,          .RVRVR,          .RV/VB pV P.                  ! RR
VP$                  RVP0                  RVP2                  RVRVP4                  /VB pV P.                  P7                  VP8                  4      p\;        VP<                  4      pVV,           P?                  4       p\A        V4      p V PC                  VP8                  VP0                  VR7      PE                  R4      p!V!R,          p"V R,          p#VP8                  R,          p$VPF                  R,          p%V PH                  ! RRV$R\K        V4      RVP$                  RVRV/VB p&\M        V&PN                  V#V"V%V&PP                  VPR                  VP<                  VPR                  VPR                  VPT                  VPT                  VPT                  V&PT                  R7      # )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_embedsT)r½  rC   r¿  r  r  )rª  r«  r¬  r­  r®  r   rž  rJ   r³  r×  ru  rK   )rc   rJ   r×  r“  r|  re   r”  rv  )r[   ra   rb   rU   r\   rc   rd   re   rf   rg   rh   ri   rj   r…   ).r   iöÿÿÿr5   )+r	  rˆ   r�   r*   r®  r+   rÂ  rÀ  r}   Únumelr-   Ú	ones_liker›  rœ  Úwherer�   r„   r¶  rB   rC   rŒ   r-  r·  r¸  rJ   rI   rK   r  rS   rz   rT   r3  r«   rº  r5  rU   r¹  r·  r_   r[   r\   rL   rM   )'r¾   re  rÊ  r½  rC   rË  rÌ  rÍ  rÑ   r”   r�   rÆ  r*   r+   rJ   r×  Úhas_geometry_promptsÚgeometry_prompt_featuresÚgeometry_prompt_maskrª  r¬  r«  Ú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_logitsrb   ra   rc   rU   Úmask_outputss'   &&&&&&&&,                              r1   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Ð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ð
ð  5°RÕ8Ð9ð
ð +ð	
ð
 ñ
ˆð ×+Ò+ñ 
Ø+×=Ñ=ð
à)×7Ñ7ð
ð !0× 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ð
ð #2×"CÑ"Cð
ð 5ð	
ð
 -ð
ð ñ
ˆô +Ø#×.Ñ.Ø!Ø#Ø+Ø%×2Ñ2Ø"1×"?Ñ"?Ø$3×$CÑ$CØ"1×"?Ñ"?Ø!/×!=Ñ!=Ø,×7Ñ7Ø$3×$>Ñ$>Ø$3×$>Ñ$>Ø$0×$;Ñ$;ô
ð 	
r4   )	r¸  r·  rº  r¶  r¹  r°  r³  r®  r±  r¯   )NNNNNNN)r6   r7   r8   r9   rÕ  rÓ  Ú"_keys_to_ignore_on_load_unexpectedr±   r   r   rÂ  rÇ  rÆ   r<   r=   rÉ   rÊ   s   @@r1   r¥  r¥  �  s�   ù‡ € Ø Ð(ÐØ(ÐàØð*Ð&÷
ó ð@ Ø÷$ñ $ó ó ð$ðL ÷ó ðð@ Ø÷|
ñ |
ó ó ÷|
ð |
r4   r¥  )gü©ñÒMbP?r‡  )Nrï   )r-   r˜  )r¥  rY  rÛ  rÅ  )mrþ  Úcollections.abcr   r   Údataclassesr   ÚnumpyrN  r-   Ú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_loggerr6   ró   r'   r@   rG   rQ   rY   r_   rz   r¡   r«   rÒ   r­   rÞ   rà   rü   r:  rC  rE  rU  rl  r‘  r•  r—  r¤  rÅ  rÛ  rö  r.  rE  rY  ri  r|  r½  rÉ  rÞ  rï  r  rC  rc  rr  r†  r¥  Ú__all__r5   r4   r1   Ú<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÷`÷34òl"ôˆb�i‰iô ÷"%ô8P)�B—I‘Iô P)ôh?4˜RŸY™Yô ?4òD#õ$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‚r4   