Ë
    ÜÓ^jÅÄ  ã                   ó¬  — d dl Zd dlZd dl mZ d dlmZ d dlZd dlmZ ddlm	Z
 ddlmZ ddlmZmZ dd	lmZ dd
lmZ ddlmZmZ ddlmZ ddlmZmZmZmZ ddlmZm Z  ddl!m"Z"m#Z# ddl$m%Z%  G d„ dejL                  «      Z' ed¬«      e G d„ de«      «       «       Z( ed¬«      e G d„ de«      «       «       Z) ed¬«      e G d„ de«      «       «       Z* ed¬«      e G d„ d e«      «       «       Z+ G d!„ d"ejL                  «      Z, G d#„ d$ejL                  «      Z- G d%„ d&ejL                  «      Z. G d'„ d(ejL                  «      Z/	 	 dLd)ejL                  d*ej`                  d+ej`                  d,ej`                  d-ej`                  dz  d.e1dz  d/e1d0ee   fd1„Z2 G d2„ d3ejL                  «      Z3 G d4„ d5ejL                  «      Z4d6„ Z5d7„ Z6 G d8„ d9e«      Z7 G d:„ d;e«      Z8e G d<„ d=e«      «       Z9 G d>„ d?e9«      Z:e G d@„ dAe9«      «       Z; edB¬«       G dC„ dDe9«      «       Z< edE¬«       G dF„ dGe9«      «       Z= edH¬«       G dI„ dJee9«      «       Z>g dK¢Z?y)Mé    N)ÚCallable)Ú	dataclass)Únné   )Úinitialization)ÚACT2FN)ÚBackboneMixinÚfilter_output_hidden_states)ÚGradientCheckpointingLayer)ÚBackboneOutput)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)ÚModelOutputÚTransformersKwargsÚauto_docstringÚ	torch_int)Úcan_return_tupleÚmerge_with_config_defaults)ÚOutputRecorderÚcapture_outputsé   )Ú
SwinConfigc                   ór   ‡ — e Zd ZdZd	deddfˆ fd„Zdej                  dej                  fd„Zde	fd„Z
ˆ xZS )
ÚSwinDropPathzÏStochastic depth (DropPath) per sample, for residual blocks.

    Identity when ``drop_prob`` is 0 or outside training. See `Deep Networks with Stochastic Depth
    <https://arxiv.org/abs/1603.09382>`_.
    Ú	drop_probÚreturnNc                 ó0   •— t         ‰| �  «        || _        y ©N)ÚsuperÚ__init__r   )Úselfr   Ú	__class__s     €úq/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/swin/modeling_swin.pyr!   zSwinDropPath.__init__1   s   ø€ Ü‰ÑÔØ"ˆ�ó    Úhidden_statesc                 óP  — | j                   dk(  s| j                  s|S d| j                   z
  }|j                  d   fd|j                  dz
  z  z   }t	        j
                  ||j                  |j                  ¬«      }t	        j                  ||z   «      }|j                  |«      |z  S )Nç        r   r   )r   ©ÚdtypeÚdevice)
r   ÚtrainingÚshapeÚndimÚtorchÚrandr*   r+   ÚfloorÚdiv)r"   r&   Ú	keep_probr-   Úrandom_tensors        r$   ÚforwardzSwinDropPath.forward5   s—   € Ø�>‰>˜SÒ ¨¯ªØ Ð Ø˜Ÿ™Ñ&ˆ	Ø×$Ñ$ QÑ'Ð)¨D°M×4FÑ4FÈÑ4JÑ,KÑKˆÜŸ
™
 5°×0CÑ0CÈM×L`ÑL`ÔaˆÜŸ™ M°IÑ$=Ó>ˆØ× Ñ  Ó+¨mÑ;Ð;r%   c                 ó    — d| j                   › �S )Nzp=)r   )r"   s    r$   Ú
extra_reprzSwinDropPath.extra_repr>   s   € Ø�D—N‘NÐ#Ð$Ð$r%   )r(   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__Úfloatr!   r/   ÚTensorr5   Ústrr7   Ú__classcell__©r#   s   @r$   r   r   *   sB   ø„ ññ# %ð #°$õ #ð< U§\¡\ð <°e·l±ló <ð%˜C÷ %r%   r   zN
    Swin encoder's outputs, with potential hidden states and attentions.
    )Úcustom_introc                   óÐ   — e Zd ZU dZdZej                  dz  ed<   dZe	ej                  df   dz  ed<   dZ
e	ej                  df   dz  ed<   dZe	ej                  df   dz  ed<   y)ÚSwinEncoderOutputaí  
    reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
        Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
        shape `(batch_size, hidden_size, height, width)`.

        Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
        include the spatial dimensions.
    NÚlast_hidden_state.r&   Ú
attentionsÚreshaped_hidden_states)r8   r9   r:   r;   rD   r/   ÚFloatTensorÚ__annotations__r&   ÚtuplerE   rF   © r%   r$   rC   rC   B   s}   … ñð 37Ð�u×(Ñ(¨4Ñ/Ó6Ø:>€M�5˜×*Ñ*¨CÐ/Ñ0°4Ñ7Ó>Ø7;€J��e×'Ñ'¨Ð,Ñ-°Ñ4Ó;ØCGÐ˜E %×"3Ñ"3°SÐ"8Ñ9¸DÑ@ÔGr%   rC   zV
    Swin model's outputs that also contains a pooling of the last hidden states.
    c                   óø   — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	e
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   y)	ÚSwinModelOutputa±  
    pooler_output (`torch.FloatTensor` of shape `(batch_size, hidden_size)`, *optional*, returned when `add_pooling_layer=True` is passed):
        Average pooling of the last layer hidden-state.
    reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
        Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
        shape `(batch_size, hidden_size, height, width)`.

        Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
        include the spatial dimensions.
    NrD   Úpooler_output.r&   rE   rF   )r8   r9   r:   r;   rD   r/   rG   rH   rM   r&   rI   rE   rF   rJ   r%   r$   rL   rL   X   s’   … ñ	ð 37Ð�u×(Ñ(¨4Ñ/Ó6Ø.2€M�5×$Ñ$ tÑ+Ó2Ø:>€M�5˜×*Ñ*¨CÐ/Ñ0°4Ñ7Ó>Ø7;€J��e×'Ñ'¨Ð,Ñ-°Ñ4Ó;ØCGÐ˜E %×"3Ñ"3°SÐ"8Ñ9¸DÑ@ÔGr%   rL   z*
    Swin masked image model outputs.
    c                   óø   — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	e
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   y)	ÚSwinMaskedImageModelingOutputa  
    loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `bool_masked_pos` is provided):
        Masked image modeling (MLM) loss.
    reconstruction (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
        Reconstructed pixel values.
    reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
        Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
        shape `(batch_size, hidden_size, height, width)`.

        Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
        include the spatial dimensions.
    NÚlossÚreconstruction.r&   rE   rF   )r8   r9   r:   r;   rP   r/   rG   rH   rQ   r&   rI   rE   rF   rJ   r%   r$   rO   rO   q   s‘   … ñð &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø/3€N�E×%Ñ%¨Ñ,Ó3Ø:>€M�5˜×*Ñ*¨CÐ/Ñ0°4Ñ7Ó>Ø7;€J��e×'Ñ'¨Ð,Ñ-°Ñ4Ó;ØCGÐ˜E %×"3Ñ"3°SÐ"8Ñ9¸DÑ@ÔGr%   rO   z0
    Swin outputs for image classification.
    c                   óø   — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	e
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   y)	ÚSwinImageClassifierOutputa7  
    loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
        Classification (or regression if config.num_labels==1) loss.
    logits (`torch.FloatTensor` of shape `(batch_size, config.num_labels)`):
        Classification (or regression if config.num_labels==1) scores (before SoftMax).
    reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
        Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
        shape `(batch_size, hidden_size, height, width)`.

        Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
        include the spatial dimensions.
    NrP   Úlogits.r&   rE   rF   )r8   r9   r:   r;   rP   r/   rG   rH   rT   r&   rI   rE   rF   rJ   r%   r$   rS   rS   Œ   s‘   … ñð &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø'+€FˆE×Ñ Ñ$Ó+Ø:>€M�5˜×*Ñ*¨CÐ/Ñ0°4Ñ7Ó>Ø7;€J��e×'Ñ'¨Ð,Ñ-°Ñ4Ó;ØCGÐ˜E %×"3Ñ"3°SÐ"8Ñ9¸DÑ@ÔGr%   rS   c            
       óÐ   ‡ — e Zd ZdZdˆ fd„	Zdej                  dededej                  fd„Z	 	 dd	ej                  dz  d
ej                  dz  dedeej                     fd„Zˆ xZS )ÚSwinEmbeddingszW
    Construct the patch and position embeddings. Optionally, also the mask token.
    c                 ól  •— t         ‰| �  «        t        |«      | _        | j                  j                  }| j                  j
                  | _        |r4t        j                  t        j                  dd|j                  «      «      nd | _        |j                  r4t        j                  t        j                  d||j                  «      «      nd | _        t        j                  |j                  «      | _        t        j"                  |j$                  «      | _        |j(                  | _        || _        y )Nr   )r    r!   ÚSwinPatchEmbeddingsÚpatch_embeddingsÚnum_patchesÚ	grid_sizeÚ
