Ë
    ÜÓ^j	¼  ã                   ó(  — d Z 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 ddlmZ ddlmZ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&m'Z'm(Z(m)Z)m*Z*m+Z+ ddl,m-Z-  ej\                  e/«      Z0 G d„ dejb                  «      Z2 ed¬«      e G d„ de«      «       «       Z3 ed¬«      e G d„ de«      «       «       Z4 ed¬«      e G d„ d e«      «       «       Z5 ed!¬«      e G d"„ d#e«      «       «       Z6d$„ Z7d%„ Z8 G d&„ d'ejb                  «      Z9 G d(„ d)ejb                  «      Z: G d*„ d+ejb                  «      Z; G d,„ d-ejb                  «      Z< G d.„ d/e'«      Z= G d0„ d1e)«      Z> G d2„ d3e(«      Z? G d4„ d5e«      Z@e G d6„ d7e*«      «       ZA G d8„ d9eA«      ZBe G d:„ d;eA«      «       ZC ed<¬«       G d=„ d>eA«      «       ZD ed?¬«       G d@„ dAeA«      «       ZE edB¬«       G dC„ dDeeA«      «       ZFg dE¢ZGy)FzPyTorch Swin Transformer model.é    N)ÚCallable)Ú	dataclass)Únné   )Úinitialization)ÚACT2FN)ÚBackboneMixinÚfilter_output_hidden_states)ÚGradientCheckpointingLayer)ÚBackboneOutput)ÚALL_ATTENTION_FUNCTIONS)ÚUnpack)ÚModelOutputÚTransformersKwargsÚauto_docstringÚloggingÚ	torch_int)Úcan_return_tupleÚmerge_with_config_defaults)ÚOutputRecorderÚcapture_outputsé   )ÚPreTrainedModelÚViTAttentionÚViTLayerÚViTMLPÚViTPreTrainedModelÚeager_attention_forwardé   )Ú
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     €úp/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/swin/modular_swin.pyr(   zSwinDropPath.__init__7   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Úrandr1   r2   ÚfloorÚdiv)r)   r-   Ú	keep_probr4   Úrandom_tensors        r+   ÚforwardzSwinDropPath.forward;   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_reprD   s   € Ø�D—N‘NÐ#Ð$Ð$r,   )r/   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__Úfloatr(   r6   ÚTensorr<   Ústrr>   Ú__classcell__©r*   s   @r+   r"   r"   0   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)r?   r@   rA   rB   rK   r6   ÚFloatTensorÚ__annotations__r-   ÚtuplerL   rM   © r,   r+   rJ   rJ   H   s}   … ñð 37Ð�u×(Ñ(¨4Ñ/Ó6Ø:>€M�5˜×*Ñ*¨CÐ/Ñ0°4Ñ7Ó>Ø7;€J��e×'Ñ'¨Ð,Ñ-°Ñ4Ó;ØCGÐ˜E %×"3Ñ"3°SÐ"8Ñ9¸DÑ@ÔGr,   rJ   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.
    NrK   Úpooler_output.r-   rL   rM   )r?   r@   rA   rB   rK   r6   rN   rO   rT   r-   rP   rL   rM   rQ   r,   r+   rS   rS   ^   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,   rS   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-   rL   rM   )r?   r@   rA   rB   rW   r6   rN   rO   rX   r-   rP   rL   rM   rQ   r,   r+   rV   rV   w   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,   rV   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.
    NrW   Úlogits.r-   rL   rM   )r?   r@   rA   rB   rW   r6   rN   rO   r[   r-   rP   rL   rM   rQ   r,   r+   rZ   rZ   ’   s‘   … ñð &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø'+€FˆE×Ñ Ñ$Ó+Ø:>€M�5˜×*Ñ*¨CÐ/Ñ0°4Ñ7Ó>Ø7;€J��e×'Ñ'¨Ð,Ñ-°Ñ4Ó;ØCGÐ˜E %×"3Ñ"3°SÐ"8Ñ9¸DÑ@ÔGr,   rZ   c                 óÄ   — | j                   \  }}}}| j                  |||z  |||z  ||«      } | j                  dd«      j                  «       j                  d|||«      }|S )z2
    Partitions the given input into windows.
    r   r   éÿÿÿÿ©r4   ÚviewÚ	transposeÚ
contiguous)Úinput_featureÚwindow_sizeÚ
batch_sizeÚheightÚwidthÚnum_channelsÚwindowss          r+   Úwindow_partitionri   ­   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.
    r]   r   r   r^   )rh   rc   re   rf   rg   s        r+   Úwindow_reverserk   ¹   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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   Ú	Parameterr6   ÚzerosÚ	embed_dimÚ
