Ë
    ÛÓ^jñ™  ã                   óè  — d Z ddlm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 ddlmZ ddlmZmZ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m Z  ddl!m"Z"m#Z# ddl$m%Z% ddl&m'Z'm(Z(m)Z)  ejT                  e+«      Z,dejZ                  dejZ                  fd„Z.dejZ                  dejZ                  fd„Z/dejZ                  dejZ                  fd„Z0 ed¬«      e G d„ de«      «       «       Z1 ed¬«      e G d „ d!e«      «       «       Z2ee G d"„ d#e«      «       «       Z3 G d$„ d%ejh                  «      Z5 G d&„ d'ejh                  «      Z6	 dKd(ejh                  d)ejZ                  d*ejZ                  d+ejZ                  d,ejZ                  dz  d-e7d.e7d/ee   fd0„Z8 G d1„ d2ejh                  «      Z9 G d3„ d4ejh                  «      Z: G d5„ d6e«      Z;e G d7„ d8e«      «       Z< G d9„ d:ejh                  «      Z= ed;¬«       G d<„ d=e<«      «       Z> ed>¬«       G d?„ d@e<«      «       Z?e G dA„ dBe<«      «       Z@e G dC„ dDe<«      «       ZAe G dE„ dFe<«      «       ZB edG¬«       G dH„ dIe<«      «       ZCg dJ¢ZDy)LzPyTorch CLIP model.é    )ÚCallable)Ú	dataclass)ÚAnyN)Únné   )Úinitialization)ÚACT2FN)Úcreate_causal_mask)ÚGradientCheckpointingLayer)ÚBaseModelOutputÚBaseModelOutputWithPoolingÚImageClassifierOutput)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)ÚModelOutputÚTransformersKwargsÚauto_docstringÚloggingÚ	torch_int)Úcan_return_tupleÚmerge_with_config_defaults)Úcapture_outputsé   )Ú
CLIPConfigÚCLIPTextConfigÚCLIPVisionConfigÚlogitsÚreturnc                 ó’   — t         j                  j                  | t        j                  t        | «      | j                  ¬«      «      S )N©Údevice)r   Ú
functionalÚcross_entropyÚtorchÚarangeÚlenr"   )r   s    úq/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/clip/modeling_clip.pyÚcontrastive_lossr)   /   s/   € Ü�=‰=×&Ñ& v¬u¯|©|¼CÀ»KÐPV×P]ÑP]Ô/^Ó_Ð_ó    Ú
similarityc                 óR   — t        | «      }t        | j                  «      }||z   dz  S )Ng       @)r)   ÚT)r+   Úcaption_lossÚ
image_losss      r(   Úimage_text_contrastive_lossr0   3   s*   € Ü# JÓ/€LÜ! *§,¡,Ó/€JØ˜:Ñ%¨Ñ,Ð,r*   Útensorc                 óŽ   — t        j                  | d«      }t        j                  |dd¬«      }t        j                  |d«      }|S )z½
    This method is equivalent to tensor.norm(p=2, dim=-1, keepdim=True) and used to make
    model `executorch` exportable. See issue https://github.com/pytorch/executorch/issues/3566
    é   éÿÿÿÿT)ÚdimÚkeepdimç      à?)r%   ÚpowÚsum)r1   Úsquare_tensorÚ