patch_gridr   Ú	Parameterr/   ÚzerosÚ	embed_dimÚ
mask_tokenÚuse_absolute_embeddingsÚposition_embeddingsÚ	LayerNormÚnormÚDropoutÚhidden_dropout_probÚdropoutÚ
patch_sizeÚconfig)r"   ri   Úuse_mask_tokenrZ   r#   s       €r$   r!   zSwinEmbeddings.__init__¬   sß   ø€ Ü‰ÑÔä 3°FÓ ;ˆÔØ×+Ñ+×7Ñ7ˆØ×/Ñ/×9Ñ9ˆŒÙO]œ"Ÿ,™,¤u§{¡{°1°a¸×9IÑ9IÓ'JÔKÐcgˆŒð LR×KiÒKiŒB�L‰LœŸ™ Q¨°V×5EÑ5EÓFÔGÐosð 	Ô ô —L‘L ×!1Ñ!1Ó2ˆŒ	Ü—z‘z &×"<Ñ"<Ó=ˆŒØ ×+Ñ+ˆŒØˆ�r%   Ú
embeddingsÚheightÚwidthr   c                 ó(  — |j                   d   }| j                  j                   d   }t        j                  j	                  «       s||k(  r||k(  r| j                  S |j                   d   }|| j
                  z  }|| j
                  z  }t        |dz  «      }	| j                  j                  d|	|	|«      }
|
j                  dddd«      }
t        j                  j                  |
||fdd¬	«      }
|
j                  dddd«      j                  dd|«      S )
zÌ
        Interpolate pre-trained position encodings to support higher-resolution images at inference.
        Unlike ViT, Swin has no CLS token, so position embeddings cover patch positions only.
        r   éÿÿÿÿç      à?r   r   é   ÚbicubicF)ÚsizeÚmodeÚalign_corners)r-   rb   r/   ÚjitÚ
is_tracingrh   r   ÚreshapeÚpermuter   Ú
functionalÚinterpolateÚview)r"   rk   rl   rm   rZ   Únum_positionsÚdimÚ
new_heightÚ	new_widthÚsqrt_num_positionsÚpatch_pos_embeds              r$   Úinterpolate_pos_encodingz'SwinEmbeddings.interpolate_pos_encoding½   s  € ð
 !×&Ñ& qÑ)ˆØ×0Ñ0×6Ñ6°qÑ9ˆô �y‰y×#Ñ#Ô%¨+¸Ò*FÈ6ÐUZÊ?Ø×+Ñ+Ð+à×Ñ˜rÑ"ˆà˜tŸ™Ñ.ˆ
Ø˜TŸ_™_Ñ,ˆ	ä& }°cÑ'9Ó:ÐØ×2Ñ2×:Ñ:¸1Ð>PÐRdÐfiÓjˆØ)×1Ñ1°!°Q¸¸1Ó=ˆäŸ-™-×3Ñ3ØØ˜iÐ(ØØð	 4ó 
ˆð ×&Ñ& q¨!¨Q°Ó2×7Ñ7¸¸2¸sÓCÐCr%   NÚpixel_valuesÚbool_masked_posrƒ   c                 óÂ  — |j                   \  }}}}| j                  |«      \  }}	| j                  |«      }|j                  «       \  }
}}|�K| j                  j                  |
|d«      }|j                  d«      j                  |«      }|d|z
  z  ||z  z   }| j                  �(|r|| j                  |||«      z   }n|| j                  z   }| j                  |«      }||	fS )Nro   g      ð?)r-   rY   rd   rs   r`   ÚexpandÚ	unsqueezeÚtype_asrb   rƒ   rg   )r"   r„   r…   rƒ   Ú_Únum_channelsrl   rm   rk   Úoutput_dimensionsÚ
batch_sizeÚseq_lenÚmask_tokensÚmasks                 r$   r5   zSwinEmbeddings.forwardÛ   sô   € ð *6×);Ñ);Ñ&ˆˆ<˜ Ø(,×(=Ñ(=¸lÓ(KÑ%ˆ
Ð%Ø—Y‘Y˜zÓ*ˆ
Ø!+§¡Ó!2Ñˆ
�G˜QàÐ&ØŸ/™/×0Ñ0°¸WÀbÓIˆKà"×,Ñ,¨RÓ0×8Ñ8¸ÓEˆDØ# s¨T¡zÑ2°[À4Ñ5GÑGˆJà×#Ñ#Ð/Ù'Ø'¨$×*GÑ*GÈ
ÐTZÐ\aÓ*bÑb‘
à'¨$×*BÑ*BÑB�
à—\‘\ *Ó-ˆ
àÐ,Ð,Ð,r%   ©F)NF)r8   r9   r:   r;   r!   r/   r=   Úintrƒ   rG   Ú
BoolTensorÚboolrI   r5   r?   r@   s   @r$   rV   rV   §   s’   ø„ ñõð"D°5·<±<ð DÈð DÐUXð DÐ]b×]iÑ]ió DðB 48Ø).ñ	-à×'Ñ'¨$Ñ.ð-ð ×)Ñ)¨DÑ0ð-ð #'ð	-ð
 
ˆu�|‰|Ñ	÷-r%   rV   c                   óv   ‡ — e Zd ZdZˆ fd„Zd„ Zdej                  dz  deej                  ee
   f   fd„Zˆ xZS )rX   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                 óæ  •— t         ‰| �  «        |j                  |j                  }}|j                  |j
                  }}t        |t        j                  j                  «      r|n||f}t        |t        j                  j                  «      r|n||f}|d   |d   z  |d   |d   z  z  }|| _        || _
        |d   |d   z  |d   |d   z  f| _        t        j                  ||||¬«      | _        y )Nr   r   )Úkernel_sizeÚstride)r    r!   Ú
image_sizerh   r‹   r_   Ú
isinstanceÚcollectionsÚabcÚIterablerZ   r[   r   ÚConv2dÚ
projection)r"   ri   r™   rh   r‹   Úhidden_sizerZ   r#   s          €r$   r!   zSwinPatchEmbeddings.__init__þ   sì   ø€ Ü‰ÑÔØ!'×!2Ñ!2°F×4EÑ4E�Jˆ
Ø$*×$7Ñ$7¸×9IÑ9I�kˆÜ#-¨j¼+¿/¹/×:RÑ:RÔ#S‘ZÐZdÐfpÐYqˆ
Ü#-¨j¼+¿/¹/×:RÑ:RÔ#S‘ZÐZdÐfpÐYqˆ
Ø! !‘}¨
°1©Ñ5¸*ÀQ¹-È:ÐVWÉ=Ñ:XÑYˆØ$ˆŒØ&ˆÔØ$ Q™-¨:°a©=Ñ8¸*ÀQ¹-È:ÐVWÉ=Ñ:XÐYˆŒäŸ)™) L°+È:Ð^hÔiˆ�r%   c                 ón  — || j                   d   z  dk7  rDd| j                   d   || j                   d   z  z
  f}t        j                  j                  ||«      }|| j                   d   z  dk7  rFddd| j                   d   || j                   d   z  z
  f}t        j                  j                  ||«      }|S )z9Pad pixel_values to be divisible by patch_size if needed.r   r   )rh   r   rz   Úpad)r"   r„   rl   rm   Ú
pad_valuess        r$   Ú	maybe_padzSwinPatchEmbeddings.maybe_pad  s±   € à�4—?‘? 1Ñ%Ñ%¨Ò*Ø˜TŸ_™_¨QÑ/°%¸$¿/¹/È!Ñ:LÑ2LÑLÐMˆJÜŸ=™=×,Ñ,¨\¸:ÓFˆLØ�D—O‘O AÑ&Ñ&¨!Ò+Ø˜Q  4§?¡?°1Ñ#5¸ÀÇÁÐQRÑASÑ8SÑ#SÐTˆJÜŸ=™=×,Ñ,¨\¸:ÓFˆLØÐr%   r„   Nr   c                 óà   — |j                   \  }}}}| j                  |||«      }| j                  |«      }|j                   \  }}}}||f}|j                  d«      j	                  dd«      }||fS )Nrq   r   )r-   r¤   rŸ   ÚflattenÚ	transpose)r"   r„   rŠ   r‹   rl   rm   rk   rŒ   s           r$   r5   zSwinPatchEmbeddings.forward  s}   € Ø)5×);Ñ);Ñ&ˆˆ<˜ à—~‘~ l°F¸EÓBˆØ—_‘_ \Ó2ˆ
Ø(×.Ñ.Ñˆˆ1ˆf�eØ# U˜OÐØ×'Ñ'¨Ó*×4Ñ4°Q¸Ó:ˆ
àÐ,Ð,Ð,r%   )r8   r9   r:   r;   r!   r¤   r/   rG   rI   r=   r’   r5   r?   r@   s   @r$   rX   rX   ÷   sF   ø„ ñôjòð	- E×$5Ñ$5¸Ñ$<ð 	-ÀÀuÇ|Á|ÐUZÐ[^ÑU_ÐG_ÑA`÷ 	-r%   rX   c                   ó²   ‡ — e Zd ZdZdeddfˆ fd„Zdej                  dededej                  fd	„Zdej                  d
e	eef   dej                  fd„Z
ˆ xZS )ÚSwinPatchMergingzd
    Patch Merging Layer.

    Args:
        dim (`int`):
            Number of input channels.
    r~   r   Nc                 ó¢   •— t         ‰| �  «        t        j                  d|z  d|z  d¬«      | _        t        j
                  d|z  «      | _        y )Né   rq   F©Úbias)r    r!   r   ÚLinearÚ	reductionrc   rd   )r"   r~   r#   s     €r$   r!   zSwinPatchMerging.__init__*  s>   ø€ Ü‰ÑÔÜŸ™ 1 s¡7¨A°©G¸%Ô@ˆŒÜ—L‘L  S¡Ó)ˆ�	r%   Úinput_featurerl   rm   c           
      ó~   — |dz  dk(  s|dz  dk(  r,t         j                  j                  |ddd|dz  d|dz  f«      }|S )zPPad input feature map to be divisible by 2 in both spatial dimensions if needed.rq   r   r   )r   rz   r¢   )r"   r°   rl   rm   s       r$   r¤   zSwinPatchMerging.maybe_pad/  sL   € à�Q‰J˜!ŠO ¨¡¨a¢ÜŸM™M×-Ñ-¨m¸aÀÀAÀuÈqÁyÐRSÐU[Ð^_ÑU_Ð=`ÓaˆMØÐr%   Úinput_dimensionsc                 óœ  — |\  }}|j                   \  }}}|j                  ||||«      }| j                  |||«      }t        j                  t        d«      D ��	cg c]%  }t        d«      D ]  }	|d d …|	d d…|d d…d d …f   ‘Œ Œ' c}	}d¬«      }|j                  |dd|z  «      }| j                  |«      }| j                  |«      }|S c c}	}w )Nrq   ro   ©r~   r«   )r-   r|   r¤   r/   ÚcatÚrangerd   r¯   )
