Ë
    ÛÓ^j¯b  ã                   ó¼  — 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 ddlmZ dd	l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 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/m0Z0 	 dBdejb                  dejd                  dejd                  dejd                  dejd                  dz  de3de3e4z  fd„Z5 G d„ de'«      Z6 G d „ d!e%«      Z7 ed"¬#«      e G d$„ d%e«      «       «       Z8 G d&„ d'ejb                  «      Z9 G d(„ d)ejb                  «      Z: G d*„ d+e#«      Z;ejx                  e6d,œZ= G d-„ d.e«      Z> G d/„ d0ejb                  «      Z?e G d1„ d2e«      «       Z@e G d3„ d4e@«      «       ZA G d5„ d6e-«      ZBdZC G d7„ d8ejb                  «      ZD G d9„ d:e,«      ZE G d;„ d<e+«      ZF G d=„ d>e)«      ZG G d?„ d@e*«      ZHg dA¢ZIy)Cé    N)ÚCallable)Ú	dataclassé   )Úinitialization)ÚACT2FN)ÚCache)ÚGradientCheckpointingLayer)ÚBaseModelOutputÚBaseModelOutputWithPooling)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)ÚTransformersKwargsÚauto_docstringÚ	torch_int)Úcan_return_tupleÚmerge_with_config_defaults)Úcapture_outputsé   )ÚCLIPMLP)ÚJanusVisionAttention)ÚLlamaRMSNorm)ÚLlavaCausalLMOutputWithPastÚLlavaForConditionalGenerationÚ