mask_tokenÚuse_absolute_embeddingsÚposition_embeddingsÚ	LayerNormÚnormÚDropoutÚhidden_dropout_probÚdropoutÚ
patch_sizeÚconfig)r)   r€   Úuse_mask_tokenrq   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,   Ú
embeddingsre   rf   r$   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   r   r   ÚbicubicF)ÚsizeÚmodeÚalign_corners)r4   ry   r6   ÚjitÚ
is_tracingr   r   ÚreshapeÚpermuter   Ú
functionalÚinterpolater_   )r)   r‚   re   rf   rq   Ú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 )Nr]   g      ð?)r4   rp   r{   r†   rw   ÚexpandÚ	unsqueezeÚtype_asry   r•   r~   )r)   r–   r—   r•   Ú_rg   re   rf   r‚   Úoutput_dimensionsrd   Úseq_lenÚmask_tokensÚmasks                 r+   r<   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)r?   r@   rA   rB   r(   r6   rD   Úintr•   rN   Ú
BoolTensorÚboolrP   r<   rF   rG   s   @r+   rm   rm   Ã   s’   ø„ ñõð"D°5·<±<ð DÈð DÐUXð DÐ]b×]iÑ]ió DðB 48Ø).ñ	-à×'Ñ'¨$Ñ.ð-ð ×)Ñ)¨DÑ0ð-ð #'ð	-ð
 
ˆu�|‰|Ñ	÷-r,   rm   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 )ro   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_sizer   rg   rv   Ú
isinstanceÚcollectionsÚabcÚIterablerq   rr   r   ÚConv2dÚ
projection)r)   r€   r©   r   rg   Úhidden_sizerq   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   )r   r   r�   Úpad)r)   r–   re   rf   Ú
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 )Nr   r   )r4   r´   r¯   Úflattenr`   )r)   r–   rœ   rg   re   rf   r‚   r�   s           r+   r<   zSwinPatchEmbeddings.forward1  s}   € Ø)5×);Ñ);Ñ&ˆˆ<˜ à—~‘~ l°F¸EÓBˆØ—_‘_ \Ó2ˆ
Ø(×.Ñ.Ñˆˆ1ˆf�eØ# U˜OÐØ×'Ñ'¨Ó*×4Ñ4°Q¸Ó:ˆ
àÐ,Ð,Ð,r,   )r?   r@   rA   rB   r(   r´   r6   rN   rP   rD   r¢   r<   rF   rG   s   @r+   ro   ro     sF   ø„ ñôjòð	- E×$5Ñ$5¸Ñ$<ð 	-ÀÀuÇ|Á|ÐUZÐ[^ÑU_ÐG_ÑA`÷ 	-r,   ro   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é   r   F©Úbias)r'   r(   r   ÚLinearÚ	reductionrz   r{   )r)   r�   r*   s     €r+   r(   zSwinPatchMerging.__init__F  s>   ø€ Ü‰ÑÔÜŸ™ 1 s¡7¨A°©G¸%Ô@ˆŒÜ—L‘L  S¡Ó)ˆ�	r,   rb   re   rf   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.r   r   r   )r   r�   r²   )r)   rb   re   rf   s       r+   r´   zSwinPatchMerging.maybe_padK  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 )Nr   r]   ©r�   rº   )r4   r_   r´   r6   ÚcatÚranger{   r¾   )
r)   rb   rÀ   re   rf   rd   r�   rg   ÚcolÚrows
             r+   r<   zSwinPatchMerging.forwardQ  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
)r?   r@   rA   rB   r¢   r(   r6   rD   r´   rP   r<   rF   rG   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_headsrc   c                 ó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   r   Úrelative_position_indexr]   F)Ú
persistent)r'   r(   rc   Úwindow_arear   rt   r6   ru   Úrelative_position_bias_tableÚregister_bufferÚ_create_relative_position_indexr_   )r)   rÉ   rc   r*   s      €r+   r(   z!SwinRelativePositionBias.__init__o  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)Úindexingr   r]   )	r6   Úarangerc   ÚstackÚmeshgridr¶   rŒ   ra   Úsum)r)   Úcoords_hÚcoords_wÚcoordsÚcoords_flattenÚrelative_coordss         r+   rÐ   z8SwinRelativePositionBias._create_relative_position_index~  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 )Nr]   r   r   r   )rÎ   rË   r_   rÍ   rŒ   ra   rš   )r)   Úrelative_position_biass     r+   r<   z SwinRelativePositionBias.forward�  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,   )r?   r@   rA   rB   r¢   rP   r(   r6   rD   rÐ   r<   rF   rG   s   @r+   rÈ   rÈ   e  sE   ø„ ñð
 #ð 