r"   r°   r²   rl   rm   r�   r~   r‹   ÚcolÚrows
             r$   r5   zSwinPatchMerging.forward5  sÙ   € Ø(‰ˆ�à(5×(;Ñ(;Ñ%ˆ
�C˜à%×*Ñ*¨:°v¸uÀlÓSˆàŸ™ }°f¸eÓDˆäŸ	™	Ü<AÀ!»H×Y°SÔPUÐVWÓPXÒYÈˆ]š1˜c˜f 1˜f c f¨1 fªaÐ/Ó0ÐYÐ0ÓYÐ_aô
ˆð &×*Ñ*¨:°r¸1¸|Ñ;KÓLˆàŸ	™	 -Ó0ˆØŸ™ }Ó5ˆàÐùó Zs   Á*C
)r8   r9   r:   r;   r’   r!   r/   r=   r¤   rI   r5   r?   r@   s   @r$   r©   r©   !  su   ø„ ñð*˜Cð * Dõ *ð
 u§|¡|ð ¸Sð Èð ÐQV×Q]ÑQ]ó ð U§\¡\ð ÀUÈ3ÐPSÈ8Á_ð ÐY^×YeÑYe÷ r%   r©   c                   óv   ‡ — e Zd ZdZdedeeef   fˆ fd„Zdej                  fd„Z	dej                  fd„Z
ˆ xZS )ÚSwinRelativePositionBiasaç  
    Relative position bias for Swin's window-based attention, following the style of BeitRelativePositionBias.

    Unlike BeiT, Swin has no CLS token, so the table covers exactly (2*ws_h-1)*(2*ws_w-1) unique
    relative positions. The lookup index is purely determined by window_size (static), so it is stored
    as a non-persistent buffer (recomputed from config on load, never serialised). The table values
    are learned parameters and must be re-read on every forward call.
    Ú	num_headsÚwindow_sizec                 ó8  •— t         ‰| �  «        || _        |d   |d   z  | _        t	        j
                  t        j                  d|d   z  dz
  d|d   z  dz
  z  |«      «      | _        | j                  d| j                  «       j                  d«      d¬«       y )Nr   r   rq   Úrelative_position_indexro   F)Ú
persistent)r    r!   r¼   Úwindow_arear   r]   r/   r^   Úrelative_position_bias_tableÚregister_bufferÚ_create_relative_position_indexr|   )r"   r»   r¼   r#   s      €r$   r!   z!SwinRelativePositionBias.__init__S  s�   ø€ Ü‰ÑÔØ&ˆÔØ& q™>¨K¸©NÑ:ˆÔÜ,.¯L©LÜ�K‰K˜˜[¨™^Ñ+¨aÑ/°A¸ÀA¹Ñ4FÈÑ4JÑKÈYÓWó-
ˆÔ)ð
 	×ÑØ%Ø×0Ñ0Ó2×7Ñ7¸Ó;Øð 	õ 	
r%   r   c                 ó‚  — t        j                  | j                  d   «      }t        j                  | j                  d   «      }t        j                  t        j                  ||gd¬«      «      }t        j
                  |d«      }|d d …d d …d f   |d d …d d d …f   z
  }|j                  ddd«      j                  «       }|d d …d d …dfxx   | j                  d   dz
  z  cc<   |d d …d d …dfxx   | j                  d   dz
  z  cc<   |d d …d d …dfxx   d| j                  d   z  dz
  z  cc<   |j                  d«      S )Nr   r   Úij)Úindexingrq   ro   )	r/   Úaranger¼   ÚstackÚmeshgridr¦   ry   Ú
contiguousÚsum)r"   Úcoords_hÚcoords_wÚcoordsÚcoords_flattenÚrelative_coordss         r$   rÃ   z8SwinRelativePositionBias._create_relative_position_indexb  s)  € Ü—<‘< × 0Ñ 0°Ñ 3Ó4ˆÜ—<‘< × 0Ñ 0°Ñ 3Ó4ˆä—‘œUŸ^™^¨X°xÐ,@È4ÔPÓQˆÜŸ™ v¨qÓ1ˆà(ªªA¨t¨Ñ4°~ÂaÈÊqÀjÑ7QÑQˆØ)×1Ñ1°!°Q¸Ó:×EÑEÓGˆð 	šš1˜a˜Ó  D×$4Ñ$4°QÑ$7¸!Ñ$;Ñ;Ó Øšš1˜a˜Ó  D×$4Ñ$4°QÑ$7¸!Ñ$;Ñ;Ó Øšš1˜a˜Ó  A¨×(8Ñ(8¸Ñ(;Ñ$;¸aÑ$?Ñ?Ó à×"Ñ" 2Ó&Ð&r%   c                 óâ   — | j                   | j                     }|j                  | j                  | j                  d«      }|j	                  ddd«      j                  «       j                  d«      S )Nro   rq   r   r   )rÁ   r¾   r|   rÀ   ry   rÊ   rˆ   )r"   Úrelative_position_biass     r$   r5   z SwinRelativePositionBias.forwards  sd   € Ø!%×!BÑ!BÀ4×C_ÑC_Ñ!`ÐØ!7×!<Ñ!<¸T×=MÑ=MÈt×O_ÑO_ÐacÓ!dÐØ%×-Ñ-¨a°°AÓ6×AÑAÓC×MÑMÈaÓPÐPr%   )r8   r9   r:   r;   r’   rI   r!   r/   r=   rÃ   r5   r?   r@   s   @r$   rº   rº   I  sE   ø„ ñð
 #ð 
°E¸#¸s¸(±Oõ 
ð'°·±ó 'ð"Q˜Ÿ™÷ Qr%   rº   ÚmoduleÚqueryÚkeyÚvalueÚattention_maskÚscalingrg   Úkwargsc                 óì  — |€|j                  d«      dz  }t        j                  ||j                  dd«      «      |z  }|�||z   }t        j
                  j                  |dt        j                  ¬«      j                  |j                  «      }t        j
                  j                  ||| j                  ¬«      }t        j                  ||«      }	|	j                  dd«      j                  «       }	|	|fS )Nro   ç      à¿rq   r   )r~   r*   )Úpr,   r   )rs   r/   Úmatmulr§   r   rz   ÚsoftmaxÚfloat32Útor*   rg   r,   rÊ   )
rÓ   rÔ   rÕ   rÖ   r×   rØ   rg   rÙ   Úattn_weightsÚattn_outputs
             r$   Úeager_attention_forwardrã   y  sÓ   € ð €Ø—*‘*˜R“. DÑ(ˆô —<‘<  s§}¡}°Q¸Ó':Ó;¸gÑE€LàÐ!Ø# nÑ4ˆä—=‘=×(Ñ(¨¸2ÄUÇ]Á]Ð(ÓS×VÑVÐW\×WbÑWbÓc€LÜ—=‘=×(Ñ(¨¸È6Ï?É?Ð(Ó[€Lä—,‘,˜|¨UÓ3€KØ×'Ñ'¨¨1Ó-×8Ñ8Ó:€Kà˜Ð$Ð$r%   c                   ó²   ‡ — e Zd Zdedededefˆ fd„Z	 ddej                  dej                  dz  d	e	e
   d
eej                  ej                  f   fd„Zˆ xZS )ÚSwinAttentionri   r    Únum_attention_headsr¼   c                 óð  •— t         ‰| �  «        || _        || _        ||z  | _        |j
                  | _        | j                  dz  | _        d| _        t        j                  |||j                  ¬«      | _        t        j                  |||j                  ¬«      | _        t        j                  |||j                  ¬«      | _        t        j                  ||«      | _        t!        |||f«      | _        y )NrÛ   Fr¬   )r    r!   ri   ræ   Úhead_dimÚattention_probs_dropout_probÚattention_dropoutrØ   Ú	is_causalr   r®   Úqkv_biasÚq_projÚk_projÚv_projÚo_projrº   rÒ   )r"   ri   r    ræ   r¼   r#   s        €r$   r!   zSwinAttention.__init__–  sÀ   ø€ Ü‰ÑÔØˆŒØ#6ˆÔ Ø#Ð':Ñ:ˆŒØ!'×!DÑ!DˆÔØ—}‘} dÑ*ˆŒØˆŒä—i‘i ¨[¸v¿¹ÔOˆŒÜ—i‘i ¨[¸v¿¹ÔOˆŒÜ—i‘i ¨[¸v¿¹ÔOˆŒÜ—i‘i ¨[Ó9ˆŒä&>Ð?RÐU`ÐbmÐTnÓ&oˆÕ#r%   Nr&   r×   rÙ   r   c                 ó�  — |j                   d d }g |¢d‘| j                  ‘­}| j                  |«      j                  |«      j	                  dd«      }| j                  |«      j                  |«      j	                  dd«      }| j                  |«      j                  |«      j	                  dd«      }| j                  «       }	|�g|j                   d   }
