






import unittest

import numpy as np

from transformers import MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING, TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
from transformers.pipelines import AudioClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_torchaudio,
    slow,
)

from .test_pipelines_common import ANY


@is_pipeline_test
class 							__UpperCamelCase     (  unittest.TestCase ):
	__snake_case						:Any =							MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
	__snake_case						:Tuple =							TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING







	def 			_a (	self   :				Optional[Any]							,					_lowerCAmelCase   :				Any							,					_lowerCAmelCase   :				Tuple							,					_lowerCAmelCase   :				int      )		->			Any:
		"""simple docstring"""







		__lowercase   							=	AudioClassificationPipeline(model=_lowerCAmelCase							,					feature_extractor=_lowerCAmelCase      )

		# test with a raw waveform
		__lowercase   							=	np.zeros((3_4000,)      )
		__lowercase   							=	np.zeros((1_4000,)      )
		return audio_classifier, [audioa, audio]







	def 			_a (	self   :				str							,					_lowerCAmelCase   :				Tuple							,					_lowerCAmelCase   :				Union[str, Any]      )		->			Dict:
		"""simple docstring"""







		__lowercase							,    __lowercase   							=	examples
		__lowercase   							=	audio_classifier(_lowerCAmelCase      )
		# by default a model is initialized with num_labels=2
		self.assertEqual(
		    _lowerCAmelCase							,					[
		        {"""score""": ANY(_lowerCAmelCase      ), """label""": ANY(_lowerCAmelCase      )},
		        {"""score""": ANY(_lowerCAmelCase      ), """label""": ANY(_lowerCAmelCase      )},
		    ]							,					)
		__lowercase   							=	audio_classifier(_lowerCAmelCase							,					top_k=1      )
		self.assertEqual(
		    _lowerCAmelCase							,					[
		        {"""score""": ANY(_lowerCAmelCase      ), """label""": ANY(_lowerCAmelCase      )},
		    ]							,					)

		self.run_torchaudio(_lowerCAmelCase      )







	@require_torchaudio
	def 			_a (	self   :				Union[str, Any]							,					_lowerCAmelCase   :				List[str]      )		->			Optional[Any]:
		"""simple docstring"""







		import datasets

		# test with a local file
		__lowercase   							=	datasets.load_dataset("""hf-internal-testing/librispeech_asr_dummy"""							,					"""clean"""							,					split="""validation"""      )
		__lowercase   							=	dataset[0]["""audio"""]["""array"""]
		__lowercase   							=	audio_classifier(_lowerCAmelCase      )
		self.assertEqual(
		    _lowerCAmelCase							,					[
		        {"""score""": ANY(_lowerCAmelCase      ), """label""": ANY(_lowerCAmelCase      )},
		        {"""score""": ANY(_lowerCAmelCase      ), """label""": ANY(_lowerCAmelCase      )},
		    ]							,					)







	@require_torch
	def 			_a (	self   :				Optional[Any]      )		->			Dict:
		"""simple docstring"""







		__lowercase   							=	"""anton-l/wav2vec2-random-tiny-classifier"""

		__lowercase   							=	pipeline("""audio-classification"""							,					model=_lowerCAmelCase      )

		__lowercase   							=	np.ones((8000,)      )
		__lowercase   							=	audio_classifier(_lowerCAmelCase							,					top_k=4      )

		__lowercase   							=	[
		    {"""score""": 0.0_842, """label""": """no"""},
		    {"""score""": 0.0_838, """label""": """up"""},
		    {"""score""": 0.0_837, """label""": """go"""},
		    {"""score""": 0.0_834, """label""": """right"""},
		]
		__lowercase   							=	[
		    {"""score""": 0.0_845, """label""": """stop"""},
		    {"""score""": 0.0_844, """label""": """on"""},
		    {"""score""": 0.0_841, """label""": """right"""},
		    {"""score""": 0.0_834, """label""": """left"""},
		]
		self.assertIn(nested_simplify(_lowerCAmelCase							,					decimals=4      )							,					[EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]      )

		__lowercase   							=	{"""array""": np.ones((8000,)      ), """sampling_rate""": audio_classifier.feature_extractor.sampling_rate}
		__lowercase   							=	audio_classifier(_lowerCAmelCase							,					top_k=4      )
		self.assertIn(nested_simplify(_lowerCAmelCase							,					decimals=4      )							,					[EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]      )







	@require_torch
	@slow
	def 			_a (	self   :				str      )		->			Union[str, Any]:
		"""simple docstring"""







		import datasets

		__lowercase   							=	"""superb/wav2vec2-base-superb-ks"""

		__lowercase   							=	pipeline("""audio-classification"""							,					model=_lowerCAmelCase      )
		__lowercase   							=	datasets.load_dataset("""anton-l/superb_dummy"""							,					"""ks"""							,					split="""test"""      )

		__lowercase   							=	np.array(dataset[3]["""speech"""]							,					dtype=np.floataa      )
		__lowercase   							=	audio_classifier(_lowerCAmelCase							,					top_k=4      )
		self.assertEqual(
		    nested_simplify(_lowerCAmelCase							,					decimals=3      )							,					[
		        {"""score""": 0.981, """label""": """go"""},
		        {"""score""": 0.007, """label""": """up"""},
		        {"""score""": 0.006, """label""": """_unknown_"""},
		        {"""score""": 0.001, """label""": """down"""},
		    ]							,					)







	@require_tf
	@unittest.skip("""Audio classification is not implemented for TF"""      )
	def 			_a (	self   :				Union[str, Any]      )		->			Dict:
		"""simple docstring"""







		pass