sum_tensorÚnormed_tensors       r(   Ú_get_vector_normr=   9   s<   € ô
 —I‘I˜f aÓ(€MÜ—‘˜=¨b¸$Ô?€JÜ—I‘I˜j¨#Ó.€MØÐr*   z}
    Base class for vision model's outputs that also contains image embeddings of the pooling of the last hidden states.
    )Úcustom_introc                   óÆ   — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	e
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   y)ÚCLIPVisionModelOutputzø
    image_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim)` *optional* returned when model is initialized with `with_projection=True`):
        The image embeddings obtained by applying the projection layer to the pooler_output.
    NÚimage_embedsÚlast_hidden_state.Úhidden_statesÚ
attentions)Ú__name__Ú
__module__Ú__qualname__Ú__doc__rA   r%   ÚFloatTensorÚ__annotations__rB   rC   ÚtuplerD   © r*   r(   r@   r@   D   sr   … ñð
 .2€L�%×#Ñ# dÑ*Ó1Ø26Ð�u×(Ñ(¨4Ñ/Ó6Ø:>€M�5˜×*Ñ*¨CÐ/Ñ0°4Ñ7Ó>Ø7;€J��e×'Ñ'¨Ð,Ñ-°Ñ4Ô;r*   r@   ze
    Base class for text 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<   y)ÚCLIPTextModelOutputzö
    text_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim)` *optional* returned when model is initialized with `with_projection=True`):
        The text embeddings obtained by applying the projection layer to the pooler_output.
    NÚtext_embedsrB   .rC   rD   )rE   rF   rG   rH   rO   r%   rI   rJ   rB   rC   rK   rD   rL   r*   r(   rN   rN   V   sr   … ñð
 -1€K�×"Ñ" TÑ)Ó0Ø26Ð�u×(Ñ(¨4Ñ/Ó6Ø:>€M�5˜×*Ñ*¨CÐ/Ñ0°4Ñ7Ó>Ø7;€J��e×'Ñ'¨Ð,Ñ-°Ñ4Ô;r*   rN   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j                  dz  ed<   dZ
ej                  dz  ed<   dZej                  dz  ed<   dZeed<   dZeed	<   d
ee   fd„Zy)Ú
CLIPOutputa©  
    loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `return_loss` is `True`):
        Contrastive loss for image-text similarity.
    logits_per_image (`torch.FloatTensor` of shape `(image_batch_size, text_batch_size)`):
        The scaled dot product scores between `image_embeds` and `text_embeds`. This represents the image-text
        similarity scores.
    logits_per_text (`torch.FloatTensor` of shape `(text_batch_size, image_batch_size)`):
        The scaled dot product scores between `text_embeds` and `image_embeds`. This represents the text-image
        similarity scores.
    text_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim`):
        The text embeddings obtained by applying the projection layer to the pooled output of [`CLIPTextModel`].
    image_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim`):
        The image embeddings obtained by applying the projection layer to the pooled output of [`CLIPVisionModel`].
    text_model_output (`BaseModelOutputWithPooling`):
        The output of the [`CLIPTextModel`].
    vision_model_output (`BaseModelOutputWithPooling`):
        The output of the [`CLIPVisionModel`].
    NÚlossÚlogits_per_imageÚlogits_per_textrO   rA   Útext_model_outputÚvision_model_outputr   c                 óB   — t        d„ | j                  «       D «       «      S )Nc              3   ó`   K  — | ]&  }t        |t        «      r|j                  «       n|–— Œ( y ­w©N)Ú
isinstancer   Úto_tuple)Ú.0Úvs     r(   ú	<genexpr>z&CLIPOutput.to_tuple.<locals>.<genexpr>‡   s$   è ø€ Ò^È1¤Z°´;Ô%?�Q—Z‘Z”\ÀQÓFÑ^ùs   ‚,.)rK   Úvalues©Úselfs    r(   r[   zCLIPOutput.to_tuple†   s   € ÜÑ^ÐPT×P[ÑP[ÓP]Ô^Ó^Ð^r*   )rE   rF   rG   rH   rR   r%   rI   rJ   rS   rT   rO   rA   rU   r   rV   rK   r   r[   rL   r*   r(   rQ   rQ   h   s�   … ñð& &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø15Ð�e×'Ñ'¨$Ñ.Ó5Ø04€O�U×&Ñ&¨Ñ-Ó4Ø,0€K�×"Ñ" TÑ)Ó0Ø-1€L�%×#Ñ# dÑ*Ó1Ø48ÐÐ1Ó8Ø6:ÐÐ3Ó:ð_˜% ™*ô _r*   rQ   c                   óž   ‡ — e Zd Zdefˆ fd„Zdej                  dededej                  fd„Zd
dej                  dej                  fd	„Z
ˆ xZS )ÚCLIPVisionEmbeddingsÚconfigc                 óÚ  •— t         ‰| �  «        || _        |j                  | _        |j
                  | _        |j                  | _        t        j                  t        j                  | j                  «      «      | _        t        j                  |j                  | j                  | j                  | j                  d¬«      | _        | j
                  | j                  z  dz  | _        | j                  dz   | _        t        j"                  | j                   | j                  «      | _        | j'                  dt        j(                  | j                   «      j+                  d«      d¬«       y )NF)Úin_channelsÚout_channelsÚkernel_sizeÚstrideÚbiasr3   r   Úposition_ids©r   r4   ©Ú
persistent)ÚsuperÚ__init__rd   Úhidden_sizeÚ	embed_dimÚ
image_sizeÚ
patch_sizer   Ú	Parameterr%   ÚrandnÚclass_embeddingÚConv2dÚnum_channelsÚpatch_embeddingÚnum_patchesÚnum_positionsÚ	EmbeddingÚposition_embeddingÚregister_bufferr&   Úexpand©ra   rd   Ú	__class__s     €r(   rp   zCLIPVisionEmbeddings.__init__‹   s	  ø€ Ü‰ÑÔØˆŒØ×+Ñ+ˆŒØ ×+Ñ+ˆŒØ ×+Ñ+ˆŒä!Ÿ|™|¬E¯K©K¸¿¹Ó,GÓHˆÔä!Ÿy™yØ×+Ñ+ØŸ™ØŸ™Ø—?‘?Øô 
ˆÔð !ŸO™O¨t¯©Ñ>À1ÑDˆÔØ!×-Ñ-°Ñ1ˆÔÜ"$§,¡,¨t×/AÑ/AÀ4Ç>Á>Ó"RˆÔØ×Ñ˜^¬U¯\©\¸$×:LÑ:LÓ-M×-TÑ-TÐU\Ó-]ÐjoÐÕpr*   Ú
embeddingsÚheightÚwidthr   c                 óÒ  — |j                   d   dz
  }| j                  j                  j                  d«      }|j                   d   dz
  }t        j
                  j                  «       s%||k(  r ||k(  r| j                  | j                  «      S |dd…dd…f   }|dd…dd…f   }|j                   d   }	|| j                  z  }
|| j                  z  }t        |dz  «      }|j                  d|||	«      }|j                  dddd«      }t        j                  j                  ||
|fdd	¬
«      }|j                  dddd«      j                  dd|	«      }t	        j                   ||fd¬«      S )a   
        This method allows to interpolate the pre-trained position encodings, to be able to use the model on higher resolution
        images. This method is also adapted to support torch.jit tracing.

        Adapted from:
        - https://github.com/facebookresearch/dino/blob/de9ee3df6cf39fac952ab558447af1fa1365362a/vision_transformer.py#L174-L194, and
        - https://github.com/facebookresearch/dinov2/blob/e1277af2ba9496fbadf7aec6eba56e8d882d1e35/dinov2/models/vision_transformer.py#L179-L211
        r   r   Nr4   r7   r   r3   ÚbicubicF)ÚsizeÚmodeÚalign_corners©r5   )Úshaper~   ÚweightÚ	unsqueezer%   ÚjitÚ
is_tracingrk   rt   r   ÚreshapeÚpermuter   r#   ÚinterpolateÚviewÚcat)ra   rƒ   r„   r…   r{   r~   r|   Úclass_pos_embedÚpatch_pos_embedr5   Ú
new_heightÚ	new_widthÚsqrt_num_positionss                r(   Úinterpolate_pos_encodingz-CLIPVisionEmbeddings.interpolate_pos_encoding¡   sv  € ð !×&Ñ& qÑ)¨AÑ-ˆØ!×4Ñ4×;Ñ;×EÑEÀaÓHÐØ*×0Ñ0°Ñ3°aÑ7ˆô �y‰y×#Ñ#Ô%¨+¸Ò*FÈ6ÐUZÊ?Ø×*Ñ*¨4×+<Ñ+<Ó=Ð=à,ªQ°°°¨UÑ3ˆØ,ªQ°±¨UÑ3ˆà×Ñ˜rÑ"ˆà˜tŸ™Ñ.ˆ
Ø˜TŸ_™_Ñ,ˆ	ä& }°cÑ'9Ó:ÐØ)×1Ñ1°!Ð5GÐI[Ð]`ÓaˆØ)×1Ñ1°!°Q¸¸1Ó=ˆäŸ-™-×3Ñ3ØØ˜iÐ(ØØð	 4ó 
ˆð *×1Ñ1°!°Q¸¸1Ó=×BÑBÀ1ÀbÈ#ÓNˆä�y‰y˜/¨?Ð;ÀÔCÐCr*   Úpixel_valuesc                 ó`  — |j                   \  }}}}|sJ|| j                  k7  s|| j                  k7  r,t        d|› d|› d| j                  › d| j                  › d�	«      ‚| j                  j                  j
                  }| j                  |j                  |¬«      «      }|j                  d«      j                  dd«      }| j                  j                  |dd«      }	t        j                  |	|gd¬	«      }
|r|
| j                  |
||«      z   }
|
S |
| j                  | j                  «      z   }
|
S )
NzInput image size (Ú*z) doesn't match model (z).)Údtyper3   r   r4   r‹   )rŒ   rs   Ú
ValueErrorrz   r�   rŸ   ÚtoÚflattenÚ	transposerw   r€   r%   r•   r›   r~   rk   )ra   rœ   r›   Ú
batch_sizeÚ_r„   r…   Útarget_dtypeÚpatch_embedsÚclass_embedsrƒ   s              r(   ÚforwardzCLIPVisionEmbeddings.forwardÊ   s6  € Ø'3×'9Ñ'9Ñ$ˆ
�A�v˜uÙ'¨V°t·±Ò-FÈ%ÐSW×SbÑSbÒJbÜØ$ V H¨A¨e¨WÐ4KÈDÏOÉOÐK\Ð\]Ð^b×^mÑ^mÐ]nÐnpÐqóð ð ×+Ñ+×2Ñ2×8Ñ8ˆØ×+Ñ+¨L¯O©OÀ,¨OÓ,OÓPˆØ#×+Ñ+¨AÓ.×8Ñ8¸¸AÓ>ˆà×+Ñ+×2Ñ2°:¸qÀ"ÓEˆÜ—Y‘Y ¨lÐ;ÀÔCˆ
Ù#Ø# d×&CÑ&CÀJÐPVÐX]Ó&^Ñ^ˆJð Ðð $ d×&=Ñ&=¸d×>OÑ>OÓ&PÑPˆJØÐr*   ©F)rE   rF   rG   r   rp   r%   ÚTensorÚintr›   rI   r©   Ú__classcell__©r‚   s   @r(   rc   rc   Š   se   ø„ ðqÐ/õ qð,'D°5·<±<ð 'DÈð 'DÐUXð 'DÐ]b×]iÑ]ió 'DñR E×$5Ñ$5ð ÐZ_×ZfÑZf÷ r*   rc   c            	       ó¦   ‡ — e Zd Zdefˆ fd„Z	 	 	 d	dej                  dz  dej                  dz  dej                  dz  dej                  fd„Z	ˆ xZ
S )
ÚCLIPTextEmbeddingsrd   c                 óN  •— t         ‰| �  «        |j                  }t        j                  |j
                  |«      | _        t        j                  |j                  |«      | _        | j                  dt        j                  |j                  «      j                  d«      d¬«       y )Nrk   rl   Frm   )ro   rp   rq   r   r}   Ú
