tjddlZddlmZddlZddlmZddlmZmZmZddl m Z ddl m Z ddlmZmZmZmZmZddlmZdd lmZdd lmZmZmZdd lmZd d lmZddl m!Z!eGddeZ"eGddeZ#Gddej$Z%eGddeZ&edGdde&Z'Gddej$Z(eGdde&Z)ed Gd!d"e&Z*ed#Gd$d%e&Z+gd&Z,dS)'N) dataclass)BCEWithLogitsLossCrossEntropyLossMSELoss)initialization)ACT2FN)BaseModelOutputBaseModelOutputWithPoolingMaskedLMOutputSequenceClassifierOutputTokenClassifierOutput)PreTrainedModel)Unpack)TransformersKwargsauto_docstringtorch_compilable_check)can_return_tuple) AutoModel)ModernVBertConfigceZdZUdZdZejed<dZe ejdzed<dZ e ejdzed<dZ e ejdzed<dS)ModernVBertBaseModelOutputaY Base class for ModernVBERT model's outputs. Args: last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`): Sequence of hidden-states at the output of the last layer of the model. If `past_key_values` is used only the last hidden-state of the sequences of shape `(batch_size, 1, hidden_size)` is output. 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, if the model has an embedding layer, + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`): Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`. Attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads. image_hidden_states (`tuple(torch.FloatTensor)`, *optional*): Tuple of `torch.FloatTensor` (one for the output of the image embeddings, `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states of the model produced by the vision encoder Nlast_hidden_state hidden_states attentionsimage_hidden_states) __name__ __module__ __qualname____doc__rtorch FloatTensor__annotations__rtuplerrr/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/transformers/models/modernvbert/modeling_modernvbert.pyrr-s,,0u(///59M5*+d299926Je'(4/666;?u01D8?????r(rceZdZUdZdZejdzed<dZejed<dZ e ejdfdzed<dZ e ejdfdzed<dZ ejdzed<dS) ModernVBertMaskedLMOutputaG Base class for ModernVBERT model's outputs with masked language modeling loss. Args: loss (`torch.FloatTensor`, *optional*, returned when `labels` is provided): Masked language modeling (MLM) loss. logits (`torch.FloatTensor`): Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax). 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, if the model has an embedding layer, + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`): Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`. Attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads. image_hidden_states (`tuple(torch.FloatTensor)`, *optional*): Tuple of `torch.FloatTensor` (one for the output of the image embeddings, `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states of the model produced by the vision encoder Nlosslogits.rrr) rr r!r"r,r#r$r%r-rr&rrr'r(r)r+r+Ks,&*D% d "))) $FE $$$:>M5*C/047>>>7;Je',-4;;;48*T188888r(r+c.eZdZdZfdZdZdZxZS)ModernVBertConnectorz Connector module for ModernVBERT. It performs a pixel shuffle operation followed by a linear projection to match the text model's hidden size. Based on https://pytorch.org/docs/stable/generated/torch.nn.PixelShuffle.html ct|j|_tj|jj|jdzz|jjd|_dS)NrFbias) super__init__pixel_shuffle_factornnLinear vision_config hidden_size text_configmodality_projectionselfconfig __class__s r)r4zModernVBertConnector.__init__pse $*$?!#%9  ,0KQ0N O   *$ $ $    r(c|\}}}t|dzx}}|||||}|||t||z ||z}|dddd}||t||z t||z ||dzz}|dddd}||t||dzz ||dzzS)Ng?rrrr)sizeintviewpermutereshape)r=rr5 batch_size seq_length embed_dimheightwidths r) pixel_shufflez"ModernVBertConnector.pixel_shuffleys=,?,D,D,F,F) J Z_---166z65R[\\166 E,@$@ A A9OcCc  299!Q1EE199  ,, - - -- . . -q0 1    299!Q1EE"** J*>*ABCCYRfhiRiEj   r(cb|||j}||SN)rKr5r;)r=rs r)forwardzModernVBertConnector.forwards1"001DdF_``''(;<<model)imagetextTpast_key_valuesct|dtjdtffd }t |t rFjjtj djj j zz }||j |dSt |trFjjtj djj j zz }||j|dSt |t t"frCjjtj jj jz }||j|dSdS)Nmodulestdctjdd}tj|jd|| |z||zt |t jt jfr"|j tj |j dSdSdS)Ninitializer_cutoff_factor@)meanrYab) getattrr>init trunc_normal_weight isinstancer6r7Conv2dr2zeros_)rXrY cutoff_factorr=s r) init_weightz=ModernVBertPreTrainedModel._init_weights..init_weights#DK1LcRRM    .3&#%     &29bi"899 -;*K ,,,,, - -**r(r\)r3 _init_weightsr6Modulefloatrer/r>initializer_rangemathsqrtr:num_hidden_layersr;ModernVBertForMaskedLMlm_head$ModernVBertForSequenceClassification!ModernVBertForTokenClassificationr9 classifier)r=rXriout_std final_out_stdr?s` r)rjz(ModernVBertPreTrainedModel._init_weightss[ f%%% - - - - - - - - f2 3 3 :k3didkF]Fo@o6p6ppG K2G < < < < <  6 7 7 :k3didkF]Fo@o6p6ppG K 0 0 0 0 0  41    :!K9DIdkF]Fict||jjj|_|jjj|_tj|j |_ t||_ tj|j|_ t|j j|j jzdz|jdzz |_|jj|_|dS)Nr)r3r4r>r: pad_token_id padding_idx vocab_sizer from_configr8 vision_modelr/ connector text_modelrB image_size patch_sizer5 image_seq_lenimage_token_id post_initr<s r)r4zModernVBertModel.__init__s    ;2?+1<%1&2FGG.f55#/0BCC "-1E1PPUV V*A- /  #k8 r(c4|jSrM)rget_input_embeddingsr=s r)rz%ModernVBertModel.get_input_embeddingss33555r(c:|j|dSrM)rset_input_embeddings)r=values r)rz%ModernVBertModel.set_input_embeddingss ,,U33333r( input_ids inputs_embedsrc0|j\}}}|X||tj|jjtj|jk}|d}n||jjk}|d}ttj ||zdkd||z}tj j |ddd } | dd } |d } | dz |z} | dz |z} | d| z}tj|}|||| |ddf||<tj|d ||}|S) as This method aims at merging the token embeddings with the image hidden states into one single sequence of vectors that are fed to the transformer LM. The merging happens as follows: - The text token sequence is: `tok_1 tok_2 tok_3 ... tok_4`. - We get the image hidden states for the image through the vision encoder and that hidden state, after a pixel shuffle operation, is then projected into the text embedding space. We thus have a sequence of image hidden states of size (1, image_seq_len, hidden_dim), where 1 is for batch_size of 1 image and hidden_dim is the hidden_dim of the LM transformer. - The merging happens so that we obtain the following sequence: `vector_tok_1 vector_tok_2 vector_tok_3 vector_fake_tok_around_image {sequence of image_seq_len image hidden states} vector_fake_toke_around_image vector_tok_4`. That sequence is fed to the LM. - To fit the format of that sequence, `input_ids`, `inputs_embeds`, `attention_mask` are all 3 adapted to insert the image hidden states. Ndtypedevice).rrdimrzCAt least one sample has tokens not divisible by patch_size.)rr)r)shaperr#tensorr>rlongrsumrallr6 functionalpadcumsum unsqueeze zeros_likewhere)r=rrr_r image_masknum_image_tokensblocks_per_sampleoffsets block_offsetrow_cum chunk_idx local_idx block_idx image_embeds merged_embedss r) inputs_mergerzModernVBertModel.inputs_mergers/4:q  &*E$*C*C*E*E T[7uzR_Rfggg++J$F+JJ"dk&@@J%>>a>00 I&3q8 9 9 Q   - :(%))*;*B*Bq*B*I*I6YZ)[[ss| ###++q[Z/ q[J.  **1-- 9 ' 66 #6y7LiXbNcefefef7f#g Z  J$8$8$<$z7ModernVBertModel.get_image_features..1s!???l(+???r()rrr)rArr) dimensionrAstep)rrT)rpatch_attention_mask return_dictr')rtorrCnumelrr#any contiguousonesboolrr>r8runfoldrrr pooler_output)r=rrrrF num_images num_channelsrIrJnb_values_per_imagereal_images_indsrpatches_subgridr image_outputsrimage_featuress ` r)get_image_featuresz#ModernVBertModel.get_image_featuress7 ?K>P; J fe#TZ88 (|(j)@Z (batch_size, max_num_images, 3, max_heights, max_widths) where max_num_images is the maximum number of images among the batch_size samples in the batch. Padding images are not needed beyond padding the pixel_values at the entrance of the model. For efficiency, we only pass through the vision_model's forward the real images by discarding the padding images i.e. pixel_values of size (image_batch_size, 3, height, width) where image_batch_size would be 7 when num_images_per_sample=[1, 3, 1, 2] and max_num_images would be 3. ModernVBERT/modernvbertr checkpointattention_mask position_idsc |:|j||j}||||j}|9||j|j}||||}|jd|||d|} t| j | j | j |S)a| pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*): Mask to avoid performing attention on padding pixel indices. image_hidden_states (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`): The hidden states of the image encoder after modality projection. N)rrr)rrr)rrr)rrrrr') rrrrrrrrrrrr) r=rrrrrrrroutputss r)rNzModernVBertModel.forwardJs>  BDO@@BB9MMPPQZQabbM  #"&"9"9)@T#:##  *"5"8"8}?R[h[o"8"p"p  ..#=Vi/M "$/ ')%     *%7!/) 3     r(rM)NNNNNNN)rr r!r"rr4rrr# LongTensorTensorrrrr$rrr&r r BoolTensorrrNrOrPs@r)rrs' 0$666444()(:?,(]b]i((((T^m 9=22'2$.52+, 2 + + 2222h^ -   '+.20426158<8</ / #/  t+/ &- / (4/ / '$. / $.5/ #.5/ +,/  + +/ / /   / / / / / r(rcHeZdZdeffd ZdejdejfdZxZS)ModernVBertPredictionHeadr>c.t||_tj|j|j|j|_t|j |_ tj |j|j |j |_dS)N)epsr2)r3r4r>r6r7r9classifier_biasdenser classifier_activationact LayerNormnorm_eps norm_biasnormr<s r)r4z"ModernVBertPredictionHead.__init__sq  Yv163EvG]^^ &67L!3vO_``` r(rrcx||||SrM)rrr)r=rs r)rNz!ModernVBertPredictionHead.forwards,yy$**]";";<<===r() rr r!rr4r#rrNrOrPs@r)rrsra0aaaaaa>U\>el>>>>>>>>r(rc<eZdZddiZdeffd ZdZdZee dd  dd e j d e j d zd e j d zde j d zde j d zde jd zde j d zde j d zdeedeezfdZxZS)rqzlm_head.weightz1model.text_model.embeddings.tok_embeddings.weightr>cXt||jj|_t ||_t |j|_tj |jj |j|jj |_ | dS)Nr1)r3r4r:rrrSrprojection_headr6r7r9 decoder_biasrrrr<s r)r4zModernVBertForMaskedLM.__init__s     ,7%f-- 89KLLy!3!?W]WiWvwww  r(c|jSrMrrrs r)get_output_embeddingsz,ModernVBertForMaskedLM.get_output_embeddingss |r(c||_dSrMr)r=new_embeddingss r)set_output_embeddingsz,ModernVBertForMaskedLM.set_output_embeddingss % r(rrrNrrrrrrrlabelsrrc f|jd|||||||d| } | d} ||| } d} |Ft}|| d|j|d} t | | | j| j| j S) pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*): Mask to avoid performing attention on padding pixel indices. image_hidden_states (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`): The hidden states of the image encoder after modality projection. labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked language modeling loss. Indices should either be in `[0, ..., text_config.]` or `model.image_token_id`. Tokens with indices set to `model.image_token_id` are ignored (masked), the loss is only computed for the tokens with labels in `[0, ..., text_config.]`. rrrrrrrrNr)r,r-rrrr') rSrrrrrCrr+rrr)r=rrrrrrrrrrrr-r, criterions r)rNzModernVBertForMaskedLM.forwardsH$*  )%'%!5 3        d22=AABB  (**I9V[[T_==v{{2OOD(!/) ' ;     r(NNNNNNNN)rr r!_tied_weights_keysrr4rrrrr#rrr$rrrr&r+rNrOrPs@r)rqrqs*,_` 0      &&&^ -   '+.20426158<8<*.0 0 #0  t+0 &- 0 (4/ 0 '$. 0 $.50 #.50  4'0 +,0  * *0 0 0   0 0 0 0 0 r(rqza The ModernVBert Model with a sequence classification head on top that performs pooling. c(eZdZdeffd Zeedd ddejdej dzd ejdzd ej dzd ej dzd ej dzd ej dzdejdzde e deezfdZxZS)rsr>ct||j|_||_t ||_t |j|_tj |j |_ tj |jj|j|_|dSrM)r3r4 num_labelsr>rrSrr:headr6Dropoutclassifier_dropoutdropr7r9rurr<s r)r4z-ModernVBertForSequenceClassification.__init__s     + %f-- -f.@AA Jv899 )F$6$BFDUVV r(rrrNrrrrrrrrrrc L|jd|||||||d| } | d} |jjdkr | dddf} n|jjdkr||jdd\} } n|jdd\} } ||jn|j}|#t j| | f|t j}| |dz d | d d z } | | }| |}| |}d}|Z|jj f|jd kr d |j_ nN|jd kr7|jt jks|jt jkr d|j_ n d|j_ |jj d krWt%}|jd kr1|||}n|||}n|jj dkrGt)}||d|j|d}n*|jj dkrt-}|||}t/||| j| jS)rrrclsNr^r)rrrrrT)rkeepdim regressionsingle_label_classificationmulti_label_classificationr,r-rrr')rSr>classifier_poolingrrr#rrrrrr ru problem_typerrrrBrsqueezerrCrr rr)r=rrrrrrrrrrrrFseq_lenr pooled_outputr-r,loss_fcts r)rNz,ModernVBertForSequenceClassification.forwardsF$*  )%'%!5 3      $AJ ; )U 2 2 1!!!Q$ 7   [ +v 5 5(&3&9"1"&=# GG&/obqb&9# G)2)>Y%%MDXF%!&Z,A&X]Xb!c!c!c!2^5M5Mb5Q5Q!Q V V[\ V ] ]`n`r`rtasaa!  "344  -00 //  {'/?a''/;DK,,_q((flej.H.HFL\a\eLeLe/LDK,,/KDK,{'<77"99?a''#8FNN$4$4fnn6F6FGGDD#8FF33DD)-JJJ+--x B @ @&++b//RR)-III,..x//'!/)     r(r)rr r!rr4rrr#rrr$rrrr&r rNrOrPs@r)rsrssh 0      ^ -   '+.20426158<8<*.Q Q #Q  t+Q &- Q (4/ Q '$. Q $.5Q #.5Q  4'Q +,Q  ) )Q Q Q   Q Q Q Q Q r(rszw The ModernVBert Model with a token classification head on top, e.g. for Named Entity Recognition (NER) tasks. c(eZdZdeffd Zeedd ddejdej dzd ejdzd ej dzd ej dzd ej dzd ej dzdejdzde e deezfdZxZS)rtr>crt||j|_t||_t |j|_tj |j |_ tj |jj |j|_|dSrM)r3r4rrrSrr:rr6rrr r7r9rurr<s r)r4z*ModernVBertForTokenClassification.__init__es     +%f-- -f.@AA Jv899 )F$6$BFDUVV r(rrrNrrrrrrrrrrc |jd|||||||d| } | d} || } || } || } d} |Ft }|| d|j|d} t| | | j| j S)rrrNrrr') rSrr rurrCrrrr)r=rrrrrrrrrrrr-r,rs r)rNz)ModernVBertForTokenClassification.forwardqsH$*  )%'%!5 3      $AJ II&788 II&788!233  '))H8FKKDO<r&s* !!!!!! AAAAAAAAAA&&&&&&!!!!!!.-----&&&&&&OOOOOOOOOO------888888 @@@@@@@ @: 9999999 9<$=$=$=$=$=29$=$=$=N-:-:-:-:-:-:-:-:`| | | | | 1| | | ~ > > > > > > > >R R R R R 7R R R j l l l l l +El l  l ^ K K K K K (BK K  K \   r(