|d   |
z  }|d   }|j                  d«      j                  d«      j                  |dddd«      j                  dd||«      }|	|z   }n|	}t        j                  | j                  j                  t        «      } || ||||f| j                   sdn| j"                  | j$                  dœ|¤Ž\  }} |j                  g |¢d‘­Ž j'                  «       }| j)                  |«      }||fS )Nro   r   rq   r   r(   )rg   rØ   )r-   rè   rí   r|   r§   rî   rï   rÒ   rˆ   r‡   rx   r   Úget_interfaceri   Ú_attn_implementationrã   r,   rê   rØ   rÊ   rð   )r"   r&   r×   rÙ   Úinput_shapeÚhidden_shapeÚquery_statesÚ
key_statesÚvalue_statesrÒ   Únum_windowsr�   rŽ   Úcombined_maskÚattention_interfacerâ   rá   s                    r$   r5   zSwinAttention.forward¦  sÚ  € ð $×)Ñ)¨#¨2Ð.ˆØ8˜Ð8 bÐ8¨$¯-©-Ñ8ˆà—{‘{ =Ó1×6Ñ6°|ÓD×NÑNÈqÐRSÓTˆØ—[‘[ Ó/×4Ñ4°\ÓB×LÑLÈQÐPQÓRˆ
Ø—{‘{ =Ó1×6Ñ6°|ÓD×NÑNÈqÐRSÓTˆð "&×!<Ñ!<Ó!>ÐØÐ%à(×.Ñ.¨qÑ1ˆKØ$ Q™¨;Ñ6ˆJØ! !‘nˆGð ×(Ñ(¨Ó+ß‘˜1“ß‘˜
 B¨¨B°Ó3ß‘˜˜Q ¨Ó1ð	 ð 3°^ÑC‰Mà2ˆMä(?×(MÑ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØð	%
ð  $Ÿ}š}‘C°$×2HÑ2HØ—L‘Lñ	%
ð ñ	%
Ñ!ˆ�\ð *�k×)Ñ)Ð;¨;Ð;¸Ò;×FÑFÓHˆØ—k‘k +Ó.ˆà˜LÐ(Ð(r%   r   )r8   r9   r:   r   r’   r!   r/   r=   rG   r   r   rI   r5   r?   r@   s   @r$   rå   rå   •  s‚   ø„ ðp˜zð p¸ð pÐRUð pÐdgõ pð& 48ñ2)à—|‘|ð2)ð ×)Ñ)¨DÑ0ð2)ð Ð+Ñ,ð	2)ð
 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*÷2)r%   rå   c                   ó`   ‡ — e Zd Zdedefˆ fd„Zdej                  dej                  fd„Zˆ xZ	S )ÚSwinMLPri   r~   c                 ó  •— t         ‰| �  «        t        |j                     | _        t        j                  |t        |j                  |z  «      «      | _	        t        j                  t        |j                  |z  «      |«      | _
        y r   )r    r!   r   Ú
hidden_actÚactivation_fnr   r®   r’   Ú	mlp_ratioÚfc1Úfc2)r"   ri   r~   r#   s      €r$   r!   zSwinMLP.__init__Ü  se   ø€ Ü‰ÑÔÜ# F×$5Ñ$5Ñ6ˆÔÜ—9‘9˜S¤# f×&6Ñ&6¸Ñ&<Ó"=Ó>ˆŒÜ—9‘9œS ×!1Ñ!1°CÑ!7Ó8¸#Ó>ˆ�r%   r&   r   c                 ól   — | j                  |«      }| j                  |«      }| j                  |«      }|S r   )r  r   r  )r"   r&   s     r$   r5   zSwinMLP.forwardâ  s4   € ØŸ™ Ó/ˆØ×*Ñ*¨=Ó9ˆØŸ™ Ó/ˆàÐr%   )
r8   r9   r:   r   r’   r!   r/   r=   r5   r?   r@   s   @r$   rý   rý   Û  s1   ø„ ð?˜zð ?°õ ?ð U§\¡\ð °e·l±l÷ r%   rý   c                 óÄ   — | j                   \  }}}}| j                  |||z  |||z  ||«      } | j                  dd«      j                  «       j                  d|||«      }|S )z2
    Partitions the given input into windows.
    rq   r   ro   ©r-   r|   r§   rÊ   )r°   r¼   r�   rl   rm   r‹   Úwindowss          r$   Úwindow_partitionr  ê  st   € ð /<×.AÑ.AÑ+€J�˜˜|Ø!×&Ñ&Ø�F˜kÑ)¨;¸ÀÑ8LÈkÐ[gó€Mð ×%Ñ% a¨Ó+×6Ñ6Ó8×=Ñ=¸bÀ+È{Ð\hÓi€GØ€Nr%   c                 óÀ   — | j                   d   }| j                  d||z  ||z  |||«      } | j                  dd«      j                  «       j                  d|||«      } | S )z?
    Merges windows to produce higher resolution features.
    ro   rq   r   r  )r  r¼   rl   rm   r‹   s        r$   Úwindow_reverser
  ö  sg   € ð —=‘= Ñ$€LØ�l‰l˜2˜v¨Ñ4°e¸{Ñ6JÈKÐYdÐfrÓs€GØ×Ñ  1Ó%×0Ñ0Ó2×7Ñ7¸¸FÀEÈ<ÓX€GØ€Nr%   c                   óª  ‡ — e Zd Z	 	 ddededeeef   dededefˆ fd„Z	 ddej                  d	eeef   d
e
dee   dej                  f
d„Zdeeef   ddfd„Zdededej                  dej                   dej                  dz  f
d„Zdej                  dededeej                  eedf   f   fd„Zddej                  de
dej                  fd„Zˆ xZS )Ú	SwinLayerri   r~   Úinput_resolutionr»   Údrop_path_rateÚ
shift_sizec                 óü  •— t         ‰| �  «        t        ||||j                  ¬«      | _        t        j                  ||j                  ¬«      | _        t        j                  ||j                  ¬«      | _	        t        ||«      | _        t        j                  |j                  «      | _        |j                  | _        || _        || _        |dkD  rt#        |«      | _        y t        j$                  «       | _        y )N)r¼   ©Úepsr(   )r    r!   rå   r¼   Ú	attentionr   rc   Úlayer_norm_epsÚlayernorm_beforeÚlayernorm_afterrý   Úmlpre   rf   rg   r  r  r   ÚIdentityÚ	drop_path)r"   ri   r~   r  r»   r  r  r#   s          €r$   r!   zSwinLayer.__init__  s¾   ø€ ô 	‰ÑÔÜ& v¨s°IÈ6×K]ÑK]Ô^ˆŒÜ "§¡¨S°f×6KÑ6KÔ LˆÔÜ!Ÿ|™|¨C°V×5JÑ5JÔKˆÔÜ˜6 3Ó'ˆŒÜ—z‘z &×"<Ñ"<Ó=ˆŒØ!×-Ñ-ˆÔØ$ˆŒØ 0ˆÔØ9GÈ#Ò9Mœ nÓ5ˆ�ÔSU×S^ÑS^ÓS`ˆ�r%   r&   r²   Úalways_partitionrÙ   r   c                 ó  — |s| j                  |«       |\  }}|j                  «       \  }}}	|}
| j                  |«      }|j                  ||||	«      }| j	                  |||«      \  }}|j
                  \  }}}}t        | j                  |«      | j                  «      }|j                  d| j                  | j                  z  |	«      }| j                  |||j                  |j                  ¬«      } | j                  ||fi |¤Ž\  }}| j                  |«      }|j                  d| j                  | j                  |	«      }| j                  t        || j                  ||«      d¬«      }|d   dkD  s|d   dkD  r|d d …d |…d |…d d …f   j                  «       }|j                  |||z  |	«      }|
| j!                  |«      z   }|}| j#                  |«      }| j%                  |«      }| j                  |«      |z   }||fS )Nro   r)   T)Úreverser   r   é   )Úset_shift_and_window_sizers   r  r|   r¤   r-   r  Úcyclic_shiftr¼   Úget_attn_maskr*   r+   r  rg   r
  rÊ   r  r  r  )r"   r&   r²   r  rÙ   rl   rm   r�   rŠ   ÚchannelsÚshortcutr£   Ú