vocab_sizeÚtoken_embeddingÚmax_position_embeddingsr~   r   r%   r&   r€   ©ra   rd   rr   r‚   s      €r(   rp   zCLIPTextEmbeddings.__init__Þ   sƒ   ø€ Ü‰ÑÔØ×&Ñ&ˆ	ä!Ÿ|™|¨F×,=Ñ,=¸yÓIˆÔÜ"$§,¡,¨v×/MÑ/MÈyÓ"YˆÔð 	×ÑØœEŸL™L¨×)GÑ)GÓH×OÑOÐPWÓXÐejð 	õ 	
r*   NÚ	input_idsrk   Úinputs_embedsr   c                 ó8  — |�|j                   d   n|j                   d   }| j                  j                  j                   d   }||kD  rt        d|› d|› �«      ‚|€| j                  d d …d |…f   }|€| j                  |«      }| j                  |«      }||z   }|S )Nr4   éþÿÿÿr   zRSequence length must be less than max_position_embeddings (got `sequence length`: z and max_position_embeddings: )rŒ   r~   r�   r    rk   r³   )ra   r¶   rk   r·   Ú
seq_lengthÚmax_position_embeddingÚposition_embeddingsrƒ   s           r(   r©   zCLIPTextEmbeddings.forwardê   sÇ   € ð -6Ð,A�Y—_‘_ RÒ(À}×GZÑGZÐ[]ÑG^ˆ
Ø!%×!8Ñ!8×!?Ñ!?×!EÑ!EÀaÑ!HÐàÐ.Ò.ÜØdØ�,Ð<Ð=SÐ<TðVóð ð
 ÐØ×,Ñ,ªQ°°°¨^Ñ<ˆLàÐ Ø ×0Ñ0°Ó;ˆMà"×5Ñ5°lÓCÐØ"Ð%8Ñ8ˆ
àÐr*   ©NNN)rE   rF   rG   r   rp   r%   Ú
LongTensorrI   r«   r©   r­   r®   s   @r(   r°   r°   Ý   sj   ø„ ð

˜~õ 

ð .2Ø04Ø26ñ	à×#Ñ# dÑ*ðð ×&Ñ&¨Ñ-ðð ×(Ñ(¨4Ñ/ð	ð
 
�‰÷r*   r°   ÚmoduleÚqueryÚkeyÚvalueÚattention_maskÚscalingÚdropoutÚkwargsc                 óÀ  — 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 )Nr4   r¹   )r5   rŸ   )ÚpÚtrainingr   r3   )r%   Úmatmulr£   r   r#   ÚsoftmaxÚfloat32r¡   rŸ   rÅ   rÉ   Ú
contiguous)
r¿   rÀ   rÁ   rÂ   rÃ   rÄ   rÅ   rÆ   Úattn_weightsÚattn_outputs
             r(   Úeager_attention_forwardrÐ     sº   € ô —<‘<  s§}¡}°R¸Ó'<Ó=ÀÑG€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Zdeez  fˆ fd„Z	 d
dej                  dej                  dz  de	e
   deej                  ej                  dz  f   fd	„Zˆ xZS )ÚCLIPAttentionz=Multi-headed attention from 'Attention Is All You Need' paperrd   c                 ó€  •— t         ‰| �  «        || _        |j                  | _        |j
                  | _        | j                  | j                  z  | _        | j                  dz  | _        |j                  | _
        d| _        t        j                  | j                  | j                  «      | _        t        j                  | j                  | j                  «      | _        t        j                  | j                  | j                  «      | _        t        j                  | j                  | j                  «      | _        y )Nç      à¿F)ro   rp   rd   rq   rr   Únum_attention_headsÚ	num_headsÚhead_dimÚscaleÚattention_dropoutrÅ   Ú	is_causalr   ÚLinearÚk_projÚv_projÚq_projÚout_projr�   s     €r(   rp   zCLIPAttention.__init__  sÏ   ø€ Ü‰ÑÔØˆŒØ×+Ñ+ˆŒØ×3Ñ3ˆŒØŸ™¨$¯.©.Ñ8ˆŒØ—]‘] DÑ(ˆŒ
Ø×/Ñ/ˆŒØˆŒä—i‘i §¡°·±Ó?ˆŒÜ—i‘i §¡°·±Ó?ˆŒÜ—i‘i §¡°·±Ó?ˆŒÜŸ	™	 $§.¡.°$·.±.ÓAˆ�r*   NrC   rÃ   rÆ   r   c                 ó¦  — |j                   dd }g |¢d‘| j                  ‘­}| j                  |«      }| j                  |«      }| j	                  |«      }|j                  |«      j                  dd«      }|j                  |«      j                  dd«      }|j                  |«      j                  dd«      }t        j                  | j                  j                  t        «      }	 |	| ||||f| j                  | j                  sdn| j                  dœ|¤Ž\  }
} |
j                  g |¢d‘­Ž j!                  «       }
| j#                  |
«      }
|
|fS )z#Input shape: Batch x Time x ChannelNr4   r   r3   ç        )rÄ   rÅ   )rŒ   r×   rÞ   rÜ   rÝ   r”   r£   r   Úget_interfacerd   Ú_attn_implementationrÐ   rØ   rÉ   rÅ   r‘   rÍ   rß   )ra   rC   rÃ   rÆ   Úinput_shapeÚhidden_shapeÚqueriesÚkeysr_   Úattention_interfacerÏ   rÎ   s               r(   r©   zCLIPAttention.forward,  sO  € ð $×)Ñ)¨#¨2Ð.ˆà8˜Ð8 bÐ8¨$¯-©-Ñ8ˆØ—+‘+˜mÓ,ˆØ�{‰{˜=Ó)ˆØ—‘˜]Ó+ˆà—,‘,˜|Ó,×6Ñ6°q¸!Ó<ˆØ�y‰y˜Ó&×0Ñ0°°AÓ6ˆØ—‘˜\Ó*×4Ñ4°Q¸Ó:ˆä(?×(MÑ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØð	%
ð —J‘JØ#Ÿ}š}‘C°$·,±,ñ	%
ð ñ	%
Ñ!ˆ�\ð *�k×)Ñ)Ð;¨;Ð;¸Ò;×FÑFÓHˆØ—m‘m KÓ0ˆà˜LÐ(Ð(r*   rY   )rE   rF   rG   rH   r   r   rp   r%   r«   r   r   rK   r©   r­   r®   s   @r(   rÒ   rÒ     st   ø„ ÙGðBÐ/°.Ñ@õ Bð$ /3ñ%)à—|‘|ð%)ð Ÿ™ tÑ+ð%)ð Ð+Ñ,ð	%)ð
 
