Ë
    ÛÓ^jèY  ã                   ó¢  — d Z ddlZddlmZ ddlmZmZ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mZ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 ddlmZm Z m!Z!m"Z"m#Z#m$Z$m%Z% ddl&m'Z'  ejP                  e)«      Z* G d„ de!«      Z+ G d„ de%«      Z, G d„ de «      Z- G d„ de"«      Z.e G d„ de«      «       Z/e G d„ de$«      «       Z0 G d„ de#«      Z1 G d„ de«      Z2 ed ¬!«       G d"„ d#e/e«      «       Z3e G d$„ d%e/«      «       Z4 ed&¬!«       G d'„ d(e/«      «       Z5e G d)„ d*e/«      «       Z6e G d+„ d,e/«      «       Z7e G d-„ d.e/«      «       Z8g d/¢Z9y)0zPyTorch Data2VecText model.é    N)ÚBCEWithLogitsLossÚCrossEntropyLossÚMSELossé   )Úinitialization)ÚGenerationMixin)Ú,BaseModelOutputWithPoolingAndCrossAttentionsÚ!CausalLMOutputWithCrossAttentionsÚMaskedLMOutputÚMultipleChoiceModelOutputÚQuestionAnsweringModelOutputÚSequenceClassifierOutputÚTokenClassifierOutput)ÚPreTrainedModel)ÚUnpack)ÚTransformersKwargsÚauto_docstringÚlogging)Úcan_return_tupleé   )ÚRobertaClassificationHeadÚRobertaCrossAttentionÚRobertaEmbeddingsÚRobertaLayerÚRobertaLMHeadÚRobertaModelÚRobertaSelfAttentioné   )ÚData2VecTextConfigc                   ó   — e Zd Zy)ÚData2VecTextEmbeddingsN©Ú__name__Ú
__module__Ú__qualname__© ó    ú}/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/data2vec/modular_data2vec_text.pyr!   r!   2   ó   „ Ør'   r!   c                   ó   — e Zd Zy)ÚData2VecTextSelfAttentionNr"   r&   r'   r(   r+   r+   6   r)   r'   r+   c                   ó   — e Zd Zy)ÚData2VecTextCrossAttentionNr"   r&   r'   r(   r-   r-   :   r)   r'   r-   c                   ó   — e Zd Zy)ÚData2VecTextLayerNr"   r&   r'   r(   r/   r/   >   r)   r'   r/   c                   óN   ‡ — e Zd ZeZdZdZddgZdZdZ	dZ
dZeeedœZˆ fd„Zˆ xZS )ÚData2VecTextPreTrainedModelÚdata2vec_textTÚData2VecTextForTextEmbeddingsr/   )Úhidden_statesÚ
attentionsÚcross_attentionsc                 ó6  •— t         ‰| �  |«       t        |t        «      ryt	        j
                  |j                  t        j                  |j                  j                  d   «      j                  d«      «       t	        j                  |j                  «       y y )Néÿÿÿÿ)r   r8   )ÚsuperÚ_init_weightsÚ