°E¸#¸s¸(±Oõ 
ð'°·±ó 'ð"Q˜Ÿ™÷ Qr,   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 )ÚSwinAttentionr€   r°   Únum_attention_headsrc   c                 ó´  •— t         ‰| �  |«       || _        ||z  | _        | j                  dz  | _        t        j                  |||j                  ¬«      | _        t        j                  |||j                  ¬«      | _	        t        j                  |||j                  ¬«      | _
        t        j                  ||«      | _        t        |||f«      | _        y )Ng      à¿r»   )r'   r(   rá   Úhead_dimÚscalingr   r½   Úqkv_biasÚq_projÚk_projÚv_projÚo_projrÈ   rÞ   )r)   r€   r°   rá   rc   r*   s        €r+   r(   zSwinAttention.__init__–  s¦   ø€ Ü‰Ñ˜Ô Ø#6ˆÔ Ø#Ð':Ñ:ˆŒØ—}‘} dÑ*ˆŒä—i‘i ¨[¸v¿¹ÔOˆŒÜ—i‘i ¨[¸v¿¹ÔOˆŒÜ—i‘i ¨[¸v¿¹ÔOˆŒÜ—i‘i ¨[Ó9ˆŒä&>Ð?RÐU`ÐbmÐTnÓ&oˆÕ#r,   Nr-   Úattention_maskÚkwargsr$   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 )Nr]   r   r   r   r/   )r~   rä   )r4   rã   ræ   r_   r`   rç   rè   rÞ   rš   r™   r‹   r   Úget_interfacer€   Ú_attn_implementationr   r3   Úattention_dropouträ   ra   ré   )r)   r-   rê   rë   Úinput_shapeÚhidden_shapeÚquery_statesÚ
key_statesÚvalue_statesrÞ   Únum_windowsrd   rž   Úcombined_maskÚattention_interfaceÚattn_outputÚattn_weightss                    r+   r<   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&   )r?   r@   rA   r    r¢   r(   r6   rD   rN   r   r   rP   r<   rF   rG   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d„Zy)ÚSwinMLPr€   r�   c                 ó6  — t         j                  j                  | «       t        |j                     | _        t        j                  |t        |j                  |z  «      «      | _	        t        j                  t        |j                  |z  «      |«      | _
        y r&   )r   ÚModuler(   r   Ú
hidden_actÚactivation_fnr½   r¢   Ú	mlp_ratioÚfc1Úfc2)r)   r€   r�   s      r+   r(   zSwinMLP.__init__Ù  sk   € Ü
�	‰	×Ñ˜4Ô Ü# F×$5Ñ$5Ñ6ˆÔÜ—9‘9˜S¤# f×&6Ñ&6¸Ñ&<Ó"=Ó>ˆŒÜ—9‘9œS ×!1Ñ!1°CÑ!7Ó8¸#Ó>ˆ�r,   N)r?   r@   rA   r    r¢   r(   rQ   r,   r+   rû   rû   Ø  s   „ ð?˜zð ?°ô ?r,   rû   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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	 dde	j                  deeef   dedee   de	j                  f
d„Zˆ xZS )Ú	SwinLayerr€   r�   Úinput_resolutionrÉ   Údrop_path_rateÚ
shift_sizec                 ó´  •— t         ‰| �  «        |j                  | _        t        ||||j                  ¬«      | _        t        j                  ||j                  ¬«      | _        t        j                  ||j                  ¬«      | _	        t        ||«      | _        || _        || _        |dkD  rt        |«      | _        y t        j                  «       | _        y )N)rc   ©Úepsr/   )r'   r(   rc   rà   Ú	attentionr   rz   Úlayer_norm_epsÚlayernorm_beforeÚlayernorm_afterrû   Úmlpr  r  r"   ÚIdentityÚ	drop_path)r)   r€   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Ó'ˆŒØ$ˆŒØ 0ˆÔØ9GÈ#Ò9Mœ nÓ5ˆ�ÔSU×S^ÑS^ÓS`ˆ�r,   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)Úminrc   r   r  r6   r‰   rŠ   Útensor)r)   r  s     r+   Úset_shift_and_window_sizez#SwinLayer.set_shift_and_window_sizeô  s\   € äÐÓ  D×$4Ñ$4Ò4Ü'¨›lˆDŒOä=B¿Y¹Y×=QÑ=QÔ=S”—	‘	œ%Ÿ,™,Ð'7Ó8Ô9ÔY\Ð]mÓYnð Õð 5r,   re   rf   r1   r2   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)r2   r   r]   r   r   g      YÀr/   )
r  r6   rÔ   rc   ÚlongÚtori   r_   rš   Úmasked_fill)r)   re   rf   r1   r2   Úh_idxÚw_idxÚh_regionÚw_regionÚimg_maskÚmask_windowsÚ	attn_masks               r+   Úget_attn_maskzSwinLayer.get_attn_maskü  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,   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   )rc   r   r�   r²   )r)   r-   re   rf   Ú	pad_rightÚ
pad_bottomr³   s          r+   r´   zSwinLayer.maybe_pad  s�   € à×%Ñ%¨°×0@Ñ0@Ñ(@Ñ@ÀD×DTÑDTÑTˆ	Ø×&Ñ&¨°$×2BÑ2BÑ)BÑBÀd×FVÑFVÑVˆ
Ø˜˜A˜y¨!¨ZÐ8ˆ
ÜŸ™×)Ñ)¨-¸ÓDˆØ˜jÐ(Ð(r,   Úreversec                 ó˜   — | 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   r]   )r   r   )ÚshiftsÚdims)r  r6   Úroll)r)   r-   r%  Ú	directions       r+   Úcyclic_shiftzSwinLayer.cyclic_shift  sM   € à�?‰?˜QÒÙ$™¨"ˆIÜ!ŸJ™JØØ! D§O¡OÑ3°YÀÇÁÑ5PÐQØôˆMð
 Ðr,   rÀ   Úalways_partitionrë   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 )Nr]   r0   T)r%  r   r   é   )r  r†   r  r_   r´   r4   ri   r+  rc   r!  r1   r2   r  r~   rk   ra   r  r  r  )r)   r-   rÀ   r,  rë   re   rf   rd   rœ   ÚchannelsÚshortcutr³   Ú