ˆu�|‰|˜UŸ\™\¨DÑ0Ð0Ñ	1÷%)r*   rÒ   c                   óV   ‡ — e Zd Zˆ fd„Zdej
                  dej
                  fd„Zˆ xZS )ÚCLIPMLPc                 ó  •— t         ‰| �  «        || _        t        |j                     | _        t        j                  |j                  |j                  «      | _
        t        j                  |j                  |j                  «      | _        y rY   )ro   rp   rd   r	   Ú
hidden_actÚactivation_fnr   rÛ   rq   Úintermediate_sizeÚfc1Úfc2r�   s     €r(   rp   zCLIPMLP.__init__U  sd   ø€ Ü‰ÑÔØˆŒÜ# F×$5Ñ$5Ñ6ˆÔÜ—9‘9˜V×/Ñ/°×1IÑ1IÓJˆŒÜ—9‘9˜V×5Ñ5°v×7IÑ7IÓJˆ�r*   rC   r   c                 ól   — | j                  |«      }| j                  |«      }| j                  |«      }|S rY   )rï   rí   rð   )ra   rC   s     r(   r©   zCLIPMLP.forward\  s4   € ØŸ™ Ó/ˆØ×*Ñ*¨=Ó9ˆØŸ™ Ó/ˆØÐr*   )rE   rF   rG   rp   r%   r«   r©   r­   r®   s   @r(   rê   rê   T  s$   ø„ ôKð U§\¡\ð °e·l±l÷ r*   rê   c                   ó„   ‡ — e Zd Zdeez  fˆ fd„Zdej                  dej                  dee	   dej                  fd„Zˆ xZS )ÚCLIPEncoderLayerrd   c                 óD  •— t         ‰| �  «        |j                  | _        t	        |«      | _        t        j                  | j                  |j                  ¬«      | _	        t        |«      | _        t        j                  | j                  |j                  ¬«      | _        y ©N)Úeps)ro   rp   rq   rr   rÒ   Ú	self_attnr   Ú	LayerNormÚlayer_norm_epsÚlayer_norm1rê   ÚmlpÚlayer_norm2r�   s     €r(   rp   zCLIPEncoderLayer.__init__d  sl   ø€ Ü‰ÑÔØ×+Ñ+ˆŒÜ& vÓ.ˆŒÜŸ<™<¨¯©¸F×<QÑ<QÔRˆÔÜ˜6“?ˆŒÜŸ<™<¨¯©¸F×<QÑ<QÔRˆÕr*   rC   rÃ   rÆ   r   c                 ó¸   — |}| j                  |«      } | j                  d||dœ|¤Ž\  }}||z   }|}| j                  |«      }| j                  |«      }||z   }|S )N)rC   rÃ   rL   )rú   r÷   rü   rû   )ra   rC   rÃ   rÆ   Úresidualr¥   s         r(   r©   zCLIPEncoderLayer.forwardl  s‚   € ð !ˆà×(Ñ(¨Ó7ˆØ)˜4Ÿ>™>ð 
Ø'Ø)ñ
ð ñ
Ñˆ�qð
 ! =Ñ0ˆà ˆØ×(Ñ(¨Ó7ˆØŸ™ Ó/ˆØ  =Ñ0ˆàÐr*   )rE   rF   rG   r   r   rp   r%   r«   r   r   rI   r©   r­   r®   s   @r(   ró   ró   c  sV   ø„ ðSÐ/°.Ñ@õ Sðà—|‘|ðð Ÿ™ðð Ð+Ñ,ð	ð
 
×	Ñ	÷r*   ró   c                   ó€   ‡ — e Zd ZU eed<   dZdZg d¢ZdZdZ	dZ
dZdZeedœZ ej"                  «       ˆ fd„«       Zˆ xZS )ÚCLIPPreTrainedModelrd   Úclip)ÚimageÚtext)r°   ró   rc   T)rC   rD   c                 ó¨
  •— t         ‰| �  |«       | j                  j                  }t	        |t
        «      r¸t        j                  |j                  j                  d|dz  ¬«       t        j                  |j                  j                  d|dz  ¬«       t        j                  |j                  t        j                  |j                  j                  d   «      j!                  d«      «       y	t	        |t"        «      �rt        j                  |j$                  d|j&                  dz  |z  ¬«       t        j                  |j(                  j                  |j                  j*                  |z  ¬«       t        j                  |j                  j                  |j                  j*                  |z  ¬«       t        j                  |j                  t        j                  |j,                  «      j!                  d«      «       y	t	        |t.        «      rî|j&                  dz  d|j                  j0                  z  dz  z  |z  }|j&                  dz  |z  }t        j                  |j2                  j                  |¬«       t        j                  |j4                  j                  |¬«       t        j                  |j6                  j                  |¬«       t        j                  |j8                  j                  |¬«       y	t	        |t:        «      r¯|j                  j<                  dz  d|j                  j0                  z  dz  z  |z  }d|j                  j<                  z  dz  |z  }t        j                  |j>                  j                  |¬«       t        j                  |j@                  j                  |¬«       y	t	        |tB        «      rwt        j                  |jD                  j                  |jF                  dz  |z  ¬«       t        j                  |jH                  j                  |jJ                  dz  |z  ¬«       y	t	        |tL        «      rFt        j                  |jH                  j                  | j                  j<                  dz  |z  ¬«       y	t	        |tN        «      rFt        j                  |jD                  j                  | j                  j<                  dz  |z  ¬«       y	t	        |tP        «      rPt        j                  |jR                  j                  | j                  jT                  j<                  dz  |z  ¬«       y	y	)
zInitialize the weightsrá   g{®Gáz”?)ÚmeanÚstdr4   rl   rÔ   )r  r3   N)+ro   Ú_init_weightsrd   Úinitializer_factorrZ   r°   ÚinitÚnormal_r³   r�   r~   Úcopy_rk   r%   r&   rŒ   r€   rc   rw   rr   rz   Úinitializer_ranger|   rÒ   Únum_hidden_layersrÞ   rÜ   rÝ   rß   rê   rq   rï   rð   Ú	CLIPModelÚtext_projectionÚtext_embed_dimÚvisual_projectionÚvision_embed_dimÚCLIPVisionModelWithProjectionÚCLIPTextModelWithProjectionÚCLIPForImageClassificationÚ
classifierÚvision_config)ra   r¿   ÚfactorÚin_proj_stdÚout_proj_stdÚfc_stdr‚   s         €r(   r  z!CLIPPreTrainedModel._init_weights•  sÉ  ø€ ô 	‰Ñ˜fÔ%Ø—‘×/Ñ/ˆÜ�fÔ0Ô1Ü�L‰L˜×/Ñ/×6Ñ6¸SÀfÈtÁmÕTÜ�L‰L˜×2Ñ2×9Ñ9ÀÈÐRVÉÕWÜ�J‰J�v×*Ñ*¬E¯L©L¸×9LÑ9L×9RÑ9RÐSUÑ9VÓ,W×,^Ñ,^Ð_fÓ,gÕhÜ˜Ô 4Õ5Ü�L‰L˜×/Ñ/°c¸v×?OÑ?OÐQUÑ?UÐX^Ñ?^Õ_Ü�L‰L˜×/Ñ/×6Ñ6¸F¿M¹M×<[Ñ<[Ð^dÑ<dÕeÜ�L‰L˜×2Ñ2×9Ñ9¸v¿}¹}×?^Ñ?^ÐagÑ?gÕhÜ�J‰J�v×*Ñ*¬E¯L©L¸×9MÑ9MÓ,N×,UÑ,UÐV]Ó,^Õ_Ü˜¤Ô.Ø!×+Ñ+¨TÑ1°q¸6¿=¹=×;ZÑ;ZÑ7ZÐ_cÑ6cÑdÐgmÑmˆKØ"×,Ñ,¨dÑ2°fÑ<ˆLÜ�L‰L˜Ÿ™×-Ñ-°;Õ?Ü�L‰L˜Ÿ™×-Ñ-°;Õ?Ü�L‰L˜Ÿ™×-Ñ-°;Õ?Ü�L‰L˜Ÿ™×/Ñ/°\ÖBÜ˜¤Ô(Ø!Ÿ=™=×4Ñ4°dÑ:ÀÀFÇMÁM×DcÑDcÑ@cÐhlÑ?lÑmÐpvÑvˆKØ˜&Ÿ-™-×3Ñ3Ñ3¸Ñ<¸vÑEˆFÜ�L‰L˜Ÿ™×*Ñ*°Õ7Ü�L‰L˜Ÿ™×*Ñ*°Ö<Ü˜¤	Ô*Ü�L‰LØ×&Ñ&×-Ñ-Ø×)Ñ)¨4Ñ/°&Ñ8õô �L‰LØ×(Ñ(×/Ñ/Ø×+Ñ+¨TÑ1°FÑ:öô ˜Ô =Ô>Ü�L‰LØ×(Ñ(×/Ñ/Ø—K‘K×+Ñ+¨TÑ1°FÑ:öô ˜Ô ;Ô<Ü�L‰LØ×&Ñ&×-Ñ-Ø—K‘K×+Ñ+¨TÑ1°FÑ:öô ˜Ô :Ô;Ü�L‰LØ×!Ñ!×(Ñ(Ø—K‘K×-Ñ-×9Ñ9¸4Ñ?À&ÑHöð <r*   )rE   rF   rG   r   rJ   Úbase_model_prefixÚinput_modalitiesÚ_no_split_modulesÚsupports_gradient_checkpointingÚ_supports_sdpaÚ_supports_flash_attnÚ_supports_flex_attnÚ_supports_attention_backendró   rÒ   Ú_can_record_outputsr%   Úno_gradr  r­   r®   s   @r(   r   r   „  sb   ø… àÓØÐØ(ÐÚZÐà&*Ð#Ø€NØÐØÐØ"&Ðà)Ø#ñÐð
 €U‡]�]ƒ_ó0ó ô0r*   r   c                   ó`   ‡ — e Zd ZdZdefˆ fd„Z	 d	dej                  dz  dee	   de
fd„Zˆ xZS )
ÚCLIPEncoderz­
    Transformer encoder consisting of `config.num_hidden_layers` self attention layers. Each layer is a
    [`CLIPEncoderLayer`].

    Args:
        config: CLIPConfig
    rd   c                 óÐ   •— t         ‰| �  «        || _        t        j                  t        |j                  «      D �cg c]  }t        |«      ‘Œ c}«      | _        d| _	        y c c}w ©NF)
ro   rp   rd   r   Ú
ModuleListÚranger  ró   ÚlayersÚgradient_checkpointing)ra   rd   r¥   r‚   s      €r(   rp   zCLIPEncoder.__init__Ò  sO   ø€ Ü‰ÑÔØˆŒÜ—m‘mÄuÈV×MeÑMeÓGfÖ$gÀ!Ô%5°fÕ%=Ò$gÓhˆŒØ&+ˆÕ#ùò %hs   ½A#NrÃ   rÆ   r   c                 óT   — |}| j                   D ]  } |||fi |¤Ž}Œ t        |¬«      S )N)rB   )r,  r   )ra   r·   rÃ   rÆ   rC   Úencoder_layers         r(   r©   zCLIPEncoder.forwardØ  sH   € ð &ˆØ!Ÿ[™[ò 	ˆMÙ)ØØñð ñ‰Mð	ô Ø+ô
ð 	
r*   rY   )rE   rF   rG   rH   r   rp   r%   r«   r   r   r   r©   r­   r®   s   @r(   r'  r'  É  sK   ø„ ñð,˜zõ ,ð /3ñ
ð Ÿ™ tÑ+ð
ð Ð+Ñ,ð	
ð
 
÷
r*   r'  zI
    The text model from CLIP without any head or projection on top.
    c                   óÜ   ‡ — e Zd ZU eed<   dZdZdefˆ fd„Ze e	d¬«      e
	 	 	 ddej                  dz  d	ej                  dz  d
ej                  dz  dee   def
d„«       «       «       Zˆ xZS )ÚCLIPTextModelrd   ©r  r³   c                 ó
  •— t         ‰| �  |«       |j                  }t        |«      | _        t        |«      | _        t        j                  ||j                  ¬«      | _
        |j                  | _        | j                  «        y rõ   )ro   rp   rq   r°   rƒ   r'  Úencoderr   rø   rù   Úfinal_layer_normÚeos_token_idÚ	post_initrµ   s      €r(   rp   zCLIPTextModel.__init__õ  sf   ø€ Ü‰Ñ˜Ô Ø×&Ñ&ˆ	Ü,¨VÓ4ˆŒÜ" 6Ó*ˆŒÜ "§¡¨Y¸F×<QÑ<QÔ RˆÔð #×/Ñ/ˆÔØ�‰Õr*   F©Útie_last_hidden_statesNr¶   rÃ   rk   rÆ   r   c                 óh  — |€t        d«      ‚|j                  «       }|j                  d|d   «      }| j                  ||¬«      }t	        | j
                  ||d¬«      }|j                  dd«        | j                  d||ddœ|¤Ž}|j                  }| j                  |«      }| j                  d	k(  rm|t        j                  |j                  d
   |j                  ¬«      |j                  t        j                   |j                  ¬«      j#                  d¬«      f   }	n‡|t        j                  |j                  d
   |j                  ¬«      |j                  t        j                   |j                  ¬«      | j                  k(  j!                  «       j#                  d¬«      f   }	t%        ||	¬«      S )a9  
        Examples:

        ```python
        >>> from transformers import AutoTokenizer, CLIPTextModel

        >>> model = CLIPTextModel.from_pretrained("openai/clip-vit-base-patch32")
        >>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

        >>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")

        >>> outputs = model(**inputs)
        >>> last_hidden_state = outputs.last_hidden_state
        >>> pooled_output = outputs.pooler_output  # pooled (EOS token) states
        ```NzYou have to specify input_idsr4   )r¶   rk   )rd   r·   rÃ   Úpast_key_valuesrÚ   T)r·   rÃ   rÚ   r3   r   r!   )rŸ   r"   r‹   ©rB   Úpooler_outputrL   )r    rˆ   r”   rƒ   r
   rd   Úpopr4  rB   r5  r6  r%   r&   rŒ   r"   r¡   r¬   Úargmaxr   )
ra   r¶   rÃ   rk   rÆ   rä   rC   Úencoder_outputsrB   Úpooled_outputs
             r(   r©   zCLIPTextModel.forward   s§  € ð2 ÐÜÐ<Ó=Ð=à—n‘nÓ&ˆØ—N‘N 2 {°2¡Ó7ˆ	àŸ™°)È,˜ÓWˆä+Ø—;‘;Ø'Ø)Ø ô	
ˆð 	�
‰
�; Ô%Ø+7¨4¯<©<ð ,
Ø'Ø)Øñ,
ð ñ	,
ˆð ,×=Ñ=ÐØ ×1Ñ1Ð2CÓDÐà×Ñ Ò!ð .Ü—‘Ð.×4Ñ4°QÑ7Ð@Q×@XÑ@XÔYØ—‘¤5§9¡9Ð5F×5MÑ5M�ÓN×UÑUÐZ\ÐUÓ]ð_ñ‰Mð .Ü—‘Ð.×4Ñ4°QÑ7Ð@Q×@XÑ@XÔYð —‘¤E§I¡IÐ6G×6NÑ6N�ÓOÐSW×SdÑSdÑdß‘“ß‘˜B�“ð!ñˆMô *Ø/Ø'ô
ð 	
r*   r½   )rE   rF   rG   r   rJ   r  Ú_input_embed_layerrp   r   r   r   r%   r«   r   r   r   r©   r­   r®   s   @r(   r1  r1  ë  s¯   ø… ð ÓØ ÐØ*Ðð	˜~õ 	ð  Ù¨EÔ2Øð *.Ø.2Ø,0ñ	I
à—<‘< $Ñ&ðI
ð Ÿ™ tÑ+ðI
ð —l‘l TÑ)ð	I
ð
 Ð+Ñ,ðI
ð 
$òI
ó ó 3ó  ôI
r*   r1  zK
    The vision model from CLIP without any head or projection on top.
    c                   ó¬   ‡ — e Zd ZU eed<   dZdZdZdefˆ fd„Ze	 e
d¬«      e	 	 ddej                  dz  d	edz  d
ee   defd„«       «       «       Zˆ xZS )ÚCLIPVisionModelrd   rœ   ©r  rz   c                 ó4  •— t         ‰| �  |«       |j                  }t        |«      | _        t        j                  ||j                  ¬«      | _        t        |«      | _
        t        j                  ||j                  ¬«      | _        | j                  «        y rõ   )ro   rp   rq   rc   rƒ   r   rø   rù   Úpre_layrnormr'  r4  Úpost_layernormr7  rµ   s      €r(   rp   zCLIPVisionModel.__init__Z  so   ø€ Ü‰Ñ˜Ô Ø×&Ñ&ˆ	ä.¨vÓ6ˆŒÜŸL™L¨¸×8MÑ8MÔNˆÔÜ" 6Ó*ˆŒÜ Ÿl™l¨9¸&×:OÑ:OÔPˆÔØ�‰Õr*   Fr8  Nr›   rÆ   r   c                 óÞ   — | j                  ||¬«      }| j                  |«      } | j                  dd|i|¤Ž}|j                  }|dd…ddd…f   }| j	                  |«      }t        ||¬«      S )a(  
        Example:

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

        >>> model = CLIPVisionModel.from_pretrained("openai/clip-vit-base-patch32")
        >>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

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

        >>> inputs = processor(images=image, return_tensors="pt")

        >>> outputs = model(**inputs)
        >>> last_hidden_state = outputs.last_hidden_state
        >>> pooled_output = outputs.pooler_output  # pooled CLS states
        ```)r›   r·   Nr   r<  rL   )rƒ   rG  r4  rB   rH  r   )ra   rœ   r›   rÆ   rC   r@  rB   rA  s           r(   r©   zCLIPVisionModel.forwardd  sˆ   € ð> Ÿ™¨ÐOg˜ÓhˆØ×)Ñ)¨-Ó8ˆà+7¨4¯<©<ñ ,