height_padÚ	width_padÚhidden_states_windowsÚ	attn_maskÚattention_outputrá   Úattention_windowsÚresiduals                       r$   r5   zSwinLayer.forward  s-  € ñ  Ø×*Ñ*Ð+;Ô<Ø(‰ˆ�Ø"/×"4Ñ"4Ó"6Ñˆ
�A�xØ ˆà×-Ñ-¨mÓ<ˆØ%×*Ñ*¨:°v¸uÀhÓOˆð %)§N¡N°=À&È%Ó$PÑ!ˆ�zØ&3×&9Ñ&9Ñ#ˆˆ:�y !ä 0°×1BÑ1BÀ=Ó1QÐSW×ScÑScÓ dÐØ 5× :Ñ :¸2¸t×?OÑ?OÐRV×RbÑRbÑ?bÐdlÓ mÐØ×&Ñ&Ø˜	¨×)<Ñ)<ÐEZ×EaÑEað 'ó 
ˆ	ð *8¨¯©Ð8MÈyÑ)cÐ\bÑ)cÑ&Ð˜,ØŸ<™<Ð(8Ó9Ðà,×1Ñ1°"°d×6FÑ6FÈ×HXÑHXÐZbÓcÐØ ×-Ñ-ÜÐ,¨d×.>Ñ.>À
ÈIÓVÐ`dð .ó 
Ðð �a‰=˜1Ò 
¨1¡°Ò 1Ø 1²!°W°f°W¸f¸u¸fÂaÐ2GÑ H× SÑ SÓ UÐà-×2Ñ2°:¸vÈ¹~ÈxÓXÐØ  4§>¡>Ð2CÓ#DÑDˆà ˆØ×,Ñ,¨]Ó;ˆØŸ™ Ó/ˆØŸ™ ]Ó3°hÑ>ˆà˜lÐ*Ð*r%   Nc                 ó  — t        |«      | j                  k  rgt        d«      | _        t        j
                  j                  «       r(t	        j                   t	        j                  |«      «      n
t        |«      | _        yy)zQClamp window and shift sizes when the window is larger than the input resolution.r   N)Úminr¼   r   r  r/   rv   rw   Útensor)r"   r  s     r$   r  z#SwinLayer.set_shift_and_window_sizeD  s\   € äÐÓ  D×$4Ñ$4Ò4Ü'¨›lˆDŒOä=B¿Y¹Y×=QÑ=QÔ=S”—	‘	œ%Ÿ,™,Ð'7Ó8Ô9ÔY\Ð]mÓYnð Õð 5r%   rl   rm   r*   r+   c                 óì  — | j                   dk  ryt        j                  ||¬«      }t        j                  ||¬«      }||| j                  z
  k\  j	                  «       ||| j                   z
  k\  j	                  «       z   }||| j                  z
  k\  j	                  «       ||| j                   z
  k\  j	                  «       z   }|ddd…ddf   dz  |dddd…df   z   j                  |«      }	t        |	| j                  «      }
|
j                  d| j                  | j                  z  «      }
|
j                  d«      |
j                  d«      z
  }|j                  |dk7  d«      j                  |dk(  d	«      }|S )
uµ  Build the cyclic-shift attention mask for shifted-window MSA; returns None when shift_size is 0.

        Each (h, w) position belongs to one of 9 cyclic-shift regions (3 along each axis), encoded
        as ``h_region * 3 + w_region``. Regions per axis:
        - 0: indices ``[0, axis - window_size)``
        - 1: indices ``[axis - window_size, axis - shift_size)``
        - 2: indices ``[axis - shift_size, axis)``
        Implementation note: a single arithmetic pass on `torch.arange` (two comparisons +
        broadcast add) replaces the original 9-iteration nested-Python-loop slice-assignment â€”
        fully vectorised, no per-cell host-side scatter, no GPUâ†”host sync.
        r   N)r+   r   ro   r   rq   g      YÀr(   )
r  r/   rÇ   r¼   Úlongrà   r  r|   rˆ   Úmasked_fill)r"   rl   rm   r*   r+   Úh_idxÚw_idxÚh_regionÚw_regionÚimg_maskÚmask_windowsr&  s               r$   r   zSwinLayer.get_attn_maskL  si  € ð �?‰?˜aÒØÜ—‘˜V¨FÔ3ˆÜ—‘˜U¨6Ô2ˆØ˜V d×&6Ñ&6Ñ6Ñ6×<Ñ<Ó>À%È6ÐTX×TcÑTcÑKcÑBc×AiÑAiÓAkÑkˆØ˜U T×%5Ñ%5Ñ5Ñ5×;Ñ;Ó=ÀÈ%ÐRV×RaÑRaÑJaÑAa×@gÑ@gÓ@iÑiˆØ˜T¢1 d¨DÐ0Ñ1°AÑ5¸ÀÀtÊQÐPTÐATÑ8UÑU×YÑYÐZ_Ó`ˆÜ'¨°$×2BÑ2BÓCˆØ#×(Ñ(¨¨T×-=Ñ-=À×@PÑ@PÑ-PÓQˆØ ×*Ñ*¨1Ó-°×0FÑ0FÀqÓ0IÑIˆ	Ø×)Ñ)¨)°q©.¸&ÓA×MÑMÈiÐ[\ÉnÐ^aÓbˆ	ØÐr%   .c                 óþ   — | j                   || j                   z  z
  | j                   z  }| j                   || j                   z  z
  | j                   z  }ddd|d|f}t        j                  j                  ||«      }||fS )zHPad feature map so both spatial dimensions are divisible by window_size.r   )r¼   r   rz   r¢   )r"   r&   rl   rm   Ú	pad_rightÚ
pad_bottomr£   s          r$   r¤   zSwinLayer.maybe_pade  s�   € à×%Ñ%¨°×0@Ñ0@Ñ(@Ñ@ÀD×DTÑDTÑTˆ	Ø×&Ñ&¨°$×2BÑ2BÑ)BÑBÀd×FVÑFVÑVˆ
Ø˜˜A˜y¨!¨ZÐ8ˆ
ÜŸ™×)Ñ)¨-¸ÓDˆØ˜jÐ(Ð(r%   r  c                 ó˜   — | j                   dkD  r:|rdnd}t        j                  ||| j                   z  || j                   z  fd¬«      }|S )zOApply a cyclic shift along the spatial dimensions for shifted-window attention.r   r   ro   )r   rq   )ÚshiftsÚdims)r  r/   Úroll)r"   r&   r  Ú	directions       r$   r  zSwinLayer.cyclic_shiftm  sM   € à�?‰?˜QÒÙ$™¨"ˆIÜ!ŸJ™JØØ! D§O¡OÑ3°YÀÇÁÑ5PÐQØôˆMð
 Ðr%   )r(   r   r‘   )r8   r9   r:   r   r’   rI   r<   r!   r/   r=   r”   r   r   r5   r  r*   r+   r   r¤   r  r?   r@   s   @r$   r  r     sn  ø„ ð !$Øñaàðað ðað    S ™/ð	að
 ðað ðað õað0 "'ñ	-+à—|‘|ð-+ð    S ™/ð-+ð ð	-+ð
 Ð+Ñ,ð-+ð 
�‰ó-+ð^¸%ÀÀSÀ¹/ð Èdó ð Cð °ð ¸E¿K¹Kð ÐQV×Q]ÑQ]ð Ðbg×bnÑbnÐquÑbuó ð2) u§|¡|ð )¸Sð )Èð )ÐQVÐW\×WcÑWcÐejÐknÐpsÐksÑetÐWtÑQuó )ñ	¨%¯,©,ð 	Àð 	ÐRW×R^ÑR^÷ 	r%   r  c                   ó<  ‡ — e Zd Zdededeeef   dededee   fˆ fd„Zde	j                  d	e	j                  d
ededede	j                  fd„Z	 	 dde	j                  deeef   dededee   dee	j                  e	j                  e	j                  dz  f   fd„Zˆ xZS )Ú	SwinStageri   r~   r  Údepthr»   r  c                 ó  •— t         ‰	| �  «        || _        t        j                  t        |«      D �cg c]-  }t        ||||||   |dz  dk(  rdn|j                  dz  ¬«      ‘Œ/ c}«      | _        |� ||¬«      | _	        y d | _	        y c c}w )Nrq   r   )ri   r~   r  r»   r  r  r´   )
r    r!   ri   r   Ú
ModuleListr¶   r  r¼   ÚblocksÚ
downsample)
r"   ri   r~   r  r@  r»   r  rD  Úir#   s
            €r$   r!   zSwinStage.__init__z  s•   ø€ ô 	‰ÑÔØˆŒÜ—m‘mô ˜u›ö