LlavaModelÚLlavaModelOutputWithPastÚLlavaPreTrainedModelé   )ÚInternVLConfigÚInternVLVisionConfigÚmoduleÚqueryÚkeyÚvalueÚattention_maskÚscalingÚdropoutc                 óx  — |}|}	t        j                  ||j                  dd«      «      |z  }
|�|
|z   }
t        j                  j                  |
d¬«      }
t        j                  j                  |
|| j                  ¬«      }
t        j                  |
|	«      }|j                  dd«      j                  «       }||
fS )Nr   r   éÿÿÿÿ©Údim)ÚpÚtrainingr   )	ÚtorchÚmatmulÚ	transposeÚnnÚ
functionalÚsoftmaxr'   r-   Ú
contiguous)r!   r"   r#   r$   r%   r&   r'   ÚkwargsÚ
key_statesÚvalue_statesÚattn_weightsÚattn_outputs               úx/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/internvl/modular_internvl.pyÚeager_attention_forwardr;   .   s°   € ð €JØ€Lä—<‘<  z×';Ñ';¸A¸qÓ'AÓBÀWÑL€LØÐ!Ø# nÑ4ˆô —=‘=×(Ñ(¨¸2Ð(Ó>€LÜ—=‘=×(Ñ(¨¸È6Ï?É?Ð(Ó[€LÜ—,‘,˜|¨\Ó:€KØ×'Ñ'¨¨1Ó-×8Ñ8Ó:€Kà˜Ð$Ð$ó    c                   ó   — e Zd Zy)ÚInternVLVisionRMSNormN©Ú__name__Ú
__module__Ú__qualname__© r<   r:   r>   r>   H   ó   „ Ør<   r>   c                   óp   ‡ — e Zd Zdefˆ fd„Z	 ddej                  dej                  dz  dee   fd„Z	ˆ xZ
S )	ÚInternVLVisionAttentionÚconfigc                 ó  •— t         ‰| �  |«       | `d| _        |j                  }|rt        | j                  «      nt        j                  «       | _	        |rt        | j                  «      | _
        y t        j                  «       | _
        y ©NF)ÚsuperÚ__init__Únum_key_value_groupsÚ	is_causalÚuse_qk_normr>   Ú	embed_dimr1   ÚIdentityÚq_normÚk_norm)ÚselfrG   Úqk_normÚ	__class__s      €r:   rK   z InternVLVisionAttention.__init__M   sd   ø€ Ü‰Ñ˜Ô ØÐ%ð ˆŒØ×$Ñ$ˆá?FÔ+¨D¯N©NÔ;ÌBÏKÉKËMˆŒÙ?FÔ+¨D¯N©NÓ;ˆ�ÌBÏKÉKËMˆ�r<   NÚhidden_statesr%   r5   c                 ór  — |j                  «       \  }}}| j                  |«      }| j                  |«      }| j                  |«      }	| j	                  |«      }| j                  |«      }|j                  ||| j                  | j                  «      j                  dd«      }|j                  ||| j                  | j                  «      j                  dd«      }|	j                  ||| j                  | j                  «      j                  dd«      }	t        j                  | j                  j                  t        «      }
 |
| |||	|f| j                   sdn| j"                  | j$                  ddœ|¤Ž\  }}|j                  ||| j&                  «      }| j)                  |«      }| j+                  |«      }||fS )Nr   r   ç        F)r'   r&   rM   )ÚsizeÚq_projÚk_projÚv_projrQ   rR   ÚreshapeÚ	num_headsÚhead_dimr0   Úviewr   Úget_interfacerG   Ú_attn_implementationr;   r-   Úattention_dropoutÚscalerO   Úprojection_layerÚprojection_dropout)rS   rV   r%   r5   Ú
batch_sizeÚseq_lenÚ_Úquery_statesr6   r7   Úattention_interfacer9   r8   Úoutputs                 r:   ÚforwardzInternVLVisionAttention.forwardX   s›  € ð "/×!3Ñ!3Ó!5Ñˆ
�G˜Qà—{‘{ =Ó1ˆØ—[‘[ Ó/ˆ
Ø—{‘{ =Ó1ˆà—{‘{ <Ó0ˆØ—[‘[ Ó,ˆ
à#×+Ñ+¨J¸ÀÇÁÐQU×Q^ÑQ^Ó_×iÑiÐjkÐmnÓoˆØ×'Ñ'¨
°G¸T¿^¹^ÈTÏ]É]Ó[×eÑeÐfgÐijÓkˆ
Ø#×(Ñ(¨°W¸d¿n¹nÈdÏmÉmÓ\×fÑfÐghÐjkÓlˆä(?×(MÑ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØð
%
ð  $Ÿ}š}‘C°$×2HÑ2HØ—J‘JØñ
%
ð ñ
%
Ñ!ˆ�\ð "×)Ñ)¨*°g¸t¿~¹~ÓNˆà×&Ñ& {Ó3ˆØ×(Ñ(¨Ó0ˆà�|Ð#Ð#r<   ©N)r@   rA   rB   r    rK   r.   ÚTensorr   r   rm   Ú__classcell__©rU   s   @r:   rF   rF   L   sK   ø„ ð	ZÐ3õ 	Zð /3ñ'$à—|‘|ð'$ð Ÿ™ tÑ+ð'$ð Ð+Ñ,÷	'$r<   rF   z7
    Class for outputs of [`InternVLVisionModel`].
    ©Úcustom_introc                   ó   — e Zd ZdZy)Ú$InternVLVisionModelOutputWithPoolingaF  
    pooler_output (`torch.FloatTensor` of shape `(batch_size, hidden_size)`):
        Average of the last layer hidden states of the patch tokens (excluding the *[CLS]* token) if
        *config.use_mean_pooling* is set to True. If set to False, then the final hidden state of the *[CLS]* token
        will be returned.
    N)r@   rA   rB   Ú__doc__rC   r<   r:   ru   ru   ‚   s   „ òr<   ru   c                   óZ   ‡ — e Zd ZdZˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚInternVLVisionPatchEmbeddingszì
    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
                  }}|d   |d   z  |d   |d   z  z  }|d   |d   z  |d   |d   z  f}|| _        || _        || _        || _        || _        t        j                  ||||¬«      | _
        y )Nr   r   )Úkernel_sizeÚstride)rJ   rK   Ú
image_sizeÚ
patch_sizeÚnum_channelsÚhidden_sizeÚnum_patchesÚpatch_shaper1   ÚConv2dÚ
projection)	rS   rG   r|   r}   r~   r   r€   r�   rU   s	           €r:   rK   z&InternVLVisionPatchEmbeddings.__init__˜   s¿   ø€ Ü‰ÑÔØ!'×!2Ñ!2°F×4EÑ4E�Jˆ
Ø$*×$7Ñ$7¸×9KÑ9K�kˆà! !‘}¨
°1©Ñ5¸*ÀQ¹-È:ÐVWÉ=Ñ:XÑYˆØ! !‘}¨
°1©Ñ5°zÀ!±}È
ÐSTÉÑ7UÐVˆØ$ˆŒØ$ˆŒØ(ˆÔØ&ˆÔØ&ˆÔäŸ)™) L°+È:Ð^hÔiˆ�r<   Úpixel_valuesÚreturnc                 ó  — |j                   \  }}}}|| j                  k7  rt        d«      ‚| j                  |j	                  | j                  j
                  j                  «      «      }|j                  d«      j                  dd«      }|S )NzeMake sure that the channel dimension of the pixel values match with the one set in the configuration.r   r   )	Úshaper~   Ú
ValueErrorrƒ   ÚtoÚweightÚdtypeÚflattenr0   )rS   r„   rg   r~   ÚheightÚwidthÚ
embeddingss          r:   rm   z%InternVLVisionPatchEmbeddings.forward§   s€   € Ø2>×2DÑ2DÑ/ˆ
�L &¨%Ø˜4×,Ñ,Ò,ÜØwóð ð —_‘_ \§_¡_°T·_±_×5KÑ5K×5QÑ5QÓ%RÓSˆ
Ø×'Ñ'¨Ó*×4Ñ4°Q¸Ó:ˆ
àÐr<   )	r@   rA   rB   rv   rK   r.   ro   rm   rp   rq   s   @r:   rx   rx   ‘   s)   ø„ ñôjð
 E§L¡Lð 
°U·\±\÷ 
r<   rx   c                   óÆ   ‡ — e Zd ZdZdeddfˆ fd„Zdej                  dededej                  fd	„Z		 dd
ej                  dej                  dz  dej                  fd„Zˆ xZS )ÚInternVLVisionEmbeddingszc
    Construct the CLS token, position and patch embeddings. Optionally, also the mask token.

    rG   r…   Nc                 ó2  •— t         ‰| �  «        t        j                  t	        j
                  dd|j                  «      «      | _        |j                  r:t        j                  t	        j
                  dd|j                  «      «      | _	        nd | _	        t        |«      | _        |j                  | _        t        |j                  t        j                   j"                  «      r|j                  n|j                  |j                  f| _        | j                  j$                  }|j&                  r=t        j                  t	        j
                  d|dz   |j                  «      «      | _        nd | _        t        j*                  |j,                  «      | _        y )Nr   )rJ   rK   r1   Ú	Parameterr.   Úzerosr   Ú	cls_tokenÚuse_mask_tokenÚ
mask_tokenrx   Úpatch_embeddingsr}   Ú
isinstancer|   ÚcollectionsÚabcÚIterabler€   Ú use_absolute_position_embeddingsÚposition_embeddingsÚDropoutÚhidden_dropout_probr'   )rS   rG   r€   rU   s      €r:   rK   z!InternVLVisionEmbeddings.__init__¼   s$  ø€ Ü‰ÑÔäŸ™¤e§k¡k°!°Q¸×8JÑ8JÓ&KÓLˆŒØ× Ò Ü Ÿl™l¬5¯;©;°q¸!¸V×=OÑ=OÓ+PÓQˆD�Oà"ˆDŒOÜ =¸fÓ EˆÔØ ×+Ñ+ˆŒô ˜&×+Ñ+¬[¯_©_×-EÑ-EÔFð ×Òà×#Ñ# V×%6Ñ%6Ð7ð 	Œð
 ×+Ñ+×7Ñ7ˆØ×2Ò2Ü')§|¡|´E·K±KÀÀ;ÐQRÁ?ÐTZ×TfÑTfÓ4gÓ'hˆDÕ$à'+ˆDÔ$Ü—z‘z &×"<Ñ"<Ó=ˆ�r<   r�   r�   rŽ   c                 ó²  — |j                   d   dz
  }| j                  j                   d   dz
  }t        j                  j	                  «       s||k(  r||k(  r| j                  S | j                  dd…dd…f   }| j                  dd…dd…f   }|j                   d   }|| j
                  d   z  }	|| j
                  d   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   Nr)   r   ç      à?r   r   ÚbicubicF)rY   ÚmodeÚalign_cornersr*   )r‡   rž   r.   ÚjitÚ
is_tracingr}   r   r]   Úpermuter1   r2   Úinterpolater`   Úcat)rS   r�   r�   rŽ   r€   Únum_positionsÚclass_pos_embedÚpatch_pos_embedr+   Ú
new_heightÚ	new_widthÚsqrt_num_positionss               r:   Úinterpolate_pos_encodingz1InternVLVisionEmbeddings.interpolate_pos_encodingÒ   sj  € ð !×&Ñ& qÑ)¨AÑ-ˆØ×0Ñ0×6Ñ6°qÑ9¸AÑ=ˆô �y‰y×#Ñ#Ô%¨+¸Ò*FÈ6ÐUZÊ?Ø×+Ñ+Ð+à×2Ñ2²1°b°q°b°5Ñ9ˆØ×2Ñ2²1°a±b°5Ñ9ˆà×Ñ˜rÑ"ˆà˜tŸ™¨qÑ1Ñ1ˆ
Ø˜TŸ_™_¨QÑ/Ñ/ˆ	ä& }°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<   r„   Úbool_masked_posc                 óÞ  — |j                   \  }}}}| j                  |«      }|j                  «       \  }}}|�K| j                  j	                  ||d«      }	|j                  d«      j                  |	«      }
|d|
z
  z  |	|