'''simple docstring'''





import tempfile
import unittest

from transformers import TaConfig, is_torch_available
from transformers.testing_utils import (
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
    torch_device,
)

from ...generation.test_utils import GenerationTesterMixin
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import AutoTokenizer, UMTaForConditionalGeneration, UMTaForQuestionAnswering, UMTaModel




class 				UpperCAmelCase			:


 def __init__(      self							:	Tuple			,       __lowerCamelCase							:	List[str]			,       __lowerCamelCase							:	Tuple=9_9			,       __lowerCamelCase							:	int=1_3			,       __lowerCamelCase							:	List[str]=7			,       __lowerCamelCase							:	Dict=9			,       __lowerCamelCase							:	List[Any]=True			,       __lowerCamelCase							:	Tuple=True			,       __lowerCamelCase							:	List[str]=False			,       __lowerCamelCase							:	List[Any]=3_2			,       __lowerCamelCase							:	int=5			,       __lowerCamelCase							:	Optional[Any]=4			,       __lowerCamelCase							:	Tuple=3_7			,       __lowerCamelCase							:	Any=8			,       __lowerCamelCase							:	Any=0.1			,       __lowerCamelCase							:	Any=0.0_02			,       __lowerCamelCase							:	List[str]=1			,       __lowerCamelCase							:	str=0			,       __lowerCamelCase							:	str=0			,       __lowerCamelCase							:	str=None			,       __lowerCamelCase							:	List[Any]=None			,       ):
    UpperCAmelCase__	:Tuple      =      parent
    UpperCAmelCase__	:str      =      batch_size
    UpperCAmelCase__	:int      =      encoder_seq_length
    UpperCAmelCase__	:Optional[int]      =      decoder_seq_length
    # For common tests
    UpperCAmelCase__	:int      =      self.decoder_seq_length
    UpperCAmelCase__	:List[Any]      =      is_training
    UpperCAmelCase__	:Any      =      use_attention_mask
    UpperCAmelCase__	:Tuple      =      use_labels
    UpperCAmelCase__	:Optional[int]      =      vocab_size
    UpperCAmelCase__	:Optional[Any]      =      hidden_size
    UpperCAmelCase__	:Optional[Any]      =      num_hidden_layers
    UpperCAmelCase__	:Tuple      =      num_attention_heads
    UpperCAmelCase__	:str      =      d_ff
    UpperCAmelCase__	:Tuple      =      relative_attention_num_buckets
    UpperCAmelCase__	:int      =      dropout_rate
    UpperCAmelCase__	:Dict      =      initializer_factor
    UpperCAmelCase__	:int      =      eos_token_id
    UpperCAmelCase__	:Tuple      =      pad_token_id
    UpperCAmelCase__	:Tuple      =      decoder_start_token_id
    UpperCAmelCase__	:List[str]      =      None
    UpperCAmelCase__	:List[str]      =      decoder_layers


 def        __SCREAMING_SNAKE_CASE					(      self							:	Union[str, Any] ):
    return TaConfig.from_pretrained('''google/umt5-base''' )


 def        __SCREAMING_SNAKE_CASE					(      self							:	Optional[Any]			,       __lowerCamelCase							:	Dict			,       __lowerCamelCase							:	Optional[Any]			,       __lowerCamelCase							:	Optional[int]			,       __lowerCamelCase							:	Optional[Any]=None			,       __lowerCamelCase							:	Dict=None			,       __lowerCamelCase							:	Union[str, Any]=None			,       __lowerCamelCase							:	Optional[int]=None			,       __lowerCamelCase							:	List[Any]=None			,       ):
    if attention_mask is None:
       UpperCAmelCase__	:Optional[Any]      =      input_ids.ne(config.pad_token_id )
    if decoder_attention_mask is None:
       UpperCAmelCase__	:Any      =      decoder_input_ids.ne(config.pad_token_id )
    if head_mask is None:
       UpperCAmelCase__	:List[str]      =      torch.ones(config.num_hidden_layers			,       config.num_attention_heads			,       device=__lowerCamelCase )
    if decoder_head_mask is None:
       UpperCAmelCase__	:Optional[Any]      =      torch.ones(config.num_decoder_layers			,       config.num_attention_heads			,       device=__lowerCamelCase )
    if cross_attn_head_mask is None:
       UpperCAmelCase__	:List[Any]      =      torch.ones(
           config.num_decoder_layers			,       config.num_attention_heads			,       device=__lowerCamelCase )
    return {
        "input_ids": input_ids,
        "decoder_input_ids": decoder_input_ids,
        "attention_mask": attention_mask,
        "decoder_attention_mask": decoder_attention_mask,
        "head_mask": head_mask,
        "decoder_head_mask": decoder_head_mask,
        "cross_attn_head_mask": cross_attn_head_mask,
    }


 def        __SCREAMING_SNAKE_CASE					(      self							:	List[str] ):
    UpperCAmelCase__	:Optional[int]      =      ids_tensor([self.batch_size, self.encoder_seq_length]			,       self.vocab_size )
    UpperCAmelCase__	:List[Any]      =      ids_tensor([self.batch_size, self.decoder_seq_length]			,       self.vocab_size )

    # we need to clamp the input ids here to avoid having pad token in between
    # this is because for NllbMoe the position_ids are prepared such that
    # all pad tokens have pos id = 2 and rest are between 2..seq_length
    # and the seq_length here is seq_length - num_pad_tokens
    # but when using past, there is no way of knowing if the past input ids had
    # pad tokens in them, which results in incorrect seq_lenth and which in turn results in
    # position_ids being off by num_pad_tokens in past input
    UpperCAmelCase__	:int      =      input_ids.clamp(self.pad_token_id + 1 )
    UpperCAmelCase__	:Tuple      =      decoder_input_ids.clamp(self.pad_token_id + 1 )

    UpperCAmelCase__	:Dict      =      self.get_config()
    UpperCAmelCase__	:Union[str, Any]      =      config.num_attention_heads
    UpperCAmelCase__	:Dict      =      self.prepare_inputs_dict(__lowerCamelCase			,       __lowerCamelCase			,       __lowerCamelCase )
    return config, input_dict


 def        __SCREAMING_SNAKE_CASE					(      self							:	Optional[int] ):
    UpperCAmelCase__   ,						UpperCAmelCase__	:int      =      self.prepare_config_and_inputs()
    return config, inputs_dict


 def        __SCREAMING_SNAKE_CASE					(      self							:	Optional[int] ):
    return TaConfig(
        vocab_size=1_6_6			,       d_model=self.hidden_size			,       d_ff=self.d_ff			,       d_kv=self.hidden_size // self.num_attention_heads			,       num_layers=self.num_hidden_layers			,       num_decoder_layers=self.decoder_layers			,       num_heads=self.num_attention_heads			,       relative_attention_num_buckets=self.relative_attention_num_buckets			,       dropout_rate=self.dropout_rate			,       initializer_factor=self.initializer_factor			,       eos_token_id=self.eos_token_id			,       bos_token_id=self.pad_token_id			,       pad_token_id=self.pad_token_id			,       decoder_start_token_id=self.decoder_start_token_id			,       )


 def        __SCREAMING_SNAKE_CASE					(      self							:	Optional[Any] ):
    return TaConfig(
        vocab_size=self.vocab_size			,       d_model=self.hidden_size			,       d_ff=self.d_ff			,       d_kv=self.hidden_size // self.num_attention_heads			,       num_layers=self.num_hidden_layers			,       num_decoder_layers=self.decoder_layers			,       num_heads=self.num_attention_heads			,       relative_attention_num_buckets=self.relative_attention_num_buckets			,       dropout_rate=self.dropout_rate			,       initializer_factor=self.initializer_factor			,       eos_token_id=self.eos_token_id			,       bos_token_id=self.pad_token_id			,       pad_token_id=self.pad_token_id			,       decoder_start_token_id=self.decoder_start_token_id			,       )


 def        __SCREAMING_SNAKE_CASE					(      self							:	Tuple			,       __lowerCamelCase							:	Union[str, Any]			,       __lowerCamelCase							:	List[Any]			,       __lowerCamelCase							:	Optional[int]			,       __lowerCamelCase							:	List[str]			,       __lowerCamelCase							:	Dict			,       __lowerCamelCase							:	List[Any]			,       ):
    UpperCAmelCase__	:str      =      UMTaModel(config=__lowerCamelCase )
    model.to(__lowerCamelCase )
    model.eval()
    UpperCAmelCase__	:Optional[int]      =      model(
        input_ids=__lowerCamelCase			,       decoder_input_ids=__lowerCamelCase			,       attention_mask=__lowerCamelCase			,       decoder_attention_mask=__lowerCamelCase			,       )
    UpperCAmelCase__	:List[Any]      =      model(input_ids=__lowerCamelCase			,       decoder_input_ids=__lowerCamelCase )
    UpperCAmelCase__	:Dict      =      result.last_hidden_state
    UpperCAmelCase__	:Tuple      =      result.past_key_values
    UpperCAmelCase__	:Dict      =      result.encoder_last_hidden_state

    self.parent.assertEqual(encoder_output.size()			,       (self.batch_size, self.encoder_seq_length, self.hidden_size) )
    self.parent.assertEqual(decoder_output.size()			,       (self.batch_size, self.decoder_seq_length, self.hidden_size) )
    # There should be `num_layers` key value embeddings stored in decoder_past
    self.parent.assertEqual(len(__lowerCamelCase )			,       config.num_layers )
    # There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple
    self.parent.assertEqual(len(decoder_past[0] )			,       4 )


 def        __SCREAMING_SNAKE_CASE					(      self							:	List[Any]			,       __lowerCamelCase							:	int			,       __lowerCamelCase							:	Dict			,       __lowerCamelCase							:	List[Any]			,       __lowerCamelCase							:	Optional[int]			,       __lowerCamelCase							:	Union[str, Any]			,       __lowerCamelCase							:	List[str]			,       ):
    UpperCAmelCase__	:Tuple      =      UMTaModel(config=__lowerCamelCase ).get_decoder().to(__lowerCamelCase ).eval()
    # first forward pass
    UpperCAmelCase__	:Dict      =      model(__lowerCamelCase			,       use_cache=__lowerCamelCase )
    UpperCAmelCase__	:Any      =      model(__lowerCamelCase )
    UpperCAmelCase__	:List[str]      =      model(__lowerCamelCase			,       use_cache=__lowerCamelCase )

    self.parent.assertTrue(len(__lowerCamelCase ) == len(__lowerCamelCase ) )
    self.parent.assertTrue(len(__lowerCamelCase ) == len(__lowerCamelCase ) + 1 )

    UpperCAmelCase__   ,						UpperCAmelCase__	:int      =      outputs.to_tuple()

    # create hypothetical next token and extent to next_input_ids
    UpperCAmelCase__	:int      =      ids_tensor((self.batch_size, 1)			,       config.vocab_size )

    # append to next input_ids and
    UpperCAmelCase__	:Union[str, Any]      =      torch.cat([input_ids, next_tokens]			,       dim=-1 )

    UpperCAmelCase__	:Union[str, Any]      =      model(__lowerCamelCase )['''last_hidden_state''']
    UpperCAmelCase__	:str      =      model(__lowerCamelCase			,       past_key_values=__lowerCamelCase )['''last_hidden_state''']

    # select random slice
    UpperCAmelCase__	:Tuple      =      ids_tensor((1,)			,       output_from_past.shape[-1] ).item()
    UpperCAmelCase__	:Any      =      output_from_no_past[:, -1, random_slice_idx].detach()
    UpperCAmelCase__	:Union[str, Any]      =      output_from_past[:, 0, random_slice_idx].detach()

    # test that outputs are equal for slice
    self.parent.assertTrue(torch.allclose(__lowerCamelCase			,       __lowerCamelCase			,       atol=1e-3 ) )





 def        __SCREAMING_SNAKE_CASE					(      self							:	Any			,       __lowerCamelCase							:	Tuple			,       __lowerCamelCase							:	str			,       ):
    UpperCAmelCase__	:Optional[Any]      =      UMTaModel(config=__lowerCamelCase ).to(__lowerCamelCase ).half().eval()
    UpperCAmelCase__	:Any      =      model(**__lowerCamelCase )['''last_hidden_state''']
    self.parent.assertFalse(torch.isnan(__lowerCamelCase ).any().item() )




@require_torch
class 				UpperCAmelCase			(			_snake_case						, _snake_case						, _snake_case						, unittest.TestCase						):
 UpperCAmelCase				=					(
     (UMTaModel, UMTaForConditionalGeneration, UMTaForQuestionAnswering) if is_torch_available() else ()
 )
 UpperCAmelCase				=					(UMTaForConditionalGeneration,) if is_torch_available() else ()
 UpperCAmelCase				=					(
     {
         "conversational": UMTaForConditionalGeneration,
         "feature-extraction": UMTaModel,
         "summarization": UMTaForConditionalGeneration,
         "text2text-generation": UMTaForConditionalGeneration,
         "translation": UMTaForConditionalGeneration,
         "question-answering": UMTaForQuestionAnswering,
     }
     if is_torch_available()
     else {}
 )
 UpperCAmelCase				=					True
 UpperCAmelCase				=					False
 UpperCAmelCase				=					False
 UpperCAmelCase				=					True
 UpperCAmelCase				=					True
 # The small UMT5 model needs higher percentages for CPU/MP tests
 UpperCAmelCase				=					[0.8, 0.9]


 def        __SCREAMING_SNAKE_CASE					(      self							:	str ):
    UpperCAmelCase__	:Optional[Any]      =      UMTaModelTester(self )


 @unittest.skip('''Test has a segmentation fault on torch 1.8.0''' )
 def        __SCREAMING_SNAKE_CASE					(      self							:	int ):
    UpperCAmelCase__	:int      =      self.model_tester.prepare_config_and_inputs()
    UpperCAmelCase__	:Optional[int]      =      UMTaModel(config_and_inputs[0] ).to(__lowerCamelCase )
    with tempfile.TemporaryDirectory() as tmpdirname:
       torch.onnx.export(
           __lowerCamelCase			,       (config_and_inputs[1], config_and_inputs[3], config_and_inputs[2])			,       f'''{tmpdirname}/t5_test.onnx'''			,       export_params=__lowerCamelCase			,       opset_version=9			,       input_names=['''input_ids''', '''decoder_input_ids''']			,       )


 @unittest.skipIf(torch_device == '''cpu'''			,       '''Cant do half precision''' )
 def        __SCREAMING_SNAKE_CASE					(      self							:	List[str] ):
    UpperCAmelCase__	:Optional[int]      =      self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model_fpaa_forward(*__lowerCamelCase )


 def        __SCREAMING_SNAKE_CASE					(      self							:	Optional[int] ):
    UpperCAmelCase__	:Tuple      =      ['''encoder_attentions''', '''decoder_attentions''', '''cross_attentions''']
    UpperCAmelCase__	:Optional[int]      =      self.model_tester.prepare_config_and_inputs()
    UpperCAmelCase__	:int      =      config_and_inputs[0]
    UpperCAmelCase__	:Optional[Any]      =      UMTaForConditionalGeneration(__lowerCamelCase ).eval()
    model.to(__lowerCamelCase )

    UpperCAmelCase__	:List[str]      =      {
        '''head_mask''': torch.zeros(config.num_layers			,       config.num_heads			,       device=__lowerCamelCase ),
        '''decoder_head_mask''': torch.zeros(config.num_decoder_layers			,       config.num_heads			,       device=__lowerCamelCase ),
        '''cross_attn_head_mask''': torch.zeros(config.num_decoder_layers			,       config.num_heads			,       device=__lowerCamelCase ),
    }

    for attn_name, (name, mask) in zip(__lowerCamelCase			,       head_masking.items() ):
       UpperCAmelCase__	:Union[str, Any]      =      {name: mask}
       # Explicitly pass decoder_head_mask as it is required from T5 model when head_mask specified
       if name == "head_mask":
          UpperCAmelCase__	:Optional[Any]      =      torch.ones(
              config.num_decoder_layers			,       config.num_heads			,       device=__lowerCamelCase )

       UpperCAmelCase__	:Union[str, Any]      =      model.generate(
           config_and_inputs[1]['''input_ids''']			,       num_beams=1			,       max_length=3			,       output_attentions=__lowerCamelCase			,       return_dict_in_generate=__lowerCamelCase			,       **__lowerCamelCase			,       )
       # We check the state of decoder_attentions and cross_attentions just from the last step
       UpperCAmelCase__	:List[Any]      =      out[attn_name] if attn_name == attention_names[0] else out[attn_name][-1]
       self.assertEqual(sum([w.sum().item() for w in attn_weights] )			,       0.0 )





 @unittest.skip('''Does not work on the tiny model as we keep hitting edge cases.''' )
 def        __SCREAMING_SNAKE_CASE					(      self							:	Union[str, Any] ):
    pass




@require_torch
@require_sentencepiece
@require_tokenizers
class 				UpperCAmelCase			(			unittest.TestCase						):


 @slow
 @unittest.skip(
     '''Unless we stop stripping left and right by default for all special tokens, the expected ids obtained here will not match the original ones. Wait for https://github.com/huggingface/transformers/pull/23909 to be merged''' )
 def        __SCREAMING_SNAKE_CASE					(      self							:	Any ):
    UpperCAmelCase__	:Optional[Any]      =      UMTaForConditionalGeneration.from_pretrained('''google/umt5-small'''			,       return_dict=__lowerCamelCase ).to(__lowerCamelCase )
    UpperCAmelCase__	:List[str]      =      AutoTokenizer.from_pretrained('''google/umt5-small'''			,       use_fast=__lowerCamelCase			,       legacy=__lowerCamelCase )
    UpperCAmelCase__	:Dict      =      [
        '''Bonjour monsieur <extra_id_0> bien <extra_id_1>.''',
        '''No se como puedo <extra_id_0>.''',
        '''This is the reason why we <extra_id_0> them.''',
        '''The <extra_id_0> walks in <extra_id_1>, seats''',
        '''A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.''',
    ]
    UpperCAmelCase__	:Optional[Any]      =      tokenizer(__lowerCamelCase			,       return_tensors='''pt'''			,       padding=__lowerCamelCase ).input_ids
    # fmt: off
    UpperCAmelCase__	:List[Any]      =      torch.tensor(
        [
            [ 3_8_5_3_0, 2_1_0_7_0_3, 2_5_6_2_9_9, 1_4_1_0, 2_5_6_2_9_8, 2_7_4, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
            [   8_2_6, 3_2_1, 6_7_1, 2_5_9_2_2, 2_5_6_2_9_9, 2_7_4, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
            [  1_4_6_0, 3_3_9, 3_1_2, 1_9_0_1_4, 1_0_6_2_0, 7_5_8, 2_5_6_2_9_9, 2_3_5_5,2_7_4, 1, 0, 0, 0, 0, 0, 0,0, 0],
            [   5_1_7, 2_5_6_2_9_9, 1_4_8_6_9, 2_8_1, 3_0_1, 2_5_6_2_9_8, 2_7_5, 1_1_9_9_8_3,1, 0, 0, 0, 0, 0, 0, 0,0, 0],
            [   3_2_0, 2_5_6_2_9_9, 1_4_8_6_9, 2_8_1, 2_2_3_4, 2_8_9, 2_2_7_5, 3_3_3,6_1_3_9_1, 2_8_9, 2_5_6_2_9_8, 5_4_3, 2_5_6_2_9_7, 1_6_8_7_1_4, 3_2_9, 2_5_6_2_9_6,2_7_4, 1],
        ] )
    # fmt: on
    torch.testing.assert_allclose(__lowerCamelCase			,       __lowerCamelCase )

    UpperCAmelCase__	:Dict      =      model.generate(input_ids.to(__lowerCamelCase ) )
    UpperCAmelCase__	:str      =      [
        '''<pad><extra_id_0> et<extra_id_1> [eod] <extra_id_2><extra_id_55>.. [eod] 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 <extra_id_56>ajšietosto<extra_id_56>lleux<extra_id_19><extra_id_6>ajšie</s>''',
        '''<pad><extra_id_0>.<extra_id_1>.,<0x0A>...spech <0x0A><extra_id_20> <extra_id_21></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>''',
        '''<pad><extra_id_0> are not going to be a part of the world. We are not going to be a part of<extra_id_1> and<extra_id_2><0x0A><extra_id_48>.<extra_id_48></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>''',
        '''<pad><extra_id_0> door<extra_id_1>, the door<extra_id_2> 피해[/</s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>''',
        '''<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>''',
    ]
    UpperCAmelCase__	:Dict      =      tokenizer.batch_decode(__lowerCamelCase )
    self.assertEqual(__lowerCamelCase			,       __lowerCamelCase )