ð ô Ø!ØØ%5Ø'Ø#,¨Q¡<Ø%&¨¡U¨a¢Z™q°f×6HÑ6HÈAÑ6Möò
ó
ˆŒð 2<Ð1G™*¨Ô-ˆ�ÈTˆ�ùò
s   ³2B
r&   Ú!hidden_states_before_downsamplingrl   rm   Ú(output_hidden_states_before_downsamplingr   c                 óæ   — |r|||}}}n%| j                   �||dz   dz  |dz   dz  }}}n|||}}}|j                  \  }	}
}|j                  |	|||«      j                  dddd«      j	                  «       S )u†  
        Select the spatial hidden states for this stage and reshape from (B, L, C) to (B, C, H, W).

        The chosen state and its resolution depend on output_hidden_states_before_downsampling:
        - True  â†’ pre-downsampling states at (height, width) â€” used by the backbone.
        - False â†’ post-downsampling states at half the resolution (if a downsampler exists).
        r   rq   r   r   )rD  r-   r|   ry   rÊ   )r"   r&   rF  rl   rm   rG  Úspatial_stateÚhÚwr�   rŠ   r    s               r$   Úget_reshaped_hidden_statesz$SwinStage.get_reshaped_hidden_states–  s�   € ñ 4Ø"CÀVÈU˜a˜1‰MØ�_‰_Ð(Ø"/°&¸1±*ÀÑ1BÀUÈQÁYÐSTÑDT˜a˜1‰Mà"/°¸˜a˜1ˆMà%2×%8Ñ%8Ñ"ˆ
�A�{Ø×!Ñ! *¨a°°KÓ@×HÑHÈÈAÈqÐRSÓT×_Ñ_ÓaÐar%   r²   r  rÙ   Nc                 óÄ   — |\  }}d }| j                   D ]  }	 |	||fd|i|¤Ž\  }}Œ |}
| j                  �| j                  |
|«      }| j                  ||
|||«      }|||fS )Nr  )rC  rD  rL  )r"   r&   r²   r  rG  rÙ   rl   rm   Úlast_attn_weightsÚlayer_modulerF  rF   s               r$   r5   zSwinStage.forward¯  sŸ   € ð )‰ˆ�Ø ÐØ ŸK™Kò 	ˆLÙ/;ØÐ/ñ0ØBRð0ØV\ñ0Ñ,ˆMÑ,ð	ð
 -:Ð)Ø�?‰?Ð&Ø ŸO™OÐ,MÐO_Ó`ˆMà!%×!@Ñ!@ØÐ<¸fÀeÐMuó"
Ðð Ð4Ð6GÐGÐGr%   )FF)r8   r9   r:   r   r’   rI   Úlistr<   r!   r/   r=   r”   rL  r   r   r5   r?   r@   s   @r$   r?  r?  y  s$  ø„ ðRàðRð ðRð    S ™/ð	Rð
 ðRð ðRð ˜‘;õRð8bà—|‘|ðbð ,1¯<©<ðbð ð	bð
 ðbð 37ðbð 
�‰óbð: "'Ø9>ñHà—|‘|ðHð    S ™/ðHð ð	Hð
 37ðHð Ð+Ñ,ðHð 
ˆu�|‰|˜UŸ\™\¨5¯<©<¸$Ñ+>Ð>Ñ	?÷Hr%   r?  c                   ó¶   ‡ — e Zd ZU eed<   dZdZdZdZdgZ	dZ
dZdZdZdZ eedd¬	«       eed
d¬	«      dœZdZddgZ ej*                  «       ˆ fd„«       Zˆ xZS )ÚSwinPreTrainedModelri   Úswinr„   )ÚimageTr?  Fr   )ÚindexÚcapture_initial_hidden_staterq   )r&   rE   rY   z(attention\.self\.relative_position_indexz:attention\.relative_position_bias\.relative_position_indexc                 óÎ  •— t         ‰| �  |«       t        |t        «      rX|j                  �t        j                  |j                  «       |j                  � t        j                  |j                  «       yyt        |t        «      r]t        j                  |j                  «       t        j                  |j                  |j                  «       j                  d«      «       yy)zInitialize the weightsNro   )r    Ú_init_weightsrš   rV   r`   ÚinitÚzeros_rb   rº   rÁ   Úcopy_r¾   rÃ   r|   )r"   rÓ   r#   s     €r$   rX  z!SwinPreTrainedModel._init_weightsç  s¨   ø€ ô 	‰Ñ˜fÔ%Ü�fœnÔ-Ø× Ñ Ð,Ü—‘˜F×-Ñ-Ô.Ø×)Ñ)Ð5Ü—‘˜F×6Ñ6Õ7ð 6ä˜Ô 8Ô9Ü�K‰K˜×;Ñ;Ô<Ü�J‰J�v×5Ñ5°v×7]Ñ7]Ó7_×7dÑ7dÐegÓ7hÕið :r%   )r8   r9   r:   r   rH   Úbase_model_prefixÚmain_input_nameÚinput_modalitiesÚsupports_gradient_checkpointingÚ_no_split_modulesÚ_supports_sdpaÚ_supports_flash_attnÚ_supports_flex_attnÚ_supports_attention_backendÚ_can_compile_fullgraphr   r?  Ú_can_record_outputsÚ_input_embed_layerÚ"_keys_to_ignore_on_load_unexpectedr/   Úno_gradrX  r?   r@   s   @r$   rR  rR  É  s¡   ø… àÓØÐØ$€OØ!ÐØ&*Ð#Ø$˜ÐØ€NØ ÐØÐØ"&ÐØ!Ðñ (¨	¸ÐY]Ô^ñ
 % Y°aÐV[Ô\ñ	Ðð ,Ðð 	4ØEð*Ð&ð
 €U‡]�]ƒ_ó
jó ô
jr%   rR  c                   ó®   ‡ — e Zd Zdedeeef   fˆ fd„Ze ed¬«      e		 	 	 dde
j                  deeef   ded	ed
edee   defd„«       «       «       Zˆ xZS )ÚSwinEncoderri   r[   c                 ó  •— t         ‰| �  |«       t        |j                  «      | _        || _        t        t        |j                  «      «      D �cg c]4  }|j                  |z  t        t        |j                  «      dz
  d«      z  ‘Œ6 }}t        j                  t        | j                  «      D �cg c]¥  }t        |t        |j                  d|z  z  «      |d   d|z  z  |d   d|z  z  f|j                  |   |j                  |   |t        |j                  d | «      t        |j                  d |dz    «       || j                  dz
  k  rt         nd ¬«      ‘Œ§ c}«      | _        | j%                  «        y c c}w c c}w )Nr   rq   r   )ri   r~   r  r@  r»   r  rD  )r    r!   ÚlenÚdepthsÚ
num_layersri   r¶   rË   r  Úmaxr   rB  r?  r’   r_   r»   r©   ÚlayersÚ	post_init)r"   ri   r[   rE  ÚdprÚ	layer_idxr#   s         €r$   r!   zSwinEncoder.__init__ö  sd  ø€ Ü‰Ñ˜Ô Ü˜fŸm™mÓ,ˆŒØˆŒÜSXÔY\Ð]c×]jÑ]jÓYkÓSlÖmÈaˆv×$Ñ$ qÑ(¬3¬s°6·=±=Ó/AÀAÑ/EÀqÓ+IÓIÐmˆÐmÜ—m‘mô "' t§¡Ó!7öð ô Ø!Ü˜F×,Ñ,¨q°)©|Ñ;Ó<Ø&/°¡l°q¸)±|Ñ&DÀiÐPQÁlÐWXÐZcÑWcÑFdÐ%eØ Ÿ-™-¨	Ñ2Ø$×.Ñ.¨yÑ9Ø!¤# f§m¡m°J°YÐ&?Ó"@Ä3ÀvÇ}Á}ÐUdÐW`ÐcdÑWdÐGeÓCfÐgØ4=ÀÇÁÐRSÑ@SÒ4SÕ/ÐZ^öòó
ˆŒð 	�‰Õùò nùòs   Á9E:Â3B*E?F)Útie_last_hidden_statesr&   r²   r  Úoutput_hidden_statesrG  rÙ   r   c                 óN  — d}|rH|j                   \  }}	}
 |j                  |g|¢|
‘­Ž j                  dddd«      j                  «       }|f}| j                  D ]>  } |||f||dœ|¤Ž\  }}}	|r||fz  }|j
                  €Œ)|d   dz   dz  |d   dz   dz  f}Œ@ t        ||¬«      S )aÕ  
        input_dimensions (`tuple[int, int]`):
            Spatial `(height, width)` of the patch grid entering the encoder.
        always_partition (`bool`, *optional*, defaults to `False`):
            If `True`, always apply window partitioning regardless of input resolution.
        output_hidden_states_before_downsampling (`bool`, *optional*, defaults to `False`):
            If `True`, `reshaped_hidden_states` contains pre-downsampling feature maps.
        Nr   r   r   rq   ©r  rG  )rD   rF   )r-   r|   ry   rÊ   rq  rD  rC   )r"   r&   r²   r  rv  rG  rÙ   Úall_reshaped_hidden_statesr�   rŠ   r    Ústem_spatialrO  Úreshaped_hidden_states                 r$   r5   zSwinEncoder.forward  s  € ð( &*Ð"Ùð *7×)<Ñ)<Ñ&ˆJ˜˜;à"�×"Ñ" :ÐNÐ0@ÐNÀ+ÒN×VÑVÐWXÐZ[Ð]^Ð`aÓb×mÑmÓoð ð +7¨Ð&à ŸK™Kò 	dˆLÙ6BØØ ð7ð "2Ø9añ	7ð
 ñ7Ñ3ˆMÐ0°!ñ $Ø*Ð/DÐ.FÑFÐ*Ø×&Ñ&Ñ2Ø%5°aÑ%8¸1Ñ%<ÀÑ$BÐEUÐVWÑEXÐ[\ÑE\ÐabÑDbÐ#cÑ ð	dô !Ø+Ø#=ô
ð 	
r%   )FFF)r8   r9   r:   r   rI   r’   r!   r   r   r   r/   r=   r”   r   r   rC   r5   r?   r@   s   @r$   rk  rk  õ  s¨   ø„ ð˜zð °e¸CÀ¸H±oõ ð*  Ù¨EÔ2Øð
 "'Ø%*Ø9>ñ+