isinstancer!   ÚinitÚcopy_Úposition_idsÚtorchÚarangeÚshapeÚexpandÚzeros_Útoken_type_ids)ÚselfÚmoduleÚ	__class__s     €r(   r:   z)Data2VecTextPreTrainedModel._init_weightsR   sm   ø€ Ü‰Ñ˜fÔ%Ü�fÔ4Ô5Ü�J‰J�v×*Ñ*¬E¯L©L¸×9LÑ9L×9RÑ9RÐSUÑ9VÓ,W×,^Ñ,^Ð_fÓ,gÔhÜ�K‰K˜×-Ñ-Õ.ð 6r'   )r#   r$   r%   r   Úconfig_classÚbase_model_prefixÚsupports_gradient_checkpointingÚ_no_split_modulesÚ_supports_flash_attnÚ_supports_sdpaÚ_supports_flex_attnÚ_supports_attention_backendr/   r+   r-   Ú_can_record_outputsr:   Ú__classcell__©rG   s   @r(   r1   r1   B   sR   ø„ à%€LØ'ÐØ&*Ð#Ø8Ð:MÐNÐØÐØ€NØÐØ"&Ðà*Ø/Ø6ñÐ÷/ð /r'   r1   c                   ó   — e Zd Zy)ÚData2VecTextModelNr"   r&   r'   r(   rT   rT   Y   s   „ àr'   rT   c                   ó   — e Zd Zy)ÚData2VecTextLMHeadNr"   r&   r'   r(   rV   rV   ^   r)   r'   rV   c                   ó   — e Zd Zy)ÚData2VecTextClassificationHeadNr"   r&   r'   r(   rX   rX   b   r)   r'   rX   zX
    Data2VecText Model with a `language modeling` head on top for CLM fine-tuning.
    )Úcustom_introc                   ó¾  ‡ — e Zd ZdddœZˆ fd„Zd„ Z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	j                  dz  de	j                  dz  de	j                  dz  de	j                  dz  deee	j                        dz  dedz  dee	j                  z  dee   deez  fd„«       «       Zˆ xZS )ÚData2VecTextForCausalLMú/data2vec_text.embeddings.word_embeddings.weightúlm_head.bias©zlm_head.decoder.weightzlm_head.decoder.biasc                 óÊ   •— t         ‰| �  |«       |j                  st        j	                  d«       t        |d¬«      | _        t        |«      | _        | j                  «        y )NzTIf you want to use `Data2VecTextLMHeadModel` as a standalone, add `is_decoder=True.`F©Úadd_pooling_layer©
r9   Ú__init__Ú
is_decoderÚloggerÚwarningrT   r2   rV   Úlm_headÚ	post_init©rE   ÚconfigrG   s     €r(   rc   z Data2VecTextForCausalLM.__init__q   sM   ø€ Ü‰Ñ˜Ô à× Ò Ü�N‰NÐqÔrä.¨vÈÔOˆÔÜ)¨&Ó1ˆŒð 	�‰Õr'   c                 ó.   — | j                   j                  S ©N©rg   Údecoder©rE   s    r(   Úget_output_embeddingsz-Data2VecTextForCausalLM.get_output_embeddings}   ó   € Ø�|‰|×#Ñ#Ð#r'   c                 ó&   — || j                   _        y rl   rm   ©rE   Únew_embeddingss     r(   Úset_output_embeddingsz-Data2VecTextForCausalLM.set_output_embeddings€   ó   € Ø-ˆ�‰Õr'   NÚ	input_idsÚattention_maskrD   r>   Úinputs_embedsÚencoder_hidden_statesÚencoder_attention_maskÚlabelsÚpast_key_valuesÚ	use_cacheÚlogits_to_keepÚkwargsÚreturnc                 óž  — |�d}
 | j                   |f|||||||	|
ddœ	|¤Ž}|j                  }t        |t        «      rt	        | d«      n|}| j                  |dd…|dd…f   «      }d}|�* | j                  d||| j                  j                  dœ|¤Ž}t        |||j                  |j                  |j                  |j                  ¬«      S )aA  
        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
            Labels for computing the left-to-right language modeling loss (next word prediction). Indices should be in
            `[-100, 0, ..., config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are
            ignored (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`

        Example:

        ```python
        >>> from transformers import AutoTokenizer, Data2VecTextForCausalLM, Data2VecTextConfig
        >>> import torch

        >>> tokenizer = AutoTokenizer.from_pretrained("facebook/data2vec-text-base")
        >>> config = Data2VecTextConfig.from_pretrained("facebook/data2vec-text-base")
        >>> config.is_decoder = True
        >>> model = Data2VecTextForCausalLM.from_pretrained("facebook/data2vec-text-base", config=config)

        >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
        >>> outputs = model(**inputs)

        >>> prediction_logits = outputs.logits
        ```NFT)	rx   rD   r>   ry   rz   r{   r}   r~   Úreturn_dict)Úlogitsr|   Ú