z  z   }| j                  j	                  |dd«      }t        j                  ||fd¬«      }| j                  �|| j                  |||«      z   }| j                  |«      }|S )Nr)   r   r*   )r‡   r˜   rY   r—   ÚexpandÚ	unsqueezeÚtype_asr•   r.   rª   rž   r±   r'   )rS   r„   r²   ri   r�   rŽ   r�   rg   rh   Úmask_tokensÚwÚ
cls_tokenss               r:   rm   z InternVLVisionEmbeddings.forwardú   só   € ð
 +×0Ñ0Ñˆˆ1ˆf�eØ×*Ñ*¨<Ó8ˆ
Ø!+§¡Ó!2Ñˆ
�G˜QàÐ&ØŸ/™/×0Ñ0°¸WÀbÓIˆKà×)Ñ)¨"Ó-×5Ñ5°kÓBˆAØ# q¨1¡uÑ-°¸a±Ñ?ˆJà—^‘^×*Ñ*¨:°r¸2Ó>ˆ
Ü—Y‘Y 
¨JÐ7¸QÔ?ˆ
à×#Ñ#Ð/Ø# d×&CÑ&CÀJÐPVÐX]Ó&^Ñ^ˆJà—\‘\ *Ó-ˆ
àÐr<   rn   )r@   rA   rB   rv   r    rK   r.   ro   Úintr±   Ú
BoolTensorrm   rp   rq   s   @r:   r‘   r‘   ¶   sˆ   ø„ ñð
>Ð3ð >¸õ >ð,&D°5·<±<ð &DÈð &DÐUXð &DÐ]b×]iÑ]ió &DðV 48ñà—l‘lðð ×)Ñ)¨DÑ0ðð 
�‰÷	r<   r‘   c                   ó   — e Zd Zy)ÚInternVLVisionMLPNr?   rC   r<   r:   r½   r½     rD   r<   r½   )Ú
layer_normÚrms_normc                   ó¢   ‡ — e Zd ZdZdeddfˆ fd„Zdej                  deej                     eej                  ej                  f   z  fd„Z	ˆ xZ
S )ÚInternVLVisionLayerz?This corresponds to the Block class in the timm implementation.rG   r…   Nc                 ó®  •— t         ‰| �  «        |j                  | _        d| _        t	        |«      | _        t        |«      | _        t        |j                     |j                  |j                  ¬«      | _        t        |j                     |j                  |j                  ¬«      | _        |j                  }t        j                   |t#        j$                  |j                  «      z  d¬«      | _        t        j                   |t#        j$                  |j                  «      z  d¬«      | _        t        j*                  |j,                  «      | _        y )Nr   ©ÚepsT)Úrequires_grad)rJ   rK   Úchunk_size_feed_forwardÚseq_len_dimrF   Ú	attentionr½   ÚmlpÚNORM2FNÚ	norm_typer   Úlayer_norm_epsÚlayernorm_beforeÚlayernorm_afterÚlayer_scale_init_valuer1   r“   r.   ÚonesÚlambda_1Úlambda_2rŸ   r    r'   )rS   rG   Úinit_valuesrU   s      €r:   rK   zInternVLVisionLayer.__init__  sù   ø€ Ü‰ÑÔØ'-×'EÑ'EˆÔ$ØˆÔÜ0°Ó8ˆŒÜ$ VÓ,ˆŒä '¨×(8Ñ(8Ñ 9¸&×:LÑ:LÐRX×RgÑRgÔ hˆÔÜ& v×'7Ñ'7Ñ8¸×9KÑ9KÐQW×QfÑQfÔgˆÔà×3Ñ3ˆÜŸ™ [´5·:±:¸f×>PÑ>PÓ3QÑ%QÐaeÔfˆŒÜŸ™ [´5·:±:¸f×>PÑ>PÓ3QÑ%QÐaeÔfˆŒÜ—z‘z &×"<Ñ"<Ó=ˆ�r<   rV   c                 ó  — | j                  | j                  |«      «      \  }}| j                  |z  }||z   }| j                  |«      }| j	                  |«      }| j                  |«      }| j                  �| j                  |z  }||z   }|S rn   )rÈ   rÍ   rÑ   rÎ   rÉ   r'   rÒ   )rS   rV   Úattention_outputri   Úlayer_outputs        r:   rm   zInternVLVisionLayer.forward-  sœ   € ð #Ÿn™nØ×!Ñ! -Ó0ó
ÑÐ˜!ð  Ÿ=™=Ð+;Ñ;Ðð )¨=Ñ8ˆð ×+Ñ+¨MÓ:ˆà—x‘x Ó-ˆØ—|‘| LÓ1ˆà�=‰=Ð$ØŸ=™=¨<Ñ7ˆLð $ mÑ3ˆàÐr<   )r@   rA   rB   rv   r    rK   r.   ro   Útuplerm   rp   rq   s   @r:   rÁ   rÁ     sU   ø„ ÙIð>Ð3ð >¸õ >ðà—|‘|ðð 
ˆu�|‰|Ñ	˜u U§\¡\°5·<±<Ð%?Ñ@Ñ	@÷r<   rÁ   c                   óR   ‡ — e Zd Zdeddfˆ fd„Zdej                  deez  fd„Z	ˆ xZ
S )ÚInternVLVisionEncoderrG   r…   Nc                 óÐ   •— t         ‰| �  «        || _        t        j                  t        |j                  «      D �cg c]  }t        |«      ‘Œ c}«      | _        d| _	        y c c}w rI   )
rJ   rK   rG   r1   Ú
ModuleListÚrangeÚnum_hidden_layersrÁ   ÚlayerÚgradient_checkpointing)rS   rG   ÚirU   s      €r:   rK   zInternVLVisionEncoder.__init__J  sO   ø€ Ü‰ÑÔØˆŒÜ—]‘]ÌÈv×OgÑOgÓIhÖ#iÀAÔ$7¸Õ$?Ò#iÓjˆŒ
Ø&+ˆÕ#ùò $js   ½A#rV   c                 óL   — | j                   D ]
  } ||«      }Œ t        |¬«      S )N)Úlast_hidden_state)rÞ   r
   )rS   rV   Úlayer_modules      r:   rm   zInternVLVisionEncoder.forwardP  s3   € ð !ŸJ™Jò 	8ˆLÙ(¨Ó7‰Mð	8ô Ø+ô
ð 	
r<   )r@   rA   rB   r    rK   r.   ro   r×   r
   rm   rp   rq   s   @r:   rÙ   rÙ   I  s7   ø„ ð,Ð3ð ,¸õ ,ð	