à—|‘|ð+
ð    S ™/ð+
ð ð	+
ð
 #ð+
ð 37ð+
ð Ð+Ñ,ð+
ð 
ò+
ó ó 3ó  ô+
r%   rk  c                   ó’   ‡ — e Zd Zd	ˆ fd„	Zee	 	 	 d
dej                  dz  dej                  dz  de	de
e   def
d„«       «       Zˆ xZS )Ú	SwinModelc                 óê  •— t         ‰| �  |«       || _        t        |j                  «      | _        t        |j                  d| j
                  dz
  z  z  «      | _        t        ||¬«      | _
        t        || j                  j                  «      | _        t        j                  | j                  |j                   ¬«      | _        |rt        j$                  d«      nd| _        | j)                  «        y)a  
        add_pooling_layer (`bool`, *optional*, defaults to `True`):
            Whether or not to apply pooling layer.
        use_mask_token (`bool`, *optional*, defaults to `False`):
            Whether or not to create and apply mask tokens in the embedding layer.
        rq   r   )rj   r  N)r    r!   ri   rm  rn  ro  r’   r_   Únum_featuresrV   rk   rk  r\   Úencoderr   rc   r  Ú	layernormÚAdaptiveAvgPool1dÚpoolerrr  )r"   ri   Úadd_pooling_layerrj   r#   s       €r$   r!   zSwinModel.__init__>  sµ   ø€ ô 	‰Ñ˜Ô ØˆŒÜ˜fŸm™mÓ,ˆŒÜ × 0Ñ 0°1¸¿¹È1Ñ9LÑ3MÑ MÓNˆÔä(¨ÀÔOˆŒÜ" 6¨4¯?©?×+EÑ+EÓFˆŒäŸ™ d×&7Ñ&7¸V×=RÑ=RÔSˆŒÙ1B”b×*Ñ*¨1Ô-ÈˆŒð 	�‰Õr%   Nr„   r…   rƒ   rÙ   r   c                 óÈ  — |j                  d| j                  j                  «      }| j                  |||¬«      \  }} | j                  ||fd|i|¤Ž}|j
                  }	| j                  |	«      }	d}
| j                  �7| j                  |	j                  dd«      «      }
t        j                  |
d«      }
t        |	|
|j                  |j                  |j                  ¬«      S )zË
        bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, num_patches)`, *optional*):
            Boolean masked positions. Indicates which patches are masked (1) and which aren't (0).
        rv  ©r…   rƒ   Nr   rq   )rD   rM   r&   rE   rF   )Úpopri   rv  rk   r€  rD   r�  rƒ  r§   r/   r¦   rL   r&   rE   rF   )r"   r„   r…   rƒ   rÙ   rv  Úembedding_outputr²   Úencoder_outputsÚsequence_outputÚpooled_outputs              r$   r5   zSwinModel.forwardS  sñ   € ð  &Ÿz™zÐ*@À$Ç+Á+×BbÑBbÓcÐà-1¯_©_Ø¨/ÐTlð .=ó .
Ñ*ÐÐ*ð '˜$Ÿ,™,ØØñ
ð "6ð
ð ñ	
ˆð *×;Ñ;ˆØŸ.™.¨Ó9ˆàˆØ�;‰;Ð"Ø ŸK™K¨×(AÑ(AÀ!ÀQÓ(GÓHˆMÜ!ŸM™M¨-¸Ó;ˆMäØ-Ø'Ø)×7Ñ7Ø&×1Ñ1Ø#2×#IÑ#Iô
ð 	
r%   )TF©NNF)r8   r9   r:   r!   r   r   r/   rG   r“   r”   r   r   rL   r5   r?   r@   s   @r$   r}  r}  <  s{   ø„ õð* Øð 26Ø37Ø).ñ	(
à×'Ñ'¨$Ñ.ð(
ð ×)Ñ)¨DÑ0ð(
ð #'ð	(
ð
 Ð+Ñ,ð(
ð 
ò(
ó ó ô(
r%   r}  ad  
    Swin Model with a decoder on top for masked image modeling, as proposed in [SimMIM](https://huggingface.co/papers/2111.09886).

    <Tip>

    Note that we provide a script to pre-train this model on custom data in our [examples
    directory](https://github.com/huggingface/transformers/tree/main/examples/pytorch/image-pretraining).

    </Tip>
    c                   ó�   ‡ — e Zd Zˆ fd„Zee	 	 	 d	dej                  dz  dej                  dz  de	de
e   def
d„«       «       Zˆ xZS )
ÚSwinForMaskedImageModelingc                 óŠ  •— t         ‰| �  |«       t        |dd¬«      | _        t	        |j
                  d|j                  dz
  z  z  «      }t        j                  t        j                  ||j                  dz  |j                  z  d¬«      t        j                  |j                  «      «      | _        | j                  «        y )NFT)r„  rj   rq   r   )Úin_channelsÚout_channelsr—   )r    r!   r}  rS  r’   r_   ro  r   Ú
Sequentialrž   Úencoder_strider‹   ÚPixelShuffleÚdecoderrr  )r"   ri   r  r#   s      €r$   r!   z#SwinForMaskedImageModeling.__init__�  s    ø€ Ü‰Ñ˜Ô ä˜f¸ÈdÔSˆŒ	ä˜6×+Ñ+¨a°F×4EÑ4EÈÑ4IÑ.JÑJÓKˆÜ—}‘}Ü�I‰IØ(°v×7LÑ7LÈaÑ7OÐRX×ReÑReÑ7eÐstôô �O‰O˜F×1Ñ1Ó2ó	
ˆŒð 	�‰Õr%   Nr„   r…   rƒ   rÙ   r   c                 ó|  —  | j                   |f||dœ|¤Ž}|j                  }|j                  dd«      }|j                  \  }}}	t	        j
                  |	dz  «      x}
}|j                  |||
|«      }| j                  |«      }d}|��| j                  j                  | j                  j                  z  }|j                  d||«      }|j                  | j                  j                  d«      j                  | j                  j                  d«      j                  d«      j                  «       }t        j                  j!                  ||d¬«      }||z  j#                  «       |j#                  «       d	z   z  | j                  j$                  z  }t'        |||j(                  |j*                  |j,                  ¬
«      S )aˆ  
        bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, num_patches)`):
            Boolean masked positions. Indicates which patches are masked (1) and which aren't (0).

        Examples:
        ```python
        >>> from transformers import AutoImageProcessor, SwinForMaskedImageModeling
        >>> import torch
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))

        >>> image_processor = AutoImageProcessor.from_pretrained("microsoft/swin-base-simmim-window6-192")
        >>> model = SwinForMaskedImageModeling.from_pretrained("microsoft/swin-base-simmim-window6-192")

        >>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
        >>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
        >>> # create random boolean mask of shape (batch_size, num_patches)
        >>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()

        >>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
        >>> loss, reconstructed_pixel_values = outputs.loss, outputs.reconstruction
        >>> list(reconstructed_pixel_values.shape)
        [1, 3, 192, 192]
        ```r†  r   rq   rp   Nro   Únone)r¯   gñhãˆµøä>)rP   rQ   r&   rE   rF   )rS  rD   r§   r-   Úmathr1   rx   r•  ri   r™   rh   Úrepeat_interleaverˆ   rÊ   r   rz   Úl1_lossrË   r‹   rO   r&   rE   rF   )r"   r„   r…   rƒ   rÙ   ÚoutputsrŠ  r�   r‹   Úsequence_lengthrl   rm   Úreconstructed_pixel_valuesÚmasked_im_lossrs   r�   Úreconstruction_losss                    r$   r5   z"SwinForMaskedImageModeling.forward�  s¥  € ðL �$—)‘)Øð
à+Ø%=ñ
ð ñ	
ˆð "×3Ñ3ˆà)×3Ñ3°A°qÓ9ˆØ4C×4IÑ4IÑ1ˆ
�L /ÜŸ™ O°SÑ$8Ó9Ð9ˆ�Ø)×1Ñ1°*¸lÈFÐTYÓZˆð &*§\¡\°/Ó%BÐ"àˆØÑ&Ø—;‘;×)Ñ)¨T¯[©[×-CÑ-CÑCˆDØ-×5Ñ5°b¸$ÀÓEˆOà×1Ñ1°$·+±+×2HÑ2HÈ!ÓLß"Ñ" 4§;¡;×#9Ñ#9¸1Ó=ß‘˜1“ß‘“ð	 ô #%§-¡-×"7Ñ"7¸ÐF`ÐlrÐ"7Ó"sÐØ1°DÑ8×=Ñ=Ó?À4Ç8Á8Ã:ÐPTÑCTÑUÐX\×XcÑXc×XpÑXpÑpˆNä,ØØ5Ø!×/Ñ/Ø×)Ñ)Ø#*×#AÑ#Aô
ð 	
r%   rŒ  )r8   r9   r:   r!   r   r   r/   rG   r“   r”   r   r   rO   r5   r?   r@   s   @r$   rŽ  rŽ  €  s‚   ø„ ôð  Øð 26Ø37Ø).ñ	H
à×'Ñ'¨$Ñ.ðH
ð ×)Ñ)¨DÑ0ðH
ð #'ð	H
ð
 Ð+Ñ,ðH