Ø'ð,
àñ,
ˆð
 ,×=Ñ=ÐØ)ª!¨Q²¨'Ñ2ˆØ×+Ñ+¨MÓ:ˆä)Ø/Ø'ô
ð 	
r*   r)  )rE   rF   rG   r   rJ   Úmain_input_namer  rB  rp   r   r   r   r%   rI   Úboolr   r   r   r©   r­   r®   s   @r(   rD  rD  O  s•   ø… ð ÓØ$€OØ!ÐØ*ÐðÐ/õ ð  Ù¨EÔ2Øð 26Ø05ñ+
à×'Ñ'¨$Ñ.ð+
ð #'¨¡+ð+
ð Ð+Ñ,ð	+
ð
 
$ò+
ó ó 3ó  ô+
r*   rD  c                   ó¼  ‡ — e Zd Zdefˆ fd„Zee	 	 ddej                  dej                  dz  dej                  dz  de	e
   deez  f
d	„«       «       Zee	 dd
ej                  dede	e
   deez  fd„«       «       Zee	 	 	 	 	 	 ddej"                  dz  d
ej                  dz  dej                  dz  dej"                  dz  dedz  dede	e
   defd„«       «       Zˆ xZS )r  rd   c                 óˆ  •— t         ‰| �  |«       |j                  }|j                  }|j                  | _        |j
                  | _        |j
                  | _        t        j                  |«      | _
        t        j                  |«      | _        t        j                  | j                  | j                  d¬«      | _        t        j                  | j                  | j                  d¬«      | _        t        j"                  t%        j&                  | j(                  j*                  «      «      | _        | j/                  «        y ©NF)rj   )ro   rp   Útext_configr  Úprojection_dimrq   r  r  r1  Ú_from_configÚ