vocab_size)Úlossr„   r}   r4   r5   r6   r&   )r2   Úlast_hidden_stater;   ÚintÚslicerg   Úloss_functionrj   r…   r
   r}   r4   r5   r6   )rE   rw   rx   rD   r>   ry   rz   r{   r|   r}   r~   r   r€   Úoutputsr4   Úslice_indicesr„   r†   s                     r(   ÚforwardzData2VecTextForCausalLM.forwardƒ   sÿ   € ðN ÐØˆIà@RÀ×@RÑ@RØðA
à)Ø)Ø%Ø'Ø"7Ø#9Ø+ØØñA
ð ñA
ˆð  ×1Ñ1ˆä8BÀ>ÔSVÔ8Wœ˜~˜o¨tÔ4Ð]kˆØ—‘˜mªA¨}ºaÐ,?Ñ@ÓAˆàˆØÐØ%�4×%Ñ%Ðp¨V¸FÈtÏ{É{×OeÑOeÑpÐioÑpˆDä0ØØØ#×3Ñ3Ø!×/Ñ/Ø×)Ñ)Ø$×5Ñ5ô
ð 	
r'   )NNNNNNNNNNr   )r#   r$   r%   Ú_tied_weights_keysrc   rp   ru   r   r   r?   Ú
LongTensorÚFloatTensorÚtupleÚboolrˆ   ÚTensorr   r   r
   r�   rQ   rR   s   @r(   r[   r[   f   sw  ø„ ð #TØ .ñÐô

ò$ò.ð Øð .2Ø37Ø26Ø04Ø26Ø:>Ø;?Ø*.ØBFØ!%Ø-.ñF
à×#Ñ# dÑ*ðF
ð ×)Ñ)¨DÑ0ðF
ð ×(Ñ(¨4Ñ/ð	F
ð
 ×&Ñ&¨Ñ-ðF
ð ×(Ñ(¨4Ñ/ðF
ð  %×0Ñ0°4Ñ7ðF
ð !&× 1Ñ 1°DÑ 8ðF
ð × Ñ  4Ñ'ðF
ð ˜u U×%6Ñ%6Ñ7Ñ8¸4Ñ?ðF
ð ˜$‘;ðF
ð ˜eŸl™lÑ*ðF
ð Ð+Ñ,ðF
ð 
Ð2Ñ	2òF
ó ó ôF
r'   r[   c                   óf  ‡ — e Zd ZdddœZˆ fd„Zd„ Z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	j                  dz  de	j                  dz  de	j                  dz  de	j                  dz  dee   deez  fd„«       «       Zˆ xZS )ÚData2VecTextForMaskedLMr\   r]   r^   c                 óÊ   •— t         ‰| �  |«       |j                  rt        j	                  d«       t        |d¬«      | _        t        |«      | _        | j                  «        y )NzsIf you want to use `Data2VecTextForMaskedLM` make sure `config.is_decoder=False` for bi-directional self-attention.Fr`   rb   ri   s     €r(   rc   z Data2VecTextForMaskedLM.__init__Õ   sS   ø€ Ü‰Ñ˜Ô à×ÒÜ�N‰Nð1ôô
 /¨vÈÔOˆÔÜ)¨&Ó1ˆŒð 	�‰Õr'   c                 ó.   — | j                   j                  S rl   rm   ro   s    r(   rp   z-Data2VecTextForMaskedLM.get_output_embeddingsä   rq   r'   c                 ó&   — || j                   _        y rl   rm   rs   s     r(   ru   z-Data2VecTextForMaskedLM.set_output_embeddingsç   rv   r'   Nrw   rx   rD   r>   ry   rz   r{   r|   r€   r�   c	                 ót  —  | j                   |f||||||ddœ|	¤Ž}
|
d   }| j                  |«      }d}|�at        «       }|j                  |j                  «      } ||j                  d| j                  j                  «      |j                  d«      «      }t        |||
j                  |
j                  ¬«      S )a¢  
        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
            Labels for computing the masked language modeling loss. Indices should be in `[-100, 0, ...,
            config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored (masked), the
            loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`
        T)rx   rD   r>   ry   rz   r{   rƒ   r   Nr8   ©r†   r„   r4   r5   )r2   rg   r   ÚtoÚdeviceÚviewrj   r…   r   r4   r5   )rE   rw   rx   rD   r>   ry   rz   r{   r|   r€   r‹   Úsequence_outputÚprediction_scoresÚmasked_lm_lossÚloss_fcts                  r(   r�   zData2VecTextForMaskedLM.forwardê   sÕ   € ð( %�$×$Ñ$Øð

à)Ø)Ø%Ø'Ø"7Ø#9Øñ

ð ñ

ˆð " !™*ˆØ ŸL™L¨Ó9ÐàˆØÐÜ'Ó)ˆHà—Y‘YÐ0×7Ñ7Ó8ˆFÙ%Ð&7×&<Ñ&<¸RÀÇÁ×AWÑAWÓ&XÐZ`×ZeÑZeÐfhÓZiÓjˆNäØØ$Ø!×/Ñ/Ø×)Ñ)ô	
ð 	
r'   )NNNNNNNN)r#   r$   r%   rŽ   rc   rp   ru   r   r   r?   r�   r�   r   r   r‘   r   r�   rQ   rR   s   @r(   r•   r•   Î   s  ø„ ð #TØ .ñÐô
ò$ò.ð Øð .2Ø37Ø26Ø04Ø26Ø:>Ø;?Ø*.ñ,
à×#Ñ# dÑ*ð,
ð ×)Ñ)¨DÑ0ð,
ð ×(Ñ(¨4Ñ/ð	,
ð
 ×&Ñ&¨Ñ-ð,
ð ×(Ñ(¨4Ñ/ð,
ð  %×0Ñ0°4Ñ7ð,
ð !&× 1Ñ 1°DÑ 8ð,
ð × Ñ  4Ñ'ð,
ð Ð+Ñ,ð,
ð 
�Ñ	ò,
ó ó ô,
r'   r•   z¤
    Data2VecText Model transformer with a sequence classification/regression head on top (a linear layer on top of the
    pooled output) e.g. for GLUE tasks.
    c                   ó  ‡ — e Zd 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j                  dz  dej                  dz  d	e	e
   d
eez  fd„«       «       Zˆ xZS )Ú%Data2VecTextForSequenceClassificationc                 ó¸   •— t         ‰| �  |«       |j                  | _        || _        t	        |d¬«      | _        t        |«      | _        | j                  «        y ©NFr`   )	r9   rc   Ú
num_labelsrj   rT   r2   rX   Ú
classifierrh   ri   s     €r(   rc   z.Data2VecTextForSequenceClassification.__init__"  sK   ø€ Ü‰Ñ˜Ô Ø ×+Ñ+ˆŒØˆŒä.¨vÈÔOˆÔÜ8¸Ó@ˆŒð 	�‰Õr'   Nrw   rx   rD   r>   ry   r|   r€   r�   c           	      óô  —  | j                   |f||||ddœ|¤Ž}|d   }	| j                  |	«      }
d}|��¢|j                  |
j                  «      }| j                  j
                  €�| j                  dk(  rd| j                  _        nl| j                  dkD  rL|j                  t        j                  k(  s|j                  t        j                  k(  rd| j                  _        nd| j                  _        | j                  j
                  dk(  rIt        «       }| j                  dk(  r& ||
j                  «       |j                  «       «      }nŒ ||
|«      }n‚| j                  j
                  dk(  r=t        «       } ||
j                  d	| j                  «      |j                  d	«      «      }n,| j                  j
                  dk(  rt        «       } ||
|«      }t!        ||
|j"                  |j$                  ¬
«      S )a�  
        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
            Labels for computing the sequence 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).
        T©rx   rD   r>   ry   rƒ   r   Nr   Ú
regressionÚsingle_label_classificationÚmulti_label_classificationr8   rš   )r2   r§   r›   rœ   rj   Úproblem_typer¦   Údtyper?   Úlongrˆ   r   Úsqueezer   r�   r   r   r4   r5   ©rE   rw   rx   rD   r>   ry   r|   r€   r‹   rž   r„   r†   r¡   s                r(   r�   z-Data2VecTextForSequenceClassification.forward-  s¯  € ð$ %�$×$Ñ$Øð
à)Ø)Ø%Ø'Øñ
ð ñ
ˆð " !™*ˆØ—‘ Ó1ˆàˆØÑØ—Y‘Y˜vŸ}™}Ó-ˆFà�{‰{×'Ñ'Ð/Ø—?‘? aÒ'Ø/;�D—K‘KÕ,Ø—_‘_ qÒ(¨f¯l©l¼e¿j¹jÒ.HÈFÏLÉLÔ\a×\eÑ\eÒLeØ/L�D—K‘KÕ,à/K�D—K‘KÔ,à�{‰{×'Ñ'¨<Ò7Ü"›9�Ø—?‘? aÒ'Ù# F§N¡NÓ$4°f·n±nÓ6FÓG‘Dá# F¨FÓ3‘DØ—‘×)Ñ)Ð-JÒJÜ+Ó-�Ù §¡¨B°·±Ó @À&Ç+Á+ÈbÃ/ÓR‘Ø—‘×)Ñ)Ð-IÒIÜ,Ó.�Ù ¨Ó/�ä'ØØØ!×/Ñ/Ø×)Ñ)ô	
ð 	
r'   ©NNNNNN)r#   r$   r%   rc   r   r   r?   r�   r�   r   r   r‘   r   r�   rQ   rR   s   @r(   r£   r£     sÔ   ø„ ô	ð Øð .2Ø37Ø26Ø04Ø26Ø*.ñ:
à×#Ñ# dÑ*ð:
ð ×)Ñ)¨DÑ0ð:
ð ×(Ñ(¨4Ñ/ð	:
ð
 ×&Ñ&¨Ñ-ð:
ð ×(Ñ(¨4Ñ/ð:
ð × Ñ  4Ñ'ð:
ð Ð+Ñ,ð:
ð 
Ð)Ñ	)ò:
ó ó ô:
r'   r£   c                   ó  ‡ — e Zd 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j                  dz  dej                  dz  d	e	e
   d
eez  fd„«       «       Zˆ xZS )ÚData2VecTextForMultipleChoicec                 óö   •— t         ‰| �  |«       t        |«      | _        t	        j
                  |j                  «      | _        t	        j                  |j                  d«      | _
        | j                  «        y )Nr   )r9   rc   rT   r2   ÚnnÚDropoutÚhidden_dropout_probÚdropoutÚLinearÚhidden_sizer§   rh   ri   s     €r(   rc   z&Data2VecTextForMultipleChoice.__init__n  sW   ø€ Ü‰Ñ˜Ô ä.¨vÓ6ˆÔÜ—z‘z &×"<Ñ"<Ó=ˆŒÜŸ)™) F×$6Ñ$6¸Ó:ˆŒð 	�‰Õr'   Nrw   rD   rx   r|   r>   ry   r€   r�   c           	      ó"  — |�|j                   d   n|j                   d   }|�!|j                  d|j                  d«      «      nd}	|�!|j                  d|j                  d«      «      nd}
|�!|j                  d|j                  d«      «      nd}|�!|j                  d|j                  d«      «      nd}|�1|j                  d|j                  d«      |j                  d«      «      nd} | j                  |	f|
|||ddœ|¤Ž}|d   }| j	                  |«      }| j                  |«      }|j                  d|«      }d}|�.t        «       }|j                  |j                  «      } |||«      }t        |||j                  |j                  ¬«      S )a[  
        input_ids (`torch.LongTensor` of shape `(batch_size, num_choices, sequence_length)`):
            Indices of input sequence tokens in the vocabulary.

            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
            [`PreTrainedTokenizer.__call__`] for details.

            [What are input IDs?](../glossary#input-ids)
        token_type_ids (`torch.LongTensor` of shape `(batch_size, num_choices, sequence_length)`, *optional*):
            Segment token indices to indicate first and second portions of the inputs. Indices are selected in `[0,
            1]`:

            - 0 corresponds to a *sentence A* token,
            - 1 corresponds to a *sentence B* token.

            [What are token type IDs?](../glossary#token-type-ids)
        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
            Labels for computing the multiple choice classification loss. Indices should be in `[0, ...,
            num_choices-1]` where `num_choices` is the size of the second dimension of the input tensors. (See
            `input_ids` above)
        position_ids (`torch.LongTensor` of shape `(batch_size, num_choices, sequence_length)`, *optional*):
            Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
            config.max_position_embeddings - 1]`.

            [What are position IDs?](../glossary#position-ids)
        inputs_embeds (`torch.FloatTensor` of shape `(batch_size, num_choices, sequence_length, hidden_size)`, *optional*):
            Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
            is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
            model's internal embedding lookup matrix.
        Nr   r8   éþÿÿÿT)r>   rD   rx   ry   rƒ   rš   )rA   r�   Úsizer2   r¹   r§   r   r›   rœ   r   r4   r5   )rE   rw   rD   rx   r|   r>   ry   r€   Únum_choicesÚflat_input_idsÚflat_position_idsÚflat_token_type_idsÚflat_attention_maskÚflat_inputs_embedsr‹   Úpooled_outputr„   Úreshaped_logitsr†   r¡   s                       r(   r�   z%Data2VecTextForMultipleChoice.forwardx  s·  € ðT -6Ð,A�i—o‘o aÒ(À}×GZÑGZÐ[\ÑG]ˆàCLÐCX˜Ÿ™¨¨I¯N©N¸2Ó,>Ô?Ð^bˆØLXÐLd˜L×-Ñ-¨b°,×2CÑ2CÀBÓ2GÔHÐjnÐØR`ÐRl˜n×1Ñ1°"°n×6IÑ6IÈ"Ó6MÔNÐrvÐØR`ÐRl˜n×1Ñ1°"°n×6IÑ6IÈ"Ó6MÔNÐrvÐð Ð(ð ×Ñ˜r =×#5Ñ#5°bÓ#9¸=×;MÑ;MÈbÓ;QÔRàð 	ð %�$×$Ñ$Øð
à*Ø.Ø.Ø,Øñ
ð ñ
ˆð   ™
ˆàŸ™ ]Ó3ˆØ—‘ Ó/ˆØ Ÿ+™+ b¨+Ó6ˆàˆØÐÜ'Ó)ˆHà—Y‘Y˜×5Ñ5Ó6ˆFÙ˜O¨VÓ4ˆDä(ØØ"Ø!×/Ñ/Ø×)Ñ)ô	
ð 	
r'   r²   )r#   r$   r%   rc   r   r   r?   r�   r�   r   r   r‘   r   r�   rQ   rR   s   @r(   r´   r´   l  sÞ   ø„ ôð Øð .2Ø26Ø37Ø*.Ø04Ø26ñO
à×#Ñ# dÑ*ðO
ð ×(Ñ(¨4Ñ/ðO
ð ×)Ñ)¨DÑ0ð	O
ð
 × Ñ  4Ñ'ðO
ð ×&Ñ&¨Ñ-ðO
ð ×(Ñ(¨4Ñ/ðO
ð Ð+Ñ,ðO
ð 
Ð*Ñ	*òO
ó ó ôO
r'   r´   c                   ó  ‡ — e Zd 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j                  dz  dej                  dz  d	e	e
   d
eez  fd„«       «       Zˆ xZS )Ú"Data2VecTextForTokenClassificationc                 ód  •— t         ‰| �  |«       |j                  | _        t        |d¬«      | _        |j
                  �|j
                  n|j                  }t        j                  |«      | _	        t        j                  |j                  |j                  «      | _        | j                  «        y r¥   )r9   rc   r¦   rT   r2   Úclassifier_dropoutr¸   r¶   r·   r¹   rº   r»   r§   rh   )rE   rj   rÊ   rG   s      €r(   rc   z+Data2VecTextForTokenClassification.__init__Î  s‹   ø€ Ü‰Ñ˜Ô Ø ×+Ñ+ˆŒä.¨vÈÔOˆÔà)/×)BÑ)BÐ)NˆF×%Ò%ÐTZ×TnÑTnð 	ô —z‘zÐ"4Ó5ˆŒÜŸ)™) F×$6Ñ$6¸×8IÑ8IÓJˆŒð 	�‰Õr'   Nrw   rx   rD   r>   ry   r|   r€   r�   c           	      ó~  —  | j                   |f||||ddœ|¤Ž}|d   }	| j                  |	«      }	| j                  |	«      }