à—|‘|ð	
ð 
�Ñ	 ÷	
r<   rÙ   c                   ó‚   ‡ — e Zd ZU eed<   dZdZdZdZdgZ	dZ
dZdZdZeedœZ ej$                  «       ˆ fd„«       Zˆ xZS )	ÚInternVLVisionPreTrainedModelrG   Úinternvl_visionr„   )ÚimageÚvideoTrÁ   )rV   Ú
attentionsc                 ó$  •— t         ‰| �  |«       t        |t        «      rwt	        j
                  |j                  «       |j                  �t	        j
                  |j                  «       |j                  � t	        j
                  |j                  «       yyt        |t        «      rit	        j                  |j                  | j                  j                  «       t	        j                  |j                  | j                  j                  «       yy)zInitialize the weightsN)rJ   Ú_init_weightsr™   r‘   ÚinitÚzeros_r•   r—   rž   rÁ   Ú	constant_rÑ   rG   rÏ   rÒ   )rS   r!   rU   s     €r:   rë   z+InternVLVisionPreTrainedModel._init_weightsn  s¸   ø€ ô 	‰Ñ˜fÔ%Ü�fÔ6Ô7Ü�K‰K˜×(Ñ(Ô)Ø× Ñ Ð,Ü—‘˜F×-Ñ-Ô.Ø×)Ñ)Ð5Ü—‘˜F×6Ñ6Õ7ð 6ä˜Ô 3Ô4Ü�N‰N˜6Ÿ?™?¨D¯K©K×,NÑ,NÔOÜ�N‰N˜6Ÿ?™?¨D¯K©K×,NÑ,NÕOð 5r<   )r@   rA   rB   r    Ú__annotations__Úbase_model_prefixÚmain_input_nameÚinput_modalitiesÚsupports_gradient_checkpointingÚ_no_split_modulesÚ_supports_sdpaÚ_supports_flash_attnÚ_supports_flex_attnÚ_supports_attention_backendrÁ   rF   Ú_can_record_outputsr.   Úno_gradrë   rp   rq   s   @r:   rå   rå   \  sn   ø… à Ó Ø)ÐØ$€OØ)ÐØ&*Ð#Ø.Ð/ÐØ€NØÐØÐØ"&Ðð -Ø-ñÐð
 €U‡]�]ƒ_óPó ôPr<   rå   c                   ó¦   ‡ — e Zd Zdeddfˆ fd„Zd„ Ze ed¬«      e	 dde	j                  d	e	j                  dz  deez  fd