text_modelrD  Úvision_modelr   rÛ   r  r  ru   r%   r1   rd   Úlogit_scale_init_valueÚlogit_scaler7  )ra   rd   rO  r  r‚   s       €r(   rp   zCLIPModel.__init__—  sé   ø€ Ü‰Ñ˜Ô à×(Ñ(ˆØ×,Ñ,ˆà$×3Ñ3ˆÔØ)×5Ñ5ˆÔØ -× 9Ñ 9ˆÔä'×4Ñ4°[ÓAˆŒÜ+×8Ñ8¸ÓGˆÔä!#§¡¨4×+@Ñ+@À$×BUÑBUÐ\aÔ!bˆÔÜ!Ÿy™y¨×)<Ñ)<¸d×>QÑ>QÐX]Ô^ˆÔÜŸ<™<¬¯©°T·[±[×5WÑ5WÓ(XÓYˆÔð 	�‰Õr*   Nr¶   rÃ   rk   rÆ   r   c                 óx   —  | j                   d|||ddœ|¤Ž}|j                  }| j                  |«      |_        |S )a  
        Examples:

        ```python
        >>> import torch
        >>> from transformers import AutoTokenizer, CLIPModel

        >>> model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
        >>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

        >>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")

        >>> with torch.inference_mode():
        ...     text_features = model.get_text_features(**inputs)
        ```T)r¶   rÃ   rk   Úreturn_dictrL   )rR  r=  r  )ra   r¶   rÃ   rk   rÆ   Útext_outputsrA  s          r(   Úget_text_featureszCLIPModel.get_text_features«  sV   € ð0 4C°4·?±?ð 4
ØØ)Ø%Øñ	4
ð
 ñ4
