S^(hAHdZddlZddlZddlZddlmZmZmZmZddl Z ddl Z ddl m Z ddl m Z mZmZddlmZddlmZdd lmZmZmZmZdd lmZmZdd lmZmZmZm Z m!Z!m"Z"m#Z#dd l$m%Z%dd l&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,ddl-m.Z.erddlm/Z/e+j`e1Z2dZ3dZ4gdZ5dZ6dZ7dZ8dZ9dZ:dZ;de jxde=de=fdZ>Gdde j~Z@Gd d!e j~ZAGd"d#e jZCGd$d%eCZDGd&d'eCZEeCeEeDd(ZFGd)d*e jZGGd+d,e jZHGd-d.e jZIGd/d0e%ZJGd1d2eJZKGd3d4eJZLd5ZMd6ZNd7ZOGd8d9eJZPGd:d;eJZQe)deJZRe)d?eMGd@dAeJeZSe)dBeMGdCdDeJZTe)dEeMGdFdGeJZUGdHdIeJZVe)dJeMGdKdLeJeZWgdMZXy)NzPyTorch BART model.N)ListOptionalTupleUnion)nn)BCEWithLogitsLossCrossEntropyLossMSELoss)ACT2FN)GenerationMixin)_prepare_4d_attention_mask#_prepare_4d_attention_mask_for_sdpa!_prepare_4d_causal_attention_mask*_prepare_4d_causal_attention_mask_for_sdpa)!flash_attn_supports_top_left_maskis_flash_attn_available)BaseModelOutput)BaseModelOutputWithPastAndCrossAttentions!CausalLMOutputWithCrossAttentionsSeq2SeqLMOutputSeq2SeqModelOutput#Seq2SeqQuestionAnsweringModelOutputSeq2SeqSequenceClassifierOutput)PreTrainedModel)add_code_sample_docstringsadd_end_docstringsadd_start_docstrings%add_start_docstrings_to_model_forwardloggingreplace_return_docstrings) BartConfig)_flash_attention_forwardzfacebook/bart-baser#)r"izvalhalla/bart-large-sst2z 'POSITIVE'z%valhalla/bart-large-finetuned-squadv1gzG?z' nice puppet' input_ids pad_token_iddecoder_start_token_idc|j|j}|ddddfj|ddddf<||dddf<| td|j |dk(||S)z1 Shift input ids one token to the right. Nr"rz1self.model.config.pad_token_id has to be defined.i) new_zerosshapeclone ValueError masked_fill_)r'r(r)shifted_input_idss d/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/transformers/models/bart/modeling_bart.pyshift_tokens_rightr3Ps}"++IOO<(CRC0668ae4adLMM""#4#z'BartLearnedPositionalEmbedding.__init__es$  $++5}Er4r'past_key_values_lengthc|jdd\}}tj|||ztj|jj j |d}t|!||jzS)z3`input_ids' shape is expected to be [bsz x seqlen].Nr;)dtypedevicer+) r-torcharangelongweightrDexpandr=forwardr<)r?r'rAbszseq_len positionsr@s r2rJz&BartLearnedPositionalEmbedding.forwardkso!r* WLL "$:W$DEJJ_c_j_j_q_q &b/ wy4;;677r4)r) __name__ __module__ __qualname____doc__intr>rETensorrJ __classcell__r@s@r2r6r6`s:FsF3F 88s88r4r6c `eZdZdZd dedededeeffd Zdejffd Z xZ S) BartScaledWordEmbeddingz\ This module overrides nn.Embeddings' forward by multiplying with embeddings scale. r7r8 padding_idx embed_scalec6t||||||_yN)r=r>rY)r?r7r8rXrYr@s r2r>z BartScaledWordEmbedding.__init__{s  D&r4r'c<t|||jzSr[)r=rJrY)r?r'r@s r2rJzBartScaledWordEmbedding.forwardswy)D,<,<<rErSrJrTrUs@r2rWrWvsE's'3'S'_ghm_n'===r4rWceZdZdZ ddededededededeeffd Z d e jd ed efd Z dde jdee jdee e jdee jdee jdede e jee jee e jffdZxZS) BartAttentionz=Multi-headed attention from 'Attention Is All You Need' paper embed_dim num_headsdropout is_decoderbias is_causalconfigc t|||_||_||_||z|_||_|j |z|jk7rtd|jd|d|j dz|_||_ ||_ tj||||_ tj||||_tj||||_tj||||_y)Nz;embed_dim must be divisible by num_heads (got `embed_dim`: z and `num_heads`: z).g࿩re)r=r>rarbrchead_dimrgr/scalingrdrfrLineark_projv_projq_projout_proj) r?rarbrcrdrerfrgr@s r2r>zBartAttention.__init__s "" !Y.  MMI %$.. 8MdnnM]$YKr3 }}d* $"ii 94@ ii 94@ ii 94@  )YTB r4tensorrLrKc|j|||j|jjddj S)Nr"r;)viewrbrj transpose contiguousr?rqrLrKs r2_shapezBartAttention._shapes7{{3GQQRSUVWbbddr4 hidden_stateskey_value_statespast_key_valueattention_masklayer_head_maskoutput_attentionsreturnc |du}|j\}} } |j||jz} |r0|.|djd|jdk(r |d} |d} n |rE|j |j |d|} |j |j |d|} n|}|j |j |d|} |j |j |d|} tj|d| gd} tj|d| gd} nD|j |j |d|} |j |j |d|} |jr| | f}||jzd|jf}|j | | |j|} | j|} | j|} | jd}tj| | jdd}|j||jz| |fk7r/t!d||jz| |fd|j|{|j|d| |fk7r#t!d |d| |fd|j|j||j| ||z}|j||jz| |}t"j$j'|d}||j|jfk7r*t!d |jfd|j|jdddd|j||j| |z}|j||jz| |}|r?|j||j| |}|j||jz| |}nd}t"j$j)||j(|j* }tj|| }|j||jz| |jfk7r9t!d ||jz| |jfd|j|j||j| |j}|jdd}|j|| |j,}|j/|}|||fS) #Input shape: Batch x Time x ChannelNrr;r"r+dimz$Attention weights should be of size , but is z!Attention mask should be of size z/Head mask for a single layer should be of size ptraining `attn_output` should be of size )sizerorkr-rwrmrnrEcatrdrbrjrsreshapebmmrtr/r functionalsoftmaxrcrrarp)r?rxryrzr{r|r}is_cross_attentionrKtgt_len_ query_states key_states value_states proj_shapesrc_len attn_weightsattn_weights_reshaped attn_probs attn_outputs r2rJzBartAttention.forwards.T9',,.Wa{{=1DLL@ *q!''*.>.D.DQ.GG(*J)!,L T[[1A%BBLJ;;t{{3C'Db#NL  'T[[%?SIJ;;t{{='A2sKLN1$5z#BJJ 99nQ&7%FANLT[[%?SIJ;;t{{='A2sKL ??),7NDNN*B > Ct{{<#>CCZP 'Z''4 +|++Z8 //!$yyz/C/CAq/IJ    3#7'"J J6dnn8LgW^7_6`a %%'(*   %""$a'(BB 7a'8R7SS\]k]p]p]r\st(,,S$..'7SVddL',,S4>>-A7GTL}},,\r,B  &##%$..):: Et~~FWEXY',,./1+//2q!<|?P?PQTVZVdVdfmov?wwL',,S4>>-A7GTL  %1$5$5c4>>7T[$\ !055cDNN6JGU\]L$( !]]**<4<AAr4)r&FTFNNNNNF)rNrOrPrQrRr^boolrr#r>rErSrwrrJrTrUs@r2r`r`sMG  '+CCC C  C  CC$C>eU\\eCece 488<1526"'vB||vB#5<<0vB!u||!45 vB !. vB "%,,/ vB vB u||Xell3XeELL>Q5RR SvBr4r`cVeZdZdZfdZdej dedefdZ ddej de ej d e e ej d e ej d e ej d e d e ej e ej e e ej ffdZ xZ S)BartFlashAttention2aD Bart flash attention module. This module inherits from `BartAttention` as the weights of the module stays untouched. The only required change would be on the forward pass where it needs to correctly call the public API of flash attention and deal with padding tokens in case the input contains any of them. cBt||i|t|_yr[)r=r>r_flash_attn_uses_top_left_mask)r?argskwargsr@s r2r>zBartFlashAttention2.__init__(s# $)&) /P.Q+r4rqrLrKcR|j|||j|jSr[)rsrbrjrvs r2_reshapezBartFlashAttention2._reshape0s{{3GGr4rxryrzr{r|r}r~c |r td|du}|j\}} } |j|j|d|} |rP|N|djd|jdk(r,|dj dd} |dj dd} n*|rE|j|j |d|} |j|j|d|} n||j|j |d|} |j|j|d|} tj|dj dd| gd} tj|dj dd| gd} nD|j|j |d|} |j|j|d|} |jr$| j dd| j ddf}| jd}|||djdz }| j}|tjk(rtjrtj}nMt|j dr|j j"}n |jj$j}t&j)d |d | j+|} | j+|} | j+|} t-| | | || |j.r |j0nd |j2|j4 }|j7|| d}|j9|}|sd}||fS) Nz@BartFlashAttention2 attention does not support output_attentionsr+rr;r"r_pre_quantization_dtypezThe input hidden states seems to be silently casted in float32, this might be related to the fact you have upcasted embedding or layer norm layers in float32. We will cast back the input in .r&)rcrfuse_top_left_mask)r/rrror-rtrmrnrErrdrCfloat32is_autocast_enabledget_autocast_gpu_dtypehasattrrgrrHlogger warning_oncetor$rrcrfrrrp)r?rxryrzr{r|r}rrKq_lenrrrr kv_seq_len input_dtype target_dtyperrs r2rJzBartFlashAttention2.forward3s0 _` `.T9%**, UA}}T[[%?SI *q!''*.>.D.DQ.GG(*44Q:J)!,66q!$  (??<8L#|4J'??<8L.     $(MMDLLsnn"AA  "))#ub9 mmK0  LL.88r4r)rNrOrPrQr>rErSrRrrrrrJrTrUs@r2rr!s RHu||HcHH 488<1526"'i9||i9#5<<0i9!u||!45 i9 !. i9 "%,,/ i9 i9 u||Xell3XeELL>Q5RR Si9r4rc$eZdZ d dejdeejdeeejdeejdeejdedeejeejeeejfffd ZxZ S) BartSdpaAttentionrxryrzr{r|r}r~cz|s|*tjdt| ||||||S|du}|j \}} } |j |} |r0|.|dj d|j dk(r |d} |d} n |rE|j|j|d|} |j|j|d|} n|}|j|j|d|} |j|j|d|} tj|d| gd} tj|d| gd} nD|j|j|d|} |j|j|d|} |jr| | f}|j| | |} |jr || dkDrd nd }tjjj!| | | ||j"r |j$nd | }|j ||j&| |j(fk7r7t+d ||j&| |j(fd|j |j-dd}|j/|| |j0}|j3|}|d|fS)rNaBartModel is using BartSdpaAttention, but `torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True` or `layer_head_mask` not None. Falling back to the manual attention implementation, but specifying the manual implementation will be required from Transformers version v5.0.0 onwards. This warning can be removed using the argument `attn_implementation="eager"` when loading the model.)ryrzr{r|r}rr;r"r+rTFr&) attn_mask dropout_prfrr)rrr=rJrror-rwrmrnrErrdrfrrscaled_dot_product_attentionrrcrbrjr/rtrrarp)r?rxryrzr{r|r}rrKrrrrrrfrr@s r2rJzBartSdpaAttention.forwards  ;   l 7?!1-- /"3 # .T9',,.Wa{{=1 *q!''*.>.D.DQ.GG(*J)!,L T[[1A%BBLJ;;t{{3C'Db#NL  'T[[%?SIJ;;t{{='A2sKLN1$5z#BJJ 99nQ&7%FANLT[[%?SIJ;;t{{='A2sKL ??),7N{{<#> !NN~/E'TU+D[` hh))FF   $&*mmdll G     #t~~w !N N2CRVR_R_3`2ab$$&')  "++Aq1 "))#wG mmK0 D.00r4r) rNrOrPrErSrrrrJrTrUs@r2rrs488<1526"'f1||f1#5<<0f1!u||!45 f1 !. f1 "%,,/ f1 f1 u||Xell3XeELL>Q5RR Sf1f1r4r)eagersdpaflash_attention_2ceZdZdeffd Z d dej dej dej deede ej eej ff dZ xZ S) BartEncoderLayerrgct||j|_t |j |j|j |j||_tj|j|_ |j|_ t|j|_|j |_tj"|j|j$|_tj"|j$|j|_tj|j|_y)N)rarbrcrg)r=r>d_modelraBART_ATTENTION_CLASSES_attn_implementationencoder_attention_headsattention_dropout self_attnr LayerNormself_attn_layer_normrcr activation_function activation_fnactivation_dropoutrlencoder_ffn_dimfc1fc2final_layer_normr?rgr@s r2r>zBartEncoderLayer.__init__s /0K0KLnn44,,   %'LL$@!~~ #F$>$>?"(";";99T^^V-C-CD99V33T^^D " T^^ <r4rxr{r|r}r~c|}|j||||\}}}tjj||j|j}||z}|j |}|}|j |j|}tjj||j|j}|j|}tjj||j|j}||z}|j|}|jtjk(rtj|js#tj |jrEtj"|jj$dz }tj&|| |}|f} |r| |fz } | S)a Args: hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)` attention_mask (`torch.FloatTensor`): attention mask of size `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values. layer_head_mask (`torch.FloatTensor`): mask for attention heads in a given layer of size `(encoder_attention_heads,)`. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. )rxr{r|r}ri)minmax)rrrrcrrrrrrrrCrEfloat16isinfanyisnanfinforclamp) r?rxr{r|r}residualrr clamp_valueoutputss r2rJzBartEncoderLayer.forward#s$!)-')+/ *8* & |Q  --mt||VZVcVc-d  =0 11-@  **488M+BC  --mt?V?Vaeanan-o /  --mt||VZVcVc-d  =0 --m<   %-- / KK & * * , M0J0N0N0P++m&9&9:>>EK!KK K<[YM "    &Gr4)F) rNrOrPr#r>rE FloatTensorrrrrJrTrUs@r2rrsz=z=.-2 0((0))0** 0 $D> 0 u  (5+<+<"== > 0r4rc~eZdZdeffd Z ddej deej deej deej deej deej d eeej d ee d ee d eejeeejejfffd Z xZ S)BartDecoderLayerrgcNt||j|_t |j |j|j |jdd||_|j|_ t|j|_ |j|_ tj|j|_t |j |j|j |jd||_tj|j|_tj&|j|j(|_tj&|j(|j|_tj|j|_y)NT)rarbrcrdrfrg)rcrdrg)r=r>rrarrdecoder_attention_headsrrrcr rrrrrr encoder_attnencoder_attn_layer_normrldecoder_ffn_dimrrrrs r2r>zBartDecoderLayer.__init__Ws0 /0K0KLnn44,,  ~~ #F$>$>?"(";";$&LL$@!263N3NO NN  * *,,  (*||DNN'C$99T^^V-C-CD99V33T^^D " T^^ <r4rxr{encoder_hidden_statesencoder_attention_maskr|cross_attn_layer_head_maskrzr} use_cacher~c t|} ||ddnd} |j|| |||\}} } tjj||j|j}| |z}|j |}d}d}|w|} ||ddnd}|j ||||||\}}}tjj||j|j}| |z}|j|}| |z} |} |j|j|}tjj||j|j}|j|}tjj||j|j}| |z}|j|}|f}|r|| |fz }| r|| fz }|S)a Args: hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)` attention_mask (`torch.FloatTensor`): attention mask of size `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values. encoder_hidden_states (`torch.FloatTensor`): cross attention input to the layer of shape `(batch, seq_len, embed_dim)` encoder_attention_mask (`torch.FloatTensor`): encoder attention mask of size `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values. layer_head_mask (`torch.FloatTensor`): mask for attention heads in a given layer of size `(encoder_attention_heads,)`. cross_attn_layer_head_mask (`torch.FloatTensor`): mask for cross-attention heads in a given layer of size `(decoder_attention_heads,)`. past_key_value (`Tuple(torch.FloatTensor)`): cached past key and value projection states output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. Nr;)rxrzr{r|r}rr)rxryr{r|rzr}) rrrrcrrrrrrrrr)r?rxr{rrr|rrzr}rrself_attn_past_key_valueself_attn_weightspresent_key_valuecross_attn_present_key_valuecross_attn_weightscross_attn_past_key_valuers r2rJzBartDecoderLayer.forwardts <!:H9S>"1#5Y] >Bnn'3)+/ ?M? ; (*; --mt||VZVcVc-d  =0 11-@ (,$! ,$H@N?Yrs(;_c %NRN_N_+!65 :8"3 O`O KM-/KMM11-4< >G  )+ +Gr4)NNNNNNFT) rNrOrPr#r>rErSrrrrrJrTrUs@r2rrVs=z=@268<9=26=A8<,1$(W||W!.W ( 5 W !) 6 W "%,,/ W%-U\\$:W!u||!45W$D>WD>W u  (51B1BEDUDU1U+V"WW XWr4rcleZdZdZdedededeffd Zdejdejfd Z xZ S) BartClassificationHeadz-Head for sentence-level classification tasks. input_dim inner_dim num_classespooler_dropoutct|tj|||_tj ||_tj|||_y)N)r)r=r>rrldenseDropoutrcrp)r?rrrrr@s r2r>zBartClassificationHead.__init__sD YYy)4 zzN3  )[9 r4rxr~c|j|}|j|}tj|}|j|}|j |}|Sr[)rcrrEtanhrp)r?rxs r2rJzBartClassificationHead.forwardsN ]3  =1  =1  ]3  m4 r4) rNrOrPrQrRr^r>rErSrJrTrUs@r2rrsL7 : : : :  :U\\ellr4rcJeZdZeZdZdZddgZddgZdZ dZ dZ dZ e d Zy ) BartPreTrainedModelmodelTzencoder.versionzdecoder.versionrrpast_key_valuesc|jj}t|tjrY|j j jd||j%|jj jyyt|tjrf|j j jd||j2|j j |jjyyy)Nr&)meanstd) rginit_std isinstancerrlrHdatanormal_rezero_ EmbeddingrX)r?modulers r2 _init_weightsz!BartPreTrainedModel._init_weightsskk"" fbii ( MM   & &CS & 9{{&   &&('  - MM   & &CS & 9!!- ""6#5#56<<>..r4c|jj}tjgddddd|gg|j}|j ||d}|S)N)r r;rr% r;rD)r{r')rgr(rErqrDne)r? pad_tokenr' dummy_inputss r2rz BartPreTrainedModel.dummy_inputssWKK,, LL"2Q2q)4L!MVZVaVab 'll95" r4N)rNrOrPr# config_classbase_model_prefixsupports_gradient_checkpointing"_keys_to_ignore_on_load_unexpected_no_split_modules_skip_keys_device_placement_supports_flash_attn_2_supports_sdparpropertyrr4r2rrsUL&*#*;=N)O&,.AB"3!N ?r4rceZdZdZy)PretrainedBartModelc8tjdtyNz_The class `PretrainedBartModel` has been depreciated, please use `BartPreTrainedModel` instead.warningswarn FutureWarningr?s r2__init_subclass__z%PretrainedBartModel.__init_subclass__ m  r4NrNrOrPr%rr4r2rr r4rceZdZdZy)BartPretrainedModelc8tjdtyrr r$s r2r%z%BartPretrainedModel.__init_subclass__r&r4Nr'rr4r2r*r*r(r4r*aI This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads etc.) This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and behavior. Parameters: config ([`BartConfig`]): Model configuration class with all the parameters of the model. Initializing with a config file does not load the weights associated with the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. a! Summarization example: ```python >>> from transformers import AutoTokenizer, BartForConditionalGeneration >>> model = BartForConditionalGeneration.from_pretrained("facebook/bart-large-cnn") >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn") >>> ARTICLE_TO_SUMMARIZE = ( ... "PG&E stated it scheduled the blackouts in response to forecasts for high winds " ... "amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were " ... "scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow." ... ) >>> inputs = tokenizer([ARTICLE_TO_SUMMARIZE], max_length=1024, return_tensors="pt") >>> # Generate Summary >>> summary_ids = model.generate(inputs["input_ids"], num_beams=2, min_length=0, max_length=20) >>> tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] 'PG&E scheduled the blackouts in response to forecasts for high winds amid dry conditions' ``` Mask filling example: ```python >>> from transformers import AutoTokenizer, BartForConditionalGeneration >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-base") >>> model = BartForConditionalGeneration.from_pretrained("facebook/bart-base") >>> TXT = "My friends are but they eat too many carbs." >>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"] >>> logits = model(input_ids).logits >>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item() >>> probs = logits[0, masked_index].softmax(dim=0) >>> values, predictions = probs.topk(5) >>> tokenizer.decode(predictions).split() ['not', 'good', 'healthy', 'great', 'very'] ``` a Args: input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*): Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`: - 1 for tokens that are **not masked**, - 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*): Indices of decoder input sequence tokens in the vocabulary. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are decoder input IDs?](../glossary#decoder-input-ids) Bart uses the `eos_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`). For translation and summarization training, `decoder_input_ids` should be provided. If no `decoder_input_ids` is provided, the model will create this tensor by shifting the `input_ids` to the right for denoising pre-training following the paper. decoder_attention_mask (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*): Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also be used by default. If you want to change padding behavior, you should read [`modeling_bart._prepare_decoder_attention_mask`] and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more information on the default strategy. head_mask (`torch.Tensor` of shape `(encoder_layers, encoder_attention_heads)`, *optional*): Mask to nullify selected heads of the attention modules in the encoder. Mask values selected in `[0, 1]`: - 1 indicates the head is **not masked**, - 0 indicates the head is **masked**. decoder_head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*): Mask to nullify selected heads of the attention modules in the decoder. Mask values selected in `[0, 1]`: - 1 indicates the head is **not masked**, - 0 indicates the head is **masked**. cross_attn_head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*): Mask to nullify selected heads of the cross-attention modules in the decoder. Mask values selected in `[0, 1]`: - 1 indicates the head is **not masked**, - 0 indicates the head is **masked**. encoder_outputs (`tuple(tuple(torch.FloatTensor)`, *optional*): Tuple consists of (`last_hidden_state`, *optional*: `hidden_states`, *optional*: `attentions`) `last_hidden_state` of shape `(batch_size, sequence_length, hidden_size)`, *optional*) is a sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder. past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`): Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`. Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding. If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all `decoder_input_ids` of shape `(batch_size, sequence_length)`. inputs_embeds (`torch.FloatTensor` of shape `(batch_size, 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. decoder_inputs_embeds (`torch.FloatTensor` of shape `(batch_size, target_sequence_length, hidden_size)`, *optional*): Optionally, instead of passing `decoder_input_ids` you can choose to directly pass an embedded representation. If `past_key_values` is used, optionally only the last `decoder_inputs_embeds` have to be input (see `past_key_values`). This is useful if you want more control over how to convert `decoder_input_ids` indices into associated vectors than the model's internal embedding lookup matrix. If `decoder_input_ids` and `decoder_inputs_embeds` are both unset, `decoder_inputs_embeds` takes the value of `inputs_embeds`. use_cache (`bool`, *optional*): If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see `past_key_values`). output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail. return_dict (`bool`, *optional*): Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. ceZdZdZddedeejffd ZdZ dZ ddee jdee jd ee jd ee jd eed eed eedeeeffdZxZS) BartEncoderz Transformer encoder consisting of *config.encoder_layers* self attention layers. Each layer is a [`BartEncoderLayer`]. Args: config: BartConfig embed_tokens (nn.Embedding): output embedding rg embed_tokensct|||j|_|j|_|j }|j |_|j|_ |jrtj|nd}t|j||j||_||j |j_t#|j||_t'j(t+|j,Dcgc] }t/|c}|_|j2dk(|_|j2dk(|_t'j8||_d|_|j?ycc}wNr]rYrrF) r=r>rcencoder_layerdrop layerdroprr(rXmax_position_embeddingsmax_source_positionsscale_embeddingmathsqrtrW vocab_sizer.rHr6embed_positionsr ModuleListrangeencoder_layersrlayersr_use_flash_attention_2 _use_sdparlayernorm_embeddinggradient_checkpointing post_init)r?rgr.rarYrr@s r2r>zBartEncoder.__init__s9  ~~ 11NN !..$*$B$B!.4.D.Ddii *# 3   y$*:*:    #'3':':D   $=  * *  mmuVMbMbGc$d!%5f%=$de &,&A&AEX&X#44>#%<< #: &+# %es Fc|jSr[r.r$s r2get_input_embeddingsz BartEncoder.get_input_embeddings   r4c||_yr[rEr?values r2set_input_embeddingsz BartEncoder.set_input_embeddings !r4r'r{ head_mask inputs_embedsr}output_hidden_states return_dictr~c||n|jj}||n|jj}||n|jj}| | t d|"|}|j d|j d}n| |dddddf}n t d||j|}|j|} | j|j} || z} |j| } tjj| |j|j} |R|j r d|vr|nd}n=|j"r||st%||j&}nt)||j&}|rdnd} |rdnd} |_|j+dt-|j.k7r6t dt-|j.d |j+dd t1|j.D]\} }|r| | fz} d }|jr&t3j4g}||j6krd }|rd }nW|j8r3|jr'|j;|j<| |||| nd|}n|| |||| nd|}|d} |s| |dfz} |r| | fz} |st?d| | | fDStA| | | S)a~ Args: input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*): Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`: - 1 for tokens that are **not masked**, - 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) head_mask (`torch.Tensor` of shape `(encoder_layers, encoder_attention_heads)`, *optional*): Mask to nullify selected heads of the attention modules. Mask values selected in `[0, 1]`: - 1 indicates the head is **not masked**, - 0 indicates the head is **masked**. inputs_embeds (`torch.FloatTensor` of shape `(batch_size, 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. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail. return_dict (`bool`, *optional*): Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. NzDYou cannot specify both input_ids and inputs_embeds at the same timer+z5You have to specify either input_ids or inputs_embedsrrrz&The head_mask should be specified for  layers, but it is for rFT)NN)r|r}r"c3&K|] }|| ywr[r.0vs r2 z&BartEncoder.forward..iseqWXWdeslast_hidden_staterx attentions)!rgr}rOuse_return_dictr/rsr-r.r:rrDrArrrcrr?r@rrCrrlenr> enumeraterErandr3rB_gradient_checkpointing_func__call__tupler)r?r'r{rMrNr}rOrPinput embed_posrxencoder_statesall_attentionsidx encoder_layerto_dropdropout_probability layer_outputss r2rJzBartEncoder.forwards$\2C1N-TXT_T_TqTq$8$D $++JjJj &1%cd d  "E!r9??2+>?I  &!!Q(+ETU U   --i8M((/ LL!5!56 % 1 00?  --mt||VZVcVc-d   %**343FDI$5>O"E^UbUhUh!i">Ne]NN$See e+>Vd  r4r[)NNNNNNN)rNrOrPrQr#rrrr>rFrKrE LongTensorrSrrrrrrJrTrUs@r2r-r-sz",,9O>!" 1515,059,0/3&*J E,,-J !.J ELL) J   1 12 J $D> J 'tnJ d^J  uo% &J r4r-ceZdZdZddedeejffd ZdZ dZ ddee jdee jd ee jd ee jd ee jd ee jd eee jdee jdeedeedeedeedeeeffdZxZS) BartDecoderz Transformer decoder consisting of *config.decoder_layers* layers. Each layer is a [`BartDecoderLayer`] Args: config: BartConfig embed_tokens (nn.Embedding): output embedding rgr.cFt|||j|_|j|_|j |_|j|_|jrtj|jnd}t|j|j|j ||_||j |j_t#|j|j|_t'j(t+|j,Dcgc] }t/|c}|_|j2dk(|_|j2dk(|_t'j8|j|_d|_|j?ycc}wr0) r=r>rcdecoder_layerdropr3r(rXr4max_target_positionsr6r7r8rrWr9r.rHr6r:rr;r<decoder_layersrr>rr?r@rrArBrC)r?rgr.rYrr@s r2r>zBartDecoder.__init__xs@  ~~ 11!..$*$B$B!393I3Idii/s 3   v~~t/?/?[   #'3':':D   $=  * * NN mmuVMbMbGc$d!%5f%=$de &,&A&AEX&X#44>#%<<#? &+# %esFc|jSr[rEr$s r2rFz BartDecoder.get_input_embeddingsrGr4c||_yr[rErIs r2rKz BartDecoder.set_input_embeddingsrLr4r'r{rrrMcross_attn_head_maskrrNrr}rOrPr~c | | n|jj} | | n|jj} | | n|jj} | | n|jj} | | t d|$|} | j }|jd|d}n-| |jdd}|dddddf} n t d||ddj dnd}||j| }|jr |d|vr|nd}n-|jr| s|t||||}nt||||}|^|\|jr d|vr|nd}nG|jr || st||j|d}nt!||j|d}|j#| |}|j%|j&}||z}|j)|}t*j,j/||j.|j0}|j2r%|j0r| rt4j7d d } | rd nd}| rd nd}| r|d nd}| rd nd}t9||gd d gD]j\}}| |jdt;|j<k7s3t d|dt;|j<d|jddt?|j<D]\}}| r||fz }|j0r%tAjBg}||jDkr?|||nd}|j2r?|j0r3|jG|jH|||||||nd|||ndd| | }n||||||||nd|||nd|| |  }|d}| r ||| rdndfz }| s||dfz }|||dfz }| r||fz }| r|nd}| stKd|||||fDStM|||||S)a  Args: input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*): Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`: - 1 for tokens that are **not masked**, - 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, encoder_sequence_length, hidden_size)`, *optional*): Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder. encoder_attention_mask (`torch.LongTensor` of shape `(batch_size, encoder_sequence_length)`, *optional*): Mask to avoid performing cross-attention on padding tokens indices of encoder input_ids. Mask values selected in `[0, 1]`: - 1 for tokens that are **not masked**, - 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*): Mask to nullify selected heads of the attention modules. Mask values selected in `[0, 1]`: - 1 indicates the head is **not masked**, - 0 indicates the head is **masked**. cross_attn_head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*): Mask to nullify selected heads of the cross-attention modules in the decoder to avoid performing cross-attention on hidden heads. Mask values selected in `[0, 1]`: - 1 indicates the head is **not masked**, - 0 indicates the head is **masked**. past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`): Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`. Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding. If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all `decoder_input_ids` of shape `(batch_size, sequence_length)`. inputs_embeds (`torch.FloatTensor` of shape `(batch_size, 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. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail. return_dict (`bool`, *optional*): Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. NzTYou cannot specify both decoder_input_ids and decoder_inputs_embeds at the same timer+zEYou have to specify either decoder_input_ids or decoder_inputs_embedsrr;)rrzZ`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`...FrrMrtzThe `z` should be specified for rRr)r{rrr|rrzr}rr r"c3$K|]}|| ywr[rrTs r2rWz&BartDecoder.forward..s=s)rYrrxrZcross_attentions)'rgr}rOrr[r/r-rsrr.r?r@rrrrCrr:rrDrArrrcrrBrrzipr\r>r]rEr^r3r_r`rar)r?r'r{rrrMrtrrNrr}rOrPrb input_shaperArMrxall_hidden_statesall_self_attnsall_cross_attentionsnext_decoder_cacher mask_namerf decoder_layerrirzrj next_caches r2rJzBartDecoder.forwards `2C1N-TXT_T_TqTq$8$D $++JjJj "+!6IDKKst t  "E++K!r;r?;I  &',,.s3K!!Q(+Ede eDSC^!3A!6!0JqTbOb^imN ^^$5:N:VH& N? ]>#A&3t{{+;<$ {*DSEUDVW%NN,Q/03 #,DKK"8/ @ C#!m%55!}}&+jjn#&75D5P_S1VZN**t}} $ A A!**!")*&/&;IcN1E1Q(-W[% ! !.!#1*?+A7@7LYs^RV5I5U,S1[_#1&7' ! *!,M"}:KQQR'S&UU" =#3"55(4(]1-=,??(_/ @d -!1 1 +4'$ '5FXlm  9+&+%1   r4r[) NNNNNNNNNNNN)rNrOrPrQr#rrrr>rFrKrErkrSrrrrrrrJrTrUs@r2rmrmosYz",,9O:!" 1515=A=A,07;=A59$(,0/3&*p E,,-p !.p  ((9(9: p !))9)9 : p ELL) p 'u||4p "$u'8'8"9:p   1 12p D>p $D>p 'tnp d^p  u?? @p r4rmzRThe bare BART Model outputting raw hidden-states without any specific head on top.c%2eZdZddgZdeffd ZdZdZdZdZ d Z e e e eeee  dd eej(d eej*d eej(deej(deej*deej*deej*deeej.deeej.deej.deej.deedeedeedeedeeeff dZxZS) BartModelencoder.embed_tokens.weightdecoder.embed_tokens.weightrgcvt|||j|j}}|jrt j |jnd}t||j|||_ t||j|_ t||j|_ |jy)Nr]r1)r=r>r(r9r6r7r8rrWsharedr-encoderrmdecoderrC)r?rgrXr9rYr@s r2r>zBartModel.__init__s  "("5"5v7H7HZ 393I3Idii/s -j&..+cno "64;;7 "64;;7  r4c|jjrB|jjjt jdk(r|j jjjt jdk7rk|j|jj|j j|j|j|j jy|j|jj|j|j|j j|jyy)Nmeta) rgtie_word_embeddingsrrHrDrErr._tie_or_clone_weightsrr$s r2 _tie_weightszBartModel._tie_weightss ;; * *{{!!((ELL-,,++2299U\\&=QQ**4<<+D+DdllF_F_`**4;; 8Q8QR**4<<+D+DdkkR**4<<+D+DdkkR +r4c|jSr[)rr$s r2rFzBartModel.get_input_embeddingss {{r4c~||_|j|j_|j|j_yr[)rrr.rrIs r2rKzBartModel.set_input_embeddingss) $(KK !$(KK !r4c|jSr[)rr$s r2 get_encoderzBartModel.get_encoder ||r4c|jSr[rr$s r2 get_decoderzBartModel.get_decoderrr4) checkpoint output_typerexpected_outputr'r{decoder_input_idsdecoder_attention_maskrMdecoder_head_maskrtencoder_outputsrrNdecoder_inputs_embedsrr}rOrPr~c:|D| B| tdt||jj|jj}| | n|jj } ||n|jj }| | n|jj} ||n|jj}||j|||| | ||}nI|rGt|ts7t|dt|dkDr|dndt|dkDr|dnd}|j|||d|||| | | | || }|s||zSt|j|j |j"|j$|j&|j|j"|j$S) NzIf no `decoder_input_ids` or `decoder_inputs_embeds` are passed, `input_ids` cannot be `None`. Please pass either `input_ids` or `decoder_input_ids` or `decoder_inputs_embeds`.)r'r{rMrNr}rOrPrr"r;rX r'r{rrrMrtrrNrr}rOrP)rYrdecoder_hidden_statesdecoder_attentionsrwencoder_last_hidden_staterencoder_attentions)r/r3rgr(r)r}rOrr[rrrr\rrrYrrxrZrw)r?r'r{rrrMrrtrrrNrrr}rOrPdecoder_outputss r2rJzBartModel.forwards6  $)>)F  U !34;;33T[[5W5W! 2C1N-TXT_T_TqTq$8$D $++JjJj "+!6IDKKrrFrKrrrBART_INPUTS_DOCSTRINGr_CHECKPOINT_FOR_DOCr_CONFIG_FOR_DOC_EXPECTED_OUTPUT_SHAPErrErkrSrrrrrrJrTrUs@r2rrs 89VW z  S0 ++@A&&$. 15158<=A,0487;=A=A59=A$(,0/3&*!U E,,-U !.U $E$4$45 U !))9)9 : U ELL) U $ELL1U 'u||4U "$u'8'8"9:U "$u'8'8"9:U   1 12U  ((9(9:U D>U $D>U 'tnU d^!U " u(( )#U BU r4rzLThe BART Model with a language modeling head. Can be used for summarization.c(eZdZdZgdZdgZdeffd ZdZdZ d&d e d e e d e d e jffd Zd e d dfdZdZdZdZeeeeeee d'de ej8de ej:de ej8de ej8de ej:de ej:de ej:de eej>de eej>de ej>de ej>de ej8de e d e e d!e e d"e e d e e!eff"d#Z"dej:fd$Z#e$d%Z%xZ&S)(BartForConditionalGenerationr)rrlm_head.weightfinal_logits_biasrgcxt||t||_|j dt j d|jjjftj|j|jjjd|_ |jy)Nrr"Fri)r=r>rrregister_bufferrEzerosrr7rrlrlm_headrCrs r2r>z%BartForConditionalGeneration.__init__#s  v&  0%++q$**BSBSBbBb>c2deyy1B1B1Q1QX]^  r4c6|jjSr[)rrr$s r2rz(BartForConditionalGeneration.get_encoder,zz%%''r4c6|jjSr[)rrr$s r2rz(BartForConditionalGeneration.get_decoder/rr4Nnew_num_tokenspad_to_multiple_of mean_resizingr~czt||||}|j|jjd|S)Nr)r=resize_token_embeddings_resize_final_logits_biasrHr-)r?rrrnew_embeddingsr@s r2rz4BartForConditionalGeneration.resize_token_embeddings2s?8I[]jk &&~'<'<'B'B1'EFr4c6|jjd}||kr|jddd|f}nStjd||z f|jj}tj |j|gd}|j d|y)Nr+r"rrr)rr-rErrDrr)r?rold_num_tokensnew_bias extra_biass r2rz6BartForConditionalGeneration._resize_final_logits_bias9s//55b9 ^ +--a..@AHa.)H%IRVRhRhRoRopJyy$"8"8*!E1MH 0(;r4c|jSr[rr$s r2get_output_embeddingsz2BartForConditionalGeneration.get_output_embeddingsBrr4c||_yr[rr?rs r2set_output_embeddingsz2BartForConditionalGeneration.set_output_embeddingsE % r4c|jjrK|jj|j |j |jj yyr[)rgrrrrrrr$s r2rz)BartForConditionalGeneration._tie_weightsHsB ;; * * JJ # # %  & &t||TZZ5F5F G +r4rrr'r{rrrMrrtrrrNrlabelsrr}rOrPc>||n|jj}| R| rtjdd} |7| 5t | |jj |jj }|j||||||||| | | | |||}|j|d}||jj|jz}d}| a| j|j} t}||jd|jj| jd}|s|f|ddz}||f|zS|St|||j |j"|j$|j&|j(|j*|j, S) a labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked language modeling loss. Indices should either be in `[0, ..., config.vocab_size]` or -100 (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]`. Returns: NzJThe `use_cache` argument is changed to `False` since `labels` is provided.F)r{rrrrMrrtrrNrrr}rOrPrr+r" losslogitsrrrrwrrr)rgr[rwarningr3r(r)rrrrrDr rsr9rrrrrwrrr)r?r'r{rrrMrrtrrrNrrrr}rOrPr lm_logitsmasked_lm_lossloss_fctoutputs r2rJz$BartForConditionalGeneration.forwardMs<&1%BartForConditionalGeneration._reorder_cache..s.rU_j--aZ=N=N1OPr58r;rarrreordered_past layer_pasts ` r2_reorder_cachez+BartForConditionalGeneration._reorder_cachesT) J rcmnpopcqrrQR.! N  r4)NTNNNNNNNNNNNNNNNN)'rNrOrPrr_keys_to_ignore_on_load_missingr#r>rrrRrrrrrrrrrrrr!rrrBART_GENERATION_EXAMPLErErkrSrrrrrJr staticmethodrrTrUs@r2rrst i':&;#z((dh!7?}\` <<<&H ++@A?Y/015158<=A,0487;=A=A59=A-1$(,0/3&*#O E,,-O !.O $E$4$45 O !))9)9 : O ELL) O $ELL1O 'u||4O "$u'8'8"9:O "$u'8'8"9:O   1 12O  ((9(9:O ))*O D>O $D>O 'tn!O "d^#O $ uo% &%O 1ZBO bhELLhr4rz Bart model with a sequence classification/head on top (a linear layer on top of the pooled output) e.g. for GLUE tasks. c%eZdZddgZdeffd Zeeee e e e e  ddeej deej"deej d eej d eej"d eej"d eej"d eeej&deej&deej&deej deedeedeedeedeee ff dZxZS)BartForSequenceClassificationrrrgc t||fi|t||_t |j |j |j |j|_|jyr[) r=r>rrrr num_labelsclassifier_dropoutclassification_headrC)r?rgrr@s r2r>z&BartForSequenceClassification.__init__sZ *6*v& #9 NN NN     % % $   r4)rrrr expected_lossr'r{rrrMrrtrrNrrrr}rOrPr~c||n|jj}| d} |$| "td|jj|j ||||||||| | | | ||}|d}|j |jjj|j}ttj|jddkDr td||ddfj|j!dd|j!ddddddf}|j#|}d}| | j|j} |jj$|jj&dk(rd |j_nv|jj&dkDrL| j(tj*k(s| j(tj,k(rd |j_nd |j_|jj$d k(rSt/}|jj&dk(r&||j1| j1}n||| }n|jj$d k(rGt3}||jd|jj&| jd}n,|jj$d k(rt5}||| }|s|f|ddz}||f|zS|St7|||j8|j:|j<|j>|j@|jB|jD S) a3 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 classification loss is computed (Cross-Entropy). NFz8Passing input embeddings is currently not supported for r{rrrMrrtrrNrrr}rOrPrr"z7All examples must have the same number of tokens.r+ regressionsingle_label_classificationmulti_label_classificationr)#rgr[NotImplementedErrorr@rNreq eos_token_idrrDr\rEunique_consecutivesumr/rsrr problem_typerrCrGrRr squeezer rrrrrrwrrr)r?r'r{rrrMrrtrrNrrrr}rOrPrrxeos_masksentence_representationrrrrs r2rJz%BartForSequenceClassification.forwards>&1%>KbKbJcd ** )/#9/!5+'"7/!5#    << 8 89<<]=Q=QR u'' Q8 9A =VW W"/! "<"A"A-BTBTUVBWY[]j]o]opr]s"t r1H# ))*AB  YYv}}-F{{''/;;))Q./;DKK,[[++a/V\\UZZ5OSYS_S_chclclSl/LDKK,/KDKK,{{''<7"9;;))Q.#FNN$4fnn6FGD#FF3D))-JJ+- B 0F0F GUWY))-II,./Y,F)-)9TGf$ Ev E.#33")"?"?&99$55&-&G&G")"?"?&99  r4r)rNrOrPrr#r>rrr'_CHECKPOINT_FOR_SEQUENCE_CLASSIFICATIONrr_SEQ_CLASS_EXPECTED_OUTPUT_SEQ_CLASS_EXPECTED_LOSSrrErkrSrrrrrrJrTrUs@r2rrs89VW z ++@A:3$2. 15158<=A,0487;=A59=A-1$(,0/3&*!` E,,-` !.` $E$4$45 ` !))9)9 : ` ELL) ` $ELL1` 'u||4` "$u'8'8"9:`   1 12`  ((9(9:` ))*` D>` $D>` 'tn` d^!` " u55 6#` B` r4rz BART Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear layer on top of the hidden-states output to compute `span start logits` and `span end logits`). c'*eZdZddgZfdZeeeee e e e  dde ejde ejde ej de ej d e ejd e ejd e ejd e eej$d e ej de ej de ej$de ej$de ede ede ede edeee ff"dZxZS)BartForQuestionAnsweringrrct||d|_|j|_t||_t j |j|j|_|jyr:) r=r>rrrrrl hidden_size qa_outputsrCrs r2r>z!BartForQuestionAnswering.__init__<s[   ++v& ))F$6$68I8IJ r4)rrrrrr'r{rrrMrrtrstart_positions end_positionsrNrrr}rOrPr~c||n|jj}| | d} |j||||||||| | | |||}|d}|j|}|j dd\}}|j dj }|j dj }d}| | t| jdkDr| j d} t| jdkDr| j d} |jd}| jd|} | jd|} t|}||| }||| }||zd z }|s||f|ddz}||f|zS|St||||j|j|j|j|j |j"|j$ S) a start_positions (`torch.LongTensor` of shape `(batch_size,)`, *optional*): Labels for position (index) of the start of the labelled span for computing the token classification loss. Positions are clamped to the length of the sequence (*sequence_length*). Position outside of the sequence are not taken into account for computing the loss. end_positions (`torch.LongTensor` of shape `(batch_size,)`, *optional*): Labels for position (index) of the end of the labelled span for computing the token classification loss. Positions are clamped to the length of the sequence (*sequence_length*). Position outside of the sequence are not taken into account for computing the loss. NFrrr"r+r) ignore_indexr;) r start_logits end_logitsrrrrwrrr)rgr[rrsplitrrur\rrr rrrrrwrrr)r?r'r{rrrMrrtrrrrNrrr}rOrPrsequence_outputrr r  total_loss ignored_indexr start_lossend_lossrs r2rJz BartForQuestionAnswering.forwardHsJ&1%rrr_CHECKPOINT_FOR_QArr_QA_EXPECTED_LOSS_QA_EXPECTED_OUTPUTrrErSrkrrrrrrJrTrUs@r2rr2s89VW ++@A%7$'+ -1158<=A,0487;=A6:4859=A$(,0/3&*#\ ELL)\ !.\ $E$4$45 \ !))9)9 : \ ELL) \ $ELL1\ 'u||4\ "$u'8'8"9:\ "%"2"23\   0 01\   1 12\  ((9(9:\ D>\ $D>\ 'tn!\ "d^#\ $ u99 :%\ B\ r4rc(eZdZdZfdZdZxZS)BartDecoderWrapperz This wrapper class is a helper class to correctly load pretrained checkpoints when the causal language model is used in combination with the [`EncoderDecoderModel`] framework. cDt||t||_yr[)r=r>rmrrs r2r>zBartDecoderWrapper.__init__s  "6* r4c&|j|i|Sr[r)r?rrs r2rJzBartDecoderWrapper.forwardst||T,V,,r4)rNrOrPrQr>rJrTrUs@r2rrs +-r4rzu BART decoder with a language modeling head on top (linear layer with weights tied to the input embeddings). c eZdZdgZfdZdZdZdZdZdZ dZ e e e  dd eej d eej"d eej$d eej$deej"deej"deeej$deej$deej deedeedeedeedeee ffdZedZxZS)BartForCausalLMrc tj|}d|_d|_t||t ||_tj|j|jd|_ |jy)NTFri)copydeepcopyrdis_encoder_decoderr=r>rrrrlrr9rrCrs r2r>zBartForCausalLM.__init__sfv& $)!  '/ yy!3!3V5F5FUS  r4cB|jjjSr[rrr.r$s r2rFz$BartForCausalLM.get_input_embeddingsszz!!...r4c:||jj_yr[rrIs r2rKz$BartForCausalLM.set_input_embeddingss*/ 'r4c|jSr[rr$s r2rz%BartForCausalLM.get_output_embeddingsrr4c||_yr[rrs r2rz%BartForCausalLM.set_output_embeddingsrr4c&||j_yr[rr)r?rs r2 set_decoderzBartForCausalLM.set_decoders$ r4c.|jjSr[r$r$s r2rzBartForCausalLM.get_decoderszz!!!r4rr'r{rrrMrtrrNrrr}rOrPr~cz| | n|jj} | | n|jj} | | n|jj} |jj ||||||||| | | |  }|j |d}d}| a| j|j} t}||jd|jj| jd}| s|f|ddz}||f|zS|St|||j|j|j|j S)a Args: input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*): Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`: - 1 for tokens that are **not masked**, - 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*): Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if the model is configured as a decoder. encoder_attention_mask (`torch.FloatTensor` of shape `(batch_size, sequence_length)`, *optional*): Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in the cross-attention if the model is configured as a decoder. Mask values selected in `[0, 1]`: head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*): Mask to nullify selected heads of the attention modules. Mask values selected in `[0, 1]`: - 1 indicates the head is **not masked**, - 0 indicates the head is **masked**. cross_attn_head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*): Mask to nullify selected heads of the cross-attention modules. Mask values selected in `[0, 1]`: - 1 indicates the head is **not masked**, - 0 indicates the head is **masked**. past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`): Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`. The two additional tensors are only required when the model is used as a decoder in a Sequence to Sequence model. Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding. If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all `decoder_input_ids` of shape `(batch_size, sequence_length)`. labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked language modeling loss. Indices should either be in `[0, ..., config.vocab_size]` or -100 (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]`. use_cache (`bool`, *optional*): If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see `past_key_values`). - 1 for tokens that are **not masked**, - 0 for tokens that are **masked**. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail. return_dict (`bool`, *optional*): Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. Returns: Example: ```python >>> from transformers import AutoTokenizer, BartForCausalLM >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-base") >>> model = BartForCausalLM.from_pretrained("facebook/bart-base", add_cross_attention=False) >>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder." >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> outputs = model(**inputs) >>> logits = outputs.logits >>> expected_shape = [1, inputs.input_ids.shape[-1], model.config.vocab_size] >>> list(logits.shape) == expected_shape True ```Nrrr+r")rrrrxrZrw)rgr}rOr[rrrrrDr rsr9rrrxrZrw)r?r'r{rrrMrtrrNrrr}rOrPrrrrrs r2rJzBartForCausalLM.forwardsXL2C1N-TXT_T_TqTq$8$D $++JjJj &1%.zs.nU_j--aZ=N=N1OPnrrrs ` r2rzBartForCausalLM._reorder_cacheus=) J ncmnn N r4) NNNNNNNNNNNNN)rNrOrPrr>rFrKrrr%rr!rrrrErkrSrrrrrrJrrrTrUs@r2rrs++ /0&%"+L[jk1515=A>B,07;=A59-1$(,0/3&*N E,,-N !.N  ((9(9: N !)):): ; N ELL) N 'u||4N "$u'8'8"9:N   1 12N ))*N D>N $D>N 'tnN d^N  u77 8N lN `r4r)rrrrrrr*r)YrQrr7r!typingrrrrrEtorch.utils.checkpointrtorch.nnrr r activationsr generationr modeling_attn_mask_utilsrrrrmodeling_flash_attention_utilsrrmodeling_outputsrrrrrrrmodeling_utilsrutilsrrrrr r!configuration_bartr#r$ get_loggerrNrrrrrrrrrrrSrRr3rr6rWModuler`rrrrrrrrr*BART_START_DOCSTRINGrrr-rmrrrrrr__all__rr4r2r9s // AA!) i.+J   H %*%+E')=& %,, c [^  8R\\8, =bll =[BBII[B|{9-{9|g1 g1V ,CryyCLuryyupRYY0/@ -  -  )V_Dy %y x\ %\ ~XF #F F RRThO#6OOd x $7x x v s 2s s l -, -  y)?y  yx r4