„«       «       «       Zˆ xZS )ÚInternVLVisionModelrG   r…   Nc                 ó2  •— t         ‰| �  |«       || _        t        |«      | _        t        |«      | _        |j                  rt        j                  «       n*t        j                  |j                  |j                  ¬«      | _        | j                  «        y )NrÃ   )rJ   rK   rG   r‘   r�   rÙ   ÚencoderÚuse_mean_poolingr1   rP   Ú	LayerNormr   rÌ   Ú	layernormÚ	post_init©rS   rG   rU   s     €r:   rK   zInternVLVisionModel.__init__  so   ø€ Ü‰Ñ˜Ô ØˆŒä2°6Ó:ˆŒÜ,¨VÓ4ˆŒð $×4Ò4ŒB�K‰KŒM¼"¿,¹,Àv×GYÑGYÐ_e×_tÑ_tÔ:uð 	Œð
 	�‰Õr<   c                 ó.   — | j                   j                  S rn   )r�   r˜   )rS   s    r:   Úget_input_embeddingsz(InternVLVisionModel.get_input_embeddings�  s   € Ø�‰×/Ñ/Ð/r<   F)Útie_last_hidden_statesr„   r²   c                 óº   — | j                  ||¬«      }| j                  |«      }|d   }| j                  |«      }t        ||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).
        )r²   r   )râ   rV   ré   )r�   rþ   r  ru   rV   ré   )rS   r„   r²   r5   Úembedding_outputÚencoder_outputsÚsequence_outputs          r:   rm   zInternVLVisionModel.forward�  s`   € ð  Ÿ?™?¨<È˜?ÓYÐàŸ,™,Ð'7Ó8ˆØ)¨!Ñ,ˆØŸ.™.¨Ó9ˆä3Ø-Ø)×7Ñ7Ø&×1Ñ1ô
ð 	
r<   rn   )r@   rA   rB   r    rK   r  r   r   r   r.   ro   r»   r×   ru   rm   rp   rq   s   @r:   rü   rü   }  su   ø„ ðÐ3ð ¸õ ò0ð  Ù¨EÔ2ØàUYñ
Ø!ŸL™Lð
Ø;@×;KÑ;KÈdÑ;Rð
à	Ð5Ñ	5ò
ó ó 3ó  ô
r<   rü   c                   ó   — e Zd ZdZy)ÚInternVLPreTrainedModel)rç   Útextrè   N)r@   rA   rB   rò   rC   r<   r:   r  r  §  s   „ Ø1Ñr<   r  c                   ó*   ‡ — e Zd Zdefˆ fd„Zd„ Zˆ xZS )ÚInternVLMultiModalProjectorrG   c                 ó*  •— t         ‰| �  «        t        j                  |j                  j
                  t        d|j                  z  «      dz  z  «      | _        t        j                  |j                  j
                  t        d|j                  z  «      dz  z  |j                  j
                  «      | _        t        |j                     | _        t        j                  |j                  j
                  |j                  j
                  «      | _        y )Nr   r   )rJ   rK   r1   r   Úvision_configr   rº   Údownsample_ratior¾   ÚLinearÚtext_configÚlinear_1r   Úprojector_hidden_actÚactÚlinear_2r  s     €r:   rK   z$InternVLMultiModalProjector.__init__¯  sÍ   ø€ Ü‰ÑÔÜŸ,™, v×';Ñ';×'GÑ'GÌ#ÈaÐRX×RiÑRiÑNiÓJjÐnoÑJoÑ'oÓpˆŒÜŸ	™	Ø× Ñ ×,Ñ,¬s°1°v×7NÑ7NÑ3NÓ/OÐSTÑ/TÑTÐV\×VhÑVh×VtÑVtó
ˆŒô ˜&×5Ñ5Ñ6ˆŒÜŸ	™	 &×"4Ñ"4×"@Ñ"@À&×BTÑBT×B`ÑB`Óaˆ�r<   c                 óŽ   — | j                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }|S rn   )r¾   r  r  r  )rS   Úimage_featuresrV   s      r:   rm   z#InternVLMultiModalProjector.forward¸  s@   € ØŸ™¨Ó7ˆØŸ™ mÓ4ˆØŸ™ Ó/ˆØŸ™ mÓ4ˆØÐr<   )r@   rA   rB   r   rK   rm   rp   rq   s   @r:   r  r  ®  s   ø„ ðb˜~õ bör<   r  c                   ó   — e Zd Zy)ÚInternVLModelOutputWithPastNr?   rC   r<   r:   r  r  À  rD   r<   r  c                   óÒ  — e Zd Zddej                  defd„Zee e	d¬«      	 	 ddej                  deee   z  ee   z  dz  d	edz  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j                  dz  deee   z  ee   z  dz  d	edz  d
ee   deez  fd„«       «       Zy)ÚInternVLModelÚvision_featuresÚscale_factorc           
      ó¼  — |j                  «       \  }}}}||z  dk7  s||z  dk7  rt        d«      ‚|j                  ||t        ||z  «      t        ||z  «      «      }|j	                  dddd«      j                  «       }|j                  |t        ||z  «      t        ||z  «      t        ||dz  z  «      «      }|j	                  dddd«      j                  «       }|S )a&  Perform pixel shuffle downsampling on vision features.

        Args:
            vision_features (`torch.Tensor`):
                Input tensor of shape (batch_size, width, height, channels).
            scale_factor (`float`, *optional*, defaults to `0.5`):
                Factor by which to downsample. Default is 0.5, which halves the dimensions.

        Returns:
            vision_features (`torch.Tensor`):
                Downsampled tensor of shape (batch_size, height*scale_factor, width*scale_factor, channels/(scale_factor^2)).
        r   zKHeight and width must be divisible by scale_factor for proper downsampling.r   r   r   )rY   rˆ   r`   rº   r¨   r4   )rS   r  r   rg   rŽ   r�   Úchannelss          r:   Úpixel_shufflezInternVLModel.pixel_shuffleÅ  sø   € ð />×.BÑ.BÓ.DÑ+ˆ