ˆð %×2Ñ2ˆØ%)×%9Ñ%9¸-Ó%HˆÔ"àÐr*   rœ   r›   c                 óv   —  | j                   d||ddœ|¤Ž}|j                  }| j                  |«      |_        |S )aŠ  
        Examples:

        ```python
        >>> import torch
        >>> from transformers import AutoProcessor, CLIPModel
        >>> from transformers.image_utils import load_image

        >>> model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
        >>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> image = load_image(url)

        >>> inputs = processor(images=image, return_tensors="pt")

        >>> with torch.inference_mode():
        ...     image_features = model.get_image_features(**inputs)
        ```T)rœ   r›   rW  rL   )rS  r=  r  )ra   rœ   r›   rÆ   Úvision_outputsrA  s         r(   Úget_image_featureszCLIPModel.get_image_featuresÏ  sU   € ð6 6G°T×5FÑ5Fð 6
Ø%Ø%=Øñ6
ð ñ	6
ˆð '×4Ñ4ˆØ'+×'=Ñ'=¸mÓ'LˆÔ$àÐr*   Úreturn_lossc           	      ó  —  | j                   d||dœ|¤Ž} | j                  d|||dœ|¤Ž}	|j                  }
|	j                  }|
t        |
«      z  }
|t        |«      z  }t	        j
                  ||
j                  «       j                  |j                  «      «      }|| j                  j                  «       j                  |j                  «      z  }|j                  «       }d}|rt        |«      }t        |||||
|	|¬«      S )a  
        return_loss (`bool`, *optional*):
            Whether or not to return the contrastive loss.

        Examples:

        ```python
        >>> import torch
        >>> from transformers import AutoProcessor, CLIPModel
        >>> from transformers.image_utils import load_image

        >>> model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
        >>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> image = load_image(url)

        >>> inputs = processor(
        ...     text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="pt", padding=True
        ... )

        >>> with torch.inference_mode():
        ...     outputs = model(**inputs)
        >>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
        >>> probs = logits_per_image.softmax(dim=1)  # we can take the softmax to get the label probabilities
        ```©rœ   r›   ©r¶   rÃ   rk   N)rR   rS   rT   rO   rA   rU   rV   rL   )r\  rY  r=  r=   r%   rÊ   Útr¡   r"   rU  Úexpr0   rQ   )ra   r¶   rœ   rÃ   rk   r]  r›   rÆ   r[  rX  rA   rO   rT   rS   rR   s                  r(   r©   zCLIPModel.forwardõ  s+  € ðL 6M°T×5LÑ5Lð 6
