U 9%e@sdZddlZddlZddlZddlZddlmZmZmZm Z ddl Z ddl m Z ddl m Z mZmZddlmZddlmZdd lmZmZmZmZmZmZdd lmZdd lmZmZm Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(dd l)m*Z*m+Z+ddl,m-Z-e'.e/Z0dZ1dZ2dddddgZ3ddZ4dZ5dZ6Gddde j7Z8zddl9m:Z:e:Z8e0;dWn4edYnXe?e8Gdd d e j7Z@Gd!d"d"e j7ZAGd#d$d$e j7ZBGd%d&d&e j7ZCGd'd(d(e j7ZDGd)d*d*e j7ZEGd+d,d,e j7ZFGd-d.d.e j7ZGGd/d0d0eZHGd1d2d2eHZId3ZJd4ZKd5ZLd6ZMe$d7eJGd8d9d9eHZNe$d:eJGd;d<dd?d?eHZPe$d@eJGdAdBdBeHZQe$dCeJGdDdEdEeHZRdS)Fz PyTorch T5 model.N)ListOptionalTupleUnion)nn)BCEWithLogitsLossCrossEntropyLossMSELoss) checkpoint)ACT2FN)BaseModelOutput)BaseModelOutputWithPastAndCrossAttentionsSeq2SeqLMOutputSeq2SeqModelOutput#Seq2SeqQuestionAnsweringModelOutputSeq2SeqSequenceClassifierOutput)PreTrainedModel)ALL_LAYERNORM_LAYERS find_pruneable_heads_and_indicesprune_linear_layer) DUMMY_INPUTS DUMMY_MASKadd_start_docstrings%add_start_docstrings_to_model_forwardis_torch_fx_proxyloggingreplace_return_docstrings)assert_device_mapget_device_map)T5Configr!zt5-smallzt5-basezt5-largezt5-3bzt5-11bc Cs|zddl}ddl}ddl}Wn tk r<tdYnXtj|}t d||j |}g}i} |D]>\} } t d| d| |j || } | | | | | <qr|D]} | d} tdd | Drt d d| | | dqd | d kr.t d d| | | dq|}| | } | D]6}|d |r`|d|}n|g}|ddkrt|d}n|ddkrt|d}|d}n|ddkrt|d}|d}n|ddkrt|d}|d}nd|ddkr.t|drt|d}nt|drRt|d}n$|ddkrJt|d}n|ddksf|ddkrrt|d}n|ddkrt|d}n|dd kr| dd!krq>n|dd!krt|d"}n|dd#kr t|dkr |dr t|d$|d}q>nFzt||d}Wn2tk rPt d d| Yq>YnXt|dkr>t|d}||}q>|ddkrt|d}|dd%krt d&| jd'| || } z,|j| jkrtd(|jd)| jd*Wn<tk r(}z|j|j| jf7_W5d}~XYnXt d+| t| |j!|_"| | dqt d,d-| #d.|S)/z'Load tf checkpoints in a pytorch model.rNzLoading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.z&Converting TensorFlow checkpoint from zLoading TF weight z with shape /css|]}|dkVqdS))Zadam_vZadam_mZAdamWeightDecayOptimizerZAdamWeightDecayOptimizer_1Z global_stepN).0nr#r#a/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/transformers/models/t5/modeling_t5.py isz(load_tf_weights_in_t5..z Skipping Z_slot_z [A-Za-z]+_\d+z_(\d+))Zkernelscale embeddingweightZself_attentionlayerZenc_dec_attentionr Zdense_relu_denseZrms_norm layer_normfinal_layer_normr)Z output_biasbetabiasZsquad classifierdecoderlogitslm_headwiZwi_r*z"Transposing numpy weight of shape z for zPointer shape z and array shape mismatchedzInitialize PyTorch weight z%Weights not copied to PyTorch model: z, .)$renumpyZ tensorflow ImportErrorloggererrorospathabspathinfotrainZlist_variablesZ load_variableappendsplitanyjoinpop fullmatchgetattrhasattrlenisdigitAttributeErrorintshape transpose ValueErrorAssertionErrorargstorchZ from_numpyZastypefloat32datakeys)modelconfigZtf_checkpoint_pathr9nptfZtf_pathZ init_varsnamesZ tf_weightsnamerOarrayZtxt_nameZpointerZm_nameZ scope_namesnumer#r#r&load_tf_weights_in_t5Ls                       *     raa This is an experimental feature and is a subject to change at a moment's notice. Uses a device map to distribute attention modules of the model across several devices. If no device map is given, it will evenly distribute blocks across all devices. Args: device_map (`Dict[int, list]`, optional, defaults to None): A dictionary that maps attention modules to devices. Note that the embedding module and LMHead are always automatically mapped to the first device (for esoteric reasons). That means that the first device should have fewer attention modules mapped to it than other devices. For reference, the t5 models have the following number of attention modules: - t5-small: 6 - t5-base: 12 - t5-large: 24 - t5-3b: 24 - t5-11b: 24 Example: ```python # Here is an example of a device map on a machine with 4 GPUs using t5-3b, which has a total of 24 attention modules: model = T5ForConditionalGeneration.from_pretrained("t5-3b") device_map = { 0: [0, 1, 2], 1: [3, 4, 5, 6, 7, 8, 9], 2: [10, 11, 12, 13, 14, 15, 16], 3: [17, 18, 19, 20, 21, 22, 23], } model.parallelize(device_map) ``` a  Moves the model to cpu from a model parallel state. Example: ```python # On a 4 GPU machine with t5-3b: model = T5ForConditionalGeneration.from_pretrained("t5-3b") device_map = { 0: [0, 1, 2], 1: [3, 4, 5, 6, 7, 8, 9], 2: [10, 11, 12, 13, 14, 15, 16], 3: [17, 18, 19, 20, 21, 22, 23], } model.parallelize(device_map) # Splits the model across several devices model.deparallelize() # Put the model back on cpu and cleans memory by calling torch.cuda.empty_cache() ``` cs&eZdZdfdd ZddZZS) T5LayerNormư>cs&ttt||_||_dS)zc Construct a layernorm module in the T5 style. No bias and no subtraction of mean. N)super__init__r ParameterrTonesr+variance_epsilon)self hidden_sizeeps __class__r#r&res zT5LayerNorm.__init__cCs\|tjdjddd}|t||j}|jjtj tj fkrR||jj}|j|S)Nr-r(T)Zkeepdim) torTrUpowmeanZrsqrtrhr+dtypefloat16Zbfloat16)ri hidden_statesZvariancer#r#r&forwards zT5LayerNorm.forward)rc__name__ __module__ __qualname__rert __classcell__r#r#rlr&rbsrb) FusedRMSNormzODiscovered apex.normalization.FusedRMSNorm - will use it instead of T5LayerNormzBdiscovered apex but it failed to load, falling back to T5LayerNormcs*eZdZedfdd ZddZZS)T5DenseActDenserYcsTttj|j|jdd|_tj|j|jdd|_t|j |_ t |j |_ dSNFr1)rdrerLineard_modeld_ffr6woDropout dropout_ratedropoutr dense_act_fnactrirYrlr#r&res  zT5DenseActDense.__init__cCsl||}||}||}t|jjtjr^|j|jjjkr^|jjjtj kr^| |jjj}||}|SN) r6rr isinstancerr+rTTensorrqint8rnrirsr#r#r&rt s    zT5DenseActDense.forwardrvrwrxr!rertryr#r#rlr&r{sr{cs*eZdZedfdd ZddZZS)T5DenseGatedActDenser|csjttj|j|jdd|_tj|j|jdd|_tj|j|jdd|_t |j |_ t |j |_dSr})rdrerrrrwi_0wi_1rrrrr rrrrlr#r&re/s  zT5DenseGatedActDense.__init__cCsz|||}||}||}||}t|jjtjrl|j |jjj krl|jjj tj krl| |jjj }||}|Sr) rrrrrrr+rTrrqrrn)rirsZ hidden_geluZ hidden_linearr#r#r&rt7s   zT5DenseGatedActDense.forwardrr#r#rlr&r.srcs*eZdZedfdd ZddZZS) T5LayerFFr|csJt|jrt||_n t||_t|j|jd|_ t |j |_ dS)Nrk)rdreZ is_gated_actrDenseReluDenser{rbrlayer_norm_epsilonr.rrrrrrlr#r&reLs    zT5LayerFF.__init__cCs&||}||}|||}|Sr)r.rr)rirsZforwarded_statesr#r#r&rtVs  zT5LayerFF.forwardrr#r#rlr&rKs rcsNeZdZdedfdd ZddZedd d Zdd dZdddZ Z S) T5AttentionFr|cst|j|_||_|j|_|j|_|j|_|j|_|j |_ |j |_ |j |j|_ tj|j|j dd|_tj|j|j dd|_tj|j|j dd|_tj|j |jdd|_|jrt|j|j |_t|_d|_dSr})rdre is_decoderhas_relative_attention_biasrelative_attention_num_bucketsrelative_attention_max_distancerd_kvkey_value_proj_dim num_headsn_headsrr inner_dimrrqkvo Embeddingrelative_attention_biasset pruned_headsgradient_checkpointingrirYrrlr#r&re^s$ zT5Attention.__init__cCst|dkrdSt||j|j|j\}}t|j||_t|j||_t|j||_t|j |dd|_ |jt||_|j|j|_ |j ||_dS)Nrr dim) rKrrrrrrrrrrunion)riheadsindexr#r#r& prune_headsus zT5Attention.prune_headsT cCsd}|r4|d}||dktj|7}t|}nt|t| }|d}||k}|t||t||||tj}t|t ||d}|t |||7}|S)a Adapted from Mesh Tensorflow: https://github.com/tensorflow/mesh/blob/0cb87fe07da627bf0b7e60475d59f95ed6b5be3d/mesh_tensorflow/transformer/transformer_layers.py#L593 Translate relative position to a bucket number for relative attention. The relative position is defined as memory_position - query_position, i.e. the distance in tokens from the attending position to the attended-to position. If bidirectional=False, then positive relative positions are invalid. We use smaller buckets for small absolute relative_position and larger buckets for larger absolute relative_positions. All relative positions >=max_distance map to the same bucket. All relative positions <=-max_distance map to the same bucket. This should allow for more graceful generalization to longer sequences than the model has been trained on Args: relative_position: an int32 Tensor bidirectional: a boolean - whether the attention is bidirectional num_buckets: an integer max_distance: an integer Returns: a Tensor with the same shape as relative_position, containing int32 values in the range [0, num_buckets) rr-r ) rnrTlongabsminZ zeros_likelogfloatmathZ full_likewhere)relative_position bidirectional num_buckets max_distanceZrelative_bucketsZ max_exactZis_smallZrelative_position_if_larger#r#r&_relative_position_buckets.  z%T5Attention._relative_position_bucketNc Cs|dkr|jjj}tj|tj|ddddf}tj|tj|ddddf}||}|j||j |j|j d}||}| dddg d}|S)z%Compute binned relative position biasN)rqdevice)rrrr-rr ) rr+rrTZarangerrrrrZpermuteZ unsqueeze) ri query_length key_lengthrZcontext_positionZmemory_positionrZrelative_position_bucketvaluesr#r#r& compute_biass  zT5Attention.compute_biasc s~|jdd\} | } |dk r\t|dkr>tdt|d| |dkrV|djdn|7} |dkrh| n|jd} fddfd d } fd d }|}||j||dk r|dnd}||j||dk r|dnd}t||d d}|dkrj sDtj dj | | f|j |j d}jrVjrVd|_nj| | |j d}|dk r|dddd|d dddf}|dk r||}jrt|jd}d|tj<|dd|f}n|}||7}tjj|dd|}tjj|jjd}|dk r$||}| t||}|}jrT|rT||fnd}|f|f|f}| rz||f}|S)z Self-attention (if key_value_states is None) or attention over source sentence (provided by key_value_states). Nr-z?past_key_value should have 2 past states: keys and values. Got z past statesrr cs|djjddS)Z projectionr(r r-)viewrrrPZstates batch_sizerir#r&rOsz"T5Attention.forward..shapecs|dddjS)Zreshaper r-r()rP contiguousrrrrr#r&unshapesz$T5Attention.forward..unshapecsx|dkr||}n|dkr*||}|dk rt|dkrNtj||gdd}n&|jd|jdkrp||}n|}|S)z4projects hidden states correctly to key/query statesNr-rr )rTcatrO)rsZ proj_layerkey_value_statespast_key_value)rOr#r&projects z$T5Attention.forward..projectr rrqTrr(r)ptraining)rOrKrQrrrrTmatmulrPrZzerosrrrqrrZ requires_gradrsizerrglistboolrZ functionalZsoftmaxrZtype_asrrr)rirsmaskr position_biasrlayer_head_maskr use_cacheoutput_attentions seq_lengthZreal_seq_lengthrrrZ query_statesZ key_statesZ value_statesZscoresZposition_bias_maskedZ attn_weightsZ attn_outputpresent_key_value_stateoutputsr#)rrirOr&rts      (    zT5Attention.forward)F)Trr)N)NNNNNNFF) rvrwrxr!rer staticmethodrrrtryr#r#rlr&r]s / rcs(eZdZdfdd ZdddZZS) T5LayerSelfAttentionFcs<tt||d|_t|j|jd|_t |j |_ dS)Nrr) rdrer SelfAttentionrbrrr.rrrrrrlr#r&reIs zT5LayerSelfAttention.__init__Nc CsJ||}|j|||||||d} ||| d}|f| dd} | S)N)rrrrrrrr )r.rr) rirsattention_maskrrrrrnormed_hidden_statesattention_outputrr#r#r&rtOs  zT5LayerSelfAttention.forward)F)NNNNFFrur#r#rlr&rHs rcs&eZdZfddZdddZZS)T5LayerCrossAttentioncs<tt|dd|_t|j|jd|_t |j |_ dS)NFrr) rdrerEncDecAttentionrbrrr.rrrrrrlr#r&reis zT5LayerCrossAttention.__init__NFc  CsN||} |j| |||||||| d } ||| d} | f| dd} | S)N)rrrrrrrrrr )r.rr)rirsrrrrrrrrrrZ layer_outputrr#r#r&rtos  zT5LayerCrossAttention.forward)NNNNFNFrur#r#rlr&rhs rc s(eZdZdfdd Zd ddZZS) T5BlockFcsZt|j|_t|_|jt||d|jrF|jt||jt |dS)Nr) rdrerr ModuleListr,rCrrrrrlr#r&res  zT5Block.__init__NTc  Csb| dk rz|jstd|dkr$dnd} t| | kr`td| d| dkrJdnddt| d | dd}| dd}nd \}}|jd |||||| | d }|dd\}}|dd}|jtjkr t t | t |jj d t |jj }tj|| |d}|jo|dk }|r|dk r:|d jd}nd}|jd|||||||| | d }|d }|jtjkrt t | t |jj d t |jj }tj|| |d}|dk r||d}||dd}|jd|}|jtjkr:t t | t |jj d t |jj }tj|| |d}|f}| rV||f|}n||}|S)NzN`past_key_values` is passed to the encoder. Please make sure this is intended.r-zThere should be z past states. z$2 (past / key) for cross attention. zGot z past key / value states)NNr)rrrrrri)rmaxr )rrrrrrrrr()rr<warningrKrQr,rqrTrrrisinfrEZfinforclamprO)rirsrrencoder_hidden_statesencoder_attention_maskencoder_decoder_position_biasrcross_attn_layer_head_maskrrr return_dictZexpected_num_past_key_valuesZself_attn_past_key_valueZcross_attn_past_key_valueZself_attention_outputsrZattention_outputsZ clamp_valueZdo_cross_attentionrZcross_attention_outputsrr#r#r&rts  &             zT5Block.forward)F) NNNNNNNNFFTrur#r#rlr&rs rcs:eZdZdZedfdd ZejejdddZZ S)T5ClassificationHeadz-Head for sentence-level classification tasks.r|csBtt|j|j|_tj|jd|_t|j|j |_ dS)N)r) rdrerrrdenserZclassifier_dropoutr num_labelsout_projrrlr#r&re s zT5ClassificationHead.__init__)rsreturncCs6||}||}t|}||}||}|Sr)rrrTtanhrrr#r#r&rts      zT5ClassificationHead.forward) rvrwrx__doc__r!rerTrrtryr#r#rlr&rsrc@sVeZdZdZeZeZdZdZ dZ dgZ dgZ e ddZdd Zdd d Zd dZdS)T5PreTrainedModelz An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained models. transformerTrrcCs$tt}tt}|||d}|S)N)decoder_input_ids input_idsdecoder_attention_mask)rTZtensorrr)rirZ input_mask dummy_inputsr#r#r&r(s  zT5PreTrainedModel.dummy_inputscCs|jj}t|tr(|jj|dnt|ttt t fr|j jjj d|ddt |dr||jjs||jjjj d|ddt |dr|jjjj d||jjdd|jjjnt|tr\|jjjj d||jjddt |jdr|jjdk r|jjj|jjjj d||jjddt |jdr|jjdk r|jjjnPt|tr|jjjj d||jjddt |jdr|jjdk r|jjj|jjjj d||jjddt |jdr|jjdk r|jjjnt|tr|jjjj d||jjddt |jdrV|jjdk rV|jjj|jjjj d||jjddt |jdr|jjdk r|jjj|jjjj d||jjddt |jdr|jjdk r|jjjnt|tr|jj}|jj}|jj }|j!jjj d|||dd|j"jjj d||dd|j#jjj d||dd|j$jjj d|||dd|j%r|j&jjj d||dddS) zInitialize the weightsg?g)rpZstdr5 qa_outputsr1N)'rYZinitializer_factorrrbr+rVZfill_T5ModelT5ForConditionalGenerationT5EncoderModelT5ForQuestionAnsweringsharedZnormal_rJtie_word_embeddingsr5rrr1Zzero_rrrr{r6rrrrrrrrrrrrrr)rimodulefactorrrrr#r#r& _init_weights3s^                 zT5PreTrainedModel._init_weightsFcCst|ttfr||_dSr)rrT5Stackr)rirvaluer#r#r&_set_gradient_checkpointinglsz-T5PreTrainedModel._set_gradient_checkpointingcCs|jj}|jj}|dkr tdt|rbt|jddd|}tj||dddfgdd}n4| |j}|dddf |dddf<||d<|dkrtd| |d k||S) Nzself.model.config.decoder_start_token_id has to be defined. In T5 it is usually set to the pad_token_id.See T5 docs for more information.r()r .rr ).rz1self.model.config.pad_token_id has to be defined.) rYdecoder_start_token_id pad_token_idrQrrTfullrOrZ new_zeroscloneZ masked_fill_)rirrrZshifted_input_idsr#r#r& _shift_rightps    zT5PreTrainedModel._shift_rightN)F)rvrwrxrr! config_classraZload_tf_weightsZbase_model_prefixZis_parallelizableZsupports_gradient_checkpointingZ_no_split_modulesZ_keep_in_fp32_modulespropertyrr r rr#r#r#r&rs 9 rc sZeZdZdfdd ZeedddZeeddZdd Z d d Z dd d Z Z S)r Ncsxt||_j|_tfddtjD|_t j j d|_ t j|_|d|_d|_d|_dS)Ncs g|]}tt|dkdqS)rr)rr)r$ir|r#r& sz$T5Stack.__init__..rF)rdre embed_tokensrrrrange num_layersblockrbrrr/rrr post_initmodel_parallel device_mapr)rirYrrlr|r&res zT5Stack.__init__cCstdt|dkr.tt|jttj n||_ t |j t|jd|_ d|j kr^dndtt|j |_dtt|j |_|j D]4\}}|D]&}dt|}|j|||j|<qq|j|j|_|j|j|_dS)Na<`T5Stack.parallelize` is deprecated and will be removed in v5 of Transformers, you should load your model with `device_map='balanced'` in the call to `from_pretrained`. You can also provide your own `device_map` but it needs to be a dictionary module_name to device, so for instance {'block.0': 0, 'block.1': 1, ...}Tcpucuda:)warningswarn FutureWarningrrKrrrTcuda device_countrrrrWstrr first_devicer last_deviceitemsrnrr/)rirrrr,Z cuda_devicer#r#r& parallelizes  $* zT5Stack.parallelizecCsxtdtd|_d|_d|_d|_tt|j D]}|j | d|j |<q2|j d|_ |j d|_ t jdS)N\Like `parallelize`, `deparallelize` is deprecated and will be removed in v5 of Transformers.Fr)r!r"r#rrr'r(rrKrrnrr/rTr$ empty_cache)rirr#r#r& deparallelizeszT5Stack.deparallelizecCs|jSrrrir#r#r&get_input_embeddingsszT5Stack.get_input_embeddingscCs ||_dSrr.riZnew_embeddingsr#r#r&set_input_embeddingsszT5Stack.set_input_embeddingsc *s~|jr$tj|j|j|j|_dk r0n|jjdk rDn|jj | dk rX| n|jj } | dk rl| n|jj } |dk r|dk r|j rdnd} t d| d| dn`|dk r|}|d|d}n>|dk r|dd}n$|j rdnd} t d| d| d |dkr2|jdkr(t d ||}|\}}|dk rZ|d d jd |n|}d kr|j st d|d|dkrtj|||jd}|j r|dkr|dk r|jd}tj|||jtjd}|dkrdgt|j}|||}|j rL|dk rL|\}}}||f}|dkr@tj||jd}||}nd}|jrt|jrtrttdd|||jj}|||jj}rdnd}| rdnd}rdnd}r|j rdnd}d}d}||}tt |j|D],\} \}!}"|| }#|| }$|jrtj|j|dk r@||j}|dk rV||j}|dk rl||j}|dk r||j}|dk r||j}|#dk r|#|j}#|$dk r|$|j}$| r||f}|jr|jrfdd}%t!|%|!|||||||#|$d }&n|!|||||||#|$|"d }&dkrV|&ddd|&dd}&|&dd \}}'|&d }|j r|dk r|&rdnd}r||'f}r||&df}|j r||&df}|jr|j"#D]B\}(})| |)dkrdt$|(|j%kr|dt$|(d}qސq|&|}||}| rJ||f}| slt'dd|||||fDSt(|||||d S)!NZdecoder_rzYou cannot specify both zinput_ids and zinputs_embeds at the same timer(zYou have to specify either z input_ids or inputs_embedsz.create_custom_forward..custom_forwardr#)rr6rr)rr&create_custom_forwardPsz.T5Stack.forward..create_custom_forward) rrrrrrrrrrrrr r css|]}|dk r|VqdSrr#)r$rr#r#r&r'sz"T5Stack.forward..)last_hidden_statepast_key_valuesrs attentionscross_attentions))rrTr$ set_devicer'rrnrYrroutput_hidden_statesuse_return_dictrrQrrrOrgrrrKrZget_extended_attention_maskZinvert_attention_maskrrr<Z warning_onceZ get_head_maskrr enumeratezipr rr)r&r(r/r4r)*rirrrrr3 head_maskcross_attn_head_maskr;rrr?rZerr_msg_prefixZ input_shaperrZmask_seq_lengthZencoder_seq_lengthZextended_attention_maskZencoder_batch_sizeZencoder_sequence_length_Zencoder_hidden_shapeZencoder_extended_attention_maskZpresent_key_value_statesZall_hidden_statesZall_attentionsZall_cross_attentionsrrrsrZ layer_modulerrrr8Z layer_outputsrrrr#r7r&rts(   $                          "    zT5Stack.forward)N)N) NNNNNNNNNNNN) rvrwrxrerPARALLELIZE_DOCSTRINGr*DEPARALLELIZE_DOCSTRINGr-r0r2rtryr#r#rlr&r s(  r a The T5 model was proposed in [Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer](https://arxiv.org/abs/1910.10683) by Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu. It's an encoder decoder transformer pre-trained in a text-to-text denoising generative setting. 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 ([`T5Config`]): 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\ Args: input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): Indices of input sequence tokens in the vocabulary. T5 is a model with relative position embeddings so you should be able to pad the inputs on both the right and the left. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for detail. [What are input IDs?](../glossary#input-ids) To know more on how to prepare `input_ids` for pretraining take a look a [T5 Training](./t5#training). attention_mask (`torch.FloatTensor` 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) T5 uses the `pad_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`). To know more on how to prepare `decoder_input_ids` for pretraining take a look at [T5 Training](./t5#training). decoder_attention_mask (`torch.BoolTensor` 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. head_mask (`torch.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify selected heads of the self-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.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify selected heads of the self-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 `(num_heads,)` or `(num_layers, num_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)` 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))` of length `config.n_layers` with each tuple having 4 tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`): Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up 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. a Args: input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): Indices of input sequence tokens in the vocabulary. T5 is a model with relative position embeddings so you should be able to pad the inputs on both the right and the left. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for detail. To know more on how to prepare `input_ids` for pretraining take a look a [T5 Training](./t5#training). attention_mask (`torch.FloatTensor` 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.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify selected heads of the self-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. a_ The input argument `head_mask` was split into two arguments `head_mask` and `decoder_head_mask`. Currently, `decoder_head_mask` is set to copy `head_mask`, but this feature is deprecated and will be removed in future versions. If you do not want to use any `decoder_head_mask` now, please set `decoder_head_mask = torch.ones(num_layers, num_heads)`. z\The bare T5 Model transformer outputting raw hidden-states without any specific head on top.cs,eZdZdgZddgZedfdd Zeeddd Z ee d d Z d d Z ddZ ddZddZddZeeeeeddeejeejeejeejeejeejeejeeeejeeeejeejeejeeeeeeeeeeejefdddZZ S)rFdecoder.block.0.layer.1.EncDecAttention.relative_attention_bias.weightencoder.embed_tokens.weightdecoder.embed_tokens.weightr|cst|t|j|j|_t|}d|_ d|_ d|_ t ||j|_ t|}d|_ d|_ |j|_t ||j|_|d|_d|_dSNFT)rdrerr vocab_sizerrcopydeepcopyrris_encoder_decoderr encodernum_decoder_layersrr3rrrrirYencoder_configZdecoder_configrlr#r&reSs   zT5Model.__init__NcCsptdt|dkr0tt|jjttj n||_ t |j t|jj|j |j |j |j d|_dS)NaL`T5Model.parallelize` is deprecated and will be removed in v5 of Transformers, you should load your model with `device_map='balanced'` in the call to `from_pretrained`. You can also provide your own `device_map` but it needs to be a dictionary module_name to device, so for instance {'encoder.block.0': 0, 'encoder.block.1': 1, ...}T)r!r"r#rrKrPrrrTr$r%rrr*r3rrirr#r#r&r*js zT5Model.parallelizecCsVtdt|j|j|jd|_|jd|_d|_d|_t j dSNr+rF) r!r"r#rPr-r3rnrrrTr$r,r/r#r#r&r-}s  zT5Model.deparallelizecCs|jSrrr/r#r#r&r0szT5Model.get_input_embeddingscCs"||_|j||j|dSrrrPr2r3r1r#r#r&r2s zT5Model.set_input_embeddingscCs|jSrrPr/r#r#r& get_encoderszT5Model.get_encodercCs|jSrr3r/r#r#r& get_decoderszT5Model.get_decodercCs*|D]\}}|jj|j|qdS) Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base class PreTrainedModel N)r)rPr,Z attentionrriZheads_to_pruner,rr#r#r& _prune_headsszT5Model._prune_heads output_typer)rrrrrCdecoder_head_maskrDencoder_outputsr;r3decoder_inputs_embedsrrr?rrcCs| dk r | n|jj} |dk r |n|jj}|dk rX|dkrX|jj|jjkrXttt|}|dkrz|j ||| || ||d}nH|rt |t st |dt |dkr|dndt |dkr|dndd}|d}|j r8tj|jj||jj}|dk r||jj}|dk r ||jj}|dk r8||jj}|j||| | ||||| | ||d }|sh||St|j|j|j|j|j|j|j|jdS) a Returns: Example: ```python >>> from transformers import AutoTokenizer, T5Model >>> tokenizer = AutoTokenizer.from_pretrained("t5-small") >>> model = T5Model.from_pretrained("t5-small") >>> input_ids = tokenizer( ... "Studies have been shown that owning a dog is good for you", return_tensors="pt" ... ).input_ids # Batch size 1 >>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids # Batch size 1 >>> # preprocess: Prepend decoder_input_ids with start token which is pad token for T5Model. >>> # This is not needed for torch's T5ForConditionalGeneration as it does this internally using labels arg. >>> decoder_input_ids = model._shift_right(decoder_input_ids) >>> # forward pass >>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids) >>> last_hidden_states = outputs.last_hidden_state ```Nrrr3rCrr?rrr r-r:rsr< rrr3r;rrrCrDrrr?r)r:r;decoder_hidden_statesdecoder_attentionsr=encoder_last_hidden_staterencoder_attentions)rYrr@rrQr!r"Z_T5Model__HEAD_MASK_WARNING_MSGr#rPrr rKrrTr$r>r3r'rnrr:r;rsr<r=)rirrrrrCrarDrbr;r3rcrrr?rrsdecoder_outputsr#r#r&rtst,     zT5Model.forward)N)NNNNNNNNNNNNNNN)!rvrwrx"_keys_to_ignore_on_load_unexpected_tied_weights_keysr!rerrFr*rGr-r0r2rYr[r^rT5_INPUTS_DOCSTRINGrr_CONFIG_FOR_DOCrrT LongTensor FloatTensor BoolTensorrrrrrtryr#r#rlr&rIs`   rz0T5 Model with a `language modeling` head on top.cs`eZdZdgZdddgZedfdd Zeed$d d Z ee d d Z d dZ ddZ ddZddZddZddZeeeeedd%eejeejeejeejeejeejeejeeeejeeeejeejeejeejeeeeeeeeeeejefdddZ d&ddZ!ejdd d!Z"d"d#Z#Z$S)'rrHrIrJzlm_head.weightr|cst||j|_t|j|j|_t |}d|_ d|_ d|_ t ||j|_t |}d|_ d|_ |j|_t ||j|_tj|j|jdd|_|d|_d|_dS)NFTr~)rdrer model_dimrrrLrrMrNrrrOr rPrQrr3rr5rrrrRrlr#r&res"   z#T5ForConditionalGeneration.__init__NcCstdt|dkr0tt|jjttj n||_ t |j t|jj|j |j |j |j |j|jj|_d|_dS)Na_`T5ForConditionalGeneration.parallelize` is deprecated and will be removed in v5 of Transformers, you should load your model with `device_map='balanced'` in the call to `from_pretrained`. You can also provide your own `device_map` but it needs to be a dictionary module_name to device, so for instance {'encoder.block.0': 0, 'encoder.block.1': 1, ...}T)r!r"r#rrKrPrrrTr$r%rrr*r3r5rnr'rrTr#r#r&r*6s z&T5ForConditionalGeneration.parallelizecCsdtdt|j|j|jd|_|jd|_|jd|_d|_d|_ t j dSrU) r!r"r#rPr-r3rnr5rrrTr$r,r/r#r#r&r-Js  z(T5ForConditionalGeneration.deparallelizecCs|jSrrVr/r#r#r&r0Ysz/T5ForConditionalGeneration.get_input_embeddingscCs"||_|j||j|dSrrWr1r#r#r&r2\s z/T5ForConditionalGeneration.set_input_embeddingscCs ||_dSrr5r1r#r#r&set_output_embeddingsasz0T5ForConditionalGeneration.set_output_embeddingscCs|jSrrtr/r#r#r&get_output_embeddingsdsz0T5ForConditionalGeneration.get_output_embeddingscCs|jSrrXr/r#r#r&rYgsz&T5ForConditionalGeneration.get_encodercCs|jSrrZr/r#r#r&r[jsz&T5ForConditionalGeneration.get_decoderr_)rrrrrCrarDrbr;r3rclabelsrrr?rrcCs| dk r | n|jj} |dk r |n|jj}|dk rX|dkrX|jj|jjkrXttt|}|dkrz|j ||| ||||d}nH|rt |t st |dt |dkr|dndt |dkr|dndd}|d}|j rtj|jj| dk r|dkr| dkr|| }|j rvtj|jj||jj}|dk rF||jj}|dk r^||jj}|dk rv||jj}|j||| | ||||| |||d }|d}|j rtj|j j|j|j j|_||jjj}|jjr||jd}||}d}| dk r>td d }| |j} ||d |d | d }|sr|f|dd|}|dk rn|f|S|St|||j|j|j |j!|j"|j|j d S) a labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*): Labels for computing the sequence classification/regression loss. Indices should be in `[-100, 0, ..., config.vocab_size - 1]`. All labels set to `-100` are ignored (masked), the loss is only computed for labels in `[0, ..., config.vocab_size]` Returns: Examples: ```python >>> from transformers import AutoTokenizer, T5ForConditionalGeneration >>> tokenizer = AutoTokenizer.from_pretrained("t5-small") >>> model = T5ForConditionalGeneration.from_pretrained("t5-small") >>> # training >>> input_ids = tokenizer("The walks in park", return_tensors="pt").input_ids >>> labels = tokenizer(" cute dog the ", return_tensors="pt").input_ids >>> outputs = model(input_ids=input_ids, labels=labels) >>> loss = outputs.loss >>> logits = outputs.logits >>> # inference >>> input_ids = tokenizer( ... "summarize: studies have shown that owning a dog is good for you", return_tensors="pt" ... ).input_ids # Batch size 1 >>> outputs = model.generate(input_ids) >>> print(tokenizer.decode(outputs[0], skip_special_tokens=True)) >>> # studies have shown that owning a dog is good for you. ```Nrdrr r-rerfrrZ ignore_indexr( lossr4r;rgrhr=rirrj)#rYrr@rrQr!r"Z2_T5ForConditionalGeneration__HEAD_MASK_WARNING_MSGr#rPrr rKrrTr$r>r3r'rrnr5r+rrrsrrrrr;rsr<r=r:)rirrrrrCrarDrbr;r3rcrwrrr?rrsrksequence_outputZ lm_logitsrzloss_fctoutputr#r#r&rtms4           z"T5ForConditionalGeneration.forwardc Ks4|dk r|ddddf}||| ||||||d S)Nr() rr;rbrrCrarrDrr#) rirr;rrCrarrDrrbkwargsr#r#r&prepare_inputs_for_generationsz8T5ForConditionalGeneration.prepare_inputs_for_generation)rwcCs ||Sr)r)rirwr#r#r&%prepare_decoder_input_ids_from_labels%sz@T5ForConditionalGeneration.prepare_decoder_input_ids_from_labelsc Cs|dkrtd|Sd}|D]}d}|D]}||d||jf}q*|dj|djkrtd|djd|djdt|t|krtdt|dt|d||f}q|S) NzHYou might want to consider setting `use_cache=True` to speed up decodingr#rz%reordered_layer_past_states[0] shape z and layer_past_states[0] shape r7z&length of reordered_layer_past_states z! and length of layer_past_states )r<rZ index_selectrnrrOrQrK)rir;Zbeam_idxZreordered_decoder_pastZlayer_past_statesZreordered_layer_past_statesZlayer_past_stater#r#r&_reorder_cache(s(  z)T5ForConditionalGeneration._reorder_cache)N)NNNNNNNNNNNNNNNN)NNNNNNNN)%rvrwrxrlrmr!rerrFr*rGr-r0r2rurvrYr[rrnrrrorrTrprqrrrrrrrtrrrryr#r#rlr&rs~     rzfThe bare T5 Model transformer outputting encoder's raw hidden-states without any specific head on top.c seZdZdgZdgZedfdd ZeedddZ ee d d Z d d Z d dZ ddZddZeeeeeddeejeejeejeejeeeeeeeeejefdddZZS)rrIr3r|csZt|t|j|j|_t|}d|_ d|_ t ||j|_ | d|_d|_dSNF)rdrerrrLrrrMrNrrOr rPrrr)rirYrSrlr#r&reOs  zT5EncoderModel.__init__NcCsbtdt|dkr0tt|jjttj n||_ t |j t|jj|j |j d|_dS)NaC`T5EncoderModel.parallelize` is deprecated and will be removed in v5 of Transformers, you should load your model with `device_map='balanced'` in the call to `from_pretrained`. You can also provide your own `device_map` but it needs to be a dictionary module_name to device, so for instance {'block.0': 0, 'block.1': 1, ...}T)r!r"r#rrKrPrrrTr$r%rrr*rrTr#r#r&r*_s zT5EncoderModel.parallelizecCs>tdt|j|jd|_d|_d|_tj dSrU) r!r"r#rPr-rnrrrTr$r,r/r#r#r&r-qs zT5EncoderModel.deparallelizecCs|jSrrVr/r#r#r&r0}sz#T5EncoderModel.get_input_embeddingscCs||_|j|dSr)rrPr2r1r#r#r&r2sz#T5EncoderModel.set_input_embeddingscCs|jSrrXr/r#r#r&rYszT5EncoderModel.get_encodercCs0|D]"\}}|jj|jdj|qdS)r\rN)r)rPrr,rrr]r#r#r&r^szT5EncoderModel._prune_headsr_)rrrCr3rr?rrc Cs0|dk r |n|jj}|j|||||||d}|S)a Returns: Example: ```python >>> from transformers import AutoTokenizer, T5EncoderModel >>> tokenizer = AutoTokenizer.from_pretrained("t5-small") >>> model = T5EncoderModel.from_pretrained("t5-small") >>> input_ids = tokenizer( ... "Studies have been shown that owning a dog is good for you", return_tensors="pt" ... ).input_ids # Batch size 1 >>> outputs = model(input_ids=input_ids) >>> last_hidden_states = outputs.last_hidden_state ```Nrd)rYr@rP) rirrrCr3rr?rrbr#r#r&rts zT5EncoderModel.forward)N)NNNNNNN)rvrwrxrmrlr!rerrFr*rGr-r0r2rYr^rT5_ENCODER_INPUTS_DOCSTRINGrr rorrTrprqrrrrtryr#r#rlr&rGs<   rz T5 model with a sequence classification/head on top (a linear layer on top of the pooled output) e.g. for GLUE tasks. cseZdZdgZddgZedfdd Zeee e e dd e j ee jee j ee j ee jee jee jeee jee jee jee j eeeeeeeeeee fd d d ZZS) T5ForSequenceClassificationrHrIrJr|cs2t|t||_t||_|d|_dSr)rdrerrrclassification_headrrrrlr#r&res    z$T5ForSequenceClassification.__init__r_N)rrrrrCrarDrbr3rcrwrrr?rrcCsx|dk r |n|jj}| dk r d} |dkrB| dk rBtd|jj|dkrl| dkrl|dkrbtd||}|j||||||||| | | | ||d}|d}||jj  |j }t t |ddkrtd|j\}}}||ddf|d |ddd ddf}||}d}| dk r | |j } |jjdkr|jjdkrRd |j_n<|jjdkr| jt jks|| jt jkrd |j_nd |j_|jjd krt}|jjdkr||| }n ||| }nP|jjd krt}||d |jj| d }n|jjd kr t}||| }|sP|f|dd}|dk rL|f|S|St|||j|j|j|j |j!|j"|j#d S)aD 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). Returns: NFz8Passing input embeddings is currently not supported for If 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`.) rrrrCrarDrbr3rcrrr?rrr z7All examples must have the same number of tokens.r(Z regressionZsingle_label_classificationZmulti_label_classificationry)$rYr@NotImplementedErrorrmrvrQrreqZ eos_token_idrnrrKrTZunique_consecutivesumrOrrZ problem_typerrqrrNr squeezerrrr;rgrhr=rirrj)rirrrrrCrarDrbr3rcrwrrr?rrr{Zeos_maskrrErjZsentence_representationr4rzr|r}r#r#r&rts   ,    *   z#T5ForSequenceClassification.forward)NNNNNNNNNNNNNNN)rvrwrxrlrmr!rerrnrrrorTrprrrrqrrrrtryr#r#rlr&rsL    rz T5 Model with a span classification head on top for extractive question-answering tasks like SQuAD (linear layers on top of the hidden-states output to compute `span start logits` and `span end logits`). cseZdZdgZddgZedfdd ZddZd d Zd d Z d dZ e e e eeddeejeejeejeejeejeejeejeeeejeejeejeejeejeeeeeeeeeeejefdddZZS)rrHrIrJr|cst||j|_t|j|j|_t |}d|_ d|_ d|_ t ||j|_t |}d|_ d|_ |j|_t ||j|_|j|_t|j|j|_|d|_dSrK)rdrerrsrrrLrrMrNrrrOr rPrQrr3rrrjrrrrRrlr#r&reJs"   zT5ForQuestionAnswering.__init__cCs|jSrrVr/r#r#r&r0dsz+T5ForQuestionAnswering.get_input_embeddingscCs"||_|j||j|dSrrWr1r#r#r&r2gs z+T5ForQuestionAnswering.set_input_embeddingscCs|jSrrXr/r#r#r&rYlsz"T5ForQuestionAnswering.get_encodercCs|jSrrZr/r#r#r&r[osz"T5ForQuestionAnswering.get_decoderr_N)rrrrrCrarDrbstart_positions end_positionsr3rcrrr?rrcCs|dk r |n|jj}| dk r | n|jj} | dk r<| dk rr!typingrrrrrTrZtorch.nnrrr Ztorch.utils.checkpointr Z activationsr Zmodeling_outputsr rrrrrZmodeling_utilsrZ pytorch_utilsrrrutilsrrrrrrrZutils.model_parallel_utilsrrZconfiguration_t5r!Z get_loggerrvr<roZ_CHECKPOINT_FOR_DOCZ T5_PRETRAINED_MODEL_ARCHIVE_LISTrarFrGModulerbZapex.normalizationrzrAr; ExceptionrrCr{rrrrrrrrr ZT5_START_DOCSTRINGrnrZ__HEAD_MASK_WARNING_MSGrrrrrr#r#r#r&s     $   n!   l $|r]&H4o~