�E˜6 8à�LÑ  AÒ%¨°Ñ)=ÀÒ)BÜÐjÓkÐkð *×.Ñ.Ø˜œs 6¨LÑ#8Ó9¼3¸xÈ,Ñ?VÓ;Wó
ˆð *×1Ñ1°!°Q¸¸1Ó=×HÑHÓJˆð *×.Ñ.Øœ˜F \Ñ1Ó2´C¸ÀÑ8LÓ4MÌsÐS[Ð_kÐmnÑ_nÑSoÓOpó
ˆð
 *×1Ñ1°!°Q¸¸1Ó=×HÑHÓJˆàÐr<   zWObtains image last hidden states from the vision tower and apply multimodal projection.rr   Nr„   Úvision_feature_layerÚvision_feature_select_strategyr5   r…   c                 ó&  — |j                  | j                  ¬«      }| j                  j                  }|dk7  rd|d<    | j                  d|ddœ|¤Ž}|dk(  r|j
                  }n|j                  |   }|dk(  r|dd…dd…dd…f   }|j                  d   }t        |d	z  «      }	|j                  d
   }
|j                  |
|	|	d«      }| j                  ||¬«      }|j                  |
d|j                  d   «      }| j                  |«      }||_        |S )a!  
        pixel_values (`torch.FloatTensor]` of shape `(batch_size, channels, height, width)`)
            The tensors corresponding to the input images.
        vision_feature_layer (`int` or `list[int]`):
            Layer index or list of layer indices to extract features from.
        )r‹   r)   TÚoutput_hidden_states)r„   Úreturn_dictÚdefaultNr   r¢   r   )r   rC   )r‰   r‹   rG   r  Úvision_towerrâ   rV   r‡   rº   r]   r#  Úmulti_modal_projectorÚpooler_output)rS   r„   r$  r%  r5   r  Úvision_outputsr  r"  Úfeature_sizerg   s              r:   Úget_image_featuresz InternVLModel.get_image_featuresè  s:  € ð$ $—‘¨T¯Z©Z�Ó8ˆàŸ;™;×7Ñ7ÐØ 2Ò%Ø-1ˆFÐ)Ñ*Ø*˜×*Ñ*Ða¸ÐRVÑaÐZ`ÑaˆØ 2Ò%Ø,×>Ñ>‰Oà,×:Ñ:Ð;OÑPˆOØ)¨YÒ6Ø-ªa°±²Q¨hÑ7ˆOð #×(Ñ(¨Ñ+ˆÜ˜8 S™=Ó)ˆØ$×*Ñ*¨1Ñ-ˆ