Ø%Ø%=ñ6
ð ñ6
ˆð 4J°4×3IÑ3Ið 4
ØØ)Ø%ñ4
ð ñ	4
ˆð &×3Ñ3ˆØ"×0Ñ0ˆð $Ô&6°|Ó&DÑDˆØ!Ô$4°[Ó$AÑAˆô  Ÿ,™, {°L·N±NÓ4D×4GÑ4GÈ×HZÑHZÓ4[Ó\ˆØ)¨D×,<Ñ,<×,@Ñ,@Ó,B×,EÑ,EÀk×FXÑFXÓ,YÑYˆà*×,Ñ,Ó.ÐàˆÙÜ.¨Ó?ˆDäØØ-Ø+Ø#Ø%Ø*Ø .ô
ð 	
r*   ©NNrª   )NNNNNF)rE   rF   rG   r   rp   r   r   r%   r«   r   r   rK   r   rY  rI   rK  r\  r¾   rQ   r©   r­   r®   s   @r(   r  r  •  sœ  ø„ ð˜zõ ð( Øð /3Ø,0ñ	 à—<‘<ð ð Ÿ™ tÑ+ð ð —l‘l TÑ)ð	 ð
 Ð+Ñ,ð ð 
Ð+Ñ	+ò ó ó ð ðD Øð */ñ"à×'Ñ'ð"ð #'ð"ð Ð+Ñ,ð	"ð
 
Ð+Ñ	+ò"ó ó ð"ðH Øð .2Ø15Ø.2Ø04Ø#'Ø).ñJ
à×#Ñ# dÑ*ðJ
ð ×'Ñ'¨$Ñ.ðJ
ð Ÿ™ tÑ+ð	J
ð
 ×&Ñ&¨Ñ-ðJ
ð ˜D‘[ðJ
ð #'ðJ
ð Ð+Ñ,ðJ
ð 
òJ
ó ó ôJ
r*   r  c                   óæ   ‡ — e Zd ZU eed<   dZdefˆ fd„Zdej                  fd„Z	d„ Z
ee	 	 	 ddej                  dz  d	ej                  dz  d
ej                  dz  dee   def
d„«       «       Zˆ xZS )r  rd   r2  c                 óÚ   •— t         ‰| �  |«       t        j                  |«      | _        t        j                  |j                  |j                  d¬«      | _	        | j                  «        y rN  )ro   rp   r1  rQ  rR  r   rÛ   rq   rP  r  r7  r�   s     €r(   rp   z$CLIPTextModelWithProjection.__init__I  sP   ø€ Ü‰Ñ˜Ô ä'×4Ñ4°VÓ<ˆŒÜ!Ÿy™y¨×);Ñ);¸V×=RÑ=RÐY^Ô_ˆÔð 	�‰Õr*   r   c                 óB   — | j                   j                  j                  S rY   ©rR  rƒ   r³   r`   s    r(   Úget_input_embeddingsz0CLIPTextModelWithProjection.get_input_embeddingsR  s   € Ø�‰×)Ñ)×9Ñ9Ð9r*   c                 ó:   — || j                   j                  _        y rY   rg  )ra   rÂ   s     r(   Úset_input_embeddingsz0CLIPTextModelWithProjection.set_input_embeddingsU  s   € Ø5:ˆ�‰×"Ñ"Õ2r*   Nr¶   rÃ   rk   rÆ   c                 óÂ   —  | j                   d|||dœ|¤Ž}|j                  }| j                  |«      }t        ||j                  |j
                  |j                  ¬«      S )a@  
        Examples:

        ```python
        >>> import torch
        >>> from transformers import AutoTokenizer, CLIPTextModelWithProjection

        >>> model = CLIPTextModelWithProjection.from_pretrained("openai/clip-vit-base-patch32")
        >>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

        >>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")

        >>> with torch.inference_mode():
        ...     outputs = model(**inputs)
        >>> text_embeds = outputs.text_embeds
        ```r`  )rO   rB   rC   rD   rL   )rR  r=  r  rN   rB   rC   rD   )ra   r¶   rÃ   rk   rÆ   rX  rA  rO   s           r(   r©   z#CLIPTextModelWithProjection.forwardX  su   € ð4 4C°4·?±?ð 4
ØØ)Ø%ñ4
ð ñ	4
ˆð %×2Ñ2ˆØ×*Ñ*¨=Ó9ˆä"Ø#Ø*×<Ñ<Ø&×4Ñ4Ø#×.Ñ.ô	
ð 	
r*   r½   )rE   rF   rG   r   rJ   r  rp   r   ÚModulerh  rj  r   r   r%   r«   r   r   rN   r©   r­   r®   s   @r(   r  r  D  s¨   ø… àÓØ Ðð˜~õ ð: b§i¡ió :ò;ð Øð *.Ø.2Ø,0ñ	&
à—<‘< $Ñ&ð&
ð Ÿ™ tÑ+ð&
ð —l‘l TÑ)ð	&
ð
 Ð+Ñ,ð&
ð 
ò&
ó ó ô&
r*   r  c                   óª   ‡ — e Zd ZU eed<   dZdZdefˆ fd„Zdej                  fd„Z
ee	 	 ddej                  dz  ded	ee   defd
„«       «       Zˆ xZS )r  rd   rœ   rE  c                 óÚ   •— t         ‰| �  |«       t        j                  |«      | _        t        j                  |j                  |j                  d¬«      | _	        | j                  «        y rN  )ro   rp   rD  rQ  rS  r   rÛ   rq   rP  r  r7  r�   s     €r(   rp   z&CLIPVisionModelWithProjection.__init__‰  sQ   ø€ Ü‰Ñ˜Ô ä+×8Ñ8¸Ó@ˆÔÜ!#§¡¨6×+=Ñ+=¸v×?TÑ?TÐ[`Ô!aˆÔð 	�‰Õr*   r   c                 óB   — | j                   j                  j                  S rY   )rS  rƒ   rz   r`   s    r(   rh  z2CLIPVisionModelWithProjection.get_input_embeddings’  s   € Ø× Ñ ×+Ñ+×;Ñ;Ð;r*   Nr›   rÆ   c                 óÀ   —  | j                   d||dœ|¤Ž}|j                  }| j                  |«      }t        ||j                  |j
                  |j                  ¬«      S )aÈ  
        Examples:

        ```python
        >>> import torch
        >>> from transformers import AutoProcessor, CLIPVisionModelWithProjection
        >>> from transformers.image_utils import load_image

        >>> model = CLIPVisionModelWithProjection.from_pretrained("openai/clip-vit-base-patch32")
        >>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> image = load_image(url)

        >>> inputs = processor(images=image, return_tensors="pt")

        >>> with torch.inference_mode():
        ...     outputs = model(**inputs)
        >>> image_embeds = outputs.image_embeds
        ```r_  )rA   rB   rC   rD   rL   )rS  r=  r  r@   rB   rC   rD   )ra   rœ   r›   rÆ   r[  rA  rA   s          r(   r©   z%CLIPVisionModelWithProjection.forward•  st   € ð: 6G°T×5FÑ5Fð 6
Ø%Ø%=ñ6
ð ñ6
ˆð
 '×4Ñ4ˆØ×-Ñ-¨mÓ<ˆä$Ø%Ø,×>Ñ>Ø(×6Ñ6Ø%×0Ñ0ô	
ð 	
r*   r)  )rE   rF   rG   r   rJ   rJ  r  rp   r   rl  rh  r   r   r%   rI   rK  r   r   r@   r©   r­   r®   s   @r(   r  r  ƒ  sŒ   ø… àÓØ$€OØ!ÐðÐ/õ ð< b§i¡ió <ð Øð 26Ø).ñ(
à×'Ñ'¨$Ñ.ð(
ð #'ð(
ð Ð+Ñ,ð	(
ð
 
ò(
ó ó ô(
r*   r  z«
    CLIP vision encoder with an image classification head on top (a linear layer on top of the pooled final hidden states of
    the patch tokens) e.g. for ImageNet.
    c                   óœ   ‡ — e Zd ZdZdZdeddfˆ fd„Zee	 	 d
de	j                  dz  de	j                  dz  dee   defd	„«       «       Zˆ xZS )r  rœ   rE  rd   r   Nc                 óf  •— t         ‰| �  |«       |j                  | _        t        j	                  |j
                  «      | _        |j                  dkD  r4t        j                  |j
                  j                  |j                  «      nt        j                  «       | _        | j                  «        y )Nr   )ro   rp   Ú
num_labelsrD  rQ  r  rS  r   rÛ   rq   ÚIdentityr  r7  r�   s     €r(   rp   z#CLIPForImageClassification.__init__Ì  s‡   ø€ Ü‰Ñ˜Ô à ×+Ñ+ˆŒÜ+×8Ñ8¸×9MÑ9MÓNˆÔð OU×N_ÑN_ÐbcÒNcŒB�I‰I�f×*Ñ*×6Ñ6¸×8IÑ8IÔJÔik×itÑitÓivð 	Œð
 	�‰Õr*   ÚlabelsrÆ   c                 ó0  —  | j                   |fi |¤Ž}|j                  }t        j                  |dd…dd…dd…f   d¬«      }| j	                  |«      }d}|�| j                  ||| j                  «      }t        |||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).
        Nr   r‹   )rR   r   rC   rD   )
rS  rB   r%   r  r  Úloss_functionrd   r   rC   rD   )ra   rœ   ru  rÆ   ÚoutputsÚsequence_outputr   rR   s           r(   r©   z"CLIPForImageClassification.forwardÚ  s¢   € ð /@¨d×.?Ñ.?Øñ/
àñ/
ˆð
 "×3Ñ3ˆäŸ*™* _²Q¸¹ºA°XÑ%>ÀAÔFˆØ—‘ Ó1ˆàˆØÐØ×%Ñ% f¨f°d·k±kÓBˆDä$ØØØ!×/Ñ/Ø×)Ñ)ô	
ð 	
r*   rc  )rE   rF   rG   rJ  r  r   rp   r   r   r%   r«   r   r   r   r©   r­   r®   s   @r(   r  r  Â  s…   ø„ ð %€OØ!Ðð˜zð ¨dõ ð Øð -1Ø&*ñ
à—l‘l TÑ)ð
ð —‘˜tÑ#ð
ð Ð+Ñ,ð	
ð
 
ò
ó ó ô
r*   r  )r  r   r1  r  rD  r  r  )rá   )ErH   Úcollections.abcr   Údataclassesr   Útypingr   r%   r   Ú r   r	  Úactivationsr	   Úmasking_utilsr
   Úmodeling_layersr   Úmodeling_outputsr   r   r   Úmodeling_utilsr   r   Úprocessing_utilsr   Úutilsr   r   r   r   r   Úutils.genericr   r   Úutils.output_capturingr   Úconfiguration_clipr   r   r   Ú
get_loggerrE   Úloggerr«   r)   r0   r=   r@   rN   rQ   rl  rc   r°   ÚfloatrÐ   rÒ   rê   ró   r   r'  r1  rD  r  r  r  r  Ú__all__rL   r*   r(   ú<module>rŒ     s  ðñ å $Ý !Ý ã Ý å &Ý !Ý /Ý 9ß bÑ bß FÝ &÷õ ÷ JÝ 5ß LÑ Lð 
ˆ×	Ñ	˜HÓ	%€ð
`˜UŸ\™\ð `¨e¯l©ló `ð-¨E¯L©Lð -¸U¿\¹\ó -ð˜UŸ\™\ð ¨e¯l©ló ñ ðôð
 ô	<˜Kó 	<ó óð	<ñ ðôð
 ô	<˜+ó 	<ó óð	<ð Ø
ô_�ó _ó ó ð_ô@P˜2Ÿ9™9ô Pôf%˜Ÿ™ô %ð^ ñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 —L‘L 4Ñ'ð%ð ð%ð ð%ð Ð'Ñ(ó%ô*7)�B—I‘Iô 7)ôtˆb�i‰iô ôÐ1ô ðB ôA˜/ó Aó ðAôH
�"—)‘)ô 
ñD ðôô
\
Ð'ó \
óð
\
ñ~ ðôô
>
Ð)ó >
óð
>
ðB ôk
Ð#ó k
ó ðk
ð\ ô;
Ð"5ó ;
ó ð;
ð| ô;
Ð$7ó ;
ó ð;
ñ| ðôô3
Ð!4ó 3
óð3
òl�r*   