d}|�Wt        «       }|j	                  |
j
                  «      } ||
j                  d| j                  «      |j                  d«      «      }t        ||
|j                  |j                  ¬«      S )zÛ
        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
            Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`.
        Tr©   r   Nr8   rš   )r2   r¹   r§   r   r›   rœ   r�   r¦   r   r4   r5   r±   s                r(   r�   z*Data2VecTextForTokenClassification.forwardÜ  sË   € ð  %�$×$Ñ$Øð
à)Ø)Ø%Ø'Øñ
ð ñ
ˆð " !™*ˆàŸ,™, Ó7ˆØ—‘ Ó1ˆàˆØÐÜ'Ó)ˆHà—Y‘Y˜vŸ}™}Ó-ˆFÙ˜FŸK™K¨¨D¯O©OÓ<¸f¿k¹kÈ"»oÓNˆDä$ØØØ!×/Ñ/Ø×)Ñ)ô	
ð 	
r'   r²   )r#   r$   r%   rc   r   r   r?   r�   r�   r   r   r‘   r   r�   rQ   rR   s   @r(   rÈ   rÈ   Ì  sÔ   ø„ ôð Øð .2Ø37Ø26Ø04Ø26Ø*.ñ)
à×#Ñ# dÑ*ð)
ð ×)Ñ)¨DÑ0ð)
ð ×(Ñ(¨4Ñ/ð	)
ð
 ×&Ñ&¨Ñ-ð)
ð ×(Ñ(¨4Ñ/ð)
ð × Ñ  4Ñ'ð)
ð Ð+Ñ,ð)
ð 
Ð&Ñ	&ò)
ó ó ô)
r'   rÈ   c                   ó0  ‡ — e Zd 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j                  dz  dej                  dz  d	ej                  dz  d
e	e
   deez  fd„«       «       Zˆ xZS )Ú Data2VecTextForQuestionAnsweringc                 óè   •— t         ‰| �  |«       |j                  | _        t        |d¬«      | _        t        j                  |j                  |j                  «      | _        | j                  «        y r¥   )
r9   rc   r¦   rT   r2   r¶   rº   r»   Ú
qa_outputsrh   ri   s     €r(   rc   z)Data2VecTextForQuestionAnswering.__init__  sV   ø€ Ü‰Ñ˜Ô Ø ×+Ñ+ˆŒä.¨vÈÔOˆÔÜŸ)™) F×$6Ñ$6¸×8IÑ8IÓJˆŒð 	�‰Õr'   Nrw   rx   rD   r>   ry   Ústart_positionsÚend_positionsr€   r�   c           	      óÆ  —  | j                   |f||||ddœ|¤Ž}	|	d   }
| j                  |
«      }|j                  dd¬«      \  }}|j                  d«      j	                  «       }|j                  d«      j	                  «       }d }|�·|�µt        |j                  «       «      dkD  r|j                  d«      }t        |j                  «       «      dkD  r|j                  d«      }|j                  d«      }|j                  d|«      }|j                  d|«      }t        |¬«      } |||«      } |||«      }||z   dz  }t        ||||	j                  |	j                  ¬	«      S )
NTr©   r   r   r8   )Údim)Úignore_indexr   )r†   Ústart_logitsÚ
end_logitsr4   r5   )r2   rÏ   Úsplitr°   Ú
contiguousÚlenr¾   Úclampr   r   r4   r5   )rE   rw   rx   rD   r>   ry   rÐ   rÑ   r€   r‹   rž   r„   rÕ   rÖ   Ú
total_lossÚignored_indexr¡   Ú
start_lossÚend_losss                      r(   r�   z(Data2VecTextForQuestionAnswering.forward  s‚  € ð %�$×$Ñ$Øð
à)Ø)Ø%Ø'Øñ
ð ñ
ˆð " !™*ˆà—‘ Ó1ˆØ#)§<¡<°°r <Ó#:Ñ ˆ�jØ#×+Ñ+¨BÓ/×:Ñ:Ó<ˆØ×'Ñ'¨Ó+×6Ñ6Ó8ˆ
àˆ
ØÐ&¨=Ð+Dä�?×'Ñ'Ó)Ó*¨QÒ.Ø"1×"9Ñ"9¸"Ó"=�Ü�=×%Ñ%Ó'Ó(¨1Ò,Ø -× 5Ñ 5°bÓ 9�à(×-Ñ-¨aÓ0ˆMØ-×3Ñ3°A°}ÓEˆOØ)×/Ñ/°°=ÓAˆMä'°]ÔCˆHÙ! ,°Ó@ˆJÙ 
¨MÓ:ˆHØ$ xÑ/°1Ñ4ˆJä+ØØ%Ø!Ø!×/Ñ/Ø×)Ñ)ô
ð 	
r'   )NNNNNNN)r#   r$   r%   rc   r   r   r?   r�   r�   r   r   r‘   r   r�   rQ   rR   s   @r(   rÍ   rÍ   
  sì   ø„ ôð Øð .2Ø37Ø26Ø04Ø26Ø37Ø15ñ3
à×#Ñ# dÑ*ð3
ð ×)Ñ)¨DÑ0ð3
ð ×(Ñ(¨4Ñ/ð	3
ð
 ×&Ñ&¨Ñ-ð3
ð ×(Ñ(¨4Ñ/ð3
ð ×)Ñ)¨DÑ0ð3
ð ×'Ñ'¨$Ñ.ð3
ð Ð+Ñ,ð3
ð 
Ð-Ñ	-ò3
ó ó ô3
r'   rÍ   )r[   r•   r´   rÍ   r£   rÈ   rT   r1   ):Ú__doc__r?   Útorch.nnr¶   r   r   r   Ú r   r<   Ú
generationr   Úmodeling_outputsr	   r
   r   r   r   r   r   Úmodeling_utilsr   Úprocessing_utilsr   Úutilsr   r   r   Úutils.genericr   Úroberta.modeling_robertar   r   r   r   r   r   r   Úconfiguration_data2vec_textr   Ú
get_loggerr#   re   r!   r+   r-   r/   r1   rT   rV   rX   r[   r•   r£   r´   rÈ   rÍ   Ú__all__r&   r'   r(   ú<module>rì      sÀ  ðñ "ã Ý ß AÑ Aå &Ý )÷÷ ñ õ .Ý &ß @Ñ @Ý -÷÷ ñ õ <ð 
ˆ×	Ñ	˜HÓ	%€ô	Ð.ô 	ô	Ð 4ô 	ô	Ð!6ô 	ô	˜ô 	ð ô/ /ó /ó ð/ð, ô	˜ó 	ó ð	ô	˜ô 	ô	Ð%>ô 	ñ ðôô
`
Ð9¸?ó `
óð
`
ðF ôI
Ð9ó I
ó ðI
ñX ðôôH
Ð,Gó H
óðH
ðV ô\
Ð$?ó \
ó ð\
ð~ ô:
Ð)Dó :
ó ð:
ðz ô@
Ð'Bó @
ó ð@
òF	�r'   