ð *×1Ñ1°*¸lÈLÐZ\Ó]ˆð ×,Ñ,¨_ÐK[Ð,Ó\ˆð *×1Ñ1°*¸bÀ/×BWÑBWÐXZÑB[Ó\ˆð ×4Ñ4°_ÓEˆØ'6ˆÔ$àÐr<   Ú	input_idsr%   Úposition_idsÚpast_key_valuesÚinputs_embedsc	                 óä  — |d u |d uz  rt        d«      ‚|€ | j                  «       |«      }|�k| j                  |||d¬«      j                  }
|
j	                  |j
                  |j                  «      }
| j                  |||
¬«      }|j                  ||
«      } | j                  d||||dœ|	¤Ž}t        |j                  |j                  |j                  |j                  |�
¬«      S d ¬«      S )Nz:You must specify exactly one of input_ids or inputs_embedsT)r„   r$  r%  r(  )r3  r  )r%   r1  r2  r3  )râ   r2  rV   ré   Úimage_hidden_statesrC   )rˆ   r  r/  r,  r‰   Údevicer‹   Úget_placeholder_maskÚmasked_scatterÚlanguage_modelr  râ   r2  rV   ré   )rS   r0  r„   r%   r1  r2  r3  r$  r%  r5   r  Úspecial_image_maskÚoutputss                r:   rm   zInternVLModel.forward  s9  € ð ˜Ð -°tÐ";Ò<ÜÐYÓZÐZàÐ Ø7˜D×5Ñ5Ó7¸	ÓBˆMàÐ#Ø!×4Ñ4Ø)Ø%9Ø/MØ ð	 5ó ÷
 ‰mð ð ,×.Ñ.¨}×/CÑ/CÀ]×EXÑEXÓYˆNØ!%×!:Ñ!:Ø¨À~ð ";ó "Ðð *×8Ñ8Ð9KÈ^Ó\ˆMà%�$×%Ñ%ð 
Ø)Ø%Ø+Ø'ñ	
ð
 ñ
ˆô +Ø%×7Ñ7Ø#×3Ñ3Ø!×/Ñ/Ø×)Ñ)Ø2>Ð2J ô
ð 	
ð
 QUô