height_padÚ	width_padÚhidden_states_windowsr   Úattention_outputrù   Úattention_windowsÚresiduals                       r+   r<   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,   )r/   r   r¡   )r?   r@   rA   r    r¢   rP   rC   r(   r  r6   r1   r2   rD   r!  r´   r¤   r+  r   r   r<   rF   rG   s   @r+   r  r  à  sm  ø„ ð !$Øñaàðað ðað    S ™/ð	að
 ðað ðað õað&¸%ÀÀ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^ó 	ð "'ñ	-+à—|‘|ð-+ð    S ™/ð-+ð ð	-+ð
 Ð+Ñ,ð-+ð 
�‰÷-+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 )Ú	SwinStager€   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 )Nr   r   )r€   r�   r  rÉ   r  r  rÂ   )
r'   r(   r€   r   Ú
ModuleListrÄ   r  rc   ÚblocksÚ
downsample)
r)   r€   r�   r  r9  rÉ   r  r=  Úir*   s
            €r+   r(   zSwinStage.__init__Y  s•   ø€ ô 	‰ÑÔØˆŒÜ—m‘mô ˜u›ö
ð ô Ø!ØØ%5Ø'Ø#,¨Q¡<Ø%&¨¡U¨a¢Z™q°f×6HÑ6HÈAÑ6Möò
ó
ˆŒð 2<Ð1G™*¨Ô-ˆ�ÈTˆ�ùò
s   ³2B
r-   Ú!hidden_states_before_downsamplingre   rf   Ú(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   r   r   r   )r=  r4   r_   rŒ   ra   )r)   r-   r?  re   rf   r@  Úspatial_stateÚhÚwrd   rœ   r°   s               r+   Úget_reshaped_hidden_statesz$SwinStage.get_reshaped_hidden_statesu  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,  )r<  r=  rE  )r)   r-   rÀ   r,  r@  rë   re   rf   Úlast_attn_weightsÚlayer_moduler?  rM   s               r+   r<   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)r?   r@   rA   r    r¢   rP   ÚlistrC   r(   r6   rD   r¤   rE  r   r   r<   rF   rG   s   @r+   r8  r8  X  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,   r8  c                   óŠ   — e Zd ZU eed<   dgZdZdZddgZ e	e
dd¬«       e	e
d	d¬«      d
œZ ej                  «       d„ «       Zy)ÚSwinPreTrainedModelr€   r8  Fz(attention\.self\.relative_position_indexz:attention\.relative_position_bias\.relative_position_indexr   T)ÚindexÚcapture_initial_hidden_stater   )r-   rL   c                 óÚ  — t        j                  | |«       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 weightsNr]   )r   Ú_init_weightsrª   rm   rw   ÚinitÚzeros_ry   rÈ   rÎ   Úcopy_rË   rÐ   r_   )r)   Úmodules     r+   rO  z!SwinPreTrainedModel._init_weights¾  sª   € ô 	×%Ñ% d¨FÔ3Ü�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,   N)r?   r@   rA   r    rO   Ú_no_split_modulesÚ_supports_flash_attnÚ_supports_flex_attnÚ"_keys_to_ignore_on_load_unexpectedr   r8  Ú_can_record_outputsr6   Úno_gradrO  rQ   r,   r+   rK  rK  ¨  sp   … àÓØ$˜ÐØ ÐØÐð 	4ØEð*Ð&ñ (¨	¸ÐY]Ô^ñ
 % Y°aÐV[Ô\ñ	Ðð €U‡]�]ƒ_ñ
