


import unittest

from transformers import SPIECE_UNDERLINE, XLNetTokenizer, XLNetTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


snake_case							: Any      =   get_tests_dir('''fixtures/test_sentencepiece.model''')







@require_sentencepiece
@require_tokenizers
class  snake_case_     (lowerCamelCase_			,		unittest.TestCase   ):
					UpperCAmelCase__      :					int					   =    XLNetTokenizer
					UpperCAmelCase__      :					Optional[Any]					   =    XLNetTokenizerFast
					UpperCAmelCase__      :					int					   =    True
					UpperCAmelCase__      :					int					   =    True
					def 				lowerCamelCase__(   self     :Optional[int]   )      ->					Dict:
												super().setUp()

												# We have a SentencePiece fixture for testing
												a__    =  XLNetTokenizer(__snake_case    ,keep_accents=__snake_case   )
												tokenizer.sanitize_special_tokens()
												tokenizer.save_pretrained(self.tmpdirname   )
					def 				lowerCamelCase__(   self     :Union[str, Any]   )      ->					Optional[int]:
												a__    =  '<s>'
												a__    =  1

												self.assertEqual(self.get_tokenizer()._convert_token_to_id(__snake_case   )    ,__snake_case   )
												self.assertEqual(self.get_tokenizer()._convert_id_to_token(__snake_case   )    ,__snake_case   )
					def 				lowerCamelCase__(   self     :Union[str, Any]   )      ->					List[Any]:
												a__    =  list(self.get_tokenizer().get_vocab().keys()   )

												self.assertEqual(vocab_keys[0]    ,'<unk>'   )
												self.assertEqual(vocab_keys[1]    ,'<s>'   )
												self.assertEqual(vocab_keys[-1]    ,'<eod>'   )
												self.assertEqual(len(__snake_case   )    ,10_06   )
					def 				lowerCamelCase__(   self     :List[Any]   )      ->					int:
												self.assertEqual(self.get_tokenizer().vocab_size    ,10_00   )
					def 				lowerCamelCase__(   self     :List[Any]   )      ->					List[Any]:
												a__    =  XLNetTokenizer(__snake_case    ,keep_accents=__snake_case   )

												a__    =  tokenizer.tokenize('This is a test'   )
												self.assertListEqual(__snake_case    ,['▁This', '▁is', '▁a', '▁t', 'est']   )

												self.assertListEqual(tokenizer.convert_tokens_to_ids(__snake_case   )    ,[2_85, 46, 10, 1_70, 3_82]   )

												a__    =  tokenizer.tokenize('I was born in 92000, and this is falsé.'   )
												self.assertListEqual(
												    __snake_case    ,[
												        SPIECE_UNDERLINE + 'I',
												        SPIECE_UNDERLINE + 'was',
												        SPIECE_UNDERLINE + 'b',
												        'or',
												        'n',
												        SPIECE_UNDERLINE + 'in',
												        SPIECE_UNDERLINE + '',
												        '9',
												        '2',
												        '0',
												        '0',
												        '0',
												        ',',
												        SPIECE_UNDERLINE + 'and',
												        SPIECE_UNDERLINE + 'this',
												        SPIECE_UNDERLINE + 'is',
												        SPIECE_UNDERLINE + 'f',
												        'al',
												        's',
												        'é',
												        '.',
												    ]    ,)
												a__    =  tokenizer.convert_tokens_to_ids(__snake_case   )
												self.assertListEqual(__snake_case    ,[8, 21, 84, 55, 24, 19, 7, 0, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 0, 4]   )

												a__    =  tokenizer.convert_ids_to_tokens(__snake_case   )
												self.assertListEqual(
												    __snake_case    ,[
												        SPIECE_UNDERLINE + 'I',
												        SPIECE_UNDERLINE + 'was',
												        SPIECE_UNDERLINE + 'b',
												        'or',
												        'n',
												        SPIECE_UNDERLINE + 'in',
												        SPIECE_UNDERLINE + '',
												        '<unk>',
												        '2',
												        '0',
												        '0',
												        '0',
												        ',',
												        SPIECE_UNDERLINE + 'and',
												        SPIECE_UNDERLINE + 'this',
												        SPIECE_UNDERLINE + 'is',
												        SPIECE_UNDERLINE + 'f',
												        'al',
												        's',
												        '<unk>',
												        '.',
												    ]    ,)
					def 				lowerCamelCase__(   self     :Optional[int]   )      ->					List[Any]:
												a__    =  XLNetTokenizer(__snake_case    ,do_lower_case=__snake_case   )
												a__    =  tokenizer.tokenize('I was born in 92000, and this is falsé.'   )
												self.assertListEqual(
												    __snake_case    ,[
												        SPIECE_UNDERLINE + '',
												        'i',
												        SPIECE_UNDERLINE + 'was',
												        SPIECE_UNDERLINE + 'b',
												        'or',
												        'n',
												        SPIECE_UNDERLINE + 'in',
												        SPIECE_UNDERLINE + '',
												        '9',
												        '2',
												        '0',
												        '0',
												        '0',
												        ',',
												        SPIECE_UNDERLINE + 'and',
												        SPIECE_UNDERLINE + 'this',
												        SPIECE_UNDERLINE + 'is',
												        SPIECE_UNDERLINE + 'f',
												        'al',
												        'se',
												        '.',
												    ]    ,)
												self.assertListEqual(tokenizer.tokenize('H\u00E9llo'   )    ,['▁he', 'll', 'o']   )
					def 				lowerCamelCase__(   self     :int   )      ->					List[Any]:
												a__    =  XLNetTokenizer(__snake_case    ,do_lower_case=__snake_case   )
												a__    =  tokenizer.tokenize('I was born in 92000, and this is falsé.'   )
												self.assertListEqual(
												    __snake_case    ,[
												        SPIECE_UNDERLINE + 'I',
												        SPIECE_UNDERLINE + 'was',
												        SPIECE_UNDERLINE + 'b',
												        'or',
												        'n',
												        SPIECE_UNDERLINE + 'in',
												        SPIECE_UNDERLINE + '',
												        '9',
												        '2',
												        '0',
												        '0',
												        '0',
												        ',',
												        SPIECE_UNDERLINE + 'and',
												        SPIECE_UNDERLINE + 'this',
												        SPIECE_UNDERLINE + 'is',
												        SPIECE_UNDERLINE + 'f',
												        'al',
												        'se',
												        '.',
												    ]    ,)
					@slow
					def 				lowerCamelCase__(   self     :Optional[Any]   )      ->					str:
												a__    =  XLNetTokenizer.from_pretrained('xlnet-base-cased'   )

												a__    =  tokenizer.encode('sequence builders'    ,add_special_tokens=__snake_case   )
												a__    =  tokenizer.encode('multi-sequence build'    ,add_special_tokens=__snake_case   )

												a__    =  tokenizer.build_inputs_with_special_tokens(__snake_case   )
												a__    =  tokenizer.build_inputs_with_special_tokens(__snake_case    ,__snake_case   )

												assert encoded_sentence == text + [4, 3]
												assert encoded_pair == text + [4] + text_a + [4, 3]



					@slow
					def 				lowerCamelCase__(   self     :Any   )      ->					Optional[int]:
												# fmt: off
												a__    =  {'input_ids': [[17, 2_14_42, 2_70, 17, 10, 1_46_45, 3_18, 34, 17, 45_46, 31_45, 7_87, 13, 77_52, 2_20_18, 23, 21, 17, 45_46, 31_45, 7_87, 13, 33_52, 1_44_31, 13, 55_00, 11, 11_76, 5_80, 13, 1_68_19, 47_97, 23, 17, 10, 1_71_35, 6_58, 19, 4_57, 79_32, 13, 1_84, 19, 31_54, 1_71_35, 64_68, 19, 14_04, 1_22_69, 19, 42_29, 53_56, 1_62_64, 46, 19, 17, 2_05_45, 1_03_95, 9, 9, 9, 11, 28, 64_21, 95_31, 2_07_29, 17, 10, 3_53, 1_70_22, 11, 21, 64_21, 95_31, 1_69_49, 17, 10, 1_15_09, 7_53, 11, 33, 95, 24_21, 73_85, 9_56, 1_44_31, 26_26, 25, 8_42, 73_85, 48_36, 21, 14_29, 22_72, 98_55, 31_20, 1_61, 2_47_38, 19, 1_32_03, 6_58, 2_18, 7_87, 21, 4_30, 1_84_82, 8_47, 26_37, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_22, 2_21_78, 27, 10_64, 22, 9_56, 13, 1_11_01, 14_29, 58_54, 2_43_13, 1_89_53, 40, 4_22, 2_43_66, 68, 17_58, 37, 1_04_83, 1_42_57, 31, 2_07, 2_63, 21, 2_03, 37_73, 25, 71, 97_35, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 32, 20_49, 34_42, 17, 1_38_94, 33_80, 23, 95, 18, 1_76_34, 22_88, 9, 4, 3]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
												# fmt: on

												self.tokenizer_integration_test_util(
												    expected_encoding=__snake_case    ,model_name='xlnet-base-cased'    ,revision='c841166438c31ec7ca9a106dee7bb312b73ae511'    ,)








from typing import Any, Dict, List, Optional, Tuple, Union

import torch
from torch import nn
from torch.utils.data import DistributedSampler, RandomSampler

from transformers import PreTrainedModel, Trainer, logging
from transformers.integrations import is_fairscale_available
from transformers.models.fsmt.configuration_fsmt import FSMTConfig
from transformers.optimization import (
    Adafactor,
    AdamW,
    get_constant_schedule,
    get_constant_schedule_with_warmup,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.trainer_pt_utils import get_tpu_sampler
from transformers.training_args import ParallelMode
from transformers.utils import is_torch_tpu_available


if is_fairscale_available():
						from fairscale.optim import OSS


snake_case							: Any      =   logging.get_logger(__name__)

snake_case							: Tuple      =   {
    '''linear''': get_linear_schedule_with_warmup,
    '''cosine''': get_cosine_schedule_with_warmup,
    '''cosine_w_restarts''': get_cosine_with_hard_restarts_schedule_with_warmup,
    '''polynomial''': get_polynomial_decay_schedule_with_warmup,
    '''constant''': get_constant_schedule,
    '''constant_w_warmup''': get_constant_schedule_with_warmup,
}







class  snake_case_     (lowerCamelCase_   ):
					def __init__(   self     :str    ,__snake_case     :Dict=None    ,__snake_case     :int=None    ,*__snake_case     :str    ,**__snake_case     :Union[str, Any]   )      ->					Tuple:
												super().__init__(*__snake_case    ,**__snake_case   )

												if config is None:
																			assert isinstance(self.model    ,__snake_case   ), (
																			    "If no `config` is passed the model to be trained has to be of type `PreTrainedModel`, but is"
																			    F' {self.model.__class__}'
																			)
																			a__    =  self.model.config
												else:
																			a__    =  config

												a__    =  data_args
												a__    =  self.config.tgt_vocab_size if isinstance(self.config    ,__snake_case   ) else self.config.vocab_size

												if self.args.label_smoothing != 0 or (self.data_args is not None and self.data_args.ignore_pad_token_for_loss):
																			assert self.config.pad_token_id is not None, (
																			    "Make sure that `config.pad_token_id` is correcly defined when ignoring `pad_token` for loss"
																			    " calculation or doing label smoothing."
																			)

												if self.config.pad_token_id is None and self.config.eos_token_id is not None:
																			logger.warning(
																			    F'The `config.pad_token_id` is `None`. Using `config.eos_token_id` = {self.config.eos_token_id} for'
																			    ' padding..'   )

												if self.args.label_smoothing == 0:
																			a__    =  torch.nn.CrossEntropyLoss(ignore_index=self.config.pad_token_id   )
												else:
																			# dynamically import label_smoothed_nll_loss
																			from utils import label_smoothed_nll_loss

																			a__    =  label_smoothed_nll_loss
					def 				lowerCamelCase__(   self     :Optional[Any]    ,__snake_case     :int   )      ->					Tuple:
												if self.optimizer is None:
																			a__    =  ['bias', 'LayerNorm.weight']
																			a__    =  [
																			    {
																			        'params': [p for n, p in self.model.named_parameters() if not any(nd in n for nd in no_decay   )],
																			        'weight_decay': self.args.weight_decay,
																			    },
																			    {
																			        'params': [p for n, p in self.model.named_parameters() if any(nd in n for nd in no_decay   )],
																			        'weight_decay': 0.0,
																			    },
																			]
																			a__    =  Adafactor if self.args.adafactor else AdamW
																			if self.args.adafactor:
																										a__    =  Adafactor
																										a__    =  {'scale_parameter': False, 'relative_step': False}
																			else:
																										a__    =  AdamW
																										a__    =  {
																										    'betas': (self.args.adam_betaa, self.args.adam_betaa),
																										    'eps': self.args.adam_epsilon,
																										}
																			a__    =  self.args.learning_rate
																			if self.sharded_ddp:
																										a__    =  OSS(
																										    params=__snake_case    ,optim=__snake_case    ,**__snake_case    ,)
																			else:
																										a__    =  optimizer_cls(__snake_case    ,**__snake_case   )

												if self.lr_scheduler is None:
																			a__    =  self._get_lr_scheduler(__snake_case   )
												else:  # ignoring --lr_scheduler
																			logger.warning('scheduler is passed to `Seq2SeqTrainer`, `--lr_scheduler` arg is ignored.'   )
					def 				lowerCamelCase__(   self     :Dict    ,__snake_case     :List[str]   )      ->					Union[str, Any]:
												a__    =  arg_to_scheduler[self.args.lr_scheduler]
												if self.args.lr_scheduler == "constant":
																			a__    =  schedule_func(self.optimizer   )
												elif self.args.lr_scheduler == "constant_w_warmup":
																			a__    =  schedule_func(self.optimizer    ,num_warmup_steps=self.args.warmup_steps   )
												else:
																			a__    =  schedule_func(
																			    self.optimizer    ,num_warmup_steps=self.args.warmup_steps    ,num_training_steps=__snake_case   )
												return scheduler
					def 				lowerCamelCase__(   self     :Optional[Any]   )      ->					Optional[torch.utils.data.Sampler]:
												if isinstance(self.train_dataset    ,torch.utils.data.IterableDataset   ):
																			return None
												elif is_torch_tpu_available():
																			return get_tpu_sampler(self.train_dataset   )
												else:
																			if self.args.sortish_sampler:
																										self.train_dataset.make_sortish_sampler(
																										    self.args.per_device_train_batch_size    ,distributed=(self.args.parallel_mode == ParallelMode.DISTRIBUTED)    ,)

																			return (
																			    RandomSampler(self.train_dataset   )
																			    if self.args.local_rank == -1
																			    else DistributedSampler(self.train_dataset   )
																			)
					def 				lowerCamelCase__(   self     :str    ,__snake_case     :Optional[int]    ,__snake_case     :List[Any]    ,__snake_case     :Any   )      ->					Optional[Any]:
												if self.args.label_smoothing == 0:
																			if self.data_args is not None and self.data_args.ignore_pad_token_for_loss:
																										# force training to ignore pad token
																										a__    =  model(**__snake_case    ,use_cache=__snake_case   )[0]
																										a__    =  self.loss_fn(logits.view(-1    ,logits.shape[-1]   )    ,labels.view(-1   )   )
																			else:
																										# compute usual loss via models
																										a__   ,      a__    =  model(**__snake_case    ,labels=__snake_case    ,use_cache=__snake_case   )[:2]
												else:
																			# compute label smoothed loss
																			a__    =  model(**__snake_case    ,use_cache=__snake_case   )[0]
																			a__    =  torch.nn.functional.log_softmax(__snake_case    ,dim=-1   )
																			a__   ,      a__    =  self.loss_fn(__snake_case    ,__snake_case    ,self.args.label_smoothing    ,ignore_index=self.config.pad_token_id   )
												return loss, logits
					def 				lowerCamelCase__(   self     :List[Any]    ,__snake_case     :Dict    ,__snake_case     :Optional[int]   )      ->					Any:
												a__    =  inputs.pop('labels'   )
												a__   ,      a__    =  self._compute_loss(__snake_case    ,__snake_case    ,__snake_case   )
												return loss
					def 				lowerCamelCase__(   self     :Optional[Any]    ,__snake_case     :nn.Module    ,__snake_case     :Dict[str, Union[torch.Tensor, Any]]    ,__snake_case     :bool    ,__snake_case     :Optional[List[str]] = None    ,)      ->					Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]:
												a__    =  self._prepare_inputs(__snake_case   )

												a__    =  {
												    'max_length': self.data_args.val_max_target_length
												    if self.data_args is not None
												    else self.config.max_length,
												    'num_beams': self.data_args.eval_beams if self.data_args is not None else self.config.num_beams,
												}

												if self.args.predict_with_generate and not self.args.prediction_loss_only:
																			a__    =  self.model.generate(
																			    inputs['input_ids']    ,attention_mask=inputs['attention_mask']    ,**__snake_case    ,)
																			# in case the batch is shorter than max length, the output should be padded
																			if generated_tokens.shape[-1] < gen_kwargs["max_length"]:
																										a__    =  self._pad_tensors_to_max_len(__snake_case    ,gen_kwargs['max_length']   )

												a__    =  inputs.pop('labels'   )
												with torch.no_grad():
																			# compute loss on predict data
																			a__   ,      a__    =  self._compute_loss(__snake_case    ,__snake_case    ,__snake_case   )

												a__    =  loss.mean().detach()
												if self.args.prediction_loss_only:
																			return (loss, None, None)

												a__    =  generated_tokens if self.args.predict_with_generate else logits

												if labels.shape[-1] < gen_kwargs["max_length"]:
																			a__    =  self._pad_tensors_to_max_len(__snake_case    ,gen_kwargs['max_length']   )

												return (loss, logits, labels)



					def 				lowerCamelCase__(   self     :List[str]    ,__snake_case     :Optional[Any]    ,__snake_case     :Union[str, Any]   )      ->					int:
												# If PAD token is not defined at least EOS token has to be defined
												a__    =  self.config.pad_token_id if self.config.pad_token_id is not None else self.config.eos_token_id

												if pad_token_id is None:
																			raise ValueError(
																			    'Make sure that either `config.pad_token_id` or `config.eos_token_id` is defined if tensor has to be'
																			    F' padded to `max_length`={max_length}'   )

												a__    =  pad_token_id * torch.ones(
												    (tensor.shape[0], max_length)    ,dtype=tensor.dtype    ,device=tensor.device   )
												a__    =  tensor
												return padded_tensor