ð 	
r<   )r¢   )NN)NNNNNNNN)r@   rA   rB   r.   ro   Úfloatr#  r   r   r   ÚFloatTensorrº   ÚlistÚstrr   r   r×   r   r/  Ú
LongTensorr   r  rm   rC   r<   r:   r  r  Ä  s¤  „ ñ!¨U¯\©\ð !Èó !ðF  ØÙØnôð DHØ59ñ	,à×'Ñ'ð,ð " D¨¡I™o°°S±	Ñ9¸DÑ@ð,ð ),¨d©
ð	,ð
 Ð+Ñ,ð,ð 
Ð+Ñ	+ò,óó ó  ð
,ð\ Øð .2Ø15Ø.2Ø04Ø(,Ø26ØCGØ59ñ-
à×#Ñ# dÑ*ð-
ð ×'Ñ'¨$Ñ.ð-
ð Ÿ™ tÑ+ð	-
ð
 ×&Ñ&¨Ñ-ð-
ð  ™ð-
ð ×(Ñ(¨4Ñ/ð-
ð " D¨¡I™o°°S±	Ñ9¸DÑ@ð-
ð ),¨d©
ð-
ð Ð+Ñ,ð-
ð 
Ð,Ñ	,ò-
ó ó ñ-
r<   r  c                   ó   — e Zd Zy)ÚInternVLCausalLMOutputWithPastNr?   rC   r<   r:   rB  rB  M  rD   r<   rB  c                   ó   ‡ — e Zd Zˆ fd„Zˆ xZS )Ú InternVLForConditionalGenerationc                  ó:   •—  t        «       j                  di | ¤Ž y)ac  
        Example:

        ```python
        >>> import torch
        >>> from transformers import AutoProcessor, AutoModelForImageTextToText

        >>> torch_device = "cuda"
        >>> processor = AutoProcessor.from_pretrained("OpenGVLab/InternVL3-1B-hf")
        >>> model = AutoModelForImageTextToText.from_pretrained(
        ...     "OpenGVLab/InternVL3-1B-hf", dtype=torch.bfloat16, device_map=torch_device
        ... )

        >>> messages = [
        ...     {
        ...         "role": "user",
        ...         "content": [
        ...             {
        ...                 "type": "image",
        ...                 "url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg",
        ...             },
        ...             {
        ...                 "type": "image",
        ...                 "url": "https://thumbs.dreamstime.com/b/golden-gate-bridge-san-francisco-purple-flowers-california-echium-candicans-36805947.jpg",
        ...             },
        ...             {"type": "text", "text": "These images depict two different landmarks. Can you identify them?"},
        ...         ],
        ...     },
        ... ]

        >>> inputs = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(torch_device)
        >>> generate_ids = model.generate(**inputs, max_new_tokens=200)
        >>> print(processor.decode(generate_ids[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True))
        The images depict the Statue of Liberty and the Golden Gate Bridge.
        ```NrC   )rJ   rm   )Úsuper_kwargsrU   s    €r:   rm   z(InternVLForConditionalGeneration.forwardR  s   ø€ ðH 	Œ‹�‰Ñ'˜,Ó'r<   )r@   rA   rB   rm   rp   rq   s   @r:   rD  rD  Q  s   ø„ ÷$(ð $(r<   rD  )rå   rü   r  r  rD  )rX   )JÚcollections.abcrš   r   Údataclassesr   r.   Útorch.nnr1   Ú r   rì   Úactivationsr   Úcache_utilsr   Úmodeling_layersr	   Úmodeling_outputsr
   r   Úmodeling_utilsr   r   Úprocessing_utilsr   Úutilsr   r   r   Úutils.genericr   r   Úutils.output_capturingr   Úclip.modeling_clipr   Újanus.modeling_janusr   Úllama.modeling_llamar   Úllava.modeling_llavar   r   r   r   r   Úconfiguration_internvlr   r    ÚModulero   r<  rº   r;   r>   rF   ru   rx   r‘   r½   r   rÊ   rÁ   rÙ   rå   rü   r  ÚINTERNVL_INPUTS_DOCSTRINGr  r  r  rB  rD  Ú__all__rC   r<   r:   ú<module>r\     s  ðó  Ý $Ý !ã Ý å &Ý !Ý  Ý 9ß Kß FÝ &ß BÑ Bß IÝ 5Ý (Ý 7Ý /÷õ ÷ Ið ñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 —L‘L 4Ñ'ð%ð ð%ð �S‰[ó%ô4	˜Lô 	ô3$Ð2ô 3$ñl ðôð
 ôÐ+Eó ó óðô  B§I¡Iô  ôJ[˜rŸy™yô [ô|	˜ô 	ð Ÿ™Ð3HÑ
I€ô+Ð4ô +ô\
˜BŸI™Iô 
ð& ôP Oó Pó ðPð@ ô&
Ð7ó &
ó ð&
ôR2Ð2ô 2ð !Ð ô "§)¡)ô ô$	Ð":ô 	ôF
�Jô F
ôR	Ð%@ô 	ô%(Ð'Dô %(òP�r<   