`i*YdZddlmZddlmZmZddlZddlmZmZddl m Z ddl m Z dd l mZmZmZd d lmZd d lmZejeZeedGddeZeedGddeZeedGddeZeGdde ZGddeZGddeZGddeZGddeZGd d!eZ ed"Gd#d$eZ!ed%Gd&d'eZ"ed(Gd)d*e Z#gd+Z$dS),z5PyTorch DPR model for Open Domain Question Answering.) dataclass)OptionalUnionN)Tensornn)BaseModelOutputWithPooling)PreTrainedModel) ModelOutputauto_docstringlogging) BertModel) DPRConfigz6 Class for outputs of [`DPRQuestionEncoder`]. ) custom_introceZdZUdZejed<dZee ejdfed<dZ ee ejdfed<dS)DPRContextEncoderOutputa pooler_output (`torch.FloatTensor` of shape `(batch_size, embeddings_size)`): The DPR encoder outputs the *pooler_output* that corresponds to the context representation. Last layer hidden-state of the first token of the sequence (classification token) further processed by a Linear layer. This output is to be used to embed contexts for nearest neighbors queries with questions embeddings. pooler_outputN. hidden_states attentions __name__ __module__ __qualname____doc__torch FloatTensor__annotations__rrtuplerx/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/transformers/models/dpr/modeling_dpr.pyrr*q$$$$=AM8E%"3S"89:AAA:>Ju0#567>>>>>r"rceZdZUdZejed<dZee ejdfed<dZ ee ejdfed<dS)DPRQuestionEncoderOutputa pooler_output (`torch.FloatTensor` of shape `(batch_size, embeddings_size)`): The DPR encoder outputs the *pooler_output* that corresponds to the question representation. Last layer hidden-state of the first token of the sequence (classification token) further processed by a Linear layer. This output is to be used to embed questions for nearest neighbors queries with context embeddings. rN.rrrr!r"r#r&r&=r$r"r&ceZdZUdZejed<dZeejed<dZ eejed<dZ ee ejdfed<dZ ee ejdfed<dS) DPRReaderOutputa start_logits (`torch.FloatTensor` of shape `(n_passages, sequence_length)`): Logits of the start index of the span for each passage. end_logits (`torch.FloatTensor` of shape `(n_passages, sequence_length)`): Logits of the end index of the span for each passage. relevance_logits (`torch.FloatTensor` of shape `(n_passages, )`): Outputs of the QA classifier of the DPRReader that corresponds to the scores of each passage to answer the question, compared to all the other passages. start_logitsN end_logitsrelevance_logits.rr) rrrrrrrr*rr+rr rr!r"r#r(r(Ps####.2J*+22248hu01888=AM8E%"3S"89:AAA:>Ju0#567>>>>>r"r(ceZdZdZdZdS)DPRPreTrainedModelTct|tjrT|jjd|jj|j |jj dSdSt|tj r_|jjd|jj|j +|jj|j  dSdSt|tj r?|jj |jj ddSdS)zInitialize the weightsg)meanstdNg?) isinstancerLinearweightdatanormal_configinitializer_rangebiaszero_ Embedding padding_idx LayerNormfill_)selfmodules r# _init_weightsz DPRPreTrainedModel._init_weightsls) fbi ( ( * M  & &CT[5R & S S S{&  &&((((('&  - - * M  & &CT[5R & S S S!- "6#56<<>>>>>.-  - - * K  " " $ $ $ M  $ $S ) ) ) ) ) * *r"N)rrr_supports_sdpar@r!r"r#r-r-hs(N*****r"r-ceZdZdZdeffd Z ddedeedeed eed ed ed ed e e e edfffdZ e d efdZxZS) DPREncoder bert_modelr6cpt|t|d|_|jjjdkrt d|j|_|jdkr.tj |jjj|j|_ | dS)NF)add_pooling_layerrz!Encoder hidden_size can't be zero) super__init__rrDr6 hidden_size ValueErrorprojection_dimrr2 encode_proj post_initr>r6 __class__s r#rHzDPREncoder.__init__s    #FeDDD ? ! - 2 2@AA A$3   " "!y)?)KVMbccD  r"NF input_idsattention_masktoken_type_ids inputs_embedsoutput_attentionsoutput_hidden_states return_dictreturn.c ||||||||}|d} | dddddf} |jdkr|| } |s| | f|ddzSt| | |j|jS)NrPrQrRrSrTrUrVrr)last_hidden_staterrr)rDrKrLr rr) r>rPrQrRrSrTrUrVoutputssequence_output pooled_outputs r#forwardzDPREncoder.forwards//))'/!5#"  "!*'1aaa0   " " ,,];;M B#]3gabbkA A)-'!/)     r"cR|jdkr |jjS|jjjS)Nr)rKrL out_featuresrDr6rI)r>s r#embeddings_sizezDPREncoder.embeddings_sizes*   " "#0 0%11r")NNNFFF)rrrbase_model_prefixrrHrrboolrr r r^propertyintra __classcell__rOs@r#rCrC}s$ y      ,0+/*."'%*!! ! ! !(! !( !  ' !  ! #! !  )5+== >! ! ! ! F2222X22222r"rCceZdZdZdeffd Z ddededeed ed ed ed e e e ed fffdZ xZ S)DPRSpanPredictorencoderr6c*t|t||_t j|jjd|_t j|jjd|_| dS)Nrr) rGrHrCrjrr2ra qa_outputs qa_classifierrMrNs r#rHzDPRSpanPredictor.__init__sq    !&)) )DL$@!DDYt|'CQGG r"NFrPrQrSrTrUrVrW.c||n|dd\}}|||||||} | d} || } | dd\} } | d} | d} || dddddf}| ||} | ||} ||}|s| | |f| ddzSt| | || j | j S)Nr)rQrSrTrUrVrr)dim)r)r*r+rr) sizerjrlsplitsqueeze contiguousrmviewr(rr)r>rPrQrSrTrUrV n_passagessequence_lengthr[r\logitsr)r*r+s r#r^zDPRSpanPredictor.forwards;D:Oinn&6&6&6UbUgUgUiUijlkljlUm# O,, )'/!5#   "!*11#)<<r<#:#: j#++B//::<< ''++6688 --oaaaAAAg.FGG$((_EE __ZAA +00<< N *.>?'!""+M M%!-!/)     r")NFFF)rrrrbrrHrrrcrr(r r^rfrgs@r#riris!y+/"'%*!+ + + +  ' +  + # + +  fck 22 3+ + + + + + + + r"ric&eZdZUdZeed<dZdZdS)DPRPretrainedContextEncoder An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained models. r6N ctx_encoderrrrrrrload_tf_weightsrbr!r"r#rzrzs5 O%r"rzc&eZdZUdZeed<dZdZdS)DPRPretrainedQuestionEncoderr{r6Nquestion_encoderr}r!r"r#rrs5 O*r"rc&eZdZUdZeed<dZdZdS)DPRPretrainedReaderr{r6Nspan_predictorr}r!r"r#rr s5 O(r"rzf The bare DPRContextEncoder transformer outputting pooler outputs as context representations. ceZdZdeffd Ze ddeedeedeedeedeed eed eed e e e ed fffd Z xZ S)DPRContextEncoderr6ct|||_t||_|dSN)rGrHr6rCr|rMrNs r#rHzDPRContextEncoder.__init__sH     %f-- r"NrPrQrRrSrTrUrVrW.c ^||n |jj}||n |jj}||n |jj}||t d||}n.||dd}nt d||jn|j} |(|tj|| n||jj k}|!tj |tj | }| |||||||} |s | ddSt| j| j| j S) aS input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): Indices of input sequence tokens in the vocabulary. To match pretraining, DPR input sequence should be formatted with [CLS] and [SEP] tokens as follows: (a) For sequence pairs (for a pair title+text for example): ``` tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP] token_type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1 ``` (b) For single sequences (for a question for example): ``` tokens: [CLS] the dog is hairy . [SEP] token_type_ids: 0 0 0 0 0 0 0 ``` DPR is a model with absolute position embeddings so it's usually advised to pad the inputs on the right rather than the left. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input IDs?](../glossary#input-ids) Examples: ```python >>> from transformers import DPRContextEncoder, DPRContextEncoderTokenizer >>> tokenizer = DPRContextEncoderTokenizer.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base") >>> model = DPRContextEncoder.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base") >>> input_ids = tokenizer("Hello, is my dog cute ?", return_tensors="pt")["input_ids"] >>> embeddings = model(input_ids).pooler_output ```NDYou cannot specify both input_ids and inputs_embeds at the same timero5You have to specify either input_ids or inputs_embedsdevicedtyperrYrrrr)r6rTrUuse_return_dictrJrqrrones pad_token_idzeroslongr|rrrr r>rPrQrRrSrTrUrV input_shaperr[s r#r^zDPRContextEncoder.forward&sb2C1N--TXT_Tq$8$D $+Jj &1%cdd d  "#..**KK  &',,..ss3KKTUU U%.%:!! @T  !$ ;v66664;#;;   !"[EJvVVVN""))'/!5##   122; &!/w?Tahas    r"NNNNNNN)rrrrrHr rrrcrrr r^rfrgs@r#rrs y'++/+/*.,0/3&*X X F#X !(X !( X  ' X $D> X 'tnX d^X  &fck(:: ;X X X ^X X X X X r"rzh The bare DPRQuestionEncoder transformer outputting pooler outputs as question representations. ceZdZdeffd Ze ddeedeedeedeedeed eed eed e e e ed fffd Z xZ S)DPRQuestionEncoderr6ct|||_t||_|dSr)rGrHr6rCrrMrNs r#rHzDPRQuestionEncoder.__init__sH     *6 2 2 r"NrPrQrRrSrTrUrVrW.c ||n |jj}||n |jj}||n |jj}||t d|+||||}n.||dd}nt d||jn|j} |(|tj || n||jj k}|!tj |tj | }| |||||||} |s | ddSt| j| j| j S) aj input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): Indices of input sequence tokens in the vocabulary. To match pretraining, DPR input sequence should be formatted with [CLS] and [SEP] tokens as follows: (a) For sequence pairs (for a pair title+text for example): ``` tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP] token_type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1 ``` (b) For single sequences (for a question for example): ``` tokens: [CLS] the dog is hairy . [SEP] token_type_ids: 0 0 0 0 0 0 0 ``` DPR is a model with absolute position embeddings so it's usually advised to pad the inputs on the right rather than the left. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input IDs?](../glossary#input-ids) Examples: ```python >>> from transformers import DPRQuestionEncoder, DPRQuestionEncoderTokenizer >>> tokenizer = DPRQuestionEncoderTokenizer.from_pretrained("facebook/dpr-question_encoder-single-nq-base") >>> model = DPRQuestionEncoder.from_pretrained("facebook/dpr-question_encoder-single-nq-base") >>> input_ids = tokenizer("Hello, is my dog cute ?", return_tensors="pt")["input_ids"] >>> embeddings = model(input_ids).pooler_output ``` NrrorrrrYrr)r6rTrUrrJ%warn_if_padding_and_no_attention_maskrqrrrrrrrr&rrrrs r#r^zDPRQuestionEncoder.forwardsb2C1N--TXT_Tq$8$D $+Jj &1%cdd d  "  6 6y. Q Q Q#..**KK  &',,..ss3KKTUU U%.%:!! @T  !$ ;v66664;#;;   !"[EJvVVVN''))'/!5#(   122; '!/w?Tahas    r"r)rrrrrHr rrrcrr&r r^rfrgs@r#rrs y'++/+/*.,0/3&*Y Y F#Y !(Y !( Y  ' Y $D> Y 'tnY d^Y  'vs{);; <Y Y Y ^Y Y Y Y Y r"rzE The bare DPRReader transformer outputting span predictions. ceZdZdeffd Ze d deedeedeedeedeed eed e e e ed fffd Z xZ S) DPRReaderr6ct|||_t||_|dSr)rGrHr6rirrMrNs r#rHzDPRReader.__init__sH     .v66 r"NrPrQrSrTrUrVrW.c||n |jj}||n |jj}||n |jj}||t d|+||||}n.||dd}nt d||jn|j}|tj ||}| ||||||S)a input_ids (`tuple[torch.LongTensor]` of shapes `(n_passages, sequence_length)`): Indices of input sequence tokens in the vocabulary. It has to be a sequence triplet with 1) the question and 2) the passages titles and 3) the passages texts To match pretraining, DPR `input_ids` sequence should be formatted with [CLS] and [SEP] with the format: `[CLS] [SEP] [SEP] ` DPR is a model with absolute position embeddings so it's usually advised to pad the inputs on the right rather than the left. Indices can be obtained using [`DPRReaderTokenizer`]. See this class documentation for more details. [What are input IDs?](../glossary#input-ids) inputs_embeds (`torch.FloatTensor` of shape `(n_passages, 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. Examples: ```python >>> from transformers import DPRReader, DPRReaderTokenizer >>> tokenizer = DPRReaderTokenizer.from_pretrained("facebook/dpr-reader-single-nq-base") >>> model = DPRReader.from_pretrained("facebook/dpr-reader-single-nq-base") >>> encoded_inputs = tokenizer( ... questions=["What is love ?"], ... titles=["Haddaway"], ... texts=["'What Is Love' is a song recorded by the artist Haddaway"], ... return_tensors="pt", ... ) >>> outputs = model(**encoded_inputs) >>> start_logits = outputs.start_logits >>> end_logits = outputs.end_logits >>> relevance_logits = outputs.relevance_logits ``` Nrrorr)rSrTrUrV) r6rTrUrrJrrqrrrr) r>rPrQrSrTrUrVrrs r#r^zDPRReader.forwards!`2C1N--TXT_Tq$8$D $+Jj &1%cdd d  "  6 6y. Q Q Q#..**KK  &',,..ss3KKTUU U%.%:!! @T  !"Z FCCCN""  '/!5# #   r")NNNNNN)rrrrrHr rrrcrr(r r^rfrgs@r#rrs y'++/*.,0/3&*K K F#K !(K  ' K $D> K 'tn K d^K  fck 22 3K K K ^K K K K K r"r)rrzr-rrrr)%r dataclassesrtypingrrrrrmodeling_outputsr modeling_utilsr utilsr r r bert.modeling_bertrconfiguration_dprr get_loggerrloggerrr&r(r-rCrirzrrrrr__all__r!r"r#rs"<;!!!!!!"""""""" ::::::------ +*****((((((  H % %  ? ? ? ? ?k ? ?   ?  ? ? ? ? ?{ ? ?   ?  ?????k??   ?$********(5252525252#525252p6 6 6 6 6 )6 6 6 |&&&&&"4&&&+++++#5+++))))),)))  a a a a a 3a a  a H b b b b b 5b b  b J T T T T T #T T  T n   r"