jó ñ
jr,   rK  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 )ÚSwinEncoderr€   rr   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   r   r   )r€   r�   r  r9  rÉ   r  r=  )r'   r(   ÚlenÚdepthsÚ
num_layersr€   rÄ   r×   r  Úmaxr   r;  r8  r¢   rv   rÉ   r¸   ÚlayersÚ	post_init)r)   r€   rr   r>  Ú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_statesr@  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   r   ©r,  r@  )rK   rM   )r4   r_   rŒ   ra   ra  r=  rJ   )r)   r-   rÀ   r,  rf  r@  rë   Úall_reshaped_hidden_statesrd   rœ   r°   Ústem_spatialrH  Úreshaped_hidden_states                 r+   r<   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)r?   r@   rA   r    rP   r¢   r(   r   r   r   r6   rD   r¤   r   r   rJ   r<   rF   rG   s   @r+   r[  r[  Ì  s¨   ø„ ð˜zð °e¸CÀ¸H±oõ ð*  Ù¨EÔ2Øð
 "'Ø%*Ø9>ñ+
à—|‘|ð+
ð    S ™/ð+
ð ð	+
ð
 #ð+
ð 37ð+
ð Ð+Ñ,ð+
ð 
ò+
ó ó 3ó  ô+
r,   r[  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.
        r   r   )r�   r	  N)r'   r(   r€   r]  r^  r_  r¢   rv   Únum_featuresrm   r‚   r[  rs   Úencoderr   rz   r  Ú	layernormÚAdaptiveAvgPool1dÚpoolerrb  )r)   r€   Úadd_pooling_layerr�   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).
        rf  ©r—   r•   Nr   r   )rK   rT   r-   rL   rM   )Úpopr€   rf  r‚   rp  rK   rq  rs  r`   r6   r¶   rS   r-   rL   rM   )r)   r–   r—   r•   rë   rf  Úembedding_outputrÀ   Úencoder_outputsÚsequence_outputÚpooled_outputs              r+   r<   zSwinModel.forward*  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)r?   r@   rA   r(   r   r   r6   rN   r£   r¤   r   r   rS   r<   rF   rG   s   @r+   rm  rm    s{   ø„ õð* Øð 26Ø37Ø).ñ	(
à×'Ñ'¨$Ñ.ð(
ð ×)Ñ)¨DÑ0ð(
ð #'ð	(
ð
 Ð+Ñ,ð(
ð 
ò(
ó ó ô(
r,   rm  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)rt  r�   r   r   )Úin_channelsÚout_channelsr§   )r'   r(   rm  Úswinr¢   rv   r_  r   Ú
Sequentialr®   Úencoder_striderg   ÚPixelShuffleÚdecoderrb  )r)   r€   ro  r*   s      €r+   r(   z#SwinForMaskedImageModeling.__init__d  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]
        ```rv  r   r   r„   Nr]   Únone)r¾   gñhãˆµøä>)rW   rX   r-   rL   rM   )r‚  rK   r`   r4   Úmathr8   r‹   r†  r€   r©   r   Úrepeat_interleaverš   ra   r   r�   Úl1_lossr×   rg   rV   r-   rL   rM   )r)   r–   r—   r•   rë   Úoutputsrz  rd   rg   Úsequence_lengthre   rf   Úreconstructed_pixel_valuesÚmasked_im_lossr†   r    Úreconstruction_losss                    r+   r<   z"SwinForMaskedImageModeling.forwardt  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|  )r?   r@   rA   r(   r   r   r6   rN   r£   r¤   r   r   rV   r<   rF   rG   s   @r+   r~  r~  W  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_labelsrm  r‚  r   r½   ro  r  Ú
classifierrb  )r)   r€   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)rW   r[   r-   rL   rM   )	r‚  rT   r•  Úloss_functionr€   rZ   r-   rL   rM   )	r)   r–   r–  r•   rë   rŒ  r{  r[   rW   s	            r+   r<   z"SwinForImageClassification.forwardÞ  sœ   € ð �$—)‘)Øñ
à%=ð
ð ñ
ˆð  ×-Ñ-ˆà—‘ Ó/ˆàˆØÐØ%�4×%Ñ% f¨f°d·k±kÑLÀVÑLˆDä(ØØØ!×/Ñ/Ø×)Ñ)Ø#*×#AÑ#Aô
ð 	
r,   r|  )r?   r@   rA   r(   r   r   r6   rN   Ú
LongTensorr¤   r   r   rZ   r<   rF   rG   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.*r€   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 )Nr   F)rt  )r'   r(   rv   rÄ   r]  r^  r¢   ro  rm  r‚  ÚzipÚout_featuresr/  r   rz   Ú
ModuleDictÚhidden_states_normsrb  )r)   r€   r>  r   Ústagerg   r*   s         €r+   r(   zSwinBackbone.__init__  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]
        ```
        Trh  rQ   r   r   r   r   )Úfeature_mapsr-   rL   )r‚  r�  Ústage_namesrM   rž  r4   rŒ   ra   r_   r   r   rL   )r)   r–   rë   rŒ  r£  r¡  Úhidden_staterd   rg   re   rf   s              r+   r<   zSwinBackbone.forward  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,   )r?   r@   rA   Ú_keys_to_ignore_on_load_missingr    r(   r   r
   r   r6   rD   r   r   r   r<   rF   rG   s   @r+   r›  r›    sd   ø„ ð (;Ð&;Ð#ð˜zõ ð Ø Øð7
à—l‘lð7
ð Ð+Ñ,ð7
ð 
ò	7
ó ó !ó ô7
r,   r›  )r’  r~  rm  rK  r›  )HrB   Úcollections.abcr«   r‰  r   Údataclassesr   r6   r   Ú r   rP  Úactivationsr   Úbackbone_utilsr	   r
   Úmodeling_layersr   Úmodeling_outputsr   Úmodeling_utilsr   Úprocessing_utilsr   Úutilsr   r   r   r   r   Úutils.genericr   r   Úutils.output_capturingr   r   Úvit.modeling_vitr   r   r   r   r   r   Úconfiguration_swinr    Ú
get_loggerr?   Úloggerrý   r"   rJ   rS   rV   rZ   ri   rk   rm   ro   r¸   rÈ   rà   rû   r  r8  rK  r[  rm  r~  r’  r›  Ú__all__rQ   r,   r+   ú<module>r¸     sš  ðñ &ã Û Ý $Ý !ã Ý å &Ý !ß HÝ 9Ý .Ý 5Ý &ß XÕ Xß Iß E÷÷ õ +ð 
ˆ×	Ñ	˜HÓ	%€ô%�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ô @)ôF?ˆfô ?ôu+�ô u+ôpMHÐ*ô MHð` ô jÐ,ó  jó ð jôFD
Ð%ô D
ðN ô@
Ð#ó @
ó ð@
ñF ð	ôô[
Ð!4ó [
óð[
ñ| ðôô2
Ð!4ó 2
óð2
ñj ðôô
L
�=Ð"5ó L
óð
L
ò^�r,   