ð 
'òH
ó ó ôH
r%   rŽ  aâ  
    Swin Model transformer with an image classification head on top (a linear layer on top of the final hidden state of
    the [CLS] token) e.g. for ImageNet.

    <Tip>

        Note that it's possible to fine-tune Swin on higher resolution images than the ones it has been trained on, by
        setting `interpolate_pos_encoding` to `True` in the forward of the model. This will interpolate the pre-trained
        position embeddings to the higher resolution.

    </Tip>
    c                   ó�   ‡ — e Zd Zˆ fd„Zee	 	 	 d	dej                  dz  dej                  dz  de	de
e   def
d„«       «       Zˆ xZS )
ÚSwinForImageClassificationc                 ó>  •— t         ‰| �  |«       |j                  | _        t        |«      | _        |j                  dkD  r4t        j                  | j                  j                  |j                  «      nt        j                  «       | _	        | j                  «        y )Nr   )r    r!   Ú
num_labelsr}  rS  r   r®   r  r  Ú
classifierrr  )r"   ri   r#   s     €r$   r!   z#SwinForImageClassification.__init__ù  sx   ø€ Ü‰Ñ˜Ô à ×+Ñ+ˆŒÜ˜fÓ%ˆŒ	ð EK×DUÑDUÐXYÒDYŒB�I‰I�d—i‘i×,Ñ,¨f×.?Ñ.?Ô@Ô_a×_jÑ_jÓ_lð 	Œð
 	�‰Õr%   Nr„   Úlabelsrƒ   rÙ   r   c                 ó  —  | j                   |fd|i|¤Ž}|j                  }| j                  |«      }d}|� | j                  ||| j                  fi |¤Ž}t        |||j                  |j                  |j                  ¬«      S )aŠ  
        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
            Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
        rƒ   N)rP   rT   r&   rE   rF   )	rS  rM   r¤  Úloss_functionri   rS   r&   rE   rF   )	r"   r„   r¥  rƒ   rÙ   r›  r‹  rT   rP   s	            r$   r5   z"SwinForImageClassification.forward  sœ   € ð �$—)‘)Øñ
à%=ð
ð ñ
ˆð  ×-Ñ-ˆà—‘ Ó/ˆàˆØÐØ%�4×%Ñ% f¨f°d·k±kÑLÀVÑLˆDä(ØØØ!×/Ñ/Ø×)Ñ)Ø#*×#AÑ#Aô
ð 	
r%   rŒ  )r8   r9   r:   r!   r   r   r/   rG   Ú
LongTensorr”   r   r   rS   r5   r?   r@   s   @r$   r¡  r¡  ê  s{   ø„ ôð Øð 26Ø*.Ø).ñ	!
à×'Ñ'¨$Ñ.ð!
ð × Ñ  4Ñ'ð!
ð #'ð	!
ð
 Ð+Ñ,ð!
ð 
#ò!
ó ó ô!
r%   r¡  zM
    Swin backbone, to be used with frameworks like DETR and MaskFormer.
    c            	       óv   ‡ — e Zd ZdgZdefˆ fd„Zeeede	j                  dee   defd„«       «       «       Zˆ xZS )ÚSwinBackbonezswin.layernorm.*ri   c           	      óÚ  •— t         ‰| �  |«       |j                  gt        t	        |j
                  «      «      D �cg c]  }t        |j                  d|z  z  «      ‘Œ c}z   | _        t        |d¬«      | _	        i }t        | j                  | j                  «      D ]  \  }}t        j                  |«      ||<   Œ t        j                  |«      | _        | j#                  «        y c c}w )Nrq   F)r„  )r    r!   r_   r¶   rm  rn  r’   r  r}  rS  ÚzipÚout_featuresr!  r   rc   Ú
ModuleDictÚhidden_states_normsrr  )r"   ri   rE  r¯  Ústager‹   r#   s         €r$   r!   zSwinBackbone.__init__5  sÎ   ø€ Ü‰Ñ˜Ô à#×-Ñ-Ð.ÔX]Ô^aÐbh×boÑboÓ^pÓXqÖ1rÐST´#°f×6FÑ6FÈÈAÉÑ6MÕ2NÒ1rÑrˆÔÜ˜f¸Ô>ˆŒ	ð !ÐÜ#& t×'8Ñ'8¸$¿-¹-Ó#Hò 	DÑˆE�<Ü)+¯©°lÓ)CÐ Ò&ð	Dä#%§=¡=Ð1DÓ#EˆÔ ð 	�‰Õùò 2ss   ½"C(r„   rÙ   r   c                 ó  —  | j                   |fdddœ|¤Ž}d}t        | j                  |j                  «      D ]®  \  }}|| j                  v sŒ|j
                  \  }}}	}
|j                  dddd«      j                  «       }|j                  ||	|
z  |«      } | j                  |   |«      }|j                  ||	|
|«      }|j                  dddd«      j                  «       }||fz  }Œ° t        ||j                  |j                  ¬«      S )	a“  
        Examples:

        ```python
        >>> from transformers import AutoImageProcessor, AutoBackbone
        >>> import torch
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))

        >>> processor = AutoImageProcessor.from_pretrained("shi-labs/nat-mini-in1k-224")
        >>> model = AutoBackbone.from_pretrained(
        ...     "microsoft/swin-tiny-patch4-window7-224", out_features=["stage1", "stage2", "stage3", "stage4"]
        ... )

        >>> inputs = processor(image, return_tensors="pt")
        >>> outputs = model(**inputs)
        >>> feature_maps = outputs.feature_maps
        >>> list(feature_maps[-1].shape)
        [1, 768, 7, 7]
        ```
        Trx  rJ   r   rq   r   r   )Úfeature_mapsr&   rE   )rS  r¬  Ústage_namesrF   r­  r-   ry   rÊ   r|   r¯  r   rE   )r"   r„   rÙ   r›  r²  r°  Úhidden_stater�   r‹   rl   rm   s              r$   r5   zSwinBackbone.forwardD  s0  € ðH �$—)‘)Øð
à!Ø59ñ
ð ñ	
ˆð ˆÜ#& t×'7Ñ'7¸×9WÑ9WÓ#Xò 	0ÑˆE�<Ø˜×)Ñ)Ò)Ø:F×:LÑ:LÑ7�
˜L¨&°%Ø+×3Ñ3°A°q¸!¸QÓ?×JÑJÓL�Ø+×0Ñ0°¸VÀe¹^È\ÓZ�Ø>˜t×7Ñ7¸Ñ>¸|ÓL�Ø+×0Ñ0°¸VÀUÈLÓY�Ø+×3Ñ3°A°q¸!¸QÓ?×JÑJÓL�Ø  Ñ/‘ð	0ô Ø%Ø!×8Ñ8Ø×)Ñ)ô
ð 	
r%   )r8   r9   r:   Ú_keys_to_ignore_on_load_missingr   r!   r   r
   r   r/   r=   r   r   r   r5   r?   r@   s   @r$   rª  rª  -  sd   ø„ ð (;Ð&;Ð#ð˜zõ ð Ø Øð7
à—l‘lð7
ð Ð+Ñ,ð7
ð 
ò	7
ó ó !ó ô7
r%   rª  )r¡  rŽ  r}  rR  rª  )Nr(   )@Úcollections.abcr›   r˜  r   Údataclassesr   r/   r   Ú r   rY  Úactivationsr   Úbackbone_utilsr	   r
   Úmodeling_layersr   Úmodeling_outputsr   Úmodeling_utilsr   r   Úprocessing_utilsr   Úutilsr   r   r   r   Úutils.genericr   r   Úutils.output_capturingr   r   Úconfiguration_swinr   ÚModuler   rC   rL   rO   rS   rV   rX   r©   rº   r=   r<   rã   rå   rý   r  r
  r  r?  rR  rk  r}  rŽ  r¡  rª  Ú__all__rJ   r%   r$   ú<module>rÅ     sû  ðó* Û Ý $Ý !ã Ý å &Ý !ß HÝ 9Ý .ß FÝ &ß OÓ Oß Iß EÝ *ô%�2—9‘9ô %ñ0 ðôð
 ôH˜ó Hó óðHñ  ðôð
 ôH�kó Hó óðHñ& ðôð
 ôH Kó Hó óðHñ* ðôð
 ôH ó Hó óðHô*M-�R—Y‘Yô M-ô`'-˜"Ÿ)™)ô '-ôT%�r—y‘yô %ôP-Q˜rŸy™yô -Qðl !Øñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 —L‘L 4Ñ'ð%ð �T‰\ð%ð ð%ð Ð'Ñ(ó%ô8C)�B—I‘Iô C)ôLˆb�i‰iô ò	òôvÐ*ô vôrMHÐ*ô MHð` ô(j˜/ó (jó ð(jôVD
Ð%ô D
ðN ô@
Ð#ó @
ó ð@
ñF ð	ôô[
Ð!4ó [
óð[
ñ| ðôô2
Ð!4ó 2
óð2
ñj ðôô
L
�=Ð"5ó L
óð
L
